Repository: utopia-rise/godot-kotlin Branch: master Commit: 8d51f614df62 Files: 934 Total size: 3.9 MB Directory structure: gitextract_19j7ugkt/ ├── .editorconfig ├── .gitattributes ├── .github/ │ ├── CODEOWNERS │ ├── ISSUE_TEMPLATE/ │ │ ├── bug_report.md │ │ └── feature_request.md │ ├── bin/ │ │ └── check-repo-is-clean.sh │ └── workflows/ │ ├── CI.yaml │ ├── check-pr-annotation-processor.yaml │ ├── check-pr-build-props.yaml │ ├── check-pr-codegen-uptodate.yaml │ ├── check-pr-compiler-native-plugin.yaml │ ├── check-pr-compiler-plugin-common.yaml │ ├── check-pr-compiler-plugin.yaml │ ├── check-pr-core.yaml │ ├── check-pr-entry-generator.yaml │ ├── check-pr-gradle-plugin.yaml │ ├── check-pr-samples-3d-platformer.yaml │ └── check-pr-samples-mini-games.yaml ├── .gitignore ├── .gitmodules ├── .readthedocs.yml ├── LICENSE ├── README.md ├── build.gradle.kts ├── buildSrc/ │ ├── build.gradle.kts │ └── src/ │ └── main/ │ └── kotlin/ │ ├── BintrayPublish.kt │ ├── DependenciesVersions.kt │ ├── godot/ │ │ ├── codegen/ │ │ │ ├── Argument.kt │ │ │ ├── Class.kt │ │ │ ├── Enum.kt │ │ │ ├── Graph.kt │ │ │ ├── ICall.kt │ │ │ ├── Method.kt │ │ │ ├── Property.kt │ │ │ ├── Signal.kt │ │ │ ├── SignalArgument.kt │ │ │ ├── TypeCast.kt │ │ │ └── generationEntry.kt │ │ └── tasks/ │ │ └── GenerateApiTask.kt │ └── os.kt ├── design-docs/ │ ├── ABOUT.md │ └── dictionary.md ├── docs/ │ ├── .gitignore │ ├── SUMMARY.md │ ├── build.sh │ ├── mkdocs.yml │ ├── requirements.txt │ ├── run.sh │ └── src/ │ └── doc/ │ ├── api-differences.md │ ├── contribution.md │ ├── index.md │ ├── setup/ │ │ ├── gradle.md │ │ └── ide.md │ ├── supported-platforms.md │ └── user-guide/ │ ├── classes.md │ ├── methods.md │ ├── properties.md │ └── signals.md ├── entry-generation/ │ ├── godot-annotation-processor/ │ │ ├── build.gradle.kts │ │ └── src/ │ │ └── main/ │ │ └── kotlin/ │ │ └── godot/ │ │ └── annotation/ │ │ └── processor/ │ │ └── GodotAnnotationProcessor.kt │ ├── godot-compiler-native-plugin/ │ │ ├── build.gradle.kts │ │ └── src/ │ │ └── main/ │ │ ├── kotlin/ │ │ │ └── godot/ │ │ │ └── compiler/ │ │ │ └── plugin/ │ │ │ └── NativeComponentRegistrar.kt │ │ └── resources/ │ │ └── META-INF/ │ │ └── services/ │ │ ├── org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor │ │ └── org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar │ ├── godot-compiler-plugin/ │ │ ├── build.gradle.kts │ │ └── src/ │ │ └── main/ │ │ ├── kotlin/ │ │ │ └── godot/ │ │ │ └── compiler/ │ │ │ └── plugin/ │ │ │ └── CommonComponentRegistrar.kt │ │ └── resources/ │ │ └── META-INF/ │ │ └── services/ │ │ ├── org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor │ │ └── org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar │ ├── godot-compiler-plugin-common/ │ │ ├── build.gradle.kts │ │ └── src/ │ │ └── main/ │ │ └── kotlin/ │ │ └── godot/ │ │ └── compiler/ │ │ └── plugin/ │ │ └── CompilerPluginConst.kt │ └── godot-entry-generator/ │ ├── build.gradle.kts │ └── src/ │ └── main/ │ └── kotlin/ │ └── godot/ │ └── entrygenerator/ │ ├── EntryGenerator.kt │ ├── exceptions/ │ │ └── WrongAnnotationUsageException.kt │ ├── extension/ │ │ ├── AnnotationExt.kt │ │ ├── ClassDescriptorExt.kt │ │ ├── KotlinTypeExt.kt │ │ ├── PropertyDescriptorExt.kt │ │ └── StringExt.kt │ ├── filebuilder/ │ │ └── EntryFileBuilder.kt │ ├── generator/ │ │ ├── ClassRegistrationGenerator.kt │ │ ├── FunctionRegistrationGenerator.kt │ │ ├── GdnsGenerator.kt │ │ ├── PropertyRegistrationGenerator.kt │ │ ├── SignalRegistrationGenerator.kt │ │ └── provider/ │ │ ├── ArrayRegistrationValuesHandler.kt │ │ ├── CoreTypeRegistrationValuesHandler.kt │ │ ├── DefaultValueHandlerProvider.kt │ │ ├── EnumFlagRegistrationValuesHandler.kt │ │ ├── EnumRegistrationValuesHandler.kt │ │ ├── IntFlagRegistrationValuesHandler.kt │ │ ├── MultiLineTextRegistrationValuesHandler.kt │ │ ├── PlaceholderTextRegistrationValuesHandler.kt │ │ ├── PrimitiveRegistrationValuesHandler.kt │ │ ├── RegistrationValuesHandler.kt │ │ └── ResourceRegistrationValuesHandler.kt │ ├── mapper/ │ │ ├── PropertyHintTypeMapper.kt │ │ ├── RpcModeAnnotationMapper.kt │ │ └── TypeToVariantAsClassNameMapper.kt │ ├── model/ │ │ ├── Annotations.kt │ │ └── ClassWithMembers.kt │ └── transformer/ │ └── TypeDeclarationsToClassWithMemberTransformer.kt ├── godot-kotlin/ │ └── godot-library/ │ ├── build.gradle.kts │ └── src/ │ ├── nativeCore/ │ │ └── kotlin/ │ │ └── godot/ │ │ └── core/ │ │ ├── ClassHandle.kt │ │ ├── ClassRegistry.kt │ │ ├── Godot.kt │ │ ├── IndexedIterator.kt │ │ ├── MethodBindCache.kt │ │ ├── TypeManager.kt │ │ ├── Wrapper.kt │ │ ├── bridge.kt │ │ ├── caseConverterExt.kt │ │ ├── classBuilderDsl.kt │ │ ├── functions.kt │ │ ├── properties.kt │ │ ├── signalProviders.kt │ │ ├── signals.kt │ │ ├── type/ │ │ │ ├── AABB.kt │ │ │ ├── Basis.kt │ │ │ ├── Color.kt │ │ │ ├── Dictionary.kt │ │ │ ├── GdString.kt │ │ │ ├── GodotArray.kt │ │ │ ├── NodePath.kt │ │ │ ├── Plane.kt │ │ │ ├── Quat.kt │ │ │ ├── RID.kt │ │ │ ├── Rect2.kt │ │ │ ├── Transform.kt │ │ │ ├── Transform2D.kt │ │ │ ├── Variant.kt │ │ │ ├── Vector2.kt │ │ │ ├── Vector3.kt │ │ │ ├── array/ │ │ │ │ ├── EnumArray.kt │ │ │ │ ├── ObjectArray.kt │ │ │ │ ├── VariantArray.kt │ │ │ │ ├── core/ │ │ │ │ │ ├── AABBArray.kt │ │ │ │ │ ├── BasisArray.kt │ │ │ │ │ ├── ColorArray.kt │ │ │ │ │ ├── CoreArray.kt │ │ │ │ │ ├── NodePathArray.kt │ │ │ │ │ ├── PlaneArray.kt │ │ │ │ │ ├── QuatArray.kt │ │ │ │ │ ├── RIDArray.kt │ │ │ │ │ ├── Rect2Array.kt │ │ │ │ │ ├── Transform2DArray.kt │ │ │ │ │ ├── TransformArray.kt │ │ │ │ │ ├── Vector2Array.kt │ │ │ │ │ └── Vector3Array.kt │ │ │ │ └── primitive/ │ │ │ │ ├── BoolVariantArray.kt │ │ │ │ ├── IntVariantArray.kt │ │ │ │ ├── RealVariantArray.kt │ │ │ │ └── StringVariantArray.kt │ │ │ ├── pool/ │ │ │ │ ├── PoolByteArray.kt │ │ │ │ ├── PoolColorArray.kt │ │ │ │ ├── PoolIntArray.kt │ │ │ │ ├── PoolRealArray.kt │ │ │ │ ├── PoolStringArray.kt │ │ │ │ ├── PoolVector2Array.kt │ │ │ │ └── PoolVector3Array.kt │ │ │ └── string/ │ │ │ ├── File.kt │ │ │ ├── Hash.kt │ │ │ ├── UnEscape.kt │ │ │ ├── Util.kt │ │ │ └── Validation.kt │ │ ├── typealias.kt │ │ └── variantTypeMapping.kt │ ├── nativeGen/ │ │ └── kotlin/ │ │ └── godot/ │ │ ├── ARVRAnchor.kt │ │ ├── ARVRCamera.kt │ │ ├── ARVRController.kt │ │ ├── ARVRInterface.kt │ │ ├── ARVRInterfaceGDNative.kt │ │ ├── ARVROrigin.kt │ │ ├── ARVRPositionalTracker.kt │ │ ├── ARVRServer.kt │ │ ├── AStar.kt │ │ ├── AStar2D.kt │ │ ├── AcceptDialog.kt │ │ ├── AnimatedSprite.kt │ │ ├── AnimatedSprite3D.kt │ │ ├── AnimatedTexture.kt │ │ ├── Animation.kt │ │ ├── AnimationNode.kt │ │ ├── AnimationNodeAdd2.kt │ │ ├── AnimationNodeAdd3.kt │ │ ├── AnimationNodeAnimation.kt │ │ ├── AnimationNodeBlend2.kt │ │ ├── AnimationNodeBlend3.kt │ │ ├── AnimationNodeBlendSpace1D.kt │ │ ├── AnimationNodeBlendSpace2D.kt │ │ ├── AnimationNodeBlendTree.kt │ │ ├── AnimationNodeOneShot.kt │ │ ├── AnimationNodeOutput.kt │ │ ├── AnimationNodeStateMachine.kt │ │ ├── AnimationNodeStateMachinePlayback.kt │ │ ├── AnimationNodeStateMachineTransition.kt │ │ ├── AnimationNodeTimeScale.kt │ │ ├── AnimationNodeTimeSeek.kt │ │ ├── AnimationNodeTransition.kt │ │ ├── AnimationPlayer.kt │ │ ├── AnimationRootNode.kt │ │ ├── AnimationTrackEditPlugin.kt │ │ ├── AnimationTree.kt │ │ ├── AnimationTreePlayer.kt │ │ ├── Area.kt │ │ ├── Area2D.kt │ │ ├── ArrayMesh.kt │ │ ├── AtlasTexture.kt │ │ ├── AudioBusLayout.kt │ │ ├── AudioEffect.kt │ │ ├── AudioEffectAmplify.kt │ │ ├── AudioEffectBandLimitFilter.kt │ │ ├── AudioEffectBandPassFilter.kt │ │ ├── AudioEffectChorus.kt │ │ ├── AudioEffectCompressor.kt │ │ ├── AudioEffectDelay.kt │ │ ├── AudioEffectDistortion.kt │ │ ├── AudioEffectEQ.kt │ │ ├── AudioEffectEQ10.kt │ │ ├── AudioEffectEQ21.kt │ │ ├── AudioEffectEQ6.kt │ │ ├── AudioEffectFilter.kt │ │ ├── AudioEffectHighPassFilter.kt │ │ ├── AudioEffectHighShelfFilter.kt │ │ ├── AudioEffectInstance.kt │ │ ├── AudioEffectLimiter.kt │ │ ├── AudioEffectLowPassFilter.kt │ │ ├── AudioEffectLowShelfFilter.kt │ │ ├── AudioEffectNotchFilter.kt │ │ ├── AudioEffectPanner.kt │ │ ├── AudioEffectPhaser.kt │ │ ├── AudioEffectPitchShift.kt │ │ ├── AudioEffectRecord.kt │ │ ├── AudioEffectReverb.kt │ │ ├── AudioEffectSpectrumAnalyzer.kt │ │ ├── AudioEffectSpectrumAnalyzerInstance.kt │ │ ├── AudioEffectStereoEnhance.kt │ │ ├── AudioServer.kt │ │ ├── AudioStream.kt │ │ ├── AudioStreamGenerator.kt │ │ ├── AudioStreamGeneratorPlayback.kt │ │ ├── AudioStreamMicrophone.kt │ │ ├── AudioStreamOGGVorbis.kt │ │ ├── AudioStreamPlayback.kt │ │ ├── AudioStreamPlaybackResampled.kt │ │ ├── AudioStreamPlayer.kt │ │ ├── AudioStreamPlayer2D.kt │ │ ├── AudioStreamPlayer3D.kt │ │ ├── AudioStreamRandomPitch.kt │ │ ├── AudioStreamSample.kt │ │ ├── BackBufferCopy.kt │ │ ├── BakedLightmap.kt │ │ ├── BakedLightmapData.kt │ │ ├── BaseButton.kt │ │ ├── BitMap.kt │ │ ├── BitmapFont.kt │ │ ├── Bone2D.kt │ │ ├── BoneAttachment.kt │ │ ├── BoxContainer.kt │ │ ├── BoxShape.kt │ │ ├── BulletPhysicsDirectBodyState.kt │ │ ├── Button.kt │ │ ├── ButtonGroup.kt │ │ ├── CPUParticles.kt │ │ ├── CPUParticles2D.kt │ │ ├── CSGBox.kt │ │ ├── CSGCombiner.kt │ │ ├── CSGCylinder.kt │ │ ├── CSGMesh.kt │ │ ├── CSGPolygon.kt │ │ ├── CSGPrimitive.kt │ │ ├── CSGShape.kt │ │ ├── CSGSphere.kt │ │ ├── CSGTorus.kt │ │ ├── Camera.kt │ │ ├── Camera2D.kt │ │ ├── CameraFeed.kt │ │ ├── CameraServer.kt │ │ ├── CameraTexture.kt │ │ ├── CanvasItem.kt │ │ ├── CanvasItemMaterial.kt │ │ ├── CanvasLayer.kt │ │ ├── CanvasModulate.kt │ │ ├── CapsuleMesh.kt │ │ ├── CapsuleShape.kt │ │ ├── CapsuleShape2D.kt │ │ ├── CenterContainer.kt │ │ ├── CharFXTransform.kt │ │ ├── CheckBox.kt │ │ ├── CheckButton.kt │ │ ├── CircleShape2D.kt │ │ ├── ClassDB.kt │ │ ├── ClippedCamera.kt │ │ ├── CollisionObject.kt │ │ ├── CollisionObject2D.kt │ │ ├── CollisionPolygon.kt │ │ ├── CollisionPolygon2D.kt │ │ ├── CollisionShape.kt │ │ ├── CollisionShape2D.kt │ │ ├── ColorPicker.kt │ │ ├── ColorPickerButton.kt │ │ ├── ColorRect.kt │ │ ├── ConcavePolygonShape.kt │ │ ├── ConcavePolygonShape2D.kt │ │ ├── ConeTwistJoint.kt │ │ ├── ConfigFile.kt │ │ ├── ConfirmationDialog.kt │ │ ├── Container.kt │ │ ├── Control.kt │ │ ├── ConvexPolygonShape.kt │ │ ├── ConvexPolygonShape2D.kt │ │ ├── Crypto.kt │ │ ├── CryptoKey.kt │ │ ├── CubeMap.kt │ │ ├── CubeMesh.kt │ │ ├── Curve.kt │ │ ├── Curve2D.kt │ │ ├── Curve3D.kt │ │ ├── CurveTexture.kt │ │ ├── CylinderMesh.kt │ │ ├── CylinderShape.kt │ │ ├── DTLSServer.kt │ │ ├── DampedSpringJoint2D.kt │ │ ├── DirectionalLight.kt │ │ ├── Directory.kt │ │ ├── DynamicFont.kt │ │ ├── DynamicFontData.kt │ │ ├── EditorExportPlugin.kt │ │ ├── EditorFeatureProfile.kt │ │ ├── EditorFileDialog.kt │ │ ├── EditorFileSystem.kt │ │ ├── EditorFileSystemDirectory.kt │ │ ├── EditorImportPlugin.kt │ │ ├── EditorInspector.kt │ │ ├── EditorInspectorPlugin.kt │ │ ├── EditorInterface.kt │ │ ├── EditorNavigationMeshGenerator.kt │ │ ├── EditorPlugin.kt │ │ ├── EditorProperty.kt │ │ ├── EditorResourceConversionPlugin.kt │ │ ├── EditorResourcePreview.kt │ │ ├── EditorResourcePreviewGenerator.kt │ │ ├── EditorSceneImporter.kt │ │ ├── EditorSceneImporterAssimp.kt │ │ ├── EditorScenePostImport.kt │ │ ├── EditorScript.kt │ │ ├── EditorSelection.kt │ │ ├── EditorSettings.kt │ │ ├── EditorSpatialGizmo.kt │ │ ├── EditorSpatialGizmoPlugin.kt │ │ ├── EditorSpinSlider.kt │ │ ├── EditorVCSInterface.kt │ │ ├── EncodedObjectAsID.kt │ │ ├── Engine.kt │ │ ├── Environment.kt │ │ ├── Expression.kt │ │ ├── ExternalTexture.kt │ │ ├── File.kt │ │ ├── FileDialog.kt │ │ ├── FileSystemDock.kt │ │ ├── Font.kt │ │ ├── FuncRef.kt │ │ ├── GDNative.kt │ │ ├── GDNativeLibrary.kt │ │ ├── GDScript.kt │ │ ├── GDScriptFunctionState.kt │ │ ├── GIProbe.kt │ │ ├── GIProbeData.kt │ │ ├── Generic6DOFJoint.kt │ │ ├── Geometry.kt │ │ ├── GeometryInstance.kt │ │ ├── GlobalConstants.kt │ │ ├── Gradient.kt │ │ ├── GradientTexture.kt │ │ ├── GraphEdit.kt │ │ ├── GraphNode.kt │ │ ├── GridContainer.kt │ │ ├── GridMap.kt │ │ ├── GrooveJoint2D.kt │ │ ├── HBoxContainer.kt │ │ ├── HScrollBar.kt │ │ ├── HSeparator.kt │ │ ├── HSlider.kt │ │ ├── HSplitContainer.kt │ │ ├── HTTPClient.kt │ │ ├── HTTPRequest.kt │ │ ├── HashingContext.kt │ │ ├── HeightMapShape.kt │ │ ├── HingeJoint.kt │ │ ├── IP.kt │ │ ├── Image.kt │ │ ├── ImageTexture.kt │ │ ├── ImmediateGeometry.kt │ │ ├── Input.kt │ │ ├── InputEvent.kt │ │ ├── InputEventAction.kt │ │ ├── InputEventGesture.kt │ │ ├── InputEventJoypadButton.kt │ │ ├── InputEventJoypadMotion.kt │ │ ├── InputEventKey.kt │ │ ├── InputEventMIDI.kt │ │ ├── InputEventMagnifyGesture.kt │ │ ├── InputEventMouse.kt │ │ ├── InputEventMouseButton.kt │ │ ├── InputEventMouseMotion.kt │ │ ├── InputEventPanGesture.kt │ │ ├── InputEventScreenDrag.kt │ │ ├── InputEventScreenTouch.kt │ │ ├── InputEventWithModifiers.kt │ │ ├── InputMap.kt │ │ ├── InstancePlaceholder.kt │ │ ├── InterpolatedCamera.kt │ │ ├── ItemList.kt │ │ ├── JNISingleton.kt │ │ ├── JSON.kt │ │ ├── JSONParseResult.kt │ │ ├── JSONRPC.kt │ │ ├── JavaClass.kt │ │ ├── JavaClassWrapper.kt │ │ ├── JavaScript.kt │ │ ├── Joint.kt │ │ ├── Joint2D.kt │ │ ├── KinematicBody.kt │ │ ├── KinematicBody2D.kt │ │ ├── KinematicCollision.kt │ │ ├── KinematicCollision2D.kt │ │ ├── Label.kt │ │ ├── LargeTexture.kt │ │ ├── Light.kt │ │ ├── Light2D.kt │ │ ├── LightOccluder2D.kt │ │ ├── Line2D.kt │ │ ├── LineEdit.kt │ │ ├── LineShape2D.kt │ │ ├── LinkButton.kt │ │ ├── Listener.kt │ │ ├── MainLoop.kt │ │ ├── MarginContainer.kt │ │ ├── Marshalls.kt │ │ ├── Material.kt │ │ ├── MenuButton.kt │ │ ├── Mesh.kt │ │ ├── MeshDataTool.kt │ │ ├── MeshInstance.kt │ │ ├── MeshInstance2D.kt │ │ ├── MeshLibrary.kt │ │ ├── MeshTexture.kt │ │ ├── MobileVRInterface.kt │ │ ├── MultiMesh.kt │ │ ├── MultiMeshInstance.kt │ │ ├── MultiMeshInstance2D.kt │ │ ├── MultiplayerAPI.kt │ │ ├── MultiplayerPeerGDNative.kt │ │ ├── Mutex.kt │ │ ├── NativeScript.kt │ │ ├── Navigation.kt │ │ ├── Navigation2D.kt │ │ ├── NavigationMesh.kt │ │ ├── NavigationMeshInstance.kt │ │ ├── NavigationPolygon.kt │ │ ├── NavigationPolygonInstance.kt │ │ ├── NetworkedMultiplayerENet.kt │ │ ├── NetworkedMultiplayerPeer.kt │ │ ├── NinePatchRect.kt │ │ ├── Node.kt │ │ ├── Node2D.kt │ │ ├── NoiseTexture.kt │ │ ├── OS.kt │ │ ├── Object.kt │ │ ├── OccluderPolygon2D.kt │ │ ├── OmniLight.kt │ │ ├── OpenSimplexNoise.kt │ │ ├── OptionButton.kt │ │ ├── PCKPacker.kt │ │ ├── PHashTranslation.kt │ │ ├── PackedDataContainer.kt │ │ ├── PackedDataContainerRef.kt │ │ ├── PackedScene.kt │ │ ├── PacketPeer.kt │ │ ├── PacketPeerDTLS.kt │ │ ├── PacketPeerGDNative.kt │ │ ├── PacketPeerStream.kt │ │ ├── PacketPeerUDP.kt │ │ ├── Panel.kt │ │ ├── PanelContainer.kt │ │ ├── PanoramaSky.kt │ │ ├── ParallaxBackground.kt │ │ ├── ParallaxLayer.kt │ │ ├── Particles.kt │ │ ├── Particles2D.kt │ │ ├── ParticlesMaterial.kt │ │ ├── Path.kt │ │ ├── Path2D.kt │ │ ├── PathFollow.kt │ │ ├── PathFollow2D.kt │ │ ├── Performance.kt │ │ ├── PhysicalBone.kt │ │ ├── Physics2DDirectBodyState.kt │ │ ├── Physics2DDirectBodyStateSW.kt │ │ ├── Physics2DDirectSpaceState.kt │ │ ├── Physics2DServer.kt │ │ ├── Physics2DShapeQueryParameters.kt │ │ ├── Physics2DShapeQueryResult.kt │ │ ├── Physics2DTestMotionResult.kt │ │ ├── PhysicsBody.kt │ │ ├── PhysicsBody2D.kt │ │ ├── PhysicsDirectBodyState.kt │ │ ├── PhysicsDirectSpaceState.kt │ │ ├── PhysicsMaterial.kt │ │ ├── PhysicsServer.kt │ │ ├── PhysicsShapeQueryParameters.kt │ │ ├── PhysicsShapeQueryResult.kt │ │ ├── PinJoint.kt │ │ ├── PinJoint2D.kt │ │ ├── PlaneMesh.kt │ │ ├── PlaneShape.kt │ │ ├── PluginScript.kt │ │ ├── PointMesh.kt │ │ ├── Polygon2D.kt │ │ ├── PolygonPathFinder.kt │ │ ├── Popup.kt │ │ ├── PopupDialog.kt │ │ ├── PopupMenu.kt │ │ ├── PopupPanel.kt │ │ ├── Position2D.kt │ │ ├── Position3D.kt │ │ ├── PrimitiveMesh.kt │ │ ├── PrismMesh.kt │ │ ├── ProceduralSky.kt │ │ ├── ProgressBar.kt │ │ ├── ProjectSettings.kt │ │ ├── ProximityGroup.kt │ │ ├── ProxyTexture.kt │ │ ├── QuadMesh.kt │ │ ├── RandomNumberGenerator.kt │ │ ├── Range.kt │ │ ├── RayCast.kt │ │ ├── RayCast2D.kt │ │ ├── RayShape.kt │ │ ├── RayShape2D.kt │ │ ├── RectangleShape2D.kt │ │ ├── Reference.kt │ │ ├── ReferenceRect.kt │ │ ├── ReflectionProbe.kt │ │ ├── RegEx.kt │ │ ├── RegExMatch.kt │ │ ├── RemoteTransform.kt │ │ ├── RemoteTransform2D.kt │ │ ├── Resource.kt │ │ ├── ResourceFormatLoader.kt │ │ ├── ResourceFormatSaver.kt │ │ ├── ResourceImporter.kt │ │ ├── ResourceInteractiveLoader.kt │ │ ├── ResourceLoader.kt │ │ ├── ResourcePreloader.kt │ │ ├── ResourceSaver.kt │ │ ├── RichTextEffect.kt │ │ ├── RichTextLabel.kt │ │ ├── RigidBody.kt │ │ ├── RigidBody2D.kt │ │ ├── RootMotionView.kt │ │ ├── SceneState.kt │ │ ├── SceneTree.kt │ │ ├── SceneTreeTimer.kt │ │ ├── Script.kt │ │ ├── ScriptCreateDialog.kt │ │ ├── ScriptEditor.kt │ │ ├── ScrollBar.kt │ │ ├── ScrollContainer.kt │ │ ├── SegmentShape2D.kt │ │ ├── Semaphore.kt │ │ ├── Separator.kt │ │ ├── Shader.kt │ │ ├── ShaderMaterial.kt │ │ ├── Shape.kt │ │ ├── Shape2D.kt │ │ ├── ShortCut.kt │ │ ├── Skeleton.kt │ │ ├── Skeleton2D.kt │ │ ├── SkeletonIK.kt │ │ ├── Skin.kt │ │ ├── SkinReference.kt │ │ ├── Sky.kt │ │ ├── Slider.kt │ │ ├── SliderJoint.kt │ │ ├── SoftBody.kt │ │ ├── Spatial.kt │ │ ├── SpatialGizmo.kt │ │ ├── SpatialMaterial.kt │ │ ├── SpatialVelocityTracker.kt │ │ ├── SphereMesh.kt │ │ ├── SphereShape.kt │ │ ├── SpinBox.kt │ │ ├── SplitContainer.kt │ │ ├── SpotLight.kt │ │ ├── SpringArm.kt │ │ ├── Sprite.kt │ │ ├── Sprite3D.kt │ │ ├── SpriteBase3D.kt │ │ ├── SpriteFrames.kt │ │ ├── StaticBody.kt │ │ ├── StaticBody2D.kt │ │ ├── StreamPeer.kt │ │ ├── StreamPeerBuffer.kt │ │ ├── StreamPeerGDNative.kt │ │ ├── StreamPeerSSL.kt │ │ ├── StreamPeerTCP.kt │ │ ├── StreamTexture.kt │ │ ├── StyleBox.kt │ │ ├── StyleBoxEmpty.kt │ │ ├── StyleBoxFlat.kt │ │ ├── StyleBoxLine.kt │ │ ├── StyleBoxTexture.kt │ │ ├── SurfaceTool.kt │ │ ├── TCP_Server.kt │ │ ├── TabContainer.kt │ │ ├── Tabs.kt │ │ ├── TextEdit.kt │ │ ├── TextFile.kt │ │ ├── Texture.kt │ │ ├── Texture3D.kt │ │ ├── TextureArray.kt │ │ ├── TextureButton.kt │ │ ├── TextureLayered.kt │ │ ├── TextureProgress.kt │ │ ├── TextureRect.kt │ │ ├── Theme.kt │ │ ├── Thread.kt │ │ ├── TileMap.kt │ │ ├── TileSet.kt │ │ ├── Timer.kt │ │ ├── ToolButton.kt │ │ ├── TouchScreenButton.kt │ │ ├── Translation.kt │ │ ├── TranslationServer.kt │ │ ├── Tree.kt │ │ ├── TreeItem.kt │ │ ├── TriangleMesh.kt │ │ ├── Tween.kt │ │ ├── UDPServer.kt │ │ ├── UPNP.kt │ │ ├── UPNPDevice.kt │ │ ├── UndoRedo.kt │ │ ├── VBoxContainer.kt │ │ ├── VScrollBar.kt │ │ ├── VSeparator.kt │ │ ├── VSlider.kt │ │ ├── VSplitContainer.kt │ │ ├── VehicleBody.kt │ │ ├── VehicleWheel.kt │ │ ├── VideoPlayer.kt │ │ ├── VideoStream.kt │ │ ├── VideoStreamGDNative.kt │ │ ├── VideoStreamTheora.kt │ │ ├── VideoStreamWebm.kt │ │ ├── Viewport.kt │ │ ├── ViewportContainer.kt │ │ ├── ViewportTexture.kt │ │ ├── VisibilityEnabler.kt │ │ ├── VisibilityEnabler2D.kt │ │ ├── VisibilityNotifier.kt │ │ ├── VisibilityNotifier2D.kt │ │ ├── VisualInstance.kt │ │ ├── VisualScript.kt │ │ ├── VisualScriptBasicTypeConstant.kt │ │ ├── VisualScriptBuiltinFunc.kt │ │ ├── VisualScriptClassConstant.kt │ │ ├── VisualScriptComment.kt │ │ ├── VisualScriptComposeArray.kt │ │ ├── VisualScriptCondition.kt │ │ ├── VisualScriptConstant.kt │ │ ├── VisualScriptConstructor.kt │ │ ├── VisualScriptCustomNode.kt │ │ ├── VisualScriptDeconstruct.kt │ │ ├── VisualScriptEditor.kt │ │ ├── VisualScriptEmitSignal.kt │ │ ├── VisualScriptEngineSingleton.kt │ │ ├── VisualScriptExpression.kt │ │ ├── VisualScriptFunction.kt │ │ ├── VisualScriptFunctionCall.kt │ │ ├── VisualScriptFunctionState.kt │ │ ├── VisualScriptGlobalConstant.kt │ │ ├── VisualScriptIndexGet.kt │ │ ├── VisualScriptIndexSet.kt │ │ ├── VisualScriptInputAction.kt │ │ ├── VisualScriptIterator.kt │ │ ├── VisualScriptLists.kt │ │ ├── VisualScriptLocalVar.kt │ │ ├── VisualScriptLocalVarSet.kt │ │ ├── VisualScriptMathConstant.kt │ │ ├── VisualScriptNode.kt │ │ ├── VisualScriptOperator.kt │ │ ├── VisualScriptPreload.kt │ │ ├── VisualScriptPropertyGet.kt │ │ ├── VisualScriptPropertySet.kt │ │ ├── VisualScriptResourcePath.kt │ │ ├── VisualScriptReturn.kt │ │ ├── VisualScriptSceneNode.kt │ │ ├── VisualScriptSceneTree.kt │ │ ├── VisualScriptSelect.kt │ │ ├── VisualScriptSelf.kt │ │ ├── VisualScriptSequence.kt │ │ ├── VisualScriptSubCall.kt │ │ ├── VisualScriptSwitch.kt │ │ ├── VisualScriptTypeCast.kt │ │ ├── VisualScriptVariableGet.kt │ │ ├── VisualScriptVariableSet.kt │ │ ├── VisualScriptWhile.kt │ │ ├── VisualScriptYield.kt │ │ ├── VisualScriptYieldSignal.kt │ │ ├── VisualServer.kt │ │ ├── VisualShader.kt │ │ ├── VisualShaderNode.kt │ │ ├── VisualShaderNodeBooleanConstant.kt │ │ ├── VisualShaderNodeBooleanUniform.kt │ │ ├── VisualShaderNodeColorConstant.kt │ │ ├── VisualShaderNodeColorFunc.kt │ │ ├── VisualShaderNodeColorOp.kt │ │ ├── VisualShaderNodeColorUniform.kt │ │ ├── VisualShaderNodeCompare.kt │ │ ├── VisualShaderNodeCubeMap.kt │ │ ├── VisualShaderNodeCubeMapUniform.kt │ │ ├── VisualShaderNodeCustom.kt │ │ ├── VisualShaderNodeDeterminant.kt │ │ ├── VisualShaderNodeDotProduct.kt │ │ ├── VisualShaderNodeExpression.kt │ │ ├── VisualShaderNodeFaceForward.kt │ │ ├── VisualShaderNodeFresnel.kt │ │ ├── VisualShaderNodeGlobalExpression.kt │ │ ├── VisualShaderNodeGroupBase.kt │ │ ├── VisualShaderNodeIf.kt │ │ ├── VisualShaderNodeInput.kt │ │ ├── VisualShaderNodeIs.kt │ │ ├── VisualShaderNodeOuterProduct.kt │ │ ├── VisualShaderNodeOutput.kt │ │ ├── VisualShaderNodeScalarClamp.kt │ │ ├── VisualShaderNodeScalarConstant.kt │ │ ├── VisualShaderNodeScalarDerivativeFunc.kt │ │ ├── VisualShaderNodeScalarFunc.kt │ │ ├── VisualShaderNodeScalarInterp.kt │ │ ├── VisualShaderNodeScalarOp.kt │ │ ├── VisualShaderNodeScalarSmoothStep.kt │ │ ├── VisualShaderNodeScalarSwitch.kt │ │ ├── VisualShaderNodeScalarUniform.kt │ │ ├── VisualShaderNodeSwitch.kt │ │ ├── VisualShaderNodeTexture.kt │ │ ├── VisualShaderNodeTextureUniform.kt │ │ ├── VisualShaderNodeTextureUniformTriplanar.kt │ │ ├── VisualShaderNodeTransformCompose.kt │ │ ├── VisualShaderNodeTransformConstant.kt │ │ ├── VisualShaderNodeTransformDecompose.kt │ │ ├── VisualShaderNodeTransformFunc.kt │ │ ├── VisualShaderNodeTransformMult.kt │ │ ├── VisualShaderNodeTransformUniform.kt │ │ ├── VisualShaderNodeTransformVecMult.kt │ │ ├── VisualShaderNodeUniform.kt │ │ ├── VisualShaderNodeVec3Constant.kt │ │ ├── VisualShaderNodeVec3Uniform.kt │ │ ├── VisualShaderNodeVectorClamp.kt │ │ ├── VisualShaderNodeVectorCompose.kt │ │ ├── VisualShaderNodeVectorDecompose.kt │ │ ├── VisualShaderNodeVectorDerivativeFunc.kt │ │ ├── VisualShaderNodeVectorDistance.kt │ │ ├── VisualShaderNodeVectorFunc.kt │ │ ├── VisualShaderNodeVectorInterp.kt │ │ ├── VisualShaderNodeVectorLen.kt │ │ ├── VisualShaderNodeVectorOp.kt │ │ ├── VisualShaderNodeVectorRefract.kt │ │ ├── VisualShaderNodeVectorScalarMix.kt │ │ ├── VisualShaderNodeVectorScalarSmoothStep.kt │ │ ├── VisualShaderNodeVectorScalarStep.kt │ │ ├── VisualShaderNodeVectorSmoothStep.kt │ │ ├── WeakRef.kt │ │ ├── WebRTCDataChannel.kt │ │ ├── WebRTCDataChannelGDNative.kt │ │ ├── WebRTCMultiplayer.kt │ │ ├── WebRTCPeerConnection.kt │ │ ├── WebRTCPeerConnectionGDNative.kt │ │ ├── WebSocketClient.kt │ │ ├── WebSocketMultiplayerPeer.kt │ │ ├── WebSocketPeer.kt │ │ ├── WebSocketServer.kt │ │ ├── WindowDialog.kt │ │ ├── World.kt │ │ ├── World2D.kt │ │ ├── WorldEnvironment.kt │ │ ├── X509Certificate.kt │ │ ├── XMLParser.kt │ │ ├── YSort.kt │ │ ├── icalls/ │ │ │ └── __icalls.kt │ │ └── registerEngineTypes.kt │ ├── nativeInternal/ │ │ └── kotlin/ │ │ └── godot/ │ │ └── internal/ │ │ ├── KObject.kt │ │ ├── type/ │ │ │ ├── CoreType.kt │ │ │ ├── nullSafety.kt │ │ │ └── typeSize.kt │ │ └── utils/ │ │ └── getFromGDNative.kt │ ├── nativeInterop/ │ │ └── cinterop/ │ │ └── godot.def │ └── nativePublic/ │ └── kotlin/ │ └── godot/ │ ├── annotation/ │ │ ├── PropertyTypeHintAnnotation.kt │ │ └── RegisterAnnotation.kt │ ├── extensions.kt │ ├── global/ │ │ ├── GD.kt │ │ ├── GDCore.kt │ │ ├── GDMath.kt │ │ ├── GDPrint.kt │ │ └── GDRandom.kt │ ├── helper/ │ │ └── Vararg.kt │ └── registration/ │ └── Range.kt ├── gradle/ │ └── wrapper/ │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradle.properties ├── gradlew ├── gradlew.bat ├── plugins/ │ └── godot-gradle-plugin/ │ ├── build.gradle.kts │ └── src/ │ └── main/ │ ├── kotlin/ │ │ └── godot/ │ │ └── gradle/ │ │ ├── GenerateGdnlib.kt │ │ ├── GodotExtension.kt │ │ ├── GodotPlatform.kt │ │ ├── GodotPlugin.kt │ │ └── subplugin/ │ │ └── GodotSubPlugin.kt │ └── resources/ │ └── META-INF/ │ └── services/ │ └── org.jetbrains.kotlin.gradle.plugin.KotlinGradleSubplugin ├── samples/ │ ├── 3d-platformer/ │ │ ├── .import/ │ │ │ ├── cutout.png-8aacc6c936bf12e889c8e11f6c4eb91c.md5 │ │ │ ├── cutout.png-8aacc6c936bf12e889c8e11f6c4eb91c.stex │ │ │ ├── icon.png-487276ed1e3a0c39cad0279d744ee560.md5 │ │ │ ├── icon.png-487276ed1e3a0c39cad0279d744ee560.stex │ │ │ ├── osb_down.png-4a1ab934f787719766862b499528d054.md5 │ │ │ ├── osb_down.png-4a1ab934f787719766862b499528d054.stex │ │ │ ├── osb_fire.png-e657a73546eb75918e9d9a3fea15cf70.md5 │ │ │ ├── osb_fire.png-e657a73546eb75918e9d9a3fea15cf70.stex │ │ │ ├── osb_jump.png-dbbef3b47abbb562ce6c81a9701121c6.md5 │ │ │ ├── osb_jump.png-dbbef3b47abbb562ce6c81a9701121c6.stex │ │ │ ├── osb_left.png-fc7230aeb0eec74933ed08f89b893288.md5 │ │ │ ├── osb_left.png-fc7230aeb0eec74933ed08f89b893288.stex │ │ │ ├── osb_right.png-5cf5add2dbc1c8dde17173ac56f3a004.md5 │ │ │ ├── osb_right.png-5cf5add2dbc1c8dde17173ac56f3a004.stex │ │ │ ├── osb_up.png-6a05b6a7bf0ede3756308a5cffdd2b9a.md5 │ │ │ ├── osb_up.png-6a05b6a7bf0ede3756308a5cffdd2b9a.stex │ │ │ ├── panorama.png-e05131d3dca9fd5b03101f18fbe08995.md5 │ │ │ ├── panorama.png-e05131d3dca9fd5b03101f18fbe08995.stex │ │ │ ├── robot_walk.wav-4313e7d5f563e62e3923080b14a79c15.md5 │ │ │ ├── robot_walk.wav-4313e7d5f563e62e3923080b14a79c15.sample │ │ │ ├── shine.png-a8253c1d2dc8acbf187823f695c13207.etc2.stex │ │ │ ├── shine.png-a8253c1d2dc8acbf187823f695c13207.md5 │ │ │ ├── shine.png-a8253c1d2dc8acbf187823f695c13207.s3tc.stex │ │ │ ├── sound_coin.wav-b4defacd1a1eab95585c7b5095506878.md5 │ │ │ ├── sound_coin.wav-b4defacd1a1eab95585c7b5095506878.sample │ │ │ ├── sound_explode.wav-23e94be75a4346bffb517c7e07035977.md5 │ │ │ ├── sound_explode.wav-23e94be75a4346bffb517c7e07035977.sample │ │ │ ├── sound_hit.wav-d8455980ada2d4a9a73508948d7317cc.md5 │ │ │ ├── sound_hit.wav-d8455980ada2d4a9a73508948d7317cc.sample │ │ │ ├── sound_jump.wav-4966d1f327e26a176b56ab335c03b5e1.md5 │ │ │ ├── sound_jump.wav-4966d1f327e26a176b56ab335c03b5e1.sample │ │ │ ├── sound_shoot.wav-f0f26619cba21d411b53ad23b8788116.md5 │ │ │ ├── sound_shoot.wav-f0f26619cba21d411b53ad23b8788116.sample │ │ │ ├── texture.png-77dc6ecaf884a35cd9dbaf886cacc46d.md5 │ │ │ ├── texture.png-77dc6ecaf884a35cd9dbaf886cacc46d.stex │ │ │ ├── texturemr.png-0568a8b09834741143da53ce460e36f1.etc2.stex │ │ │ ├── texturemr.png-0568a8b09834741143da53ce460e36f1.md5 │ │ │ └── texturemr.png-0568a8b09834741143da53ce460e36f1.s3tc.stex │ │ ├── build.gradle.kts │ │ ├── bullet.gd │ │ ├── bullet.scn │ │ ├── coin.gd │ │ ├── coin.scn │ │ ├── cutout.png.import │ │ ├── default_bus_layout.tres │ │ ├── enemy.gd │ │ ├── enemy.scn │ │ ├── export_presets.cfg │ │ ├── follow_camera.gd │ │ ├── gradle/ │ │ │ └── wrapper/ │ │ │ ├── gradle-wrapper.jar │ │ │ └── gradle-wrapper.properties │ │ ├── gradle.properties │ │ ├── gradlew │ │ ├── gradlew.bat │ │ ├── icon.png.import │ │ ├── osb_down.png.import │ │ ├── osb_fire.png.import │ │ ├── osb_jump.png.import │ │ ├── osb_left.png.import │ │ ├── osb_right.png.import │ │ ├── osb_up.png.import │ │ ├── panorama.png.import │ │ ├── platformer3d.gdnlib │ │ ├── player.gd │ │ ├── player.scn │ │ ├── project.godot │ │ ├── robot_walk.wav.import │ │ ├── robotrigged.scn │ │ ├── sb.cube │ │ ├── settings.gradle.kts │ │ ├── shine.png.import │ │ ├── sound_coin.wav.import │ │ ├── sound_explode.wav.import │ │ ├── sound_hit.wav.import │ │ ├── sound_jump.wav.import │ │ ├── sound_shoot.wav.import │ │ ├── src/ │ │ │ ├── gdns/ │ │ │ │ └── kotlin/ │ │ │ │ ├── Bullet.gdns │ │ │ │ ├── Coin.gdns │ │ │ │ ├── Enemy.gdns │ │ │ │ ├── FollowCamera.gdns │ │ │ │ └── Player.gdns │ │ │ └── godotMain/ │ │ │ └── kotlin/ │ │ │ ├── Bullet.kt │ │ │ ├── Coin.kt │ │ │ ├── Enemy.kt │ │ │ ├── FollowCamera.kt │ │ │ └── Player.kt │ │ ├── stage.scn │ │ ├── texture.png.import │ │ ├── texturemr.png.import │ │ ├── tiles.res │ │ └── tiles.scn │ ├── README.md │ └── mini-games/ │ ├── Node2D.tscn │ ├── Sprite.gd │ ├── build.gradle.kts │ ├── default_env.tres │ ├── gradle/ │ │ └── wrapper/ │ │ ├── gradle-wrapper.jar │ │ └── gradle-wrapper.properties │ ├── gradle.properties │ ├── gradlew │ ├── gradlew.bat │ ├── icon.png.import │ ├── mini-games.gdnlib │ ├── project.godot │ ├── settings.gradle.kts │ └── src/ │ ├── gdns/ │ │ └── kotlin/ │ │ └── example/ │ │ ├── TestingClass.gdns │ │ └── TextureSample.gdns │ └── godotMain/ │ └── kotlin/ │ └── example/ │ ├── TestEnum.kt │ ├── TestingClass.kt │ └── TextureSample.kt ├── settings.gradle.kts └── utils/ ├── composite-build-support/ │ ├── README.md │ └── build.gradle.kts └── godot-build-props/ ├── build.gradle.kts └── src/ └── main/ ├── kotlin/ │ └── godot/ │ └── utils/ │ └── GodotBuildProperties.kt └── resources/ └── build.properties ================================================ FILE CONTENTS ================================================ ================================================ FILE: .editorconfig ================================================ [*.{kt, kts}] indent_size = 4 indent_style = space insert_final_newline = true ================================================ FILE: .gitattributes ================================================ # # https://help.github.com/articles/dealing-with-line-endings/ # # These are explicitly windows files and should use crlf *.bat text eol=crlf old/* linguist-generated=true godot-kotlin/godot-library/src/nativeGen/kotlin/* linguist-generated=true ================================================ FILE: .github/CODEOWNERS ================================================ # fallback to everyone if there is no match * @CedNaru @chippmann @raniejade @piiertho # entry generator entry-generation/* @chippmann @raniejade # gradle plugin plugins/godot-gradle-plugin/* @raniejade # core types godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/*.kt @CedNaru # api generation buildSrc/src/main/kotlin/godot/codegen/*.kt @piiertho buildSrc/src/main/kotlin/godot/tasks/GenerateApiTask.kt @piiertho # samples/demos samples/3d-platformer @raniejade # documentation docs/* @raniejade .readthedocs.yml @raniejade ================================================ FILE: .github/ISSUE_TEMPLATE/bug_report.md ================================================ --- name: Bug report about: Create a report to help us improve title: '' labels: '' assignees: '' --- **Version:** **OS/device including version:** **Issue description:** **Steps to reproduce:** **Minimal reproduction project:** ================================================ FILE: .github/ISSUE_TEMPLATE/feature_request.md ================================================ --- name: Feature request about: Suggest an idea for this project title: '' labels: '' assignees: '' --- **Describe the problem or limitation you are having in your project:** **Describe how this feature / enhancement will help you overcome this problem or limitation:** **Show a mock up screenshots/video or a flow diagram explaining how your proposal will work:** **Describe implementation detail for your proposal (in code), if possible:** **If this enhancement will not be used often, can it be worked around with a few lines of code?:** **Is there a reason why this should be in this project and not individually solved?:** ================================================ FILE: .github/bin/check-repo-is-clean.sh ================================================ #!/usr/bin/env bash if [ -n "$(git status --porcelain)" ]; then echo "Generated code is stale, please commit them!" exit 1 else echo "Generated code up-to-date." fi ================================================ FILE: .github/workflows/CI.yaml ================================================ name: CI on: push: branches: - master tags: - '*' jobs: deploy_core: strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v2 with: fetch-depth: 1000 - run: git fetch --depth=1000 origin +refs/tags/*:refs/tags/* - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-library:bintrayUpload -PignoreSamples env: BINTRAY_USER: ${{ secrets.BINTRAY_USER }} BINTRAY_API_KEY: ${{ secrets.BINTRAY_API_KEY }} deploy_build_props: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: fetch-depth: 1000 - run: git fetch --depth=1000 origin +refs/tags/*:refs/tags/* - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-build-props:bintrayUpload -PignoreSamples env: BINTRAY_USER: ${{ secrets.BINTRAY_USER }} BINTRAY_API_KEY: ${{ secrets.BINTRAY_API_KEY }} deploy_entry_generator: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: fetch-depth: 1000 - run: git fetch --depth=1000 origin +refs/tags/*:refs/tags/* - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-entry-generator:bintrayUpload -PignoreSamples env: BINTRAY_USER: ${{ secrets.BINTRAY_USER }} BINTRAY_API_KEY: ${{ secrets.BINTRAY_API_KEY }} deploy_annotation_processor: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: fetch-depth: 1000 - run: git fetch --depth=1000 origin +refs/tags/*:refs/tags/* - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-annotation-processor:bintrayUpload -PignoreSamples env: BINTRAY_USER: ${{ secrets.BINTRAY_USER }} BINTRAY_API_KEY: ${{ secrets.BINTRAY_API_KEY }} deploy_compiler_plugin_common: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: fetch-depth: 1000 - run: git fetch --depth=1000 origin +refs/tags/*:refs/tags/* - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-compiler-plugin-common:bintrayUpload -PignoreSamples env: BINTRAY_USER: ${{ secrets.BINTRAY_USER }} BINTRAY_API_KEY: ${{ secrets.BINTRAY_API_KEY }} deploy_compiler_plugin: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: fetch-depth: 1000 - run: git fetch --depth=1000 origin +refs/tags/*:refs/tags/* - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-compiler-plugin:bintrayUpload -PignoreSamples env: BINTRAY_USER: ${{ secrets.BINTRAY_USER }} BINTRAY_API_KEY: ${{ secrets.BINTRAY_API_KEY }} deploy_compiler_native_plugin: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: fetch-depth: 1000 - run: git fetch --depth=1000 origin +refs/tags/*:refs/tags/* - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-compiler-native-plugin:bintrayUpload -PignoreSamples env: BINTRAY_USER: ${{ secrets.BINTRAY_USER }} BINTRAY_API_KEY: ${{ secrets.BINTRAY_API_KEY }} deploy_godot_gradle_plugin: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: fetch-depth: 1000 - run: git fetch --depth=1000 origin +refs/tags/*:refs/tags/* - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-gradle-plugin:bintrayUpload -PignoreSamples env: BINTRAY_USER: ${{ secrets.BINTRAY_USER }} BINTRAY_API_KEY: ${{ secrets.BINTRAY_API_KEY }} ================================================ FILE: .github/workflows/check-pr-annotation-processor.yaml ================================================ name: Check PR - godot-annotation-processor on: pull_request: paths: - 'plugins/godot-annotation-processor/**' - 'plugins/godot-entry-generator/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - 'settings.gradle.kts' - '.github/workflows/check-pr-annotation-processor.yaml' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-annotation-processor:build -PignoreSamples ================================================ FILE: .github/workflows/check-pr-build-props.yaml ================================================ name: Check PR - godot-build-props on: pull_request: paths: - 'utils/godot-build-props/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - '.github/workflows/check-pr-build-props.yaml' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-build-props:build -PignoreSamples ================================================ FILE: .github/workflows/check-pr-codegen-uptodate.yaml ================================================ name: Check PR - codegen-uptodate on: pull_request jobs: validate: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: ref: ${{ github.event.pull_request.head.sha }} - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-library:generateAPI - run: .github/bin/check-repo-is-clean.sh ================================================ FILE: .github/workflows/check-pr-compiler-native-plugin.yaml ================================================ name: Check PR - godot-compiler-native-plugin on: pull_request: paths: - 'entry-generation/godot-compiler-native-plugin/**' - 'entry-generation/godot-compiler-plugin-common/**' - 'entry-generation/godot-entry-generator/**' - 'entry-generation/godot-annotation-processor/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - 'settings.gradle.kts' - '.github/workflows/check-pr-compiler-native-plugin.yaml' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-compiler-native-plugin:build -PignoreSamples ================================================ FILE: .github/workflows/check-pr-compiler-plugin-common.yaml ================================================ name: Check PR - godot-compiler-plugin-common on: pull_request: paths: - 'entry-generation/godot-compiler-plugin-common/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - '.github/workflows/check-pr-compiler-plugin-common.yaml' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-compiler-plugin-common:build -PignoreSamples ================================================ FILE: .github/workflows/check-pr-compiler-plugin.yaml ================================================ name: Check PR - godot-compiler-plugin on: pull_request: paths: - 'entry-generation/godot-compiler-plugin/**' - 'entry-generation/godot-compiler-plugin-common/**' - 'entry-generation/godot-entry-generator/**' - 'entry-generation/godot-annotation-processor/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - 'settings.gradle.kts' - '.github/workflows/check-pr-compiler-plugin.yaml' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-compiler-plugin:build -PignoreSamples ================================================ FILE: .github/workflows/check-pr-core.yaml ================================================ name: Check PR - godot-library on: pull_request: paths: - 'godot-kotlin/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - '.github/workflows/check-pr-core.yaml' jobs: build: strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest] include: - os: ubuntu-latest task: compileKotlinLinux - os: macos-latest task: compileKotlinMacos - os: windows-latest task: compileKotlinWindows runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-library:${{ matrix.task }} -PignoreSamples ================================================ FILE: .github/workflows/check-pr-entry-generator.yaml ================================================ name: Check PR - godot-entry-generator on: pull_request: paths: - 'entry-generation/godot-entry-generator/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - '.github/workflows/check-pr-entry-generator.yaml' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-entry-generator:build -PignoreSamples ================================================ FILE: .github/workflows/check-pr-gradle-plugin.yaml ================================================ name: Check PR - godot-gradle-plugin on: pull_request: paths: - 'plugins/godot-gradle-plugin/**' - 'utils/godot-build-props/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - 'settings.gradle.kts' - '.github/workflows/check-pr-gradle-plugin.yaml' jobs: build: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - uses: eskatos/gradle-command-action@v1 with: arguments: godot-gradle-plugin:build -PignoreSamples ================================================ FILE: .github/workflows/check-pr-samples-3d-platformer.yaml ================================================ name: Check PR - samples-3d-platformer on: pull_request: paths: - 'entry-generation/godot-compiler-native-plugin/**' - 'entry-generation/godot-compiler-plugin-common/**' - 'entry-generation/godot-entry-generator/**' - 'entry-generation/godot-annotation-processor/**' - 'godot-kotlin/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - 'samples/3d-platformer/**' - '.github/workflows/check-pr-samples-3d-platform.yaml' jobs: build: strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest] include: - os: ubuntu-latest task: buildLinuxX64 publish_task: publishToMavenLocal - os: macos-latest task: -x linkDebugSharedLinuxX64 buildMacosX64 publish_task: -x publishLinuxPublicationToMavenLocal publishToMavenLocal - os: windows-latest task: -x linkDebugSharedLinuxX64 buildWindowsX64 publish_task: -x publishLinuxPublicationToMavenLocal publishToMavenLocal runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - name: Publish artifacts locally uses: eskatos/gradle-command-action@v1 with: arguments: ${{ matrix.publish_task }} -Pgodot.kotlin.dev - uses: eskatos/gradle-command-action@v1 with: build-root-directory: samples/3d-platformer arguments: ${{ matrix.task }} -Pgodot.kotlin.dev ================================================ FILE: .github/workflows/check-pr-samples-mini-games.yaml ================================================ name: Check PR - samples-mini-games on: pull_request: paths: - 'entry-generation/godot-compiler-native-plugin/**' - 'entry-generation/godot-compiler-plugin-common/**' - 'entry-generation/godot-entry-generator/**' - 'entry-generation/godot-annotation-processor/**' - 'godot-kotlin/**' - 'build.gradle.kts' - 'buildSrc/**' - 'gradle.properties' - 'samples/min-games/**' - '.github/workflows/check-pr-samples-mini-games.yaml' jobs: build: strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest] include: - os: ubuntu-latest task: buildLinuxX64 publish_task: publishToMavenLocal - os: macos-latest task: -x linkDebugSharedLinuxX64 buildMacosX64 publish_task: -x publishLinuxPublicationToMavenLocal publishToMavenLocal - os: windows-latest task: -x linkDebugSharedLinuxX64 buildWindowsX64 publish_task: -x publishLinuxPublicationToMavenLocal publishToMavenLocal runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v2 - name: Checkout submodules uses: snickerbockers/submodules-init@v4 - name: Set up JDK 11 uses: actions/setup-java@v1 with: java-version: 11 - name: Publish artifacts locally uses: eskatos/gradle-command-action@v1 with: arguments: ${{ matrix.publish_task }} -Pgodot.kotlin.dev - uses: eskatos/gradle-command-action@v1 with: build-root-directory: samples/mini-games arguments: ${{ matrix.task }} -Pgodot.kotlin.dev ================================================ FILE: .gitignore ================================================ # Ignore Gradle project-specific cache directory .gradle # Ignore Gradle build output directory build # IntelliJ IDEA **/.idea/* !**/.idea/codeStyles/* /samples/mini-games/.import/ # OSX .DS_Store ================================================ FILE: .gitmodules ================================================ [submodule "godot-kotlin/godot-headers"] path = godot-kotlin/godot-headers url = https://github.com/GodotNativeTools/godot_headers ================================================ FILE: .readthedocs.yml ================================================ # .readthedocs.yml # Read the Docs configuration file # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details # Required version: 2 # Build documentation with MkDocs mkdocs: configuration: docs/mkdocs.yml # Optionally set the version of Python and requirements required to build your docs python: version: 3.7 install: - requirements: docs/requirements.txt ================================================ FILE: LICENSE ================================================ MIT License Copyright (c) 2020 godot-kotlin Maintainers and Contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ================================================ FILE: README.md ================================================ ![Kotlin GDNative Logo](docs/src/doc/assets/img/logo.png) # Kotlin/Native binding for the Godot Game Engine ## Overview This is a **Kotlin** language binding for the [**Godot**](https://godotengine.org/) game engine. It uses [**GDNative**](https://godotengine.org/article/dlscript-here) to interact with **Godot**'s core api's. The binding provides you Godot API's as Kotlin classes, so you can write your game logic completely in Kotlin. It will be compiled into a dynamic library using [*Kotlin/Native*](https://kotlinlang.org/docs/reference/native-overview.html). You don't have to worry about any binding logic. Just write your game scripts like you would for [GDScript](https://docs.godotengine.org/en/3.1/getting_started/scripting/gdscript/gdscript_basics.html) or [C#](https://docs.godotengine.org/en/3.1/getting_started/scripting/c_sharp/) but with all the syntactic sugar of kotlin. [![GitHub](https://img.shields.io/github/license/utopia-rise/godot-kotlin?style=flat-square)](LICENSE) [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/utopia-rise/godot-kotlin/CI?style=flat-square)](https://github.com/utopia-rise/godot-kotlin/actions?query=workflow%3ACI) ## Important notes This version of the binding is currently in **Alpha** state and by no means production ready! This state will not change in the near foreseeable future. The Kotlin Native performance is not where it needs to be to make this binding efficient. Currently, the build times are incredibly slow due to the lack of incremental build support in Kotlin Native. Also, the runtime performance is much slower than GDScript in many cases. The only case where this binding shines at the moment is in computation heavy scenarios like implementing an A* pathfinding algorithm where not many calls through the cinterop layer of K/N are necessary. In all other cases were many calls are needed, like Input checking and small logic in function like `_process`, the performance is not great because of the current performance of the K/N cinterop layer. We were and are in touch with JB regarding those issues on youtrack and slack: [KT-40652](https://youtrack.jetbrains.com/issue/KT-40652) and [KT-40679](https://youtrack.jetbrains.com/issue/KT-40679) To still be able to use kotlin in a performant way, we started another project [(godot-jvm)](https://github.com/utopia-rise/godot-jvm/) which leverages an embedded JVM to use kotlin on the JVM rather than native. On our first tests, this increases performance dramatically and one can leverage the full JVM ecosystem. Head over there to see development updates. This binding will not die though. We will provide bugfixes for existing bugs if necessary, keep it as up to date as our time allows us to do, but we will not improve tooling or add new features until the performance of K/N is more acceptable. ## Documentation One can find the documentation for this binding [here](https://godot-kotl.in). ## Developer discussion Ask questions and collaborate on Discord: https://discord.gg/qSU2EQs ## Setting up IntelliJ IDEA for local builds or contribution 1. Add `godot.kotlin.dev` to `~/.gradle/gradle.properties` (on Windows you might need to stop any Gradle daemons running for this property to be picked up) 2. Run the initial build: `./gradlew publishToMavenLocal` (this will take a while) 3. In IntelliJ IDEA, import the root `build.gradle.kts`. 4. After importing the main binding, in the Gradle sidebar in IntelliJ IDEA, import the `build.gradle.kts` of the sample you want to import. (repeat for every sample you want to develop) ## Contribution Guidelines: - **CodeStyle:** We enforce the code style to match the official kotlin [coding conventions](https://kotlinlang.org/docs/reference/coding-conventions.html). Read there on how to set those up for your IDE. We will enforce this later on through CI and linting. - **Branching:** We do branching like described in `git-flow`. Each Issue has a Maintainer that is the "supervisor" for the general topic the issue belongs to. Discuss implementation details with this maintainer. ================================================ FILE: build.gradle.kts ================================================ plugins { id("org.ajoberstar.grgit") version "4.0.2" } val currentCommit = grgit.head() // check if the current commit is tagged var releaseMode = grgit.tag.list().firstOrNull { tag -> tag.commit.id == currentCommit.id } != null val devMode = project.hasProperty("godot.kotlin.dev") if (devMode && !releaseMode) { println("Dev mode detected, using static versioning") version = "0.0.1" } else { version = "0.1.0-${DependenciesVersions.godotVersion}" if (!releaseMode) { version = "$version-${currentCommit.abbreviatedId}" } } val versionString = project.version.toString() println("Inferred version: $versionString (release=$releaseMode)") subprojects { group = "com.utopia-rise" version = versionString repositories { mavenLocal() jcenter() } extra["releaseMode"] = releaseMode } ================================================ FILE: buildSrc/build.gradle.kts ================================================ plugins { `kotlin-dsl` } repositories { jcenter() mavenCentral() gradlePluginPortal() } dependencies { implementation(kotlin("gradle-plugin", version = "1.3.72")) implementation("com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.5") implementation("com.fasterxml.jackson.core:jackson-databind:2.11.0") //Remember to change version according to DependenciesVersion implementation("com.squareup:kotlinpoet:1.5.0") } ================================================ FILE: buildSrc/src/main/kotlin/BintrayPublish.kt ================================================ import com.jfrog.bintray.gradle.BintrayExtension import org.gradle.api.Plugin import org.gradle.api.Project import org.gradle.api.publish.PublishingExtension import org.gradle.api.publish.maven.MavenPublication import org.gradle.kotlin.dsl.extra class BintrayPublish : Plugin { override fun apply(target: Project) { target.plugins.apply("com.jfrog.bintray") target.plugins.apply("maven-publish") val bintrayUser = target.propOrEnv("BINTRAY_USER") val bintrayApiKey = target.propOrEnv("BINTRAY_API_KEY") var bintrayRepo = "godot-kotlin-dev" var doPublish = true //TODO : See how to handle release according to branch and tags if (target.extra["releaseMode"] == true) { bintrayRepo = "godot-kotlin" doPublish = false } val artifacts = target.extra["artifacts"] as Array target.extensions.configure(BintrayExtension::class.java) { user = bintrayUser key = bintrayApiKey publish = doPublish with(pkg) { userOrg = "utopia-rise" repo = bintrayRepo desc = "Kotlin Native bindings for Godot Engine" name = "godot-kotlin" setLicenses("MIT") setLabels("kotlin", "godot", "gamedev", "godotengine") vcsUrl = "https://github.com/utopia-rise/godot-kotlin.git" githubRepo = "utopia-rise/godot-kotlin" with(version) { name = project.rootProject.version.toString() } } setPublications(*artifacts) } target.extensions.configure(PublishingExtension::class.java) { publications { all { if (this@all is MavenPublication) { pom { url.set("https://github.com/utopia-rise/godot-kotlin") licenses { license { name.set("MIT") url.set("https://github.com/utopia-rise/godot-kotlin/blob/master/LICENSE") distribution.set("repo") } } scm { connection.set("scm:git:https://github.com/utopia-rise/godot-kotlin") developerConnection.set("scm:git:github.com:utopia-rise/godot-kotlin.git") tag.set("master") url.set("https://github.com/utopia-rise/godot-kotlin") } developers { developer { id.set("core") name.set("Ranie Jade Ramiso") url.set("https://github.com/raniejade") email.set("raniejaderamiso@gmail.com") } developer { id.set("core") name.set("Pierre-Thomas Meisels") url.set("https://github.com/piiertho") email.set("meisels27@yahoo.fr") } developer { id.set("core") name.set("Cedric Hippmann") url.set("https://github.com/chippmann") email.set("cedric.hippmann@hotmail.com") } developer { id.set("core") name.set("Tristan Grespinet") url.set("https://github.com/CedNaru") email.set("ced.naru@gmail.com") } } } } } } } } } fun Project.propOrEnv(name: String): String? { var property: String? = findProperty(name) as String? if (property == null) { property = System.getenv(name) } return property } ================================================ FILE: buildSrc/src/main/kotlin/DependenciesVersions.kt ================================================ object DependenciesVersions { const val mpaptVersion: String = "0.8.5" const val shadowJarPluginVersion: String = "5.0.0" const val kotlinPoetVersion: String = "1.5.0" const val godotVersion: String = "3.2" } ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/Argument.kt ================================================ package godot.codegen import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonIgnoreProperties import com.fasterxml.jackson.annotation.JsonProperty @JsonIgnoreProperties(ignoreUnknown = true) class Argument @JsonCreator constructor( @JsonProperty("name") var name: String, @JsonProperty("type") var type: String, @JsonProperty("has_default_value") val hasDefaultValue: Boolean = false, @JsonProperty("default_value") var defaultValue: String = "" ) { val nullable: Boolean val applyDefault: String? init { name = name.convertToCamelCase().escapeKotlinReservedNames() type = type.convertTypeToKotlin() if (defaultValue == "[Object:null]" || defaultValue == "Null") { defaultValue = "null" nullable = true } else { nullable = false } applyDefault = if (hasDefaultValue && nullable) { "null" } else if (hasDefaultValue) { when (type) { "Color", "Variant" -> "$type($defaultValue)" "Boolean" -> defaultValue.toLowerCase() "Double" -> intToFloat(defaultValue) "Vector2", "Vector3", "Rect2" -> "$type${defaultValue.replace(",", ".0,") .replace(")", ".0)")}" "Dictionary", "Transform", "Transform2D", "VariantArray", "RID", "PoolVector2Array", "PoolStringArray", "PoolVector3Array", "PoolColorArray", "PoolIntArray", "PoolRealArray", "PoolByteArray" -> "$type()" "String" -> "\"$defaultValue\"" else -> defaultValue } } else { null } } private fun intToFloat(defaultValue: String): String { if (defaultValue.indexOf('.') != -1) return defaultValue return "$defaultValue.0" } } ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/Class.kt ================================================ package godot.codegen import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonIgnoreProperties import com.fasterxml.jackson.annotation.JsonProperty import com.squareup.kotlinpoet.* import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy import java.io.File @JsonIgnoreProperties(ignoreUnknown = true) class Class @JsonCreator constructor( @JsonProperty("name") val oldName: String, @JsonProperty("base_class") var baseClass: String, @JsonProperty("singleton") val isSingleton: Boolean, @JsonProperty("singleton_name") val singletonName: String, @JsonProperty("instanciable") val isInstanciable: Boolean, @JsonProperty("constants") val constants: Map, @JsonProperty("properties") val properties: List, @JsonProperty("signals") val signals: List, @JsonProperty("methods") val methods: List, @JsonProperty("enums") val enums: List ) { val newName: String = oldName.escapeUnderscore() var shouldGenerate: Boolean = true val additionalImports = mutableListOf>() init { baseClass = baseClass.escapeUnderscore() } fun generate(outputDir: File, tree: Graph, icalls: MutableSet) { shouldGenerate = newName != "GlobalConstants" && tree.getBaseClass(this)?.isSingleton == false || isInstanciable || isSingleton if (!shouldGenerate) return applyGettersAndSettersForProperties() val className = ClassName("godot", newName) val classTypeBuilder = createTypeBuilder(className) if (newName == "Object") { classTypeBuilder.superclass(ClassName("godot.internal", "KObject")) generateSignalExtensions(classTypeBuilder) generateToVariantMethod(classTypeBuilder) } generateConstructors(classTypeBuilder) generateEnums(classTypeBuilder) val baseCompanion = if (!isSingleton && constants.isNotEmpty()) TypeSpec.companionObjectBuilder() else null generateConstants(baseCompanion ?: classTypeBuilder) generateSignals(classTypeBuilder) generateProperties(tree, icalls, classTypeBuilder) generateMethods(classTypeBuilder, tree, icalls) baseCompanion?.build()?.let { classTypeBuilder.addType(it) } //Build Type and create file val fileBuilder = FileSpec .builder("godot", className.simpleName) .addType(classTypeBuilder.build()) additionalImports.forEach { fileBuilder.addImport(it.first, it.second) } fileBuilder .addComment("THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD") .build() .writeTo(outputDir) } private fun applyGettersAndSettersForProperties() { properties.forEach { property -> methods.forEach { method -> property applyGetterOrSetter method } } } private fun createTypeBuilder(className: ClassName): TypeSpec.Builder { val typeSpec = if (isSingleton) TypeSpec.objectBuilder(className) else TypeSpec.classBuilder(className).addModifiers(KModifier.OPEN) if (isSingleton) typeSpec.superclass(ClassName("godot", "Object")) else if (baseClass.isNotEmpty()) typeSpec.superclass(ClassName("godot", baseClass)) return typeSpec } private fun generateSignalExtensions(typeBuilder: TypeSpec.Builder) { fun List.toParameterTypes() = this.map { ParameterSpec.builder(it.name.toLowerCase(), it).build() } val typeVariablesNames = mutableListOf() for (i in 0..10) { if (i != 0) typeVariablesNames.add(TypeVariableName.invoke("A${i - 1}")) val signalType = ClassName("godot.core", "Signal$i") val emitFunBuilder = FunSpec.builder("emit") val signalParameterizedType = if (typeVariablesNames.isNotEmpty()) { val parameterSpecs = typeVariablesNames.toParameterTypes() emitFunBuilder.addTypeVariables(typeVariablesNames) emitFunBuilder.addParameters(parameterSpecs) emitFunBuilder.addStatement( "%L(this@Object, ${ parameterSpecs .map { it.name } .reduce{ acc, string -> "$acc, $string" } })", "emit" ) signalType.parameterizedBy(typeVariablesNames) } else { emitFunBuilder.addStatement( "%L(this@Object)", "emit" ) signalType } emitFunBuilder.receiver(signalParameterizedType) typeBuilder.addFunction(emitFunBuilder.build()) val kTypeVariable = TypeVariableName.invoke( "K", bounds = *arrayOf( LambdaTypeName.get( returnType = UNIT, parameters = *typeVariablesNames.toTypedArray() ) ) ).copy(reified = true) val connectTypeVariableNames = listOf( *typeVariablesNames.toTypedArray(), kTypeVariable ) val objectType = ClassName("godot", "Object") typeBuilder.addFunction( FunSpec.builder("connect") .receiver(signalParameterizedType) .addTypeVariables(connectTypeVariableNames) .addModifiers(KModifier.INLINE) .addParameters( listOf( ParameterSpec.builder("target", objectType) .build(), ParameterSpec.builder("method", kTypeVariable) .build(), ParameterSpec.builder("binds", ClassName("godot.core", "VariantArray").copy(nullable = true)) .defaultValue("null") .build(), ParameterSpec.builder("flags", Long::class) .defaultValue("0") .build() ) ) .addCode(""" |val methodName = (method as %T<%T>).name |connect(this@%T, target, methodName, binds, flags) |""".trimMargin(), ClassName("kotlin.reflect", "KCallable"), UNIT, objectType ) .build() ) } } private fun generateConstructors(typeBuilder: TypeSpec.Builder) { val newFunBuilder = FunSpec.builder("__new") .returns(ClassName("kotlinx.cinterop", "COpaquePointer")) .addModifiers(KModifier.OVERRIDE) if (isSingleton) { newFunBuilder.addCode( CodeBlock.of(""" |return %M { | val ptr = %M(%T.gdnative.godot_global_get_singleton).%M("$singletonName".%M.ptr) | %M(ptr) { "No instance found for singleton $singletonName" } | ptr |} |""".trimMargin(), MemberName("kotlinx.cinterop", "memScoped"), MemberName("godot.internal.type", "nullSafe"), ClassName("godot.core", "Godot"), MemberName("kotlinx.cinterop", "invoke"), MemberName("kotlinx.cinterop", "cstr"), MemberName("kotlin", "requireNotNull") ) ) } else { if (isInstanciable) { newFunBuilder.addStatement( "return %M(\"$newName\", \"$oldName\")", MemberName("godot.internal.utils", "invokeConstructor") ) } val primaryConstructorBuilder = FunSpec.constructorBuilder() .callSuperConstructor() if (!isInstanciable) { primaryConstructorBuilder.addModifiers(KModifier.INTERNAL) } typeBuilder.primaryConstructor(primaryConstructorBuilder.build()) } if (isInstanciable || isSingleton) { typeBuilder.addFunction(newFunBuilder.build()) } } private fun generateEnums(typeBuilder: TypeSpec.Builder) { enums.forEach { typeBuilder.addType(it.generated) } } private fun generateSignals(typeBuilder: TypeSpec.Builder) { signals.forEach { if (properties.map { p -> p.name }.contains(it.name)) it.name = "signal${it.name.capitalize()}" typeBuilder.addProperty(it.generated) } } private fun generateConstants(baseCompanion: TypeSpec.Builder) { // for easy lookup val allEnumValues = enums.flatMap { it.values.keys } .toSet() constants.filter { !allEnumValues.contains(it.key) } .forEach { (key, value) -> baseCompanion.addProperty( PropertySpec .builder(key, Long::class) .addModifiers(KModifier.CONST, KModifier.FINAL) .initializer("%L", value) .build() ) } } private fun generateProperties( tree: Graph, icalls: MutableSet, propertiesReceiverType: TypeSpec.Builder ) { properties.forEach { property -> val propertySpec = property.generate(this, tree, icalls) if (propertySpec != null) { propertiesReceiverType.addProperty(propertySpec) val parameterType = property.type val parameterTypeName = ClassName(if (parameterType.isCoreType()) "godot.core" else "godot", parameterType) if (property.hasValidSetter && parameterType.isCoreTypeAdaptedForKotlin()) { val parameterName = property.name val propertyFunSpec = FunSpec.builder(parameterName) if (!isSingleton) { if (tree.doAncestorsHaveProperty(this, property)) { propertyFunSpec.addModifiers(KModifier.OVERRIDE) } else { propertyFunSpec.addModifiers(KModifier.OPEN) } } propertyFunSpec .addParameter( ParameterSpec.builder( "schedule", LambdaTypeName.get( receiver = parameterTypeName, returnType = ClassName("kotlin", "Unit") ) ).build() ) .returns(parameterTypeName) .addStatement( """return $parameterName.apply{ | schedule(this) | $parameterName = this |} |""".trimMargin() ) propertiesReceiverType.addFunction(propertyFunSpec.build()) } } } } private fun generateMethods( propertiesReceiverType: TypeSpec.Builder, tree: Graph, icalls: MutableSet ) { methods.forEach { method -> propertiesReceiverType.addFunction(method.generate(this, tree, icalls)) } } private fun generateToVariantMethod(propertiesReceiverType: TypeSpec.Builder) { val variantType = ClassName("godot.core", "Variant") propertiesReceiverType.addFunction( FunSpec.builder("toVariant") .returns(variantType) .addStatement("return %T(this)", variantType) .build() ) } } ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/Enum.kt ================================================ package godot.codegen import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonIgnoreProperties import com.fasterxml.jackson.annotation.JsonProperty import com.squareup.kotlinpoet.FunSpec import com.squareup.kotlinpoet.TypeSpec @JsonIgnoreProperties(ignoreUnknown = true) class Enum @JsonCreator constructor( @JsonProperty("name") var name: String, @JsonProperty("values") var values: Map ) { val generated by lazy { val enumBuilder = TypeSpec.enumBuilder(name.escapeUnderscore()) enumBuilder.primaryConstructor( FunSpec.constructorBuilder() .addParameter("id", Long::class) .addStatement("this.%N = %N", "id", "id") .build() ) enumBuilder.addProperty("id", Long::class) values.forEach { (key, value) -> val valueName = if (name == "RPCMode") key.removePrefix("RPC_MODE_") else key enumBuilder.addEnumConstant( valueName, TypeSpec.anonymousClassBuilder() .addSuperclassConstructorParameter("%L", value) .build() ) } val companion = TypeSpec.companionObjectBuilder() .addFunction( FunSpec.builder("from") .addParameter("value", Long::class) .addStatement("return values().single { it.%N == %N }", "id", "value") .build() ) .build() enumBuilder.addType(companion) enumBuilder.build() } } ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/Graph.kt ================================================ package godot.codegen class Graph(elements: List, sortFun: (T, T) -> Boolean) { val nodes = mutableListOf>() init { elements.forEach { nodes.add(Node(it)) } nodes.forEach { v1 -> nodes.forEach { v2 -> if (sortFun(v1.value, v2.value)) { v2.childs.add(v1) v1.parent = v2 } } } } class Node(val value: T) { var parent: Node? = null var childs = mutableListOf>() } } fun List.buildTree(): Graph { return Graph(this) { child, parent -> child.baseClass == parent.newName } } fun Graph.getMethodFromAncestor(cl: Class, method: Method): Method? { fun check(m: Method): Boolean { if (m.newName == method.newName && m.arguments.size == method.arguments.size) { var flag = true m.arguments.withIndex().forEach { if (it.value.type != method.arguments[it.index].type) flag = false } if (flag) return true } return false } fun Graph.Node.findMethodInHierarchy(): Method? { value.methods.forEach { if (check(it)) return it } return parent?.findMethodInHierarchy() } return nodes.find { it.value.newName == cl.newName }?.parent?.findMethodInHierarchy() } fun Graph.doAncestorsHaveMethod(cl: Class, method: Method): Boolean { if (method.newName == "toString") return true if (cl.baseClass == "") return false return getMethodFromAncestor(cl, method) != null } fun Graph.doAncestorsHaveProperty(cl: Class, prop: Property): Boolean { if (cl.baseClass == "") return false fun Graph.Node.findPropertyInHierarchy(): Boolean { value.properties.forEach { if (it.name == prop.name) return true } return parent?.findPropertyInHierarchy() ?: false } return nodes.find { it.value.newName == cl.newName }!!.parent!!.findPropertyInHierarchy() } fun Graph.getSanitisedArgumentName(method: Method, index: Int, cl: Class): String { val parentMethod = getMethodFromAncestor(cl, method) return (parentMethod ?: method).arguments[index].name } fun Graph.isObjectOrItsChild(className: String): Boolean { var isObjectFamily = false var classToCheck = nodes.find { it.value.newName == className } ?: return false while (!isObjectFamily) { isObjectFamily = classToCheck.value.newName == "Object" if (isObjectFamily) return true classToCheck = classToCheck.parent ?: return false } return isObjectFamily } fun Graph.getBaseClass(clazz: Class): Class? = nodes.find { it.value.newName == clazz.baseClass }?.value ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/ICall.kt ================================================ package godot.codegen import com.squareup.kotlinpoet.* import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy class ICall( var returnType: String, private val arguments: List ) { private val returnTypeClass = createReturnTypeClass() val name: String = createICallName() init { if (returnType.isEnum()) returnType = "Long" } private fun createICallName(): String { return buildString { append("_icall_${if (returnType.isEnum()) "Long" else returnType}") for (arg in arguments) { append('_') if (arg.nullable) { append('n') } append(arg.type.convertTypeForICalls()) } } } private fun createReturnTypeClass() = if (returnType == "VariantArray") { ClassName( returnType.getPackage(), returnType ) } else { ClassName( if (returnType.isEnum()) "kotlin" else returnType.getPackage(), if (returnType.isEnum()) "Long" else returnType ) } infix fun generateICall(tree: Graph): FunSpec { val spec = FunSpec .builder(name) .addModifiers(KModifier.INTERNAL) .addParameter( ParameterSpec( "mb", ClassName("kotlinx.cinterop", "CPointer") .parameterizedBy(ClassName("godot.gdnative", "godot_method_bind")) ) ) .addParameter("inst", ClassName("kotlinx.cinterop", "COpaquePointer")) addArgumentsToICall(spec) val shouldReturn = returnType != "Unit" addReturnTypeForICall(shouldReturn, spec) generateICallMethodBlock(shouldReturn, spec, tree) return spec.build() } private fun generateICallMethodBlock(shouldReturn: Boolean, spec: FunSpec.Builder, tree: Graph) { val codeBlockBuilder = CodeBlock.builder() val isPrimitive = returnType.isPrimitive() if (shouldReturn) { if (isPrimitive) { spec.addStatement("var ret: %T = ${returnType.defaultValue()}", returnTypeClass) codeBlockBuilder.add("%M {\n", MemberName("kotlinx.cinterop", "memScoped")) } else { codeBlockBuilder.add("val ret = %M {\n", MemberName("kotlinx.cinterop", "memScoped")) } } else { codeBlockBuilder.add("%M {\n", MemberName("kotlinx.cinterop", "memScoped")) } if (shouldReturn) { if (isPrimitive) { codeBlockBuilder.add( " val retVar = %M<%T>()\n", MemberName("kotlinx.cinterop", "alloc"), ClassName("kotlinx.cinterop", "${returnType}Var") ) } else { codeBlockBuilder.add( " val retVar = %M<%T>().ptr\n", MemberName("kotlinx.cinterop", "alloc"), if (returnType.isCoreType()) { ClassName("godot.gdnative", "godot_${returnType.convertToSnakeCase()}") } else ClassName("kotlinx.cinterop", "COpaquePointerVar") ) } } codeBlockBuilder.add( " val args = %M<%T>(${arguments.size + 1})\n", MemberName("kotlinx.cinterop", "allocArray"), ClassName("kotlinx.cinterop", "COpaquePointerVar") ) arguments.withIndex().forEach { val i = it.index val value = it.value val nullInstruction = if (value.nullable) "?" else "" when { value.type == "String" -> { codeBlockBuilder.add( " args[$i] = arg$i$nullInstruction.%M()$nullInstruction.value$nullInstruction.ptr\n", MemberName("godot.core", "toGDString") ) } value.type == "VariantArray" || value.type == "Variant" -> { codeBlockBuilder.add( " args[$i] = arg$i$nullInstruction._handle$nullInstruction.ptr\n" ) } value.type.isCoreType() -> { codeBlockBuilder.add( " args[$i] = arg$i$nullInstruction.getRawMemory(this)\n" ) } value.type.isPrimitive() -> { codeBlockBuilder.add( " args[$i] = arg$i.%M(this)\n", MemberName("godot.internal.type", "getRawMemory") ) } else -> { codeBlockBuilder.add( " args[$i] = arg$i$nullInstruction.ptr\n" ) } } } codeBlockBuilder.add(" args[${arguments.size}] = null\n") if (shouldReturn) { if (isPrimitive) { codeBlockBuilder.add( " %T.gdnative.godot_method_bind_ptrcall!!.%M(mb, inst, args, retVar.%M)\n", ClassName("godot.core", "Godot"), MemberName("kotlinx.cinterop", "invoke"), MemberName("kotlinx.cinterop", "ptr") ) destroyStringArgs(codeBlockBuilder) codeBlockBuilder.add( " ret = retVar.%M\n", MemberName("kotlinx.cinterop", "value") ) } else { codeBlockBuilder.add( " %T.gdnative.godot_method_bind_ptrcall!!.%M(mb, inst, args, retVar)\n", ClassName("godot.core", "Godot"), MemberName("kotlinx.cinterop", "invoke") ) destroyStringArgs(codeBlockBuilder) val returnTypeClassSimpleName = returnTypeClass.simpleName when { tree.isObjectOrItsChild(returnTypeClassSimpleName) -> { val typeManagerClass = ClassName("godot.core", "TypeManager") if (returnTypeClassSimpleName != "Object") { codeBlockBuilder.add( " %M(retVar.pointed.value!!) as %T\n", MemberName(typeManagerClass, "wrap"), returnTypeClass ) } else { codeBlockBuilder.add( " %M(retVar.pointed.value!!)\n", MemberName(typeManagerClass, "wrap") ) } } returnTypeClassSimpleName == "String" -> { codeBlockBuilder.add( " %M(retVar).toKString()\n", MemberName("godot.core", "GdString") ) } else -> { codeBlockBuilder.add( " %T(retVar)\n", returnTypeClass ) } } } } else { codeBlockBuilder.add( " %T.gdnative.godot_method_bind_ptrcall!!.%M(mb, inst, args, null)\n", ClassName("godot.core", "Godot"), MemberName("kotlinx.cinterop", "invoke") ) destroyStringArgs(codeBlockBuilder) } codeBlockBuilder.add("}\n") if (shouldReturn) { codeBlockBuilder.add("return ret") } spec.addCode(codeBlockBuilder.build()) } private fun addReturnTypeForICall(shouldReturn: Boolean, spec: FunSpec.Builder) { if (shouldReturn) { spec.returns(returnTypeClass) } } private fun addArgumentsToICall(spec: FunSpec.Builder) { arguments.withIndex().forEach { val argument = it.value val argumentTypeAsString = argument.type.convertTypeForICalls() var argumentType: TypeName = ClassName(argumentTypeAsString.getPackage(), argumentTypeAsString) if (argument.nullable) { argumentType = argumentType.copy(nullable = true) } spec.addParameter("arg${it.index}", argumentType) } } private fun destroyStringArgs(codeBlockBuilder: CodeBlock.Builder) = arguments.withIndex().forEach { if (it.value.type == "String") { codeBlockBuilder.add( " %M(args[${it.index}]!!).destroy(this)\n", MemberName("godot.core", "GdString") ) } } override fun equals(other: Any?): Boolean { if (other !is ICall) return false return this.name == other.name } override fun hashCode(): Int { return name.hashCode() } } ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/Method.kt ================================================ package godot.codegen import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonIgnoreProperties import com.fasterxml.jackson.annotation.JsonProperty import com.squareup.kotlinpoet.* @JsonIgnoreProperties(ignoreUnknown = true) open class Method @JsonCreator constructor( @JsonProperty("name") val oldName: String, @JsonProperty("return_type") var returnType: String, @JsonProperty("is_virtual") val isVirtual: Boolean, @JsonProperty("has_varargs") val hasVarargs: Boolean, @JsonProperty("arguments") val arguments: List ) { val newName: String init { newName = oldName.convertToCamelCase() returnType = returnType.convertTypeToKotlin() } var isGetterOrSetter: Boolean = false fun generate(clazz: Class, tree: Graph, icalls: MutableSet): FunSpec { // Uncomment to disable method implementation generation //if (isGetterOrSetter) return null val modifiers = mutableListOf() if (!clazz.isSingleton) { modifiers.add(getModifier(tree, clazz)) } val generatedFunBuilder = FunSpec .builder(newName) .addModifiers(modifiers) val shouldReturn = returnType != "Unit" if (shouldReturn) { val simpleName = returnType.removeEnumPrefix() val returnClassName = ClassName(returnType.getPackage(), simpleName) generatedFunBuilder.returns(returnClassName) } if (returnType.isEnum()) { val type = returnType.removeEnumPrefix() if (type.contains('.')) { clazz.additionalImports.add(returnType.getPackage() to type.split('.')[0]) } } //TODO: move adding arguments to generatedFunBuilder to separate function val callArgumentsAsString = buildCallArgumentsString( tree, clazz, generatedFunBuilder ) //cannot be inlined as it also adds the arguments to the generatedFunBuilder if (hasVarargs) { generatedFunBuilder.addParameter( "__var_args", Any::class.asTypeName().copy(nullable = true), KModifier.VARARG ) } if (!isVirtual) { generatedFunBuilder.addStatement("val mb = %M(\"${clazz.oldName}\",\"${oldName}\")", MemberName("godot.internal.utils", "getMethodBind")) val constructedICall = constructICall(callArgumentsAsString, icalls) generatedFunBuilder.addStatement( "%L%L%M%L%L", if (shouldReturn) "return " else "", when { returnType == "enum.Error" -> { "${returnType.removeEnumPrefix()}.byValue( " } returnType.isEnum() -> { "${returnType.removeEnumPrefix()}.from( " } hasVarargs && returnType != "Variant" && returnType != "Unit" -> { "$returnType from " } else -> { "" } }, MemberName("godot.icalls", constructedICall.first), constructedICall.second, when { returnType == "enum.Error" -> ".toUInt())" returnType.isEnum() -> ")" else -> "" } ) } else { if (shouldReturn) { generatedFunBuilder.addStatement( "%L %T(%S)", "throw", NotImplementedError::class, "$oldName is not implemented for ${clazz.newName}" ) } } return generatedFunBuilder.build() } private fun buildCallArgumentsString(tree: Graph, cl: Class, generatedFunBuilder: FunSpec.Builder): String { return buildString { arguments.withIndex().forEach { val index = it.index val argument = it.value if (index != 0 || !hasVarargs) append(", ") val sanitisedName = tree.getSanitisedArgumentName(this@Method, index, cl) append(sanitisedName) if (argument.type.isEnum()) append(".id") val parameterBuilder = ParameterSpec.builder( argument.name, ClassName( argument.type.getPackage(), argument.type.removeEnumPrefix() ).copy(nullable = argument.nullable) ) if (argument.applyDefault != null) parameterBuilder.defaultValue(argument.applyDefault) generatedFunBuilder.addParameter(parameterBuilder.build()) } if (hasVarargs && !isEmpty()) append(", ") } } private fun getModifier(tree: Graph, cl: Class) = if (tree.doAncestorsHaveMethod(cl, this)) KModifier.OVERRIDE else KModifier.OPEN private fun constructICall(methodArguments: String, icalls: MutableSet): Pair { if (hasVarargs) { return "_icall_varargs" to "( mb, this.ptr, " + if (methodArguments.isNotEmpty()) "arrayOf($methodArguments*__var_args))" else "__var_args)" } val icall = ICall(returnType, arguments) icalls.add(icall) return icall.name to "( mb, this.ptr$methodArguments)" } } ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/Property.kt ================================================ package godot.codegen import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonIgnoreProperties import com.fasterxml.jackson.annotation.JsonProperty import com.squareup.kotlinpoet.* @JsonIgnoreProperties(ignoreUnknown = true) class Property @JsonCreator constructor( @JsonProperty("name") var name: String, @JsonProperty("type") var type: String, @JsonProperty("getter") var getter: String, @JsonProperty("setter") var setter: String, @JsonProperty("index") val index: Int ) { var hasValidGetter: Boolean = false lateinit var validGetter: Method var hasValidSetter: Boolean = false lateinit var validSetter: Method init { name = name.convertToCamelCase() type = type.convertTypeToKotlin() getter = getter.convertToCamelCase() setter = setter.convertToCamelCase() name = name.replace('/', '_') // There are property with multiple types, and it's all Materials, so // Godot's developer should make more strict API if (type.indexOf(",") != -1) { type = "Material" } } fun generate(clazz: Class, tree: Graph, icalls: MutableSet): PropertySpec? { if (!hasValidGetter && !hasValidSetter) return null if (hasValidGetter && !validGetter.returnType.isEnum() && type != validGetter.returnType) { type = validGetter.returnType } // Sorry for this, CPUParticles has "scale" property overrides ancestor's "scale", but mismatches type if (clazz.newName == "CPUParticles" && name == "scale") name = "_scale" val modifiers = mutableListOf() if (!clazz.isSingleton) { modifiers.add(if (tree.doAncestorsHaveProperty(clazz, this)) KModifier.OVERRIDE else KModifier.OPEN) } val propertyType = ClassName(type.getPackage(), type) val propertySpecBuilder = PropertySpec .builder( name, propertyType, modifiers ) if (hasValidSetter) { propertySpecBuilder.mutable() val icall = if (index != -1) { ICall("Unit", listOf(Argument("idx", "Long"), Argument("value", type))) } else { ICall("Unit", listOf(Argument("value", type))) } icalls.add(icall) propertySpecBuilder.setter( FunSpec.setterBuilder() .addParameter("value", propertyType) .addStatement("val mb = %M(\"${clazz.oldName}\",\"${validSetter.oldName}\")", MemberName("godot.internal.utils", "getMethodBind")) .addStatement( "%M(mb, this.ptr${if (index != -1) ", $index, value)" else ", value)"}", MemberName("godot.icalls", icall.name) ) .build() ) } if (hasValidGetter) { val icall = if (index != -1) { ICall(type, listOf(Argument("idx", "Long"))) } else { ICall(type, listOf()) } icalls.add(icall) propertySpecBuilder.getter( FunSpec.getterBuilder() .addStatement("val mb = %M(\"${clazz.oldName}\",\"${validGetter.oldName}\")", MemberName("godot.internal.utils", "getMethodBind")) //Hard to maintain but do not see how to do better (Pierre-Thomas Meisels) .addStatement( "return %M(mb, this.ptr${if (index != -1) ", $index)" else ")"}", MemberName("godot.icalls", icall.name) ) .build() ) } else { propertySpecBuilder.getter( FunSpec.getterBuilder() .addStatement( "%L %T(%S)", "throw", UninitializedPropertyAccessException::class, "Cannot access property $name: has no getter" ) .build() ) } return propertySpecBuilder.build() } infix fun applyGetterOrSetter(method: Method) { if (name == "") return when (method.newName) { getter -> { if (method.returnType == "Unit" || method.arguments.size > 1 || method.isVirtual) return if (index == -1 && method.arguments.size == 1) return if (method.arguments.size == 1 && method.arguments[0].type != "Long") return validGetter = method hasValidGetter = true method.isGetterOrSetter = true } setter -> { if (method.returnType != "Unit" || method.arguments.size > 2 || method.isVirtual) return if (index == -1 && method.arguments.size == 2) return if (method.arguments.size == 2 && method.arguments[0].type != "Long") return validSetter = method hasValidSetter = true method.isGetterOrSetter = true } } } } ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/Signal.kt ================================================ package godot.codegen import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonIgnoreProperties import com.fasterxml.jackson.annotation.JsonProperty import com.squareup.kotlinpoet.ClassName import com.squareup.kotlinpoet.MemberName import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy import com.squareup.kotlinpoet.PropertySpec @JsonIgnoreProperties(ignoreUnknown = true) class Signal @JsonCreator constructor( @JsonProperty("name") var name: String, @JsonProperty("arguments") val arguments: List ) { val generated: PropertySpec get() { val builder = if (arguments.isEmpty()) { PropertySpec .builder( name.convertToCamelCase().escapeKotlinReservedNames(), ClassName("godot.core", "Signal0") ) .delegate( "%M()", MemberName("godot.core", "signal") ) } else { PropertySpec .builder( name.convertToCamelCase().escapeKotlinReservedNames(), ClassName("godot.core", "Signal${arguments.size}") .parameterizedBy(*arguments.map { ClassName(it.type.getPackage(), it.type) }.toTypedArray()) ) .delegate("%M(${ arguments .map { "\"${it.name}\"" + if (it != arguments.last()) ", " else "" } .reduce { acc, s -> acc + s } })", MemberName("godot.core", "signal") ) } return builder.build() } } ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/SignalArgument.kt ================================================ package godot.codegen import com.fasterxml.jackson.annotation.JsonCreator import com.fasterxml.jackson.annotation.JsonIgnoreProperties import com.fasterxml.jackson.annotation.JsonProperty @JsonIgnoreProperties(ignoreUnknown = true) class SignalArgument @JsonCreator constructor( @JsonProperty("name") val name: String, @JsonProperty("type") var type: String, @JsonProperty("default_value") val defaultValue: String ) { init { type = type.convertTypeToKotlin() } } ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/TypeCast.kt ================================================ package godot.codegen private val coreTypes = listOf( "VariantArray", "Basis", "Color", "Dictionary", "GodotError", "NodePath", "Plane", "PoolByteArray", "PoolIntArray", "PoolRealArray", "PoolStringArray", "PoolVector2Array", "PoolVector3Array", "PoolColorArray", "PoolIntArray", "PoolRealArray", "Quat", "Rect2", "AABB", "RID", "String", "Transform", "Transform2D", "Variant", "Vector2", "Vector3" ) private val coreTypeAdaptedForKotlin = listOf("AABB", "Basis", "Color", "Plane", "Quat", "Rect2", "Transform", "Transform2D", "Vector2", "Vector3") private val kotlinReservedNames = listOf( "class", "enum", "interface", "in", "var", "val", "Char", "Short", "Boolean", "Int", "Long", "Float", "Double", "operator", "object" ) private val primitives = listOf("Long", "Double", "Boolean", "Unit") fun String.escapeUnderscore(): String { if (this == "") return this var thisString = this while (thisString[0] == '_') thisString = thisString.drop(1) return thisString } fun String.removeEnumPrefix(): String { if (this == "") return this var thisString = this val ind = thisString.indexOf("enum.") if (ind != -1) thisString = thisString.drop(ind + 5) if (thisString == "Error") return "GodotError" return thisString.replace("::", ".").escapeUnderscore() } fun String.getPackage() = when { isEnum() -> { var thisString = this val index = thisString.indexOf("enum.") if (index != -1) thisString = thisString.drop(index + 5) if (thisString == "Error") { "godot.core" } else { thisString = thisString.replace("::", ".").split(".")[0] when { thisString.isPrimitive() || thisString == "String" -> "kotlin" thisString.isCoreType() -> "godot.core" else -> "godot" } } } isPrimitive() || this == "String" -> "kotlin" isCoreType() -> "godot.core" else -> "godot" } fun String.isEnum(): Boolean { return this.indexOf("enum.") == 0 } fun String.isPrimitive() = primitives.find { s -> s == this } != null fun String.isCoreTypeAdaptedForKotlin() = coreTypeAdaptedForKotlin.find { s -> s == this } != null fun String.isCoreType() = coreTypes.find { s -> s == this } != null fun String.escapeKotlinReservedNames() = if (kotlinReservedNames.find { s -> s == this } != null) "_$this" else this fun String.convertToCamelCase(): String { if (this == "") return this var thisString = this val prefix = buildString { while (thisString != "" && thisString[0] == '_') { this.append('_') thisString = thisString.drop(1) } } var split = thisString.split('_') val first = split[0] split = split.drop(1) return prefix + first + split.joinToString("") { it.capitalize() } } fun String.convertToSnakeCase(): String = if (this == "VariantArray") "array" else if (this == "AABB" || this == "RID" || this == "Transform2D") this.toLowerCase() else fold(StringBuilder()) { accumulator, character -> if (character in 'A'..'Z') (if (accumulator.isNotEmpty()) accumulator.append('_') else accumulator) .append(character + ('a' - 'A')) else accumulator.append(character) }.toString() fun String.convertTypeToKotlin(): String { return when { this == "int" -> "Long" this == "float" -> "Double" this == "bool" -> "Boolean" this == "void" -> "Unit" this == "Array" -> "VariantArray" else -> this } } fun String.convertTypeForICalls(): String { if (this == "enum.Error") return "UInt" if (this.isEnum()) return "Long" if (this.isPrimitive() || this.isCoreType()) return this return "Object" } fun String.defaultValue(): String = when (this) { "Long" -> "0" "Double" -> "0.0" "Boolean" -> "false" else -> throw Exception("$this is not a primitive type.") } private class TypeException(override val message: String) : Exception() ================================================ FILE: buildSrc/src/main/kotlin/godot/codegen/generationEntry.kt ================================================ package godot.codegen import com.fasterxml.jackson.core.type.TypeReference import com.fasterxml.jackson.databind.ObjectMapper import com.squareup.kotlinpoet.* import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy import java.io.File infix fun File.generateApiFrom(jsonSource: File) { val classes: List = ObjectMapper().readValue(jsonSource, object : TypeReference>() {}) val tree = classes.buildTree() val icalls = mutableSetOf() classes.forEach { clazz -> clazz.generate(this, tree, icalls) } val iCallFileSpec = FileSpec .builder("godot.icalls", "__icalls") .addFunction(generateICallsVarargsFunction()) .addImport("kotlinx.cinterop", "set", "get", "pointed") icalls.forEach { iCallFileSpec.addFunction(it generateICall tree) } this.parentFile.mkdirs() iCallFileSpec .addComment("THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD") .build() .writeTo(this) generateEngineTypesRegistration(classes).writeTo(this) } private fun generateICallsVarargsFunction(): FunSpec { return FunSpec .builder("_icall_varargs") .addModifiers(KModifier.INTERNAL) .returns(ClassName("godot.core", "Variant")) .addParameter( "mb", ClassName("kotlinx.cinterop", "CPointer") .parameterizedBy(ClassName("godot.gdnative", "godot_method_bind")) ) .addParameter( "inst", ClassName("kotlinx.cinterop", "COpaquePointer") ) .addParameter( "arguments", ClassName("kotlin", "Array").parameterizedBy(STAR) ) .addStatement( """return %M { | val args = %M<%T<%M>>(arguments.size) | for ((i,arg) in arguments.withIndex()) args[i] = %T.wrap(arg)._handle.ptr | val result = %T.gdnative.godot_method_bind_call!!.%M(mb, inst, args, arguments.size, null) | for (i in arguments.indices) %T.gdnative.godot_variant_destroy!!.%M(args[i]) | %T(result) |} |""".trimMargin(), MemberName("kotlinx.cinterop", "memScoped"), MemberName("kotlinx.cinterop", "allocArray"), ClassName("kotlinx.cinterop", "CPointerVar"), MemberName("godot.gdnative", "godot_variant"), ClassName("godot.core", "Variant"), ClassName("godot.core", "Godot"), MemberName("kotlinx.cinterop", "invoke"), ClassName("godot.core", "Godot"), MemberName("kotlinx.cinterop", "invoke"), ClassName("godot.core", "Variant") ) .build() } private fun generateEngineTypesRegistration(classes: List): FileSpec { val funBuilder = FunSpec.builder("registerEngineTypes") .addModifiers(KModifier.INTERNAL) .receiver(ClassName("godot.core", "TypeManager")) classes.filter { !it.isSingleton && it.newName != "Object" && it.shouldGenerate}.forEach { funBuilder.addStatement( "registerEngineType(%S, ::%T)", it.newName, ClassName(it.newName.getPackage(), it.newName) ) } return FileSpec.builder("godot", "registerEngineTypes") .addFunction( funBuilder.build() ) .build() } ================================================ FILE: buildSrc/src/main/kotlin/godot/tasks/GenerateApiTask.kt ================================================ package godot.tasks import org.gradle.api.DefaultTask import org.gradle.api.tasks.InputFile import org.gradle.api.tasks.OutputDirectory import org.gradle.api.tasks.TaskAction import godot.codegen.generateApiFrom open class GenerateApiTask : DefaultTask() { @InputFile val source = project.objects.fileProperty() @OutputDirectory val outputDirectory = project.objects.directoryProperty() @TaskAction fun generateAPI() { // First, we clear output directory outputDirectory.get().asFile.deleteRecursively() outputDirectory.asFile.get() generateApiFrom source.asFile.get() } } ================================================ FILE: buildSrc/src/main/kotlin/os.kt ================================================ import org.gradle.internal.os.OperatingSystem enum class OS { LINUX, MACOS, WINDOWS } val currentOS by lazy { val current = OperatingSystem.current() when { current.isLinux -> OS.LINUX current.isMacOsX -> OS.MACOS current.isWindows -> OS.WINDOWS else -> throw AssertionError("Unsupported os: ${current.name}") } } ================================================ FILE: design-docs/ABOUT.md ================================================ This folder contains decisions we made and why we made them. It exists for us to remember why we made a certain decision and for new contributors to better understand how the binding works and we certain things are the way they are. Contents: - [Dictionary](dictionary.md) ================================================ FILE: design-docs/dictionary.md ================================================ This is an example of how pages inside this category might look like: --- ## Criteria The next section list down several `Dictionary` implementations, sighting how it compares to a `kotlin.MutableMap` - specifically in the following key areas: 1. Setting a value 2. Getting a value 3. Iteration. Additionally, it will also compare the implementation to how a `Dictionary` is used in GDScript. ## Implementations ### [1] Using Variant and specialized methods (current) ```kotlin class Dictionary : Iterable> { fun set(key: Long, value: Long) fun set(key: Long, value: Double) // and so on fun set(key: String, value: Long) fun set(key: String, value: Double) // and so on fun get(key: Long): Variant fun get(key: String): Variant // and so on } ``` The idea behind this implementation is to prevent the user from passing on a *wrong value type* to the `Dictionary` by providing specialized methods that only accept the correct value types. *wrong value type*s are either types that can't be converted to a `Variant` or types that when passed to a `Variant` losses it's type identity - an example of this are the `Int` and `Float` types as `Variant` only work with the mentioned type's wider cousins: `Long` and `Double`, respectively. When creating a `Variant` from an `Int`, the value will be converted to a `Long` first before storing it - so when unwrapping the value from the `Variant` it's impossible to know if the initial value passed to it was an `Int` or a `Long`. **Setting a value** ```kotlin dic[1L] = 2L dic["hello"] = 0.5 dic[1] = "hi" // does not compile, key here is an Int dic["foo"] = 0.1f // does not compile, value here is a Float dic[SomeKotlinClass()] = 2L // does not compile as SomeKotlinClass is not Variant compatible ``` In this area, setting a value is similar with `kotlin.MutableMap`. **Getting a value** ```kotlin dic["hello"].asString() // returns a variant, use asXXX to convert it to the expected type dic.get("hello", 1L) // returns a Long value with a default of 1L if not present ``` In a way the second line is similar to how a `kotlin.MutableMap` works, however in the first line you to deal with a `Variant` first then convert it to the expected type. **Iteration** ```kotlin dic.forEach { (keyAsVariant, valueAsVariant) -> // do something here } for ((keyAsVariant, valueAsVariant) in dic) { // do something here } ``` It is almost similar to `kotlin.MutableMap` however the biggest downside is you have to deal with `Variant`s. **GDScript comparison** ```kotlin dic[1] = 2 dic["hello"] = 0.5 dic[1] = "hi" dic["foo"] = 0.1 print(dic["Hello"]) // no explicit Variant conversion. ``` Everything is a `Variant` in GDScript, but the type itself is not exposed to users - but they are automatically converted. The problems with `Int` and `Float` is not present here because GDScript is using `Long` and `Double` for natural and real numbers, respectively. If you think about it a `Variant` in Kotlin parlance is `Any`, while in C# it is an `object`. ### [2] Dictionary extending AbstractMutableMap ```kotlin class Dictionary : AbstractMutableMap() { // ... } ``` This is inspired by Godot C#, essentially `Dictionary` is a `IMap`. The idea behind this implementation is to make usage of `Dictionary` idiomatic in Kotlin but retains its behaviour in GDScript (i.e, You can assign any key and value - as long as they are `Variant` compatible). A big bonus we get here is that we can use all the API defined for `kotlin.MutableMap`. **Setting a value** ```kotlin dic[1L] = 2L dic["hello"] = 0.5 dic[1] = "hi" // compiles but the type of they key when queried will be a Long (1) dic["foo"] = 0.1f // compiles but the type of the value when queried will be a Double (2) dic[SomeKotlinClass()] = 2L // compiles but fails at runtime because SomeKotlinClass is not Variant compatible (3) ``` In a way it's similar to the first implementation except for the last three lines: (1) and (2) will lose the type information of it's key and value, respectively - but alternatively we can change the behaviour to throw an exception at runtime in a [fail-fast](https://en.wikipedia.org/wiki/Fail-fast) manner. Failing fast here means the user can pick up the mistake during development instead of discovering it after the code has been shipped. **Getting a value** ```kotlin dic["hello"] as String // explicit casting to a String dic.getOrDefault("Hello", 0) // returns an Int, via implicit casting. ``` Since values are `Any`, we have to cast to the appropriate type. This is similar to the first implementation, but doesn't use a `Variant` which in my honest opinion - shouldn't be used by users (It's not exposed in GDScript and C# - why should we? In C# it is only used to namespace: `Variant.Type` and `Variant.OP`: https://godotsharp.net/api/3.1.0/Godot.Variant/) **Iteration** ```kotlin dic.forEach { (keyAsAny, valueAsAny) -> // do something here } for ((keyAsAny, valueAsAny) in dic) { // do something here } ``` Again, similar to the first implementation but not using `Variant`. **GDScript Comparison** This has a lot of similarity with GDScript, specifically setting a value. The difference lies in retrieving the value, you have to cast to the expected type in Kotlin due to it being statically typed. Ignoring the difference in typing nature of Kotlin and GDScript, this implementation is equal to the GDScript one. ### [3] Typed Dictionary ```kotlin class Dictionary : AbstractMutableMap() { // ... } ``` This approach is a specialization of the second implementation where we allow users to specify more information about the types of its keys and values. This is the most idiomatic compared to the two previous implementation, essentially what you have here is a `kotlin.MutableMap` with a different name. One of the downside of this approach is that it's impossible to prevent users from using types that are not `Variant` compatible (i.e.`Dictionary`). **Setting a value** ```kotlin val dic: Dictionary = ... dic["Hello"] = 12 dic["Foo"] = true // does not compile, dic can only store Ints values dic[1] = 12 // does not compile, dic can only use String keys val dic: Dictionary = ... dic["Foo"] = true // works! dic[1] = 12 // works! ``` This approach allows you to restrict the type you can pass as its keys and values. If you want a `Dictionary` which behaves similarly in GDScript, then you can declare it as `Dictionary`. **Getting a value** ```kotlin val dic: Dictionary = ... var a = dic["Hello"] + 1 // works! ``` This is the area where this approach shines, you don't have to do any explicit casting to the expected type unless you declared it as `Dictionary`. **Iteration** ```kotlin val dic: Dictionary = ... dic.forEach { (key, value) -> // do something here } for ((key, value) in dic) { // do something here } ``` As mentioned in the previous section, this approach shines in reads - no more explicit casting to the expected type. **GDScript Comparison** This is very different to GDScript but it is more idiomatic in Kotlin. It is hard to compare how reads are done in both languages due to the difference in typing. ================================================ FILE: docs/.gitignore ================================================ site/ p3/ ================================================ FILE: docs/SUMMARY.md ================================================ * [Overview](src/doc/index.md) * [API differences](src/doc/api-differences.md) * [Supported platforms](src/doc/supported-platforms.md) * [Setting up]() * [Gradle](src/doc/setup/gradle.md) * [IDE](src/doc/setup/ide.md) * [User guide]() * [Classes](src/doc/user-guide/classes.md) * [Methods](src/doc/user-guide/methods.md) * [Signals](src/doc/user-guide/signals.md) * [Properties](src/doc/user-guide/properties.md) * [Contribution](src/doc/contribution.md) ================================================ FILE: docs/build.sh ================================================ #! /usr/bin/env bash set -e BASEDIR=$(dirname "$0") VIRTUALENV_DIR="$BASEDIR/p3" if [[ ! -d "$VIRTUALENV_DIR" ]]; then pip install virtualenv virtualenv -p python3 "$VIRTUALENV_DIR" source "$VIRTUALENV_DIR/bin/activate" pip install -r requirements.txt fi mkdocs build ================================================ FILE: docs/mkdocs.yml ================================================ site_name: Kotlin Native binding for Godot docs_dir: src/doc repo_name: 'utopia-rise/godot-kotlin' repo_url: 'https://github.com/utopia-rise/godot-kotlin' theme: name: material favicon: assets/img/favicon.ico palette: primary: indigo accent: light-blue logo: assets/img/logo.png extra: social: - type: 'github' link: 'https://github.com/utopia-rise' markdown_extensions: - codehilite: linenums: true - pymdownx.inlinehilite - admonition nav: - Overview: index.md - API differences: api-differences.md - Supported platforms: supported-platforms.md - Setting up: - Gradle: setup/gradle.md - IDE: setup/ide.md - User guide: - Classes: user-guide/classes.md - Methods: user-guide/methods.md - Signals: user-guide/signals.md - Properties: user-guide/properties.md - Contribution: contribution.md ================================================ FILE: docs/requirements.txt ================================================ mkdocs-material==4.6.0 mkdocs==1.0.4 ================================================ FILE: docs/run.sh ================================================ #! /usr/bin/env bash set -e BASEDIR=$(dirname "$0") VIRTUALENV_DIR="$BASEDIR/p3" if [[ ! -d "$VIRTUALENV_DIR" ]]; then pip install virtualenv virtualenv -p python3 "$VIRTUALENV_DIR" source "$VIRTUALENV_DIR/bin/activate" pip install -r requirements.txt else source "$VIRTUALENV_DIR/bin/activate" fi mkdocs serve ================================================ FILE: docs/src/doc/api-differences.md ================================================ ## Instance types and singletons Creating a new instance of a Godot type can be done like any Kotlin types. ```kotlin val spatial = Spatial() val vec = Vector3() ``` Godot singletons are mapped as Kotlin objects. ```kotlin Physics2DServer.areaGetTransform(area) ``` ## Core types Godot's built-in types are passed by value (except for `Dictionary` and `VariantArray` - more on this later), so the following snippet won't work as expected. ```kotlin val spatial = Spatial() spatial.rotation.y += 10f ``` You are actually mutating a copy of the `rotation` property, not a reference to it. To get the desired behaviour you have to re-assign the copy back. ```kotlin val rotation = spatial.rotation rotation.y += 10f spatial.rotation = rotation ``` This approach introduces a lot of boilerplate, so this binding provides a concise way of achieving the same behaviour. ```kotlin spatial.rotation { y += 10f } ``` The snippet above is functionally equivalent to the previous one. ## Collection types While `VariantArray` and `Dictionary` are passed by reference, the value returned by the retrieval methods (`VariantArray.get(...)` and `Dictionary.get(...)`) are not. ```kotlin array.get(index).asVector3().y += 10f dictionary.get("foo").asVector3().y += 5f ``` To get the desired behaviour, you can re-assign the copy back or in a similar fashion as before, this binding provides a better alternative. ```kotlin array.get(index) { y += 10f } dictionary.get(index) { y += 5f } ``` ## Enums and constants Godot enums are mapped to Kotlin enums, the generated enum exposes a `value` property that represents the value in Godot. Constants in Godot classes that represent an enum value (such as `Node.PAUSE_MODE_INHERIT`) are not present in this binding, please use the generated enum instead (`Node.PauseMode.INHERIT`). ## Signals and exposed methods In GDScript, signals and methods can have any number of arguments, this is not possible in Kotlin as it is a statically typed language. At the moment, you can create signals and expose methods to Godot with at most 10 parameters. Additionally, signals are mapped to properties of type `Signal` and must start with a prefix `signal` (check [Signals](user-guide/signals.md) section for more details). The prefix is dropped during registration, so the signal `signalReverseChanged` is known in Godot as `reverse_changed`. This is done to avoid naming conflicts with other members of a class. There is no signal type in GDScript, signals are only referenced by name so they can have the same name as methods and/or properties in the same class. ## Renamed symbols To avoid confusion and conflict with Kotlin types, the following Godot symbols are renamed. - `Array` -> `VariantArray` (to avoid confusion with a built-in type in Kotlin) - `PoolRealArray` -> `PoolFloatArray` (for naming consistency) - `Variant.asReal()` -> `Variant.asFloat()` (for naming consistency) ================================================ FILE: docs/src/doc/contribution.md ================================================ We encourage you to contribute to the project if you want. Even if you don't have any idea how the binding works or if it seems overwhelming at first, we're here to help you getting started. ## General We are working with the Code Owners feature of GitHub. This means each piece of code in our binding has a maintainer who is the "Owner" of said code. This maintainer is usually the one who implemented it or has the most knowledge about that particular part of the binding. General code may not have a specific "Owner". In this case the fallback is: all Maintainers. ## Before Contributing Before you start to invest your precious time in writing code that you want to contribute, consider following these guidelines. They are here to make the lives of all people involved easier. - If you have an idea or a bug you want to fix, first look if an issue already exists that describes this Feature/Bug. - If such a issue exists, and a person is already assigned, it means the assigned person is working on it. But don't go away yet! Maybe this person could need your help, or you have some valuable input for the topic. - If the issue exists, but no one is assigned. You are free to state your interest in implementing/fixing the issue. But don't just start working. To prevent multiple people working on the same issue, we need to know you're working on it. Write in the issue, so we can assign it to you. - If the issue does not yet exist, open one and describe as best as you can, what your idea/what the bug is you want to tackle. The provided templates are a good starting point. ## Discussions Most of our discussions are happening on Discord. So if you have Discord or don't mind starting using it, feel free to [join](https://discord.gg/qSU2EQs) our server. But don't worry if you don't have or want to use Discord. Then the discussions are just in the corresponding issue. If you discuss on Discord though: don't forget to document all relevant outcome in the corresponding issue. If you have critique or an opinion on a discussed topic, please be kind and give valuable feedback. If you are on the receiving end of the critique: don't take it personally. Many people are no native english speaker and it can happen that something which is not rude at all in the language of the writer, might sound rude in english. ================================================ FILE: docs/src/doc/index.md ================================================ [![GitHub](https://img.shields.io/github/license/utopia-rise/godot-kotlin?style=flat-square)](LICENSE) [![GitHub Workflow Status](https://img.shields.io/github/workflow/status/utopia-rise/godot-kotlin/CI?style=flat-square)](https://github.com/utopia-rise/godot-kotlin/actions?query=workflow%3ACI) godot-kotlin is a Kotlin Native binding for the Godot game engine which allows you to write your game's logic in Kotlin. If you are new to this binding, it is recommended to read through versioning section of this page, and the API differences section which describes main differences between Godot's in-house scripting language GDScript and this binding. Also, make sure you have read and understood the important notes section. For questions and further information, head over to [discord](https://godot-kotl.in). ## Versioning The binding uses semantic versioning for its own versions but adds a suffix for the supported godot version: `0.1.0-3.2` Binding Version: `0.1.0` Supported Godot Version: `3.2` ## Important notes This version of the binding is currently in **Alpha** state and by no means production ready! This state will not change in the near foreseeable future. The Kotlin Native performance is not where it needs to be to make this binding efficient. Currently, the build times are incredibly slow due to the lack of incremental build support in Kotlin Native. Also, the runtime performance is much slower than GDScript in many cases. The only case where this binding shines at the moment is in computation heavy scenarios like implementing an A* pathfinding algorithm where not many calls through the cinterop layer of K/N are necessary. In all other cases were many calls are needed, like Input checking and small logic in function like `_process`, the performance is not great because of the current performance of the K/N cinterop layer. We were and are in touch with JB regarding those issues on youtrack and slack: [KT-40652](https://youtrack.jetbrains.com/issue/KT-40652) and [KT-40679](https://youtrack.jetbrains.com/issue/KT-40679) To still be able to use kotlin in a performant way, we started another project [(godot-jvm)](https://github.com/utopia-rise/godot-jvm/) which leverages an embedded JVM to use kotlin on the JVM rather than native. On our first tests, this increases performance dramatically and one can leverage the full JVM ecosystem. Head over there to see development updates. This binding will not die though. We will provide bugfixes for existing bugs if necessary, keep it as up to date as our time allows us to do, but we will not improve tooling or add new features until the performance of K/N is more acceptable. ================================================ FILE: docs/src/doc/setup/gradle.md ================================================ This binding uses [Gradle](https://gradle.org) as its build tool and you will need version 6.0 or higher installed. The next requirement is to have a Godot project (obviously!), if you don't have it yet please create one. Open a terminal and `cd` to root directory of your Godot project. ## Wrapper On this step, we will be setting up a Gradle [wrapper](https://docs.gradle.org/current/userguide/gradle_wrapper.html). The wrapper will ensure that anyone who wants to build your project from source will use the same gradle version. ```shell touch build.gradle.kts gradle.properties settings.gradle.kts ``` The above command will create three files, which will be empty for now. ```shell gradle wrapper --gradle-version=6.5.1 ``` That is it, you have the wrapper installed! The command will produce several files, but the important ones are `gradlew` and `gradlew.bat`. Moving forward we will be using `gradlew` to run gradle (`gradlew.bat` on Windows). The first time `gradlew` is used it will download the gradle version you have specified before. ## Configuring gradle Once you have the wrapper installed, we need to set up the Gradle plugin provided by this binding. Without the plugin, you will have to manually generate the entry point, `.gdnlib` and `.gdns` files. **build.gradle.kts** !!! important "" Replace `` and `godot-kotlin-version>` with the appropriate kotlin and godot-kotlin versions, respectively. ```kotlin plugins { kotlin("multiplatform") version "" id("com.utopia-rise.godot-kotlin") version "" } repositories { jcenter() mavenCentral() // if you want to use bleeding edge builds maven("https://dl.bintray.com/utopia-rise/godot-kotlin-dev") } godot { // Build a debug binary debug.set(true) // Configure to build for all supported platforms. defaultPlatforms() } ``` **gradle.properties** !!! important "" We need to give the gradle enough memory as the default settings is not enough for the Kotlin Native compiler. ```properties org.gradle.jvmargs=-Xmx3G ``` **settings.gradle.kts** !!! danger "" This section is optional and is only required if you are using a bleeding edge build. ```kotlin pluginManagement { repositories { jcenter() gradlePluginPortal() maven("https://dl.bintray.com/utopia-rise/godot-kotlin-dev") } resolutionStrategy.eachPlugin { when (requested.id.id) { "com.utopia-rise.godot-kotlin" -> useModule("com.utopia-rise:godot-gradle-plugin:${requested.version}") } } } ``` ## Importing project into IntelliJ IDEA Before proceeding to the next section, follow [this guide](ide.md) on how to import your project into IntelliJ IDEA. ## Creating your first class Let's create a file `src/godotMain/kotlin/Simple.kt` with the following contents. ```kotlin import godot.* import godot.annotation.* import godot.core.* @RegisterClass class Simple: Spatial() { @RegisterFunction override fun _ready() { GD.print("Hello Godot from Kotlin!") } } ``` `@RegisterClass` will register the annotated class to Godot. More details can be found in the [classes](../user-guide/classes.md) section of the user guide Now we can trigger a build. ```shell ./gradlew build ``` !!! note "" The plugin automatically generates the appropriate `gdns` files which can be found at `src/gdns`. It is up to you whether you want to include those files in source control or not. Once the build completes, a file `src/gdns/Simple.gdns` is generated. You can use `Simple.gdns` in Godot when assigning a script to a node. ![Attach Node Script](../assets/img/attach.png) ## Configuring target platforms Using `defaultPlatforms()` will configure the build to build for all supported platforms. If you want to specify specific platforms, you can do this via the `platforms` property of `godot`. ```kotlin import godot.gradle.GodotPlatform godot { platforms(GodotPlatform.WINDOWS_X64) } ``` ## All Godot plugin configurations | Property | Type | Description | |-----------------------|---------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | debug | Boolean | Sets if a debug or a release build should be built. **Note:** as of kotlin version `1.3.72` release builds are broken on the kotlin side! | | gdnsDir | File | Changes the default (`src/gdns/`) output dir for generated gdns files | | gdnlibFile | File | You can set the name `gdnlib` file yourself if you want to create it yourself or don't want the generated one to be named `lowercasedProjectName.gdnlib` | | singleton | Boolean | Sets the `singleton` property inside the generated `gdnlib` file | | loadOnce | Boolean | Sets the `load_once` property inside the generated `gdnlib` file | | reloadable | Boolean | Sets the `reloadable` property inside the generated `gdnlib` file | | platforms | List | Sets the targets platforms | ================================================ FILE: docs/src/doc/setup/ide.md ================================================ You will need either [IntelliJ IDEA](https://jetbrains.com/idea) (Ultimate is preferred but the Community edition works too!) or [CLion](https://www.jetbrains.com/clion/) (**Note:** as of kotlin version `1.4` the CLion Kotlin/Native plugin is deprecated! Use Intellj IDEA if you are using kotlin version `1.4` or above!). The easiest way to install them is via the [JetBrains Toolbox](https://www.jetbrains.com/toolbox-app/) app. ## Kotlin plugin Regardless of what IDE you choose, you need to install the appropriate Kotlin plugin. This can be done within the IDE (`Settings -> Plugins`). You have to install `Kotlin` plugin for IntelliJ IDEA while install `Kotlin/Native for CLion` plugin for CLion. ## Importing Once you have the plugin installed, you can start importing your project. ![Import](../assets/img/import.png) Click `Import Project` and select your project's `build.gradle.kts` file. The IDE will take some time to index your project, but once done you can start coding! ================================================ FILE: docs/src/doc/supported-platforms.md ================================================ While Kotlin Native and Godot supports a wide range of platforms, this binding for the moment only supports the following: - Windows X64 - Linux X64 - MacOS X64 Mobile platforms such as Android and iOS will be supported at a later date. ================================================ FILE: docs/src/doc/user-guide/classes.md ================================================ To expose a class written in Kotlin it needs to extend `godot.Object` (or any type that extends it) and annotate it with `@RegisterClass`. ```kotlin @RegisterClass class RotatingCube: Spatial() { ... } ``` ## Lifecycle If you want to be notified when initialization and destruction of your class happens, override `_onInit` and `_onDestroy` functions, respectively. ```kotlin @RegisterClass class RotatingCube: Spatial() { override fun _onInit() { GD.print("Initializing RotatingCube!") } override fun _onDestroy() { GD.print("Cleaning up RotatingCube!") } } ``` `_onInit` is equivalent to GDScript's constructor `_init`, however, `_onInit` and `_onDestroy` are handled directly by this binding, not Godot. ## Instance checks Checking if an object is an instance of a particular type can be done via the `is` operator. ```kotlin @RegisterFunction override fun _ready() { val parent = getParent() if (parent is CollisionShape) { // smart cast works! parent.setShape(...) } else { throw AssertionError("Unexpected parent!") } } ``` This also works for any type you define. If you are sure that an object is always an instance of some type, then you can take advantage of Kotlin's [contracts](https://kotlinlang.org/docs/reference/whatsnew13.html#contracts) feature. ```kotlin @RegisterFunction override fun _ready() { val parent = getParent() require(parent is CollisionShape) // smart cast works here as well! parent.setShape(...) } ``` ## Registration Configuration You can customize to some extent how your class should be registered in Godot: The `@RegisterClass` annotation can take one argument: - **isTool**: If set to true, this class is treated as a tool class. Similar to the `tool` of GDScript. **Default:** false ## What's next? - [Registering properties](properties.md) - [Registering functions](methods.md) - [Registering signals](signals.md) ================================================ FILE: docs/src/doc/user-guide/methods.md ================================================ Any Kotlin function can be registered as long as its parameters and return type can be converted to a `Variant`, additionally the function must be annotated with `@RegisterFunction`. This binding only support methods with at most 10 parameters at the moment. ```kotlin @RegisterClass class RotatingCube: Spatial() { @RegisterFunction override fun _ready() { GD.print("I am ready!") } } ``` !!! important "" All methods that you register, are registered in `snake_case`! So `myVeryCoolFunction` will become `my_very_cool_function`. This is done for easier GDScript integration and that Godot can properly call overridden virtual functions from other languages. Keep this in mind when calling kotlin functions from other languages or when using functions like `call` and not using our extension functions which handle the conversion for you! ## Virtual methods Virtual methods (like `_ready`, `_process` and `_physics_process`) are declared as overridable methods. The default implementation throws a `NotImplementedException`, so you have to override it if you plan to expose a virtual method to Godot. Remember; just overriding is not enough to use that function. You have to explicitly register it as well with `@RegisterFunction` like you have to with your own methods. ## Registration Configuration You can customize to some extent how your function should be registered in Godot: The `@RegisterFunction` annotation takes one argument: - **rpcMode**: Default: `RPCMode.DISABLED` ================================================ FILE: docs/src/doc/user-guide/properties.md ================================================ Any property of a registered class can be registered as long as it meets all of the following requirements: - Defined inside a registered class - Mutable - Annotated with `@RegisterProperty` - Type can be converted to `Variant` ```kotlin @RegisterClass class RotatingCube: Spatial() { @RegisterProperty lateinit var lateInitProperty: NodePath @RegisterProperty var propertyWithDefaultValue: Float = 2f } ``` !!! important "" All properties that you register, are registered in `snake_case`! So `myVeryCoolProperty` will become `my_very_cool_property`. This is done for easier GDScript integration. Keep this in mind when interacting with kotlin properties from other languages. ## Default Values If you define a default value for a property and `visibleInEditor` (more on that later) is set to `true`, the default value will be set in the `inspector`. **Note:** If you set a default value in code and a different value in the `inspector` the value of the `inspector` will override the value in code after `init` and before `_ready`! A default value can **only** contain compile time constants and only References to compile time constants! Better you only use refs where you have no other choice like for Enums. We try to catch all wrong references during compilation and throw a corresponding exception but we may have missed some cases which then only occur during runtime. ## Registration Configuration You can customize to some extent how your property should be registered in Godot: The `@RegisterProperty` annotation takes two arguments: - **visibleInEditor**: If set to `true` the property is visible in the `inspector`. Default: `true` - **rpcMode**: Default: `RPCMode.DISABLED` ## Type Hint Registration This binding provides a plethora of annotations for defining Property Type Hints. These annotations are for the `inspector` to provide proper hints and editors to set and change values from within the inspector (like a color wheel, checkboxes, file dialogs, and so on...). Each property hint annotation can only be added to certain types of properties. Currently, the checks if the type is correct happens during compilation as we do not have an IDEA plugin yet. If the type is not correct, the compilation will fail. Below is a list of currently implemented type hints: | Annotation | Type of Property | Arguments | Short Description | |-----------------|----------------------------|-----------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------| | IntRange | Int | start: Int, end: Int, step: Int = -1, or: Range = Range.NONE | Provides a range of ints from start to end, with optional steps, and optional `lesser or greater` | | FloatRange | Float | start: Float, end: Float, step: Float = -1, or: Range = Range.NONE | Provides a range of floats from start to end, with optional steps, and optional `lesser or greater` | | DoubleRange | Double | start: Double, end: Double, step: Double = -1, or: Range = Range.NONE | Provides a range of doubles from start to end, with optional steps, and optional `lesser or greater` | | ExpRange | Float Double | start: Float, end: Float, step: Float = -1, or: Range = Range.NONE | Provides a exponential range of doubles or floats from start to end, with optional steps, and optional `lesser or greater` | | EnumTypeHint | Enum | | Registers an enum. The editor then provides a selection of the possible enum values | | ExpEasing | Float Double | attenuation: Boolean = false, inOut: Boolean = true | N/A | | EnumFlag | Set MutableSet | | Registers a flag with the enum names set as the flag names. The values in the set define which flags are set. | | IntFlag | Int | names: vararg String | Same as enum flag but the `names` set which values can be set in the inspector and no automatic conversion to the individual flag values happen. | | File | String | extensions: Array = [], global: Boolean = false | The inspector will show a File dialog in which you can select a File. The Path of the file will be stored in the property. | | Dir | String | global: Boolean = false | The inspector will show a File dialog in which you can select a directory. The Path of the directory will be stored in the property. | | MultilineText | String | | The inspector shows a multiline text input. | | PlaceHolderText | String | | N/A | | ColorNoAlpha | Color | | The inspector shows a color selection dialog without Alpha | ================================================ FILE: docs/src/doc/user-guide/signals.md ================================================ Use the delegate `signal` to create a signal and annotate it with `@RegisterSignal`. Note that the name of the signal must start with a prefix `signal` (see [API differences](../api-differences.md) section for an explanation). This binding only supports signals with at most 10 parameters at the moment. ```kotlin @RegisterClass class RotatingCube: Spatial() { @RegisterSignal val signalReverseChanged by signal("reverse") } ``` !!! important "" All signals that you register, are registered in `snake_case`! Also the `signal` prefix will be dropped (like described in [API differences](../api-differences.md)). So `signalVeryCoolSignal` will become `very_cool_signal`. This is done for easier GDScript integration. Also in GDScript signals can have the same name as properties, which is not possible in kotlin as signals **are** properties. Keep this in mind when interacting with in kotlin defined signals from other languages or when using functions like `emit` from an `Object` rather from the signal property. ## Emitting Every signal has a `emit` method which can be used to emit it. ```kotlin signalReverseChanged.emit(false) ``` ## Subscribing A method can be subscribed/connected to a signal via `connect`. The number of parameters of the method and signal must match. ```kotlin class SomeObject: Object() { fun onReverseChanged(reverse: Boolean) { GD.print("Value of reverse has changed: $reverse") } } val targetObject = SomeObject() signalReverseChanged.connect(targetObject, targetObject::onReverseChanged) ``` ================================================ FILE: entry-generation/godot-annotation-processor/build.gradle.kts ================================================ plugins { kotlin("jvm") `maven-publish` } dependencies { implementation(project(":godot-entry-generator")) implementation("de.jensklingenberg:mpapt-runtime:${DependenciesVersions.mpaptVersion}") compileOnly(kotlin("compiler")) } tasks { val sourceJar by creating(Jar::class) { archiveBaseName.set(project.name) archiveVersion.set(project.version.toString()) archiveClassifier.set("sources") from(sourceSets["main"].allSource) } build { finalizedBy(publishToMavenLocal) } } publishing { publications { val godotAnnotationProcessor by creating(MavenPublication::class) { pom { groupId = "${project.group}" artifactId = project.name version = "${project.version}" } from(components.getByName("java")) artifact(tasks.getByName("sourceJar")) } } } project.extra["artifacts"] = arrayOf("godotAnnotationProcessor") apply { plugin(BintrayPublish::class.java) } ================================================ FILE: entry-generation/godot-annotation-processor/src/main/kotlin/godot/annotation/processor/GodotAnnotationProcessor.kt ================================================ package godot.annotation.processor import de.jensklingenberg.mpapt.model.AbstractProcessor import de.jensklingenberg.mpapt.model.Element import de.jensklingenberg.mpapt.model.RoundEnvironment import de.jensklingenberg.mpapt.utils.KotlinPlatformValues import godot.entrygenerator.EntryGenerator import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.platform.TargetPlatform import org.jetbrains.kotlin.resolve.BindingContext import java.lang.instrument.IllegalClassFormatException class GodotAnnotationProcessor( private val entryGenerationOutputDir: String, private val gdnsGenerationOutputDir: String, private val gdnlibGenerationOutputFile: String, private val cleanGeneratedGdnsFiles: Boolean ) : AbstractProcessor() { lateinit var bindingContext: BindingContext override fun getSupportedAnnotationTypes(): Set = setOf( "godot.annotation.RegisterClass", "godot.annotation.RegisterProperty", "godot.annotation.RegisterFunction", "godot.annotation.RegisterSignal" ) override fun isTargetPlatformSupported(platform: TargetPlatform): Boolean { return when (val targetName = platform.first().platformName) { KotlinPlatformValues.JS -> false KotlinPlatformValues.JVM -> false KotlinPlatformValues.NATIVE -> true else -> { log("Unknown configured target: $targetName") false } } } private val classes: MutableSet = mutableSetOf() private val properties: MutableSet = mutableSetOf() private val functions: MutableSet = mutableSetOf() private val signals: MutableSet = mutableSetOf() override fun process(roundEnvironment: RoundEnvironment) { classes.addAll( roundEnvironment .getElementsAnnotatedWith("godot.annotation.RegisterClass") .map { it as Element.ClassElement } .map { it.classDescriptor } ) properties.addAll( roundEnvironment .getElementsAnnotatedWith("godot.annotation.RegisterProperty") .map { it as Element.PropertyElement } .map { it.propertyDescriptor } ) functions.addAll( roundEnvironment .getElementsAnnotatedWith("godot.annotation.RegisterFunction") .map { it as Element.FunctionElement } .map { it.func } ) signals.addAll( roundEnvironment .getElementsAnnotatedWith("godot.annotation.RegisterSignal") .map { it as Element.PropertyElement } .map { it.propertyDescriptor } ) performSanityChecks() } private fun performSanityChecks() { classes.forEach { if (it.constructors.size > 1) { throw IllegalClassFormatException("A Class annotated with \"@RegisterClass\" can only have a default constructor!\nBut ${it.name} contains ${it.constructors.size} constructors") } } functions.forEach { if (!classes.contains(it.containingDeclaration)) { throw Exception("${it.containingDeclaration.name.asString()} contains a registered function: ${it.name} but is not annotated with @RegisterClass! Classes containing functions which are registered, also have to be registered!") } } properties.forEach { if (!classes.contains(it.containingDeclaration)) { throw Exception("${it.containingDeclaration.name.asString()} contains a registered property: ${it.name} but is not annotated with @RegisterClass! Classes containing properties which are registered, also have to be registered!") } } signals.forEach { if (!classes.contains(it.containingDeclaration)) { throw Exception("${it.containingDeclaration.name.asString()} contains a signal: ${it.name} but is not annotated with @RegisterClass! Classes containing signals, also have to be registered!") } } } override fun processingOver() { val entryGenerator = EntryGenerator(bindingContext) entryGenerator.generateEntryFile(entryGenerationOutputDir, classes, properties, functions, signals) entryGenerator.generateGdnsFiles( gdnsGenerationOutputDir, gdnlibGenerationOutputFile, cleanGeneratedGdnsFiles, classes ) } } ================================================ FILE: entry-generation/godot-compiler-native-plugin/build.gradle.kts ================================================ import com.github.jengelman.gradle.plugins.shadow.ShadowExtension import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar buildscript { repositories { jcenter() } dependencies { classpath("com.github.jengelman.gradle.plugins:shadow:${DependenciesVersions.shadowJarPluginVersion}") } } plugins { kotlin("jvm") `maven-publish` } apply(plugin = "com.github.johnrengelman.shadow") val embeddable by configurations.creating { extendsFrom(configurations.implementation.get()) } dependencies { implementation(project(":godot-annotation-processor")) implementation(project(":godot-compiler-plugin-common")) implementation("de.jensklingenberg:mpapt-runtime:${DependenciesVersions.mpaptVersion}") compileOnly(kotlin("compiler")) } val shadowJar by tasks.getting(ShadowJar::class) { configurations = listOf(embeddable) @Suppress("UnstableApiUsage") manifest { attributes["Implementation-Title"] = "Godot Kotlin Native Compiler Plugin" attributes["Implementation-Version"] = project.version attributes["Main-Class"] = "godot.compilerplugin.NativeComponentRegistrar" } archiveBaseName.set("godot-compiler-native-plugin") archiveVersion.set(project.version.toString()) val classifier: String? = null //needed as we need to specify the type null represents. otherwise we get ambiguous overload exception during build archiveClassifier.set(classifier) } tasks { val sourceJar by creating(Jar::class) { archiveBaseName.set(project.name) archiveVersion.set(project.version.toString()) archiveClassifier.set("sources") from(sourceSets["main"].allSource) } build { finalizedBy(publishToMavenLocal) } } publishing { publications { val shadow by creating(MavenPublication::class) { pom { groupId = "${project.group}" artifactId = project.name version = "${project.version}" } project.extensions.getByType(ShadowExtension::class).component(this) artifact(tasks.getByName("sourceJar")) } } } project.extra["artifacts"] = arrayOf("shadow") apply { plugin(BintrayPublish::class.java) } ================================================ FILE: entry-generation/godot-compiler-native-plugin/src/main/kotlin/godot/compiler/plugin/NativeComponentRegistrar.kt ================================================ package godot.compiler.plugin import com.intellij.mock.MockProject import de.jensklingenberg.mpapt.common.MpAptProject import godot.annotation.processor.GodotAnnotationProcessor import org.jetbrains.kotlin.backend.common.extensions.IrGenerationExtension import org.jetbrains.kotlin.backend.common.extensions.IrPluginContext import org.jetbrains.kotlin.compiler.plugin.* import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor import org.jetbrains.kotlin.ir.declarations.IrModuleFragment class NativeComponentRegistrar : ComponentRegistrar { override fun registerProjectComponents(project: MockProject, configuration: CompilerConfiguration) { val enabled = checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.ENABLED)) { "enabled parameter missing" } if (enabled) { val processor = GodotAnnotationProcessor( checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.ENTRY_DIR_PATH)) { "No path for generated entry file specified" }, checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.GDNS_DIR_PATH)) { "No path for generated gdns files specified" }, checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.GDNLIB_FILE_PATH)) { "No path for generated gdnlib file specified" }, checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.CLEAN_GENERATED_GDNS_FILES)) { "No clean generated gdns files option specified" } ) val mpapt = MpAptProject(processor, configuration) StorageComponentContainerContributor.registerExtension(project, mpapt) IrGenerationExtension.registerExtension(project, object : IrGenerationExtension { override fun generate(moduleFragment: IrModuleFragment, pluginContext: IrPluginContext) { processor.bindingContext = pluginContext.bindingContext mpapt.generate(moduleFragment, pluginContext) } }) } } } class NativeGodotKotlinCompilerPluginCommandLineProcessor : CommandLineProcessor { companion object { val GDNS_DIR_PATH_OPTION = CliOption( CompilerPluginConst.CommandLineOptionNames.gdnsDirPathOption, "Absolute Path as String", CompilerPluginConst.CommandlineArguments.GDNS_DIR_PATH.toString(), required = true, allowMultipleOccurrences = false ) val GDNLIB_FILE_PATH_OPTION = CliOption( CompilerPluginConst.CommandLineOptionNames.gdnlibFileOption, "Absolute Path as String", CompilerPluginConst.CommandlineArguments.GDNLIB_FILE_PATH.toString(), required = true, allowMultipleOccurrences = false ) val ENTRY_DIR_PATH_OPTION = CliOption( CompilerPluginConst.CommandLineOptionNames.entryDirPathOption, "Absolute Path as String", CompilerPluginConst.CommandlineArguments.ENTRY_DIR_PATH.toString(), required = true, allowMultipleOccurrences = false ) val ENABLED = CliOption( CompilerPluginConst.CommandLineOptionNames.enabledOption, "Flag to enable entry generation", CompilerPluginConst.CommandlineArguments.ENABLED.toString(), required = true, allowMultipleOccurrences = false ) val CLEAN_GENERATED_GDNS_FILES = CliOption( CompilerPluginConst.CommandLineOptionNames.cleanGeneratedGdnsFiles, "Flag to enable entry generation", CompilerPluginConst.CommandlineArguments.CLEAN_GENERATED_GDNS_FILES.toString(), required = true, allowMultipleOccurrences = false ) const val PLUGIN_ID = CompilerPluginConst.compilerPluginId } override val pluginId = PLUGIN_ID override val pluginOptions = listOf( GDNS_DIR_PATH_OPTION, GDNLIB_FILE_PATH_OPTION, ENTRY_DIR_PATH_OPTION, ENABLED, CLEAN_GENERATED_GDNS_FILES ) override fun processOption(option: AbstractCliOption, value: String, configuration: CompilerConfiguration) { return when (option) { GDNS_DIR_PATH_OPTION -> configuration.put( CompilerPluginConst.CommandlineArguments.GDNS_DIR_PATH, value ) GDNLIB_FILE_PATH_OPTION -> configuration.put( CompilerPluginConst.CommandlineArguments.GDNLIB_FILE_PATH, value ) ENTRY_DIR_PATH_OPTION -> configuration.put( CompilerPluginConst.CommandlineArguments.ENTRY_DIR_PATH, value ) ENABLED -> configuration.put( CompilerPluginConst.CommandlineArguments.ENABLED, value.toBoolean() ) CLEAN_GENERATED_GDNS_FILES -> configuration.put( CompilerPluginConst.CommandlineArguments.CLEAN_GENERATED_GDNS_FILES, value.toBoolean() ) else -> throw CliOptionProcessingException("Unknown option: ${option.optionName}") } } } ================================================ FILE: entry-generation/godot-compiler-native-plugin/src/main/resources/META-INF/services/org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor ================================================ godot.compiler.plugin.NativeGodotKotlinCompilerPluginCommandLineProcessor ================================================ FILE: entry-generation/godot-compiler-native-plugin/src/main/resources/META-INF/services/org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar ================================================ godot.compiler.plugin.NativeComponentRegistrar ================================================ FILE: entry-generation/godot-compiler-plugin/build.gradle.kts ================================================ plugins { kotlin("jvm") `maven-publish` } dependencies { implementation(project(":godot-annotation-processor")) implementation(project(":godot-compiler-plugin-common")) implementation("de.jensklingenberg:mpapt-runtime:${DependenciesVersions.mpaptVersion}") compileOnly(kotlin("compiler")) } tasks { val sourceJar by creating(Jar::class) { archiveBaseName.set(project.name) archiveVersion.set(project.version.toString()) archiveClassifier.set("sources") from(sourceSets["main"].allSource) } build { finalizedBy(publishToMavenLocal) } } publishing { publications { val godotCompilerPlugin by creating(MavenPublication::class) { pom { groupId = "${project.group}" artifactId = project.name version = "${project.version}" } from(components.getByName("java")) artifact(tasks.getByName("sourceJar")) } } } project.extra["artifacts"] = arrayOf("godotCompilerPlugin") apply { plugin(BintrayPublish::class.java) } ================================================ FILE: entry-generation/godot-compiler-plugin/src/main/kotlin/godot/compiler/plugin/CommonComponentRegistrar.kt ================================================ package godot.compiler.plugin import com.intellij.mock.MockProject import de.jensklingenberg.mpapt.common.MpAptProject import godot.annotation.processor.GodotAnnotationProcessor import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension import org.jetbrains.kotlin.compiler.plugin.* import org.jetbrains.kotlin.config.CompilerConfiguration import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor import org.jetbrains.kotlin.js.translate.extensions.JsSyntheticTranslateExtension class CommonComponentRegistrar : ComponentRegistrar { override fun registerProjectComponents( project: MockProject, configuration: CompilerConfiguration ) { val enabled = checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.ENABLED)) { "enabled parameter missing" } if (enabled) { val processor = GodotAnnotationProcessor( checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.ENTRY_DIR_PATH)) { "No path for generated entry file specified" }, checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.GDNS_DIR_PATH)) { "No path for generated gdns files specified" }, checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.GDNLIB_FILE_PATH)) { "No path for generated gdnlib file specified" }, checkNotNull(configuration.get(CompilerPluginConst.CommandlineArguments.CLEAN_GENERATED_GDNS_FILES)) { "No clean generated gdns files option specified" } ) val mpapt = MpAptProject(processor, configuration) StorageComponentContainerContributor.registerExtension(project, mpapt) ClassBuilderInterceptorExtension.registerExtension(project, mpapt) JsSyntheticTranslateExtension.registerExtension(project, mpapt) } } } class CommonGodotKotlinCompilerPluginCommandLineProcessor : CommandLineProcessor { companion object { val GDNS_DIR_PATH_OPTION = CliOption( CompilerPluginConst.CommandLineOptionNames.gdnsDirPathOption, "Path to where the generated gdns files should be written to", CompilerPluginConst.CommandlineArguments.GDNS_DIR_PATH.toString(), required = true, allowMultipleOccurrences = false ) val GDNLIB_FILE_PATH_OPTION = CliOption( CompilerPluginConst.CommandLineOptionNames.gdnlibFileOption, "Absolute Path as String", CompilerPluginConst.CommandlineArguments.GDNLIB_FILE_PATH.toString(), required = true, allowMultipleOccurrences = false ) val ENTRY_DIR_PATH_OPTION = CliOption( CompilerPluginConst.CommandLineOptionNames.entryDirPathOption, "Path to where the generated entry file should be written to", CompilerPluginConst.CommandlineArguments.ENTRY_DIR_PATH.toString(), required = true, allowMultipleOccurrences = false ) val ENABLED = CliOption( CompilerPluginConst.CommandLineOptionNames.enabledOption, "Flag to enable entry generation", CompilerPluginConst.CommandlineArguments.ENABLED.toString(), required = true, allowMultipleOccurrences = false ) val CLEAN_GENERATED_GDNS_FILES = CliOption( CompilerPluginConst.CommandLineOptionNames.cleanGeneratedGdnsFiles, "Flag to enable entry generation", CompilerPluginConst.CommandlineArguments.CLEAN_GENERATED_GDNS_FILES.toString(), required = true, allowMultipleOccurrences = false ) const val PLUGIN_ID = CompilerPluginConst.compilerPluginId } override val pluginId = PLUGIN_ID override val pluginOptions = listOf( GDNS_DIR_PATH_OPTION, GDNLIB_FILE_PATH_OPTION, ENTRY_DIR_PATH_OPTION, ENABLED, CLEAN_GENERATED_GDNS_FILES ) override fun processOption(option: AbstractCliOption, value: String, configuration: CompilerConfiguration) { return when (option) { GDNS_DIR_PATH_OPTION -> configuration.put( CompilerPluginConst.CommandlineArguments.GDNS_DIR_PATH, value ) GDNLIB_FILE_PATH_OPTION -> configuration.put( CompilerPluginConst.CommandlineArguments.GDNLIB_FILE_PATH, value ) ENTRY_DIR_PATH_OPTION -> configuration.put( CompilerPluginConst.CommandlineArguments.ENTRY_DIR_PATH, value ) ENABLED -> configuration.put( CompilerPluginConst.CommandlineArguments.ENABLED, value.toBoolean() ) CLEAN_GENERATED_GDNS_FILES -> configuration.put( CompilerPluginConst.CommandlineArguments.CLEAN_GENERATED_GDNS_FILES, value.toBoolean() ) else -> throw CliOptionProcessingException("Unknown option: ${option.optionName}") } } } ================================================ FILE: entry-generation/godot-compiler-plugin/src/main/resources/META-INF/services/org.jetbrains.kotlin.compiler.plugin.CommandLineProcessor ================================================ godot.compiler.plugin.CommonGodotKotlinCompilerPluginCommandLineProcessor ================================================ FILE: entry-generation/godot-compiler-plugin/src/main/resources/META-INF/services/org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar ================================================ godot.compiler.plugin.CommonComponentRegistrar ================================================ FILE: entry-generation/godot-compiler-plugin-common/build.gradle.kts ================================================ plugins { kotlin("jvm") `maven-publish` } dependencies { compileOnly(kotlin("compiler")) } tasks { val sourceJar by creating(Jar::class) { archiveBaseName.set(project.name) archiveVersion.set(project.version.toString()) archiveClassifier.set("sources") from(sourceSets["main"].allSource) } build { finalizedBy(publishToMavenLocal) } } publishing { publications { val godotCompilerPluginCommon by creating(MavenPublication::class) { pom { groupId = "${project.group}" artifactId = project.name version = "${project.version}" } from(components.getByName("java")) artifact(tasks.getByName("sourceJar")) } } } project.extra["artifacts"] = arrayOf("godotCompilerPluginCommon") apply { plugin(BintrayPublish::class.java) } ================================================ FILE: entry-generation/godot-compiler-plugin-common/src/main/kotlin/godot/compiler/plugin/CompilerPluginConst.kt ================================================ package godot.compiler.plugin import org.jetbrains.kotlin.config.CompilerConfigurationKey object CompilerPluginConst { const val compilerPluginGroupId = "com.utopia-rise" const val compilerPluginArtifactId = "godot-compiler-plugin" const val compilerNativePluginArtifactId = "godot-compiler-native-plugin" const val compilerPluginId = "GodotCompilerPlugin" //Remember to change according to gradle.properties const val godotVersion = "3.2" object CommandLineOptionNames { const val gdnsDirPathOption = "gdns-dir-path" const val gdnlibFileOption = "gdnlib-file-path" const val entryDirPathOption = "entry-dir-path" const val enabledOption = "enabled" const val cleanGeneratedGdnsFiles = "clean-generated-gdns-files" } object CommandlineArguments { val GDNS_DIR_PATH: CompilerConfigurationKey = CompilerConfigurationKey.create("path to root of godot project") val GDNLIB_FILE_PATH: CompilerConfigurationKey = CompilerConfigurationKey.create("path to where the gdnlib file should be generated") val ENTRY_DIR_PATH: CompilerConfigurationKey = CompilerConfigurationKey.create("path to the folder in which the generated entry file should be written") val ENABLED: CompilerConfigurationKey = CompilerConfigurationKey.create("flag to enable entry generation") val CLEAN_GENERATED_GDNS_FILES: CompilerConfigurationKey = CompilerConfigurationKey.create("flag to clean generated gdns files that don't have an associated class anymore") } } ================================================ FILE: entry-generation/godot-entry-generator/build.gradle.kts ================================================ plugins { kotlin("jvm") `maven-publish` } dependencies { implementation(kotlin("stdlib")) compileOnly(kotlin("compiler")) implementation("com.squareup:kotlinpoet:${DependenciesVersions.kotlinPoetVersion}") } tasks { val sourceJar by creating(Jar::class) { archiveBaseName.set(project.name) archiveVersion.set(project.version.toString()) archiveClassifier.set("sources") from(sourceSets["main"].allSource) } build { finalizedBy(publishToMavenLocal) } } publishing { publications { val godotEntryGenerator by creating(MavenPublication::class) { pom { groupId = "${project.group}" artifactId = project.name version = "${project.version}" } from(components.getByName("java")) artifact(tasks.getByName("sourceJar")) } } } project.extra["artifacts"] = arrayOf("godotEntryGenerator") apply { plugin(BintrayPublish::class.java) } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/EntryGenerator.kt ================================================ package godot.entrygenerator import godot.entrygenerator.filebuilder.EntryFileBuilder import godot.entrygenerator.generator.GdnsGenerator import godot.entrygenerator.transformer.transformTypeDeclarationsToClassWithMember import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.resolve.BindingContext class EntryGenerator(bindingContext: BindingContext) { private val entryFileBuilder = EntryFileBuilder(bindingContext) fun generateEntryFile( outputPath: String, classes: Set, properties: Set, functions: Set, signals: Set ) { entryFileBuilder .registerClassesWithMembers( transformTypeDeclarationsToClassWithMember( classes, properties, functions, signals ) ) .build(outputPath) } fun generateGdnsFiles( outputPath: String, gdnLibFile: String, cleanGeneratedGdnsFiles: Boolean, classes: Set ) { GdnsGenerator.generateGdnsFiles(outputPath, gdnLibFile, cleanGeneratedGdnsFiles, classes) } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/exceptions/WrongAnnotationUsageException.kt ================================================ package godot.entrygenerator.exceptions import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe class WrongAnnotationUsageException( propertyDescriptor: PropertyDescriptor, propertyHintAnnotation: AnnotationDescriptor?, effectiveType: String? = null ) : Exception( "You annotated ${propertyDescriptor.fqNameSafe} with @${propertyHintAnnotation?.fqName?.asString()?.split(".") ?.last()} which ${if (effectiveType != null) "is only applicable to properties of type $effectiveType" else "cannot be applied on properties of type ${propertyDescriptor.type}"}" ) ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/extension/AnnotationExt.kt ================================================ package godot.entrygenerator.extension import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name fun Annotations.getAnnotationValue( annotation: String, key: String, defaultValue: T ): T { return this .findAnnotation(FqName(annotation)) ?.let { annotationDescriptor -> @Suppress("UNCHECKED_CAST") annotationDescriptor .allValueArguments .entries .firstOrNull { it.key == Name.identifier(key) } ?.value ?.value as T ?: defaultValue } ?: defaultValue } fun AnnotationDescriptor.getAnnotationValue( key: String, defaultValue: T ): T { @Suppress("UNCHECKED_CAST") return this .allValueArguments .entries .firstOrNull { it.key == Name.identifier(key) } ?.value ?.value as T ?: defaultValue } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/extension/ClassDescriptorExt.kt ================================================ package godot.entrygenerator.extension import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.types.asSimpleType fun ClassDescriptor.getSuperTypeNameAsString(): String { return this .typeConstructor .supertypes .first() .asSimpleType() .toString() } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/extension/KotlinTypeExt.kt ================================================ package godot.entrygenerator.extension import org.jetbrains.kotlin.js.descriptorUtils.getJetTypeFqName import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.typeUtil.supertypes fun KotlinType.isCoreType(): Boolean { return coreTypes.contains(getJetTypeFqName(false)) } fun KotlinType.isResource(): Boolean { return this.getJetTypeFqName(false) == "godot.Resource" || this .supertypes() .map { it.getJetTypeFqName(false) } .any { it == "godot.Resource" } } fun KotlinType.isCompatibleList(): Boolean { return when { getJetTypeFqName(false) == "godot.core.GodotArray" -> true else -> supertypes().any { it.getJetTypeFqName(false) == "godot.core.GodotArray" } } } fun KotlinType.getCompatibleListType(): String { return getJetTypeFqName(false).getCompatibleListType() } private fun KotlinType.getRegistrableTypeAsFqNameString(): String? { return when { getJetTypeFqName(false).isGodotPrimitive() || isCoreType() -> getJetTypeFqName(false) else -> null } } fun KotlinType.getFirstRegistrableTypeAsFqNameStringOrNull(): String? { return getRegistrableTypeAsFqNameString() ?: supertypes() .firstOrNull { it.getRegistrableTypeAsFqNameString() != null } ?.getRegistrableTypeAsFqNameString() } private val coreTypes = listOf( "godot.core.Vector2", "godot.core.Rect2", "godot.core.Vector3", "godot.core.Transform2D", "godot.core.Plane", "godot.core.Quat", "godot.core.AABB", "godot.core.Basis", "godot.core.Transform", "godot.core.Color", "godot.core.NodePath", "godot.core.RID", "godot.Object", "godot.core.Dictionary", "godot.core.PoolByteArray", "godot.core.PoolIntArray", "godot.core.PoolRealArray", "godot.core.PoolStringArray", "godot.core.PoolColorArray", "godot.core.PoolVector2Array", "godot.core.PoolVector3Array", "godot.core.VariantArray", "godot.core.ObjectArray", "godot.core.EnumArray", "godot.core.BoolVariantArray", "godot.core.IntVariantArray", "godot.core.RealVariantArray", "godot.core.StringVariantArray", "godot.core.AABBArray", "godot.core.BasisArray", "godot.core.ColorArray", "godot.core.NodePathArray", "godot.core.PlaneArray", "godot.core.QuatArray", "godot.core.Rect2Array", "godot.core.RIDArray", "godot.core.Transform2DArray", "godot.core.TransformArray", "godot.core.Vector2Array", "godot.core.Vector3Array" ) ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/extension/PropertyDescriptorExt.kt ================================================ package godot.entrygenerator.extension import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.psi.KtExpression import org.jetbrains.kotlin.psi.KtProperty import org.jetbrains.kotlin.resolve.source.KotlinSourceElement fun PropertyDescriptor.getPropertyHintAnnotation(): AnnotationDescriptor? { val propertyHintAnnotations = propertyHintAnnotations .map { FqName(it) } .filter { annotations.hasAnnotation(it) } .map { annotations.findAnnotation(it) } if (propertyHintAnnotations.size > 1) { throw IllegalStateException("The property ${this.name} has multiple PropertyHintAnnotations. You can only specify one! Defined Annotations: $propertyHintAnnotations") } if (propertyHintAnnotations.isNotEmpty() && !annotations.hasAnnotation(FqName("godot.annotation.RegisterProperty"))) { throw IllegalStateException("The property ${this.name} has a ${propertyHintAnnotations.first()?.fqName} annotation but is not annotated with @RegisterProperty. Add the @RegisterProperty annotation or remove the ${propertyHintAnnotations.first()?.fqName} annotation") } return propertyHintAnnotations.firstOrNull() } val PropertyDescriptor.assignmentPsi: KtExpression get() = ((this .source as KotlinSourceElement) .psi as KtProperty) .delegateExpressionOrInitializer!! // should not be null private val propertyHintAnnotations: List = listOf( "godot.annotation.ColorNoAlpha", "godot.annotation.Dir", "godot.annotation.DoubleRange", "godot.annotation.EnumFlag", "godot.annotation.ExpEasing", "godot.annotation.ExpRange", "godot.annotation.File", "godot.annotation.Flags", "godot.annotation.FloatRange", "godot.annotation.ImageCompressLossLess", "godot.annotation.ImageCompressLossy", "godot.annotation.IntFlag", "godot.annotation.IntIsObjectId", "godot.annotation.IntRange", "godot.annotation.Layers2DPhysics", "godot.annotation.Layers2DRender", "godot.annotation.Layers3DPhysics", "godot.annotation.Layers3DRender", "godot.annotation.Lenght", "godot.annotation.Max", "godot.annotation.MethodOfBaseType", "godot.annotation.MethodOfInstance", "godot.annotation.MethodOfScript", "godot.annotation.MethodOfVariantType", "godot.annotation.MultilineText", "godot.annotation.NodePathToEditedNode", "godot.annotation.NodePathValidTypes", "godot.annotation.ObjectId", "godot.annotation.ObjectTooBig", "godot.annotation.PlaceHolderText", "godot.annotation.PropertyOfBaseType", "godot.annotation.PropertyOfInstance", "godot.annotation.PropertyOfScript", "godot.annotation.PropertyOfVariantType", "godot.annotation.ResourceType", "godot.annotation.SaveFile", "godot.annotation.TypeString" ) ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/extension/StringExt.kt ================================================ package godot.entrygenerator.extension fun String.isString() = this == "kotlin.String" fun String.isGodotPrimitive() = when (this) { "kotlin.Int", "kotlin.Long", "kotlin.Float", "kotlin.Double", "kotlin.Boolean", "kotlin.Byte", "kotlin.Short", "kotlin.String" -> true else -> false } fun String.getAsVariantTypeOrdinal() = when (this) { "kotlin.Boolean" -> "1" "kotlin.Int", "kotlin.Long", "kotlin.Byte", "kotlin.Short", "kotlin.Enum" -> "2" "kotlin.Float", "kotlin.Double" -> "3" "kotlin.String" -> "4" "godot.core.Vector2" -> "5" "godot.core.Rect2" -> "6" "godot.core.Vector3" -> "7" "godot.core.Transform2D" -> "8" "godot.core.Plane" -> "9" "godot.core.Quat" -> "10" "godot.core.AABB" -> "11" "godot.core.Basis" -> "12" "godot.core.Transform" -> "13" "godot.core.Color" -> "14" "godot.core.NodePath" -> "15" "godot.core.RID" -> "16" "godot.core.OBJECT" -> "17" "godot.core.Dictionary" -> "18" //Array -> handled in else branch "godot.core.PoolByteArray" -> "20" "godot.core.PoolIntArray" -> "21" "godot.core.PoolRealArray" -> "22" "godot.core.PoolStringArray" -> "23" "godot.core.PoolColorArray" -> "24" "godot.core.PoolVector2Array" -> "25" "godot.core.PoolVector3Array" -> "26" else -> if (this.isCompatibleListType()) { "19" } else { null } } fun String.isCompatibleListType(): Boolean { return this.getCompatibleListType().isNotEmpty() } fun String.getCompatibleListType(): String { return when(this) { "godot.core.BoolVariantArray" -> "1" "godot.core.EnumArray", "godot.core.IntVariantArray" -> "2" "godot.core.RealVariantArray" -> "3" "godot.core.StringVariantArray" -> "4" "godot.core.Vector2Array" -> "5" "godot.core.Rect2Array" -> "6" "godot.core.Vector3Array" -> "7" "godot.core.Transform2DArray" -> "8" "godot.core.PlaneArray" -> "9" "godot.core.QuatArray" -> "10" "godot.core.AABBArray" -> "11" "godot.core.BasisArray" -> "12" "godot.core.TransformArray" -> "13" "godot.core.ColorArray" -> "14" "godot.core.NodePathArray" -> "15" "godot.core.RIDArray" -> "16" "godot.core.ObjectArray", "godot.core.CoreArray" -> "17" else -> "" } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/filebuilder/EntryFileBuilder.kt ================================================ package godot.entrygenerator.filebuilder import com.squareup.kotlinpoet.AnnotationSpec import com.squareup.kotlinpoet.ClassName import com.squareup.kotlinpoet.FileSpec import com.squareup.kotlinpoet.FunSpec import godot.entrygenerator.generator.ClassRegistrationGenerator import godot.entrygenerator.model.ClassWithMembers import org.jetbrains.kotlin.resolve.BindingContext import java.io.File class EntryFileBuilder(val bindingContext: BindingContext) { private val entryFileSpec = FileSpec .builder("godot", "Entry") .addAnnotation( AnnotationSpec .builder(ClassName("kotlin", "Suppress")) .addMember("%S", "EXPERIMENTAL_API_USAGE") .build() ) .addComment("THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD") .addFunction(generateGDNativeInitFunction()) .addFunction(generateGDNativeTerminateFunction()) private val nativeScriptInitFunctionSpec = FunSpec .builder("NativeScriptInit") .addAnnotation( AnnotationSpec .builder(ClassName("kotlin.native", "CName")) .addMember("%S", "godot_nativescript_init") .build() ) .addParameter("handle", ClassName("kotlinx.cinterop", "COpaquePointer")) .addStatement("%T.nativescriptInit(handle)", ClassName("godot.core", "Godot")) fun registerClassesWithMembers(classesWithMembers: Set): EntryFileBuilder { val classRegistryControlFlow = nativeScriptInitFunctionSpec .beginControlFlow( "with(%T(handle))·{", ClassName("godot.core", "ClassRegistry") ) //START: with ClassRegistry ClassRegistrationGenerator.registerClasses(classesWithMembers, classRegistryControlFlow, bindingContext) classRegistryControlFlow.endControlFlow() //END: with ClassRegistry return this } fun build(outputPath: String) { entryFileSpec.addFunction(nativeScriptInitFunctionSpec.build()) entryFileSpec.addFunction(generateGDNativeScriptTerminateFunction()) entryFileSpec.build().writeTo(File(outputPath)) } private fun generateGDNativeInitFunction(): FunSpec { return FunSpec .builder("GDNativeInit") .addAnnotation( AnnotationSpec .builder(ClassName("kotlin.native", "CName")) .addMember("%S", "godot_gdnative_init") .build() ) .addParameter("options", ClassName("godot.gdnative", "godot_gdnative_init_options")) .addStatement("%T.init(options)", ClassName("godot.core", "Godot")) .build() } private fun generateGDNativeTerminateFunction(): FunSpec { return FunSpec .builder("GDNativeTerminate") .addAnnotation( AnnotationSpec .builder(ClassName("kotlin.native", "CName")) .addMember("%S", "godot_gdnative_terminate") .build() ) .addParameter("options", ClassName("godot.gdnative", "godot_gdnative_terminate_options")) .addStatement("%T.terminate(options)", ClassName("godot.core", "Godot")) .build() } private fun generateGDNativeScriptTerminateFunction(): FunSpec { return FunSpec .builder("NativeScriptTerminate") .addAnnotation( AnnotationSpec .builder(ClassName("kotlin.native", "CName")) .addMember("%S", "godot_nativescript_terminate") .build() ) .addParameter("handle", ClassName("kotlinx.cinterop", "COpaquePointer")) .addStatement("%T.nativescriptTerminate(handle)", ClassName("godot.core", "Godot")) .build() } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/ClassRegistrationGenerator.kt ================================================ package godot.entrygenerator.generator import com.squareup.kotlinpoet.ClassName import com.squareup.kotlinpoet.FunSpec import godot.entrygenerator.extension.getAnnotationValue import godot.entrygenerator.extension.getSuperTypeNameAsString import godot.entrygenerator.model.ClassWithMembers import godot.entrygenerator.model.REGISTER_CLASS_ANNOTATION import godot.entrygenerator.model.REGISTER_CLASS_ANNOTATION_TOOL_ARGUMENT import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe object ClassRegistrationGenerator { fun registerClasses( classesWithMembers: Set, classRegistryControlFlow: FunSpec.Builder, bindingContext: BindingContext ) { classesWithMembers.forEach { classWithMembers -> val classNameAsString = classWithMembers.classDescriptor.name.asString() val packagePath = classWithMembers.classDescriptor.fqNameSafe.parent().asString() val className = ClassName(packagePath, classNameAsString) val superClass = classWithMembers.classDescriptor.getSuperTypeNameAsString() val registerClassControlFlow = classRegistryControlFlow.beginControlFlow( "registerClass(%S,·%S,·%L,·${isTool(classWithMembers.classDescriptor)})·{", classWithMembers.classDescriptor.fqNameSafe.asString(), superClass, className.constructorReference() ) //START: registerClass FunctionRegistrationGenerator.registerFunctions( classWithMembers.functions, registerClassControlFlow, className ) SignalRegistrationGenerator.registerSignals( classWithMembers.signals, registerClassControlFlow ) PropertyRegistrationGenerator.registerProperties( classWithMembers.properties, registerClassControlFlow, className, bindingContext ) registerClassControlFlow.endControlFlow() //END: registerClass } } private fun isTool(classDescriptor: ClassDescriptor): Boolean { return classDescriptor .annotations .getAnnotationValue(REGISTER_CLASS_ANNOTATION, REGISTER_CLASS_ANNOTATION_TOOL_ARGUMENT, false) } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/FunctionRegistrationGenerator.kt ================================================ package godot.entrygenerator.generator import com.squareup.kotlinpoet.ClassName import com.squareup.kotlinpoet.FunSpec import com.squareup.kotlinpoet.MemberName.Companion.member import com.squareup.kotlinpoet.TypeName import com.squareup.kotlinpoet.asTypeName import godot.entrygenerator.extension.getAnnotationValue import godot.entrygenerator.extension.getFirstRegistrableTypeAsFqNameStringOrNull import godot.entrygenerator.mapper.RpcModeAnnotationMapper.mapRpcModeAnnotationToClassName import godot.entrygenerator.model.REGISTER_FUNCTION_ANNOTATION import godot.entrygenerator.model.REGISTER_FUNCTION_ANNOTATION_RPC_MODE_ARGUMENT import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.js.descriptorUtils.getJetTypeFqName import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.typeUtil.supertypes object FunctionRegistrationGenerator { fun registerFunctions( functions: List, registerClassControlFlow: FunSpec.Builder, className: ClassName ) { functions.forEach { functionDescriptor -> val variantToTypeConverterList = getVariantTypeConverterList(functionDescriptor) val typeToVariantConverter = getTypeToVariantConverter(functionDescriptor) registerClassControlFlow .addStatement( getFunctionTemplateString(functionDescriptor, typeToVariantConverter.first, variantToTypeConverterList.first), functionDescriptor.name, mapRpcModeAnnotationToClassName(getRpcModeEnum(functionDescriptor)), className.member(functionDescriptor.name.asString()).reference(), typeToVariantConverter.second, *variantToTypeConverterList.second ) } } private fun getFunctionTemplateString( functionDescriptor: FunctionDescriptor, typeToVariantConverter: String, variantToTypeConverterList: String ): String { return if (functionDescriptor.valueParameters.isEmpty()) { "function(%S,·%T,·%L,·$typeToVariantConverter)" } else { "function(%S,·%T,·%L,·$typeToVariantConverter,·$variantToTypeConverterList)" } } private fun getRpcModeEnum(functionDescriptor: FunctionDescriptor): String { val compilerRpcModeEnumRepresentation = getCompilerRpcModeEnumRepresentation(functionDescriptor) val packagePath = compilerRpcModeEnumRepresentation.first.asString().replace("/", ".") val name = compilerRpcModeEnumRepresentation.second return "$packagePath.$name" } private fun getCompilerRpcModeEnumRepresentation(functionDescriptor: FunctionDescriptor): Pair { return functionDescriptor .annotations .getAnnotationValue( REGISTER_FUNCTION_ANNOTATION, REGISTER_FUNCTION_ANNOTATION_RPC_MODE_ARGUMENT, Pair(ClassId(FqName("godot.MultiplayerAPI"), Name.identifier("RPCMode")), Name.identifier("DISABLED")) ) } private fun getVariantTypeConverterList(functionDescriptor: FunctionDescriptor): Pair> { val templateArguments = mutableListOf() val template = buildString { append("listOf(") functionDescriptor.valueParameters.forEach { val firstRegistrableType = it.type.getFirstRegistrableTypeAsFqNameStringOrNull() ?: throw IllegalArgumentException("Registered function \"${functionDescriptor.fqNameSafe}\" receives an unregistrable type: ${it.name}. All arguments of a registered functions have to be either primitive or derive from a Godot type") if (firstRegistrableType == "godot.core.EnumArray") { throw IllegalArgumentException("Registered function \"${functionDescriptor.fqNameSafe}\" receives an EnumArray as param: ${it.name}. EnumArrays cannot be registered as params for functions. Use IntVariantArray instead.") } if (firstRegistrableType == "godot.core.ObjectArray") { throw IllegalArgumentException("Registered function \"${functionDescriptor.fqNameSafe}\" receives an ObjectArray as param: ${it.name}. ObjectArray cannot be registered as params for functions. Use VariantArray instead and use the asObjectArray() function for conversion.") } val typeAsString = firstRegistrableType .replaceBeforeLast(".", "") .replace(".", "") val packageAsString = firstRegistrableType .replaceAfterLast(".", "") val argumentTemplateString = if (typeAsString == "GodotArray") { "getVariantToTypeConversionFunction<%T<*>>()" } else { "getVariantToTypeConversionFunction<%T>()" } append(argumentTemplateString) templateArguments.add(ClassName(packageAsString, typeAsString)) if (functionDescriptor.valueParameters.last() != it) { append(",·") } } append(")") } return template to templateArguments.toTypedArray() } private fun getTypeToVariantConverter(functionDescriptor: FunctionDescriptor): Pair { return functionDescriptor.returnType?.let { returnType -> val className = when { isOfType(returnType, "godot.internal.type.CoreType") -> ClassName("godot.internal.type", "CoreType") isOfType(returnType, "godot.Object") -> ClassName("godot", "Object") isOfType(returnType, "godot.core.Variant") -> ClassName("godot.core", "Variant") KotlinBuiltIns.isInt(returnType) -> Int::class.asTypeName() KotlinBuiltIns.isLongOrNullableLong(returnType) -> Long::class.asTypeName() KotlinBuiltIns.isDoubleOrNullableDouble(returnType) -> Double::class.asTypeName() KotlinBuiltIns.isFloatOrNullableFloat(returnType) -> Float::class.asTypeName() KotlinBuiltIns.isBooleanOrNullableBoolean(returnType) -> Boolean::class.asTypeName() KotlinBuiltIns.isStringOrNullableString(returnType) -> String::class.asTypeName() KotlinBuiltIns.isUnit(returnType) -> null else -> throw IllegalArgumentException("Registered functions \"${functionDescriptor.fqNameSafe}\" return type is of unregistrable type: ${returnType}. You can only register functions which return either a primitive or a type derived from a Godot type") } className?.let { "getTypeToVariantConversionFunction<%T>()" to className } ?: "{·%T()·}" to ClassName("godot.core", "Variant") } ?: "{·%T()·}" to ClassName("godot.core", "Variant") } private fun isOfType(type: KotlinType, typeFqName: String): Boolean { return if (type.getJetTypeFqName(false) == typeFqName) { true } else { type .supertypes() .any { it.getJetTypeFqName(false) == typeFqName } } } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/GdnsGenerator.kt ================================================ package godot.entrygenerator.generator import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import java.io.File object GdnsGenerator { fun generateGdnsFiles( outputPath: String, gdnLibFile: String, cleanGeneratedGdnsFiles: Boolean, classes: Set ) { val existingGdnsFiles = File(outputPath) .listFiles() ?.filter { it.extension == "gdns" } ?: emptyList() val classNames = classes.map { clazz -> clazz.name.asString() } val obsoleteGdnsFiles = existingGdnsFiles .filter { !classNames.contains(it.name) } if (cleanGeneratedGdnsFiles) { obsoleteGdnsFiles.forEach { it.delete() } } classes.forEach { val fqName = it.fqNameSafe.asString() File(getGdnsFilePath(outputPath, fqName).replaceAfterLast("/", "")).mkdirs() File(getGdnsFilePath(outputPath, fqName)) .writeText(getGdnsFileContent(gdnLibFile, fqName)) } } private fun getGdnsFileContent(gdnLibFile: String, classFqName: String): String { return """ [gd_resource type="NativeScript" load_steps=2 format=2] [ext_resource path="res://$gdnLibFile" type="GDNativeLibrary" id=1] [resource] resource_name = "$classFqName" class_name = "$classFqName" library = ExtResource( 1 ) """.trimIndent() } private fun getGdnsFilePath(outputPath: String, classFqName: String): String { return "$outputPath/${classFqName.replace(".", "/")}.gdns" } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/PropertyRegistrationGenerator.kt ================================================ package godot.entrygenerator.generator import com.squareup.kotlinpoet.ClassName import com.squareup.kotlinpoet.FunSpec import com.squareup.kotlinpoet.MemberName.Companion.member import com.squareup.kotlinpoet.asTypeName import godot.entrygenerator.extension.getAnnotationValue import godot.entrygenerator.extension.getFirstRegistrableTypeAsFqNameStringOrNull import godot.entrygenerator.extension.isCompatibleList import godot.entrygenerator.generator.provider.DefaultValueHandlerProvider import godot.entrygenerator.mapper.RpcModeAnnotationMapper.mapRpcModeAnnotationToClassName import godot.entrygenerator.mapper.TypeToVariantAsClassNameMapper import godot.entrygenerator.model.REGISTER_PROPERTY_ANNOTATION import godot.entrygenerator.model.REGISTER_PROPERTY_ANNOTATION_RPC_MODE_ARGUMENT import godot.entrygenerator.model.REGISTER_PROPERTY_ANNOTATION_VISIBLE_IN_EDITOR_ARGUMENT import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.js.descriptorUtils.getJetTypeFqName import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.typeUtil.isEnum import org.jetbrains.kotlin.types.typeUtil.supertypes object PropertyRegistrationGenerator { fun registerProperties( properties: List, registerClassControlFlow: FunSpec.Builder, className: ClassName, bindingContext: BindingContext ) { properties.forEach { propertyDescriptor -> if (propertyDescriptor.type.isEnum()) { registerEnum(className, propertyDescriptor, bindingContext, registerClassControlFlow) } else if (propertyDescriptor.type.isCompatibleList() && propertyDescriptor.type.arguments.firstOrNull()?.type?.isEnum() == true) { registerEnumList(className, propertyDescriptor, bindingContext, registerClassControlFlow) } else if ( KotlinBuiltIns.isSetOrNullableSet(propertyDescriptor.type) && propertyDescriptor.type.arguments.firstOrNull()?.type?.isEnum() == true ) { registerEnumFlag(className, propertyDescriptor, bindingContext, registerClassControlFlow) } else { registerProperty(className, propertyDescriptor, bindingContext, registerClassControlFlow) } } } private fun registerEnumFlag( className: ClassName, propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext, registerClassControlFlow: FunSpec.Builder ) { val defaultValueProvider = DefaultValueHandlerProvider.provideDefaultValueHandler(propertyDescriptor, bindingContext) val (defaultValueStringTemplate, defaultValueStringTemplateValues) = defaultValueProvider.getDefaultValue() registerClassControlFlow.addStatement( "enumFlagProperty(%S,·%L,·${defaultValueStringTemplate.replace(" ", "·")},·%L,·%T)", propertyDescriptor.name, className.member(propertyDescriptor.name.asString()).reference(), *defaultValueStringTemplateValues, shouldBeVisibleInEditor(propertyDescriptor), mapRpcModeAnnotationToClassName(getRpcModeEnum(propertyDescriptor)) ) } private fun registerEnumList( className: ClassName, propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext, registerClassControlFlow: FunSpec.Builder ) { val defaultValueProvider = DefaultValueHandlerProvider.provideDefaultValueHandler(propertyDescriptor, bindingContext) val (defaultValueStringTemplate, defaultValueStringTemplateValues) = defaultValueProvider.getDefaultValue() registerClassControlFlow.addStatement( "enumListProperty(%S,·%L,·${defaultValueStringTemplate.replace(" ", "·")},·%L,·%T)", propertyDescriptor.name, className.member(propertyDescriptor.name.asString()).reference(), *defaultValueStringTemplateValues, shouldBeVisibleInEditor(propertyDescriptor), mapRpcModeAnnotationToClassName(getRpcModeEnum(propertyDescriptor)) ) } private fun registerEnum( className: ClassName, propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext, registerClassControlFlow: FunSpec.Builder ) { val defaultValueProvider = DefaultValueHandlerProvider.provideDefaultValueHandler(propertyDescriptor, bindingContext) val (defaultValueStringTemplate, defaultValueStringTemplateValues) = defaultValueProvider.getDefaultValue() registerClassControlFlow .addStatement( "enumProperty(%S,·%L,·${defaultValueStringTemplate.replace(" ", "·")},·%L,·%T)", propertyDescriptor.name, className.member(propertyDescriptor.name.asString()).reference(), *defaultValueStringTemplateValues, shouldBeVisibleInEditor(propertyDescriptor), mapRpcModeAnnotationToClassName(getRpcModeEnum(propertyDescriptor)) ) } private fun registerProperty( className: ClassName, propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext, registerClassControlFlow: FunSpec.Builder ) { val defaultValueProvider = DefaultValueHandlerProvider.provideDefaultValueHandler( propertyDescriptor, bindingContext ) val (defaultValueStringTemplate, defaultValueStringTemplateValues) = defaultValueProvider.getDefaultValue() val (variantToTypeTemplate, variantToTypeTemplateValue) = getVariantToTypeConverter(propertyDescriptor) val (typeToVariantTemplate, typeToVariantTemplateValue) = getTypeToVariantConverter(propertyDescriptor) val hintString = defaultValueProvider.getHintString() registerClassControlFlow .addStatement( "property(%S,·%L,·$typeToVariantTemplate,·$variantToTypeTemplate,·%T,·${defaultValueStringTemplate.replace(" ", "·")},·%L,·%T,·%T,·%S)", propertyDescriptor.name, className.member(propertyDescriptor.name.asString()).reference(), typeToVariantTemplateValue, variantToTypeTemplateValue, TypeToVariantAsClassNameMapper.mapTypeToVariantAsClassName( propertyDescriptor.type.toString(), propertyDescriptor.type, propertyDescriptor.type.isEnum() ), //property variant type *defaultValueStringTemplateValues, shouldBeVisibleInEditor(propertyDescriptor), mapRpcModeAnnotationToClassName(getRpcModeEnum(propertyDescriptor)), defaultValueProvider.getPropertyTypeHint(), hintString ) } private fun shouldBeVisibleInEditor(propertyDescriptor: PropertyDescriptor): Boolean { return propertyDescriptor .annotations .getAnnotationValue( REGISTER_PROPERTY_ANNOTATION, REGISTER_PROPERTY_ANNOTATION_VISIBLE_IN_EDITOR_ARGUMENT, true ) } private fun getRpcModeEnum(propertyDescriptor: PropertyDescriptor): String { val compilerRpcModeEnumRepresentation = getCompilerRpcModeEnumRepresentation(propertyDescriptor) val packagePath = compilerRpcModeEnumRepresentation.first.asString().replace("/", ".") val name = compilerRpcModeEnumRepresentation.second return "$packagePath.$name" } private fun getCompilerRpcModeEnumRepresentation(propertyDescriptor: PropertyDescriptor): Pair { return propertyDescriptor .annotations .getAnnotationValue( REGISTER_PROPERTY_ANNOTATION, REGISTER_PROPERTY_ANNOTATION_RPC_MODE_ARGUMENT, Pair(ClassId(FqName("godot.MultiplayerAPI"), Name.identifier("RPCMode")), Name.identifier("DISABLED")) ) } private fun getVariantToTypeConverter(propertyDescriptor: PropertyDescriptor): Pair { val firstRegistrableType = propertyDescriptor.type.getFirstRegistrableTypeAsFqNameStringOrNull() ?: throw IllegalArgumentException("Registered property \"${propertyDescriptor.fqNameSafe}\" is of unregistrable type: ${propertyDescriptor.type}. You can only register properties which are either primitive or derive from a Godot type") if (firstRegistrableType == "godot.core.ObjectArray") { throw IllegalArgumentException("Registered property \"${propertyDescriptor.fqNameSafe}\" is of type ObjectArray. ObjectArray cannot be registered directly. Use VariantArray instead and use the asObjectArray() function for conversion.") } val typeAsString = firstRegistrableType .replaceBeforeLast(".", "") .replace(".", "") val packageAsString = firstRegistrableType .replaceAfterLast(".", "") val argumentTemplateString = if (typeAsString == "GodotArray") { "getVariantToTypeConversionFunction<%T<*>>()" } else { "getVariantToTypeConversionFunction<%T>()" } return argumentTemplateString to ClassName(packageAsString, typeAsString) } private fun getTypeToVariantConverter(propertyDescriptor: PropertyDescriptor): Pair { val className = when { isOfType(propertyDescriptor.type, "godot.internal.type.CoreType") -> ClassName("godot.internal.type", "CoreType") isOfType(propertyDescriptor.type, "godot.Object") -> ClassName("godot", "Object") isOfType(propertyDescriptor.type, "godot.core.Variant") -> ClassName("godot.core", "Variant") KotlinBuiltIns.isInt(propertyDescriptor.type) -> Int::class.asTypeName() KotlinBuiltIns.isLongOrNullableLong(propertyDescriptor.type) -> Long::class.asTypeName() KotlinBuiltIns.isDoubleOrNullableDouble(propertyDescriptor.type) -> Double::class.asTypeName() KotlinBuiltIns.isFloatOrNullableFloat(propertyDescriptor.type) -> Float::class.asTypeName() KotlinBuiltIns.isBooleanOrNullableBoolean(propertyDescriptor.type) -> Boolean::class.asTypeName() KotlinBuiltIns.isStringOrNullableString(propertyDescriptor.type) -> String::class.asTypeName() else -> throw IllegalArgumentException("Registered property \"${propertyDescriptor.fqNameSafe}\" is of unregistrable type: ${propertyDescriptor.type}. You can only register properties which are either primitive or derive from a Godot type") } return "getTypeToVariantConversionFunction<%T>()" to className } private fun isOfType(type: KotlinType, typeFqName: String): Boolean { return if (type.getJetTypeFqName(false) == typeFqName) { true } else { type .supertypes() .any { it.getJetTypeFqName(false) == typeFqName } } } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/SignalRegistrationGenerator.kt ================================================ package godot.entrygenerator.generator import com.squareup.kotlinpoet.ClassName import com.squareup.kotlinpoet.FunSpec import godot.entrygenerator.mapper.TypeToVariantAsClassNameMapper import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.psi.KtTypeArgumentList import org.jetbrains.kotlin.psi.KtValueArgumentList import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.source.KotlinSourceElement object SignalRegistrationGenerator { fun registerSignals( signals: List, registerClassControlFlow: FunSpec.Builder ) { signals.forEach { propertyDescriptor -> signalSanityCheck(propertyDescriptor) val (signalArgumentsStringTemplate, arrayOfClassNames) = getSignalArguments(propertyDescriptor) registerClassControlFlow .addStatement( "signal(%S,·$signalArgumentsStringTemplate)", propertyDescriptor.name, *arrayOfClassNames ) } } private fun signalSanityCheck(propertyDescriptor: PropertyDescriptor) { val propertyTypeAsString = propertyDescriptor.type.toString() if (!propertyDescriptor.name.asString().startsWith("signal")) { throw IllegalStateException("All signals must be prefixed with \"signal\"! Ex: signalButtonPressed. The signal ${propertyDescriptor.fqNameSafe} does not fulfill this criteria.") } if (propertyTypeAsString.startsWith("Signal")) { try { propertyTypeAsString.replace("Signal", "").split("<")[0].toInt() } catch (e: NumberFormatException) { throw IllegalStateException("You annotated ${propertyDescriptor.fqNameSafe} with @RegisterSignal but it's type is no signal! Use \"by signal\" to define signals.") } } else { throw IllegalStateException("You annotated ${propertyDescriptor.fqNameSafe} with @RegisterSignal but it's type is no signal! Use \"by signal\" to define signals.") } } private fun getSignalArguments(propertyDescriptor: PropertyDescriptor): Pair> { val signalDelegate = (propertyDescriptor .source as KotlinSourceElement) .psi // whole property including annotation .children .last() // property delegate including `by`keyword. Ex: by signal("someName") .children .last() // property delegate. EX: signal("someName") return if (signalDelegate.children.any { it is KtTypeArgumentList }) { //if the signal has any arguments val typeArgumentsAsClassNames = signalDelegate .children .filterIsInstance() .first() //the type argument list. Ex: .children .map { it.text } //extracted each type argument as string .map { TypeToVariantAsClassNameMapper.mapTypeToVariantAsClassName(it) //convert string to ClassName for kotlinPoet to get correct imports } .toTypedArray() //convert to typed array to pass as varargs to kotlinPoet addStatement function val valueArgumentsAsString = signalDelegate .children .filterIsInstance() .first() //the value argument list. Ex: ("name1", "name2") .children .map { it.text } //extracted each value argument as string if (typeArgumentsAsClassNames.size != valueArgumentsAsString.size) { throw IllegalStateException("The value argument list has not the same size as the type argument list in this signal declaration: ${signalDelegate.text}") } Pair(assembleSignalParameterMapStringTemplate(valueArgumentsAsString), typeArgumentsAsClassNames) } else { //if the signal does not have any arguments, an empty map will be passed to the registration Pair("mapOf()", arrayOf()) } } private fun assembleSignalParameterMapStringTemplate( valueArgumentsAsString: List ): String { return buildString { append("mapOf(") valueArgumentsAsString.forEachIndexed { index, valueArgumentAsString -> append("$valueArgumentAsString·to·%T") if (index != valueArgumentsAsString.size - 1) { append(",·") } } append(")") } } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/ArrayRegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import godot.entrygenerator.exceptions.WrongAnnotationUsageException import godot.entrygenerator.extension.* import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.js.descriptorUtils.getJetTypeFqName import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.types.KotlinType import org.jetbrains.kotlin.types.typeUtil.isEnum class ArrayRegistrationValuesHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ) : RegistrationValuesHandler(propertyDescriptor, bindingContext) { override fun getPropertyTypeHint(): ClassName { return when (propertyHintAnnotation?.fqName?.asString()) { null -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_NONE") else -> throw WrongAnnotationUsageException(propertyDescriptor, propertyHintAnnotation) } } override fun getDefaultValue(): Pair> { return if (propertyDescriptor.type.arguments.firstOrNull()?.type?.isEnum() == true) { if (propertyDescriptor.isLateInit || !isVisibleInEditor()) { return "%L" to arrayOf("null") } getDefaultValueExpression(propertyDescriptor.assignmentPsi) ?: throw IllegalStateException("") //TODO: error } else { super.getDefaultValue() } } /** * Hint string array formatting: https://github.com/godotengine/godot/blob/00949f0c5fcc6a4f8382a4a97d5591fd9ec380f8/editor/editor_properties_array_dict.cpp */ override fun getHintString(): String { // at this point we know type is a VariantArray val type = propertyDescriptor.type val elementType = type.arguments.firstOrNull()?.type return when { elementType != null && KotlinBuiltIns.isAny(elementType) -> "" elementType != null && elementType.isEnum() -> { // return value is not used, hint is computed at runtime "" } else -> { buildString { var currentElementType: KotlinType? = elementType if (currentElementType == null) { val compatibleListType = type.getCompatibleListType() if (compatibleListType.isNotEmpty()) { append(":${compatibleListType}") } } loop@ while (currentElementType != null) { when { currentElementType.isCompatibleList() -> { append(":19") //variant.type.array.ordinal currentElementType = currentElementType.arguments.firstOrNull()?.type } currentElementType.getJetTypeFqName(false).isGodotPrimitive() || currentElementType.isCoreType() -> { append(":${currentElementType.getJetTypeFqName(false).getAsVariantTypeOrdinal()}") break@loop } else -> { clear() break@loop } } } delete(0, 1) } } } } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/CoreTypeRegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import godot.entrygenerator.exceptions.WrongAnnotationUsageException import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.resolve.BindingContext class CoreTypeRegistrationValuesHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ) : RegistrationValuesHandler(propertyDescriptor, bindingContext) { override fun getPropertyTypeHint(): ClassName { return when (propertyHintAnnotation?.fqName?.asString()) { "godot.annotation.ColorNoAlpha" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_COLOR_NO_ALPHA") //TODO: implement ImageCompressLossy //TODO: implement ImageCompressLossLess //TODO: implement NodePathToEditedNode //TODO: implement NodePathValidTypes null -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_NONE") else -> throw WrongAnnotationUsageException(propertyDescriptor, propertyHintAnnotation) } } override fun getHintString(): String { return when (propertyHintAnnotation?.fqName?.asString()) { "godot.annotation.ColorNoAlpha" -> getColorNoAlphaHintString() //TODO: implement ImageCompressLossy //TODO: implement ImageCompressLossLess //TODO: implement NodePathToEditedNode //TODO: implement NodePathValidTypes null -> "" else -> throw IllegalStateException("Unknown annotation ${propertyHintAnnotation.fqName}") } } private fun getColorNoAlphaHintString(): String { if (propertyDescriptor.type.toString() != "Color") { throw WrongAnnotationUsageException(propertyDescriptor, propertyHintAnnotation, "Color") } return "" //hint string is empty for this typehint } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/DefaultValueHandlerProvider.kt ================================================ package godot.entrygenerator.generator.provider import godot.entrygenerator.extension.isCompatibleList import godot.entrygenerator.extension.isCoreType import godot.entrygenerator.extension.isResource import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.types.typeUtil.isEnum object DefaultValueHandlerProvider { fun provideDefaultValueHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ): RegistrationValuesHandler { return when { KotlinBuiltIns.isInt(propertyDescriptor.type) -> if (propertyDescriptor.annotations.hasAnnotation(FqName("godot.annotation.IntFlag"))) { IntFlagRegistrationValuesHandler( propertyDescriptor, bindingContext ) } else { PrimitiveRegistrationValuesHandler( propertyDescriptor, bindingContext ) } KotlinBuiltIns.isString(propertyDescriptor.type) -> if (propertyDescriptor.annotations.hasAnnotation(FqName("godot.annotation.MultilineText"))) { MultiLineTextRegistrationValuesHandler( propertyDescriptor, bindingContext ) } else if (propertyDescriptor.annotations.hasAnnotation(FqName("godot.annotation.PlaceHolderText"))) { PlaceholderTextRegistrationValuesHandler( propertyDescriptor, bindingContext ) } else { PrimitiveRegistrationValuesHandler( propertyDescriptor, bindingContext ) } KotlinBuiltIns.isLong(propertyDescriptor.type) || KotlinBuiltIns.isFloat(propertyDescriptor.type) || KotlinBuiltIns.isDouble(propertyDescriptor.type) || KotlinBuiltIns.isBoolean(propertyDescriptor.type) -> PrimitiveRegistrationValuesHandler( propertyDescriptor, bindingContext ) propertyDescriptor.type.isEnum() -> EnumRegistrationValuesHandler(propertyDescriptor, bindingContext) propertyDescriptor.type.isCoreType() && !propertyDescriptor.type.isCompatibleList() -> CoreTypeRegistrationValuesHandler( propertyDescriptor, bindingContext ) propertyDescriptor.type.isResource() -> ResourceRegistrationValuesHandler( propertyDescriptor, bindingContext ) propertyDescriptor.type.isCompatibleList() -> ArrayRegistrationValuesHandler( propertyDescriptor, bindingContext ) KotlinBuiltIns.isSetOrNullableSet((propertyDescriptor.type)) -> EnumFlagRegistrationValuesHandler( propertyDescriptor, bindingContext ) else -> TODO() } } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/EnumFlagRegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import godot.entrygenerator.extension.assignmentPsi import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi import org.jetbrains.kotlin.psi.KtClass import org.jetbrains.kotlin.psi.KtEnumEntry import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe class EnumFlagRegistrationValuesHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ) : RegistrationValuesHandler(propertyDescriptor, bindingContext) { override fun getDefaultValue(): Pair> { if (propertyHintAnnotation == null || propertyHintAnnotation.fqName?.asString() != "godot.annotation.EnumFlag") { throw IllegalStateException("The property \"${propertyDescriptor.fqNameSafe}\" is not annotated with @EnumFlag!") } if (propertyDescriptor.isLateInit || !isVisibleInEditor()) { return "%L" to arrayOf("null") } val enumEntries = getPsiKtClass(getClassDescriptor()) .declarations .filterIsInstance() //check for the enum size //the way the intFlag is generated from the enums requires an enum to contain at most 32 entries if (enumEntries.size > 32) { throw IllegalStateException("The enum of the enumFlag ${propertyDescriptor.fqNameSafe} you tried to register has too many entries. A enum that you want to use for registering an EnumFlag can at most contain 32 enums") } return getDefaultValueExpression(propertyDescriptor.assignmentPsi) ?: "" to arrayOf() } override fun getPropertyTypeHint(): ClassName { throw UnsupportedOperationException("Hint type for enum is always the same, so it is handled by binding at runtime") } override fun getHintString(): String { throw UnsupportedOperationException("Hint string for enums is handled by the binding at runtime.") } private fun getClassDescriptor() = propertyDescriptor .type .arguments .first() .type .constructor .declarationDescriptor as ClassDescriptor private fun getPsiKtClass(classDescriptor: ClassDescriptor) = classDescriptor.findPsi() as KtClass } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/EnumRegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.resolve.BindingContext class EnumRegistrationValuesHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ) : RegistrationValuesHandler(propertyDescriptor, bindingContext) { override fun getPropertyTypeHint(): ClassName { throw UnsupportedOperationException("Hint type for enum is always the same, so it is handled by binding at runtime") } override fun getHintString(): String { throw UnsupportedOperationException("Hint string for enums is handled by the binding at runtime.") } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/IntFlagRegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import godot.entrygenerator.exceptions.WrongAnnotationUsageException import godot.entrygenerator.extension.getAnnotationValue import godot.entrygenerator.model.INT_FLAG_ANNOTATION_NAMES_ARGUMENT import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.constants.StringValue class IntFlagRegistrationValuesHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ) : RegistrationValuesHandler(propertyDescriptor, bindingContext) { override fun getPropertyTypeHint(): ClassName { return ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_FLAGS") } override fun getHintString(): String { if (!KotlinBuiltIns.isInt(propertyDescriptor.type)) { throw WrongAnnotationUsageException(propertyDescriptor, propertyHintAnnotation, Int::class.qualifiedName) } return propertyHintAnnotation ?.getAnnotationValue(INT_FLAG_ANNOTATION_NAMES_ARGUMENT, ArrayList()) ?.map { it.value } ?.joinToString(",") { it.removeSurrounding("\"") } ?: "" } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/MultiLineTextRegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.resolve.BindingContext class MultiLineTextRegistrationValuesHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ) : RegistrationValuesHandler(propertyDescriptor, bindingContext) { override fun getPropertyTypeHint(): ClassName { return ClassName( "godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_MULTILINE_TEXT" ) } override fun getHintString(): String { return "" } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/PlaceholderTextRegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.resolve.BindingContext class PlaceholderTextRegistrationValuesHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ) : RegistrationValuesHandler(propertyDescriptor, bindingContext) { override fun getPropertyTypeHint(): ClassName { return ClassName( "godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PLACEHOLDER_TEXT" ) } override fun getHintString(): String { return "" } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/PrimitiveRegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import godot.entrygenerator.exceptions.WrongAnnotationUsageException import godot.entrygenerator.extension.getAnnotationValue import godot.entrygenerator.model.* import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.constants.StringValue import org.jetbrains.kotlin.utils.join import kotlin.reflect.KClass class PrimitiveRegistrationValuesHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ) : RegistrationValuesHandler(propertyDescriptor, bindingContext) { override fun getPropertyTypeHint(): ClassName { return when (propertyHintAnnotation?.fqName?.asString()) { "godot.annotation.IntRange", "godot.annotation.FloatRange", "godot.annotation.DoubleRange" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_RANGE") "godot.annotation.ExpRange" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_EXP_RANGE") "godot.annotation.ExpEasing" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_EXP_EASING") "godot.annotation.Lenght" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LENGHT") "godot.annotation.Layers2DRender" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LAYERS_2D_RENDER") "godot.annotation.Layers2DPhysics" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LAYERS_2D_PHYSICS") "godot.annotation.Layers3DRender" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LAYERS_3D_RENDER") "godot.annotation.Layers3DPhysics" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LAYERS_3D_PHYSICS") "godot.annotation.File" -> if (propertyHintAnnotation.getAnnotationValue(FILE_AND_DIR_ANNOTATION_GLOBAL_ARGUMENT, false)) { ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_GLOBAL_FILE") } else { ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_FILE") } "godot.annotation.Dir" -> if (propertyHintAnnotation.getAnnotationValue(FILE_AND_DIR_ANNOTATION_GLOBAL_ARGUMENT, false)) { ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_GLOBAL_DIR") } else { ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_DIR") } "godot.annotation.MultilineText" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_MULTILINE_TEXT") "godot.annotation.PlaceHolderText" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PLACE_HOLDER_TEXT") "godot.annotation.ObjectId" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_OBJECT_ID") "godot.annotation.TypeString" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_TYPE_STRING") "godot.annotation.MethodOfVariantType" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_METHOD_OF_VARIANT_TYPE") "godot.annotation.MethodOfBaseType" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_METHOD_OF_BASE_TYPE") "godot.annotation.MethodOfInstance" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_METHOD_OF_INSTANCE") "godot.annotation.MethodOfScript" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_METHOD_OF_SCRIPT") "godot.annotation.PropertyOfVariantType" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE") "godot.annotation.PropertyOfBaseType" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PROPERTY_OF_BASE_TYPE") "godot.annotation.PropertyOfInstance" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PROPERTY_OF_INSTANCE") "godot.annotation.PropertyOfScript" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PROPERTY_OF_SCRIPT") "godot.annotation.SaveFile" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_SAVE_FILE") "godot.annotation.IntIsObjectId" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_INT_IS_OBJECT_ID") "godot.annotation.Max" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_MAX") null -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_NONE") else -> throw WrongAnnotationUsageException(propertyDescriptor, propertyHintAnnotation) } } override fun getHintString(): String { return when (propertyHintAnnotation?.fqName?.asString()) { "godot.annotation.IntRange" -> getRangeTypeHint(arrayOf(Int::class)) "godot.annotation.FloatRange" -> getRangeTypeHint(arrayOf(Float::class)) "godot.annotation.DoubleRange" -> getRangeTypeHint(arrayOf(Double::class)) "godot.annotation.ExpRange" -> getRangeTypeHint(arrayOf(Float::class, Double::class)) "godot.annotation.ExpEasing" -> getExpEasingTypeHint() "godot.annotation.Lenght" -> throw NotImplementedError("@Lenght annotation is not yet implemented") //getLengthTypeHint(annotationDescriptor, propertyDescriptor) "godot.annotation.Layers2DRender" -> throw NotImplementedError("@Layers2DRender annotation is not yet implemented") "godot.annotation.Layers2DPhysics" -> throw NotImplementedError("@Layers2DPhysics annotation is not yet implemented") "godot.annotation.Layers3DRender" -> throw NotImplementedError("@Layers3DRender annotation is not yet implemented") "godot.annotation.Layers3DPhysics" -> throw NotImplementedError("@Layers3DPhysics annotation is not yet implemented") "godot.annotation.File", "godot.annotation.Dir" -> getFileOrDirTypeHint() "godot.annotation.MultilineText" -> throw NotImplementedError("@MultilineText annotation is not yet implemented") "godot.annotation.PlaceHolderText" -> throw NotImplementedError("@PlaceHolderText annotation is not yet implemented") "godot.annotation.TypeString" -> throw NotImplementedError("@TypeString annotation is not yet implemented") "godot.annotation.MethodOfVariantType" -> throw NotImplementedError("@MethodOfVariantType annotation is not yet implemented") "godot.annotation.MethodOfBaseType" -> throw NotImplementedError("@MethodOfBaseType annotation is not yet implemented") "godot.annotation.MethodOfInstance" -> throw NotImplementedError("@MethodOfInstance annotation is not yet implemented") "godot.annotation.MethodOfScript" -> throw NotImplementedError("@MethodOfScript annotation is not yet implemented") "godot.annotation.PropertyOfVariantType" -> throw NotImplementedError("@PropertyOfVariantType annotation is not yet implemented") "godot.annotation.PropertyOfBaseType" -> throw NotImplementedError("@PropertyOfBaseType annotation is not yet implemented") "godot.annotation.PropertyOfInstance" -> throw NotImplementedError("@PropertyOfInstance annotation is not yet implemented") "godot.annotation.PropertyOfScript" -> throw NotImplementedError("@PropertyOfScript annotation is not yet implemented") "godot.annotation.SaveFile" -> throw NotImplementedError("@SaveFile annotation is not yet implemented") "godot.annotation.IntIsObjectId" -> throw NotImplementedError("@IntIsObjectId annotation is not yet implemented") "godot.annotation.Max" -> throw NotImplementedError("@Max annotation is not yet implemented") null -> "" else -> throw IllegalStateException("Unknown annotation ${propertyHintAnnotation.fqName}") } } private fun mapCompilerEnumRepresentationToClassName(enumRepresentation: Pair): ClassName { return ClassName( enumRepresentation.first.asString().replace("/", ".").replace(".${enumRepresentation.second}", ""), enumRepresentation.second.asString() ) } private fun getRangeTypeHint(expectedTypes: Array>): String { if (expectedTypes.map { it.toString() }.contains(propertyDescriptor.type.toString())) { throw WrongAnnotationUsageException(propertyDescriptor, propertyHintAnnotation, expectedTypes.toString()) } val start = propertyHintAnnotation!!.getAnnotationValue(RANGE_ANNOTATION_START_ARGUMENT, -1) val end = propertyHintAnnotation.getAnnotationValue(RANGE_ANNOTATION_END_ARGUMENT, -1) val step = propertyHintAnnotation.getAnnotationValue(RANGE_ANNOTATION_STEP_ARGUMENT, -1) val or = propertyHintAnnotation.getAnnotationValue( RANGE_ANNOTATION_OR_ARGUMENT, Pair(ClassId(FqName("godot.registration"), Name.identifier("Range")), Name.identifier("NONE")) ) val orAsClassName = mapCompilerEnumRepresentationToClassName(or) val argumentsForStringTemplate = mutableListOf() argumentsForStringTemplate.add(start) argumentsForStringTemplate.add(end) if (step != -1) { argumentsForStringTemplate.add(step) } if (orAsClassName.toString() != "godot.registration.Range.NONE") { argumentsForStringTemplate.add(orAsClassName.toString().split(".").last().toLowerCase()) } return join(argumentsForStringTemplate, ",") } private fun getExpEasingTypeHint(): String { if (listOf(Float::class, Double::class).map { it.toString() }.contains(propertyDescriptor.type.toString())) { throw WrongAnnotationUsageException(propertyDescriptor, propertyHintAnnotation, "Floats and Doubles") } val attenuation = propertyHintAnnotation!!.getAnnotationValue(EXP_EASING_ANNOTATION_ATTENUATION_ARGUMENT, false) val inout = propertyHintAnnotation.getAnnotationValue(EXP_EASING_ANNOTATION_INOUT_ARGUMENT, true) val stringTemplateValues = when { attenuation && inout -> "attenuation,inout" attenuation -> "attenuation" inout -> "inout" else -> "" } return stringTemplateValues } private fun getLengthTypeHint(): String { if (listOf(Float::class, Double::class).map { it.toString() }.contains(propertyDescriptor.type.toString())) { throw WrongAnnotationUsageException(propertyDescriptor, propertyHintAnnotation, "Floats and Doubles") } val length = propertyHintAnnotation!!.getAnnotationValue(LENGTH_ANNOTATION_LENGTH_ARGUMENT, -1) return if (length != -1) { "$length" } else { "" } } private fun getFileOrDirTypeHint(): String { if (propertyDescriptor.type.toString() != "String") { throw WrongAnnotationUsageException(propertyDescriptor, propertyHintAnnotation, "String") } val extensions = propertyHintAnnotation!! .getAnnotationValue(FILE_AND_DIR_ANNOTATION_EXTENSIONS_ARGUMENT, ArrayList()) .map { it.value.replace("\"", "") } return join(extensions, ",") } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/RegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import com.squareup.kotlinpoet.MemberName import godot.entrygenerator.extension.assignmentPsi import godot.entrygenerator.extension.getAnnotationValue import godot.entrygenerator.extension.getPropertyHintAnnotation import godot.entrygenerator.model.REGISTER_PROPERTY_ANNOTATION import godot.entrygenerator.model.REGISTER_PROPERTY_ANNOTATION_VISIBLE_IN_EDITOR_ARGUMENT import org.jetbrains.kotlin.backend.common.serialization.findPackage import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.js.resolve.diagnostics.findPsi import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.containingClassOrObject import org.jetbrains.kotlin.psi.psiUtil.parents import org.jetbrains.kotlin.psi.psiUtil.referenceExpression import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.bindingContextUtil.getReferenceTargets import org.jetbrains.kotlin.resolve.calls.callUtil.getType import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.descriptorUtil.isCompanionObject import org.jetbrains.kotlin.resolve.descriptorUtil.parents import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassConstructorDescriptor import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedSimpleFunctionDescriptor abstract class RegistrationValuesHandler( val propertyDescriptor: PropertyDescriptor, val bindingContext: BindingContext ) { internal val propertyHintAnnotation = propertyDescriptor.getPropertyHintAnnotation() abstract fun getPropertyTypeHint(): ClassName /** * Hint string formatting: https://github.com/godotengine/godot/blob/dcd11faad3802679a43b27155f1b6bc59aa39b60/core/object.h */ abstract fun getHintString(): String init { checkHintAnnotationUsage() } private fun checkHintAnnotationUsage() { if (!propertyDescriptor.annotations.getAnnotationValue( REGISTER_PROPERTY_ANNOTATION, REGISTER_PROPERTY_ANNOTATION_VISIBLE_IN_EDITOR_ARGUMENT, true ) && propertyHintAnnotation != null ) { throw IllegalStateException("You added the type hint annotation ${propertyHintAnnotation.fqName} to the property ${propertyDescriptor.name}. But the @RegisterProperty annotation is either not present or the isVisibleInEditor flag is not set to true") } if (!propertyDescriptor.isVar) { throw IllegalStateException("You try to register the immutable property ${propertyDescriptor.fqNameSafe} with @RegisterProperty. This is not supported! Each property that you register has to be mutable. Use var or lateinit var.") } } open fun getDefaultValue(): Pair> { if (propertyDescriptor.isLateInit || !isVisibleInEditor()) { return "%L" to arrayOf("null") } val defaultValue = getDefaultValueExpression(propertyDescriptor.assignmentPsi) if (defaultValue == null) { throw IllegalStateException("") //TODO: error } val params = mutableListOf() params.add(ClassName("godot.core", "Variant")) params.addAll(defaultValue.second) return "%T(${defaultValue.first})" to params.toTypedArray() } internal fun isVisibleInEditor(): Boolean { return propertyDescriptor.annotations.getAnnotationValue( REGISTER_PROPERTY_ANNOTATION, REGISTER_PROPERTY_ANNOTATION_VISIBLE_IN_EDITOR_ARGUMENT, true ) } internal fun getDefaultValueExpression(expression: KtExpression): Pair>? { when { //normal contant expression like: val foo = 1 expression is KtConstantExpression -> { return "%L" to arrayOf(expression.text) } //string assignments but no string templations like ("${someVarToPutInString}"): val foo = "this is awesome" expression is KtStringTemplateExpression && !expression.hasInterpolation() -> { return "%S" to arrayOf(expression.text.removeSurrounding("\"")) } expression is KtDotQualifiedExpression -> { val receiver = expression.receiverExpression val receiverRef = receiver.getReferenceTargets(bindingContext).firstOrNull() //Enums if (receiverRef != null) { val psi = receiverRef.findPsi() // TODO: receiver ref might be a deserialized descriptor, fix this once we have core classes if (psi is KtClass && psi.isEnum()) { val fqName = psi.fqName require(fqName != null) val pkg = fqName.parent().asString() val className = fqName.shortName().asString() return "%T.%L" to arrayOf(ClassName(pkg, className), expression.selectorExpression!!.text) } else if (receiverRef.isCompanionObject()) { //static ref like Vector3.UP val packagePath = requireNotNull(receiverRef.containingDeclaration).fqNameSafe.asString() val expr = expression.text.substringAfter(".") return "%T.%L" to arrayOf(ClassName(packagePath.substringBeforeLast("."), packagePath.substringAfterLast(".")), expr) } //multiline strings } else if (receiver is KtStringTemplateExpression) { val selectorExpression = expression .selectorExpression ?.referenceExpression() ?.getReferenceTargets(bindingContext) ?.firstOrNull() if (selectorExpression?.fqNameSafe?.asString() == "kotlin.text.trimIndent") { val packagePath = selectorExpression .fqNameSafe .asString() .replace(".${selectorExpression.name}", "") return "%L.%M()" to arrayOf( receiver.text, MemberName(packagePath, selectorExpression.name.asString()) ) } } } //call expressions like constructor calls or function calls expression is KtCallExpression -> { val ref = expression .referenceExpression() ?.getReferenceTargets(bindingContext) ?.firstOrNull() if (ref != null) { val psi = ref.findPsi() val transformedArgs = expression .valueArguments .mapNotNull { it.getArgumentExpression() } .map { getDefaultValueExpression(it) } // if an arg is null, then it means that it contained a non static reference var hasNullArg = false for (arg in transformedArgs) { if (arg == null) { hasNullArg = true break } } when { //constructor psi is KtConstructor<*> && !hasNullArg -> { val fqName = psi.containingClassOrObject!!.fqName require(fqName != null) val pkg = fqName.parent().asString() val className = fqName.shortName().asString() val params = mutableListOf() params.add(ClassName(pkg, className)) transformedArgs.forEach { params.addAll(it!!.second) } return "%T(${transformedArgs.joinToString { it!!.first }})" to params.toTypedArray() } //constructor ref is DeserializedClassConstructorDescriptor && !hasNullArg -> { val fqName = ref.constructedClass.fqNameSafe val pkg = fqName.parent().asString() val className = fqName.shortName().asString() val params = mutableListOf() params.add(ClassName(pkg, className)) transformedArgs.forEach { params.addAll(it!!.second) } return "%T(${transformedArgs.joinToString { it!!.first }})" to params.toTypedArray() } //godot arrays and kotlin collections //Note: kotlin collections only as constructor arguments or function params. TypeToVariantAsClassNameMapper already enshures that they are not registered as property types ref is DeserializedSimpleFunctionDescriptor && ( ref.fqNameSafe.asString().matches(Regex("^godot\\.core\\..*(ArrayOf|Array)\$")) || ref.findPackage().fqName.asString() == "kotlin.collections" ) -> { val fqName = ref.fqNameSafe val pkg = fqName.parent().asString() val functionName = fqName.shortName().asString() val params = mutableListOf() params.add(MemberName(pkg, functionName)) transformedArgs.forEach { params.addAll(it!!.second) } return "%M(${transformedArgs.joinToString { it!!.first }})" to params.toTypedArray() } //set's for enum flag registration expression.getType(bindingContext)?.let(KotlinBuiltIns::isSetOrNullableSet) == true -> { //setOf -> ref is null in this case val params = mutableListOf() params.add(expression.children.first().text) transformedArgs.forEach { params.addAll(it!!.second) } return "%L(${transformedArgs.joinToString { it!!.first }})" to params.toTypedArray() } } } } //used for flags: val foo = 1 or 3 and 5 expression is KtBinaryExpression -> { val assignment = expression .children .map { getDefaultValueExpression(it as KtExpression) } if (!assignment.any { it == null }) { return assignment.joinToString("·") { it!!.first } to assignment.map { it!!.second }.toTypedArray().flatten().toTypedArray() } } //static named reference to a global const for example expression is KtNameReferenceExpression -> { val ref = expression .referenceExpression() ?.getReferenceTargets(bindingContext) ?.firstOrNull() if (ref !is PropertyDescriptor) { throw IllegalStateException("You tried to register property ${propertyDescriptor.fqNameSafe} with a reference (${expression.text}) which is not a property. Default values which are references have to be properties. Functions are not yet supported!") } if (!ref.visibility.isPublicAPI && ref.visibility.name != "internal") { throw IllegalStateException("You tried to register property ${propertyDescriptor.fqNameSafe} with a reference (${expression.text}) which is not public. Default values which are references have to be public or at least internal") } if (!ref.isConst && !ref.parents.first().isCompanionObject()) { throw IllegalStateException("You tried to register property ${propertyDescriptor.fqNameSafe} with a reference (${expression.text}) which is not a const or static. Default values which are references have to be compile time constants or have to be static") } return "%M" to arrayOf(MemberName(ref.fqNameSafe.parent().asString(), ref.name.asString())) } //operators like the `or` operator expression is KtOperationReferenceExpression -> { return "%L" to arrayOf(expression.text) } //EnumArray -> int to enum mapping function expression is KtLambdaExpression && expression.parents.firstOrNull { it is KtNameReferenceExpression || it is KtCallExpression } != null -> { expression.parents.forEach { parent -> val packagePathOfParent = when (parent) { is KtNameReferenceExpression -> parent .referenceExpression() ?.getReferenceTargets(bindingContext) ?.firstOrNull() ?.fqNameSafe ?.asString() is KtCallExpression -> parent .referenceExpression() ?.getReferenceTargets(bindingContext) ?.firstOrNull() ?.fqNameSafe ?.asString() else -> null } //we could (and maybe should) check that the user is not using any refs inside the lambda, but IMHO this would be overkill and too much work to catch all edge cases //if he uses refs it just does not compile and he has to figure out himself whats wrong. I guess with proper documentation on how this function should be used, that's enough if (packagePathOfParent?.matches(Regex("^godot\\.core\\.(EnumArray.*|enumVariantArrayOf)\$")) == true) { return "%L" to arrayOf(expression.text) } } } } return null } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/generator/provider/ResourceRegistrationValuesHandler.kt ================================================ package godot.entrygenerator.generator.provider import com.squareup.kotlinpoet.ClassName import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe class ResourceRegistrationValuesHandler( propertyDescriptor: PropertyDescriptor, bindingContext: BindingContext ) : RegistrationValuesHandler(propertyDescriptor, bindingContext) { override fun getDefaultValue(): Pair> { if (!propertyDescriptor.isLateInit && isVisibleInEditor()) { throw IllegalStateException("You initialized the property \"${propertyDescriptor.fqNameSafe}\". Properties of type Resource which are registered using the @RegisterProperty annotation and are visible in the editor are not allowed to have a default value. Use lateinit.") } return super.getDefaultValue() } override fun getPropertyTypeHint(): ClassName { return ClassName( "godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_RESOURCE_TYPE" ) } override fun getHintString(): String { return propertyDescriptor.type.toString() } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/mapper/PropertyHintTypeMapper.kt ================================================ package godot.entrygenerator.mapper import com.squareup.kotlinpoet.ClassName import godot.entrygenerator.extension.getAnnotationValue import godot.entrygenerator.model.* import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.constants.StringValue import org.jetbrains.kotlin.types.typeUtil.isEnum import org.jetbrains.kotlin.utils.join import kotlin.reflect.KClass //TODO: remove this file. Still here for reference until all RegistrationValueHandler's are implemented object PropertyHintTypeMapper { fun mapAnnotationDescriptorToPropertyTypeClassName(annotationDescriptor: AnnotationDescriptor?): ClassName { return when (annotationDescriptor?.fqName?.asString()) { "godot.annotation.IntRange", "godot.annotation.FloatRange", "godot.annotation.DoubleRange" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_RANGE") "godot.annotation.ExpRange" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_EXP_RANGE") "godot.annotation.EnumTypeHint" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_ENUM") "godot.annotation.ExpEasing" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_EXP_EASING") "godot.annotation.Lenght" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LENGHT") "godot.annotation.Flags" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_FLAGS") "godot.annotation.Layers2DRender" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LAYERS_2D_RENDER") "godot.annotation.Layers2DPhysics" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LAYERS_2D_PHYSICS") "godot.annotation.Layers3DRender" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LAYERS_3D_RENDER") "godot.annotation.Layers3DPhysics" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_LAYERS_3D_PHYSICS") "godot.annotation.File" -> if (annotationDescriptor.getAnnotationValue(FILE_AND_DIR_ANNOTATION_GLOBAL_ARGUMENT, false)) { ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_GLOBAL_FILE") } else { ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_FILE") } "godot.annotation.Dir" -> if (annotationDescriptor.getAnnotationValue(FILE_AND_DIR_ANNOTATION_GLOBAL_ARGUMENT, false)) { ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_GLOBAL_DIR") } else { ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_DIR") } "godot.annotation.ResourceType" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_RESOURCE_TYPE") "godot.annotation.MultilineText" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_MULTILINE_TEXT") "godot.annotation.PlaceHolderText" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PLACE_HOLDER_TEXT") "godot.annotation.ColorNoAlpha" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_COLOR_NO_ALPHA") "godot.annotation.ImageCompressLossy" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSY") "godot.annotation.ImageCompressLossLess" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS") "godot.annotation.ObjectId" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_OBJECT_ID") "godot.annotation.TypeString" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_TYPE_STRING") "godot.annotation.NodePathToEditedNode" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_NODEPATH_TO_EDITED_NODE") "godot.annotation.MethodOfVariantType" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_METHOD_OF_VARIANT_TYPE") "godot.annotation.MethodOfBaseType" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_METHOD_OF_BASE_TYPE") "godot.annotation.MethodOfInstance" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_METHOD_OF_INSTANCE") "godot.annotation.MethodOfScript" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_METHOD_OF_SCRIPT") "godot.annotation.PropertyOfVariantType" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PROPERTY_OF_VARIANT_TYPE") "godot.annotation.PropertyOfBaseType" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PROPERTY_OF_BASE_TYPE") "godot.annotation.PropertyOfInstance" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PROPERTY_OF_INSTANCE") "godot.annotation.PropertyOfScript" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_PROPERTY_OF_SCRIPT") "godot.annotation.ObjectTooBig" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_OBJECT_TOO_BIG") "godot.annotation.NodePathValidTypes" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_NODEPATH_VALID_TYPES") "godot.annotation.SaveFile" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_SAVE_FILE") "godot.annotation.IntIsObjectId" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_INT_IS_OBJECT_ID") "godot.annotation.Max" -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_MAX") null -> ClassName("godot.gdnative.godot_property_hint", "GODOT_PROPERTY_HINT_NONE") else -> throw IllegalStateException("Unknown annotation ${annotationDescriptor.fqName}") } } fun mapAnnotationDescriptorToPropertyHintString( propertyDescriptor: PropertyDescriptor, annotationDescriptor: AnnotationDescriptor? ): String { if (!propertyDescriptor.annotations.getAnnotationValue( REGISTER_PROPERTY_ANNOTATION, REGISTER_PROPERTY_ANNOTATION_VISIBLE_IN_EDITOR_ARGUMENT, true ) && annotationDescriptor != null ) { throw IllegalStateException("You added the type hint annotation ${annotationDescriptor.fqName} to the property ${propertyDescriptor.name}. But the @RegisterProperty annotation is either not present or the isVisibleInEditor flag is not set to true") } return when (annotationDescriptor?.fqName?.asString()) { "godot.annotation.IntRange" -> getRangeTypeHint(annotationDescriptor, arrayOf(Int::class), propertyDescriptor) "godot.annotation.FloatRange" -> getRangeTypeHint(annotationDescriptor, arrayOf(Float::class), propertyDescriptor) "godot.annotation.DoubleRange" -> getRangeTypeHint(annotationDescriptor, arrayOf(Double::class), propertyDescriptor) "godot.annotation.ExpRange" -> getRangeTypeHint(annotationDescriptor, arrayOf(Float::class, Double::class), propertyDescriptor) "godot.annotation.EnumTypeHint" -> getEnumTypeHint(propertyDescriptor) "godot.annotation.ExpEasing" -> getExpEasingTypeHint(annotationDescriptor, propertyDescriptor) "godot.annotation.Lenght" -> throw NotImplementedError("@Lenght annotation is not yet implemented") //getLengthTypeHint(annotationDescriptor, propertyDescriptor) "godot.annotation.Flags" -> throw NotImplementedError("@Flags annotation is not yet implemented")//getFlagsTypeHint(propertyDescriptor) "godot.annotation.Layers2DRender" -> throw NotImplementedError("@Layers2DRender annotation is not yet implemented") "godot.annotation.Layers2DPhysics" -> throw NotImplementedError("@Layers2DPhysics annotation is not yet implemented") "godot.annotation.Layers3DRender" -> throw NotImplementedError("@Layers3DRender annotation is not yet implemented") "godot.annotation.Layers3DPhysics" -> throw NotImplementedError("@Layers3DPhysics annotation is not yet implemented") "godot.annotation.File", "godot.annotation.Dir" -> getFileOrDirTypeHint(annotationDescriptor, propertyDescriptor) "godot.annotation.ResourceType" -> throw NotImplementedError("@ResourceType annotation is not yet implemented") "godot.annotation.MultilineText" -> throw NotImplementedError("@MultilineText annotation is not yet implemented") "godot.annotation.PlaceHolderText" -> throw NotImplementedError("@PlaceHolderText annotation is not yet implemented") "godot.annotation.ColorNoAlpha" -> getColorNoAlphaHintString(propertyDescriptor) "godot.annotation.ImageCompressLossy" -> throw NotImplementedError("@ImageCompressLossy annotation is not yet implemented") "godot.annotation.ImageCompressLossLess" -> throw NotImplementedError("@ImageCompressLossLess annotation is not yet implemented") "godot.annotation.ObjectId" -> throw NotImplementedError("@ObjectId annotation is not yet implemented") "godot.annotation.TypeString" -> throw NotImplementedError("@TypeString annotation is not yet implemented") "godot.annotation.NodePathToEditedNode" -> throw NotImplementedError("@NodePathToEditedNode annotation is not yet implemented") "godot.annotation.MethodOfVariantType" -> throw NotImplementedError("@MethodOfVariantType annotation is not yet implemented") "godot.annotation.MethodOfBaseType" -> throw NotImplementedError("@MethodOfBaseType annotation is not yet implemented") "godot.annotation.MethodOfInstance" -> throw NotImplementedError("@MethodOfInstance annotation is not yet implemented") "godot.annotation.MethodOfScript" -> throw NotImplementedError("@MethodOfScript annotation is not yet implemented") "godot.annotation.PropertyOfVariantType" -> throw NotImplementedError("@PropertyOfVariantType annotation is not yet implemented") "godot.annotation.PropertyOfBaseType" -> throw NotImplementedError("@PropertyOfBaseType annotation is not yet implemented") "godot.annotation.PropertyOfInstance" -> throw NotImplementedError("@PropertyOfInstance annotation is not yet implemented") "godot.annotation.PropertyOfScript" -> throw NotImplementedError("@PropertyOfScript annotation is not yet implemented") "godot.annotation.ObjectTooBig" -> throw NotImplementedError("@ObjectTooBig annotation is not yet implemented") "godot.annotation.NodePathValidTypes" -> throw NotImplementedError("@NodePathValidTypes annotation is not yet implemented") "godot.annotation.SaveFile" -> throw NotImplementedError("@SaveFile annotation is not yet implemented") "godot.annotation.IntIsObjectId" -> throw NotImplementedError("@IntIsObjectId annotation is not yet implemented") "godot.annotation.Max" -> throw NotImplementedError("@Max annotation is not yet implemented") null -> "" else -> throw IllegalStateException("Unknown annotation ${annotationDescriptor.fqName}") } } private fun mapCompilerEnumRepresentationToClassName(enumRepresentation: Pair): ClassName { return ClassName( enumRepresentation.first.asString().replace("/", ".").replace(".${enumRepresentation.second}", ""), enumRepresentation.second.asString() ) } private fun getRangeTypeHint( annotationDescriptor: AnnotationDescriptor, expectedTypes: Array>, propertyDescriptor: PropertyDescriptor ): String { if (expectedTypes.map { it.toString() }.contains(propertyDescriptor.type.toString())) { throw IllegalStateException("You annotated the property ${propertyDescriptor.name} which is of type ${propertyDescriptor.type} with a range annotation of type $expectedTypes. Use the correct Annotation for the type") } val start = annotationDescriptor.getAnnotationValue(RANGE_ANNOTATION_START_ARGUMENT, -1) val end = annotationDescriptor.getAnnotationValue(RANGE_ANNOTATION_END_ARGUMENT, -1) val step = annotationDescriptor.getAnnotationValue(RANGE_ANNOTATION_STEP_ARGUMENT, -1) val or = annotationDescriptor.getAnnotationValue( RANGE_ANNOTATION_OR_ARGUMENT, Pair(ClassId(FqName("godot.registration"), Name.identifier("Range")), Name.identifier("NONE")) ) val orAsClassName = mapCompilerEnumRepresentationToClassName(or) val argumentsForStringTemplate = mutableListOf() argumentsForStringTemplate.add(start) argumentsForStringTemplate.add(end) if (step != -1) { argumentsForStringTemplate.add(step) } if (orAsClassName.toString() != "godot.registration.Range.NONE") { argumentsForStringTemplate.add(orAsClassName.toString().split(".").last().toLowerCase()) } return join(argumentsForStringTemplate, ",") } private fun getEnumTypeHint(propertyDescriptor: PropertyDescriptor): String { if (!propertyDescriptor.type.isEnum()) { throw IllegalStateException("You annotated the property ${propertyDescriptor.name} which is of type ${propertyDescriptor.type} with @EnumTypeHint. Only enums can have this annotation!") } val enumValues = propertyDescriptor .type .memberScope .getVariableNames() .map { it.asString() } .filter { it != "name" && it != "ordinal" } return join(enumValues, ",") } private fun getExpEasingTypeHint( annotationDescriptor: AnnotationDescriptor, propertyDescriptor: PropertyDescriptor ): String { if (listOf(Float::class, Double::class).map { it.toString() }.contains(propertyDescriptor.type.toString())) { throw IllegalStateException("You annotated the property ${propertyDescriptor.name} which is of type ${propertyDescriptor.type} with @ExpEasing. This annotation is only applicable for Floats and Doubles.") } val attenuation = annotationDescriptor.getAnnotationValue(EXP_EASING_ANNOTATION_ATTENUATION_ARGUMENT, false) val inout = annotationDescriptor.getAnnotationValue(EXP_EASING_ANNOTATION_INOUT_ARGUMENT, true) val stringTemplateValues = when { attenuation && inout -> "attenuation,inout" attenuation -> "attenuation" inout -> "inout" else -> "" } return stringTemplateValues } private fun getLengthTypeHint( annotationDescriptor: AnnotationDescriptor, propertyDescriptor: PropertyDescriptor ): String { if (listOf(Float::class, Double::class).map { it.toString() }.contains(propertyDescriptor.type.toString())) { throw IllegalStateException("You annotated the property ${propertyDescriptor.name} which is of type ${propertyDescriptor.type} with @Length. This annotation is only applicable for Floats and Doubles.") } val length = annotationDescriptor.getAnnotationValue(LENGTH_ANNOTATION_LENGTH_ARGUMENT, -1) return if (length != -1) { "$length" } else { "" } } private fun getFlagsTypeHint( propertyDescriptor: PropertyDescriptor ): String { if ( !(propertyDescriptor.type.toString().startsWith("Map") && propertyDescriptor.type.arguments.first().type.isEnum() && propertyDescriptor.type.arguments.last().type.toString() == "Boolean") ) { throw IllegalStateException("You annotated the property ${propertyDescriptor.name} which is of type ${propertyDescriptor.type} with @Flags. This annotation is only applicable for Map.") } val enumValues = propertyDescriptor .type .arguments .first() .type .memberScope .getVariableNames() .map { it.asString() } .filter { it != "name" || it != "ordinal" } return join(enumValues, ",") } private fun getFileOrDirTypeHint( annotationDescriptor: AnnotationDescriptor, propertyDescriptor: PropertyDescriptor ): String { if (propertyDescriptor.type.toString() != "String") { throw IllegalStateException("You annotated the property ${propertyDescriptor.name} which is of type ${propertyDescriptor.type} with ${annotationDescriptor.fqName}. This annotation is only applicable to String.") } val extensions = annotationDescriptor .getAnnotationValue(FILE_AND_DIR_ANNOTATION_EXTENSIONS_ARGUMENT, ArrayList()) .map { it.value.replace("\"", "") } return join(extensions, ",") } private fun getColorNoAlphaHintString( propertyDescriptor: PropertyDescriptor ): String { if (propertyDescriptor.type.toString() != "Color") { throw IllegalStateException("You annotated the property ${propertyDescriptor.name} which is of type ${propertyDescriptor.type} with @ColorNoAlpha. This annotation is only applicable to Color.") } return "" } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/mapper/RpcModeAnnotationMapper.kt ================================================ package godot.entrygenerator.mapper import com.squareup.kotlinpoet.ClassName object RpcModeAnnotationMapper { /** * maps RpcModeAnnotations and RPCMode registration enums to ClassNames to provide import informations for kotlinPoet */ fun mapRpcModeAnnotationToClassName(rpcModeAnnotationAsString: String): ClassName { return when (rpcModeAnnotationAsString) { "godot.MultiplayerAPI.RPCMode.DISABLED" -> ClassName("godot.MultiplayerAPI.RPCMode", "DISABLED") "godot.MultiplayerAPI.RPCMode.REMOTE" -> ClassName("godot.MultiplayerAPI.RPCMode", "REMOTE") "godot.MultiplayerAPI.RPCMode.MASTER" -> ClassName("godot.MultiplayerAPI.RPCMode", "MASTER") "godot.MultiplayerAPI.RPCMode.PUPPET" -> ClassName("godot.MultiplayerAPI.RPCMode", "PUPPET") "godot.MultiplayerAPI.RPCMode.REMOTESYNC" -> ClassName("godot.MultiplayerAPI.RPCMode", "REMOTESYNC") "godot.MultiplayerAPI.RPCMode.MASTERSYNC" -> ClassName("godot.MultiplayerAPI.RPCMode", "MASTERSYNC") "godot.MultiplayerAPI.RPCMode.PUPPETSYNC" -> ClassName("godot.MultiplayerAPI.RPCMode", "PUPPETSYNC") "godot.MultiplayerAPI.RPCMode.SLAVE" -> ClassName("godot.MultiplayerAPI.RPCMode", "SLAVE") "godot.MultiplayerAPI.RPCMode.SYNC" -> ClassName("godot.MultiplayerAPI.RPCMode", "SYNC") else -> throw IllegalArgumentException("Unknown annotation or registration $rpcModeAnnotationAsString") } } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/mapper/TypeToVariantAsClassNameMapper.kt ================================================ package godot.entrygenerator.mapper import com.squareup.kotlinpoet.ClassName import godot.entrygenerator.extension.isCompatibleList import org.jetbrains.kotlin.types.KotlinType object TypeToVariantAsClassNameMapper { fun mapTypeToVariantAsClassName( typeAsString: String, type: KotlinType? = null, isEnum: Boolean = false ): ClassName { if (isEnum) { return ClassName("godot.core.Variant.Type", "STRING") } return when (typeAsString) { "Byte", "Short", "Int", "Long" -> ClassName("godot.core.Variant.Type", "INT") "Float", "Double" -> ClassName("godot.core.Variant.Type", "REAL") "Boolean" -> ClassName("godot.core.Variant.Type", "BOOL") "String" -> ClassName("godot.core.Variant.Type", "STRING") "RID" -> ClassName("godot.core.Variant.Type", "_RID") "Vector2", "Rect2", "Vector3", "Transform2D", "Plane", "Quat", "Rect3", "Basis", "Transform", "Color", "Dictionary" -> ClassName("godot.core.Variant.Type", typeAsString.toUpperCase()) "NodePath" -> ClassName("godot.core.Variant.Type", "NODE_PATH") "PoolByteArray" -> ClassName("godot.core.Variant.Type", "POOL_BYTE_ARRAY") "PoolIntArray" -> ClassName("godot.core.Variant.Type", "POOL_INT_ARRAY") "PoolReadArray" -> ClassName("godot.core.Variant.Type", "POOL_REAL_ARRAY") "PoolStringArray" -> ClassName("godot.core.Variant.Type", "POOL_STRING_ARRAY") "PoolVector2Array" -> ClassName("godot.core.Variant.Type", "POOL_VECTOR2_ARRAY") "PoolVector3Array" -> ClassName("godot.core.Variant.Type", "POOL_VECTOR3_ARRAY") "PoolColorArray" -> ClassName("godot.core.Variant.Type", "POOL_COLOR_ARRAY") else -> { if (type != null && type.isCompatibleList()) { ClassName("godot.core.Variant.Type", "ARRAY") } else { ClassName("godot.core.Variant.Type", "OBJECT") } } } } } ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/model/Annotations.kt ================================================ package godot.entrygenerator.model const val REGISTER_CLASS_ANNOTATION = "godot.annotation.RegisterClass" const val REGISTER_FUNCTION_ANNOTATION = "godot.annotation.RegisterFunction" const val REGISTER_PROPERTY_ANNOTATION = "godot.annotation.RegisterProperty" const val REGISTER_CLASS_ANNOTATION_TOOL_ARGUMENT = "isTool" const val REGISTER_FUNCTION_ANNOTATION_RPC_MODE_ARGUMENT = "rpcMode" const val REGISTER_PROPERTY_ANNOTATION_VISIBLE_IN_EDITOR_ARGUMENT = "visibleInEditor" const val REGISTER_PROPERTY_ANNOTATION_RPC_MODE_ARGUMENT = "rpcMode" const val RANGE_ANNOTATION_START_ARGUMENT = "start" const val RANGE_ANNOTATION_END_ARGUMENT = "end" const val RANGE_ANNOTATION_STEP_ARGUMENT = "step" const val RANGE_ANNOTATION_OR_ARGUMENT = "or" const val EXP_EASING_ANNOTATION_ATTENUATION_ARGUMENT = "attenuation" const val EXP_EASING_ANNOTATION_INOUT_ARGUMENT = "inout" const val LENGTH_ANNOTATION_LENGTH_ARGUMENT = "length" const val FILE_AND_DIR_ANNOTATION_EXTENSIONS_ARGUMENT = "extensions" const val FILE_AND_DIR_ANNOTATION_GLOBAL_ARGUMENT = "global" const val INT_FLAG_ANNOTATION_NAMES_ARGUMENT = "names" ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/model/ClassWithMembers.kt ================================================ package godot.entrygenerator.model import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor data class ClassWithMembers( val classDescriptor: ClassDescriptor, val functions: MutableList = mutableListOf(), val signals: MutableList = mutableListOf(), val properties: MutableList = mutableListOf() ) ================================================ FILE: entry-generation/godot-entry-generator/src/main/kotlin/godot/entrygenerator/transformer/TypeDeclarationsToClassWithMemberTransformer.kt ================================================ package godot.entrygenerator.transformer import godot.entrygenerator.model.ClassWithMembers import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor fun transformTypeDeclarationsToClassWithMember( classes: Set, properties: Set, functions: Set, signals: Set ): Set { val classesWithMembers = mutableSetOf() classes.forEach { classesWithMembers.add(ClassWithMembers(it)) } properties.forEach { propertyDescriptor -> classesWithMembers .first { it.classDescriptor == propertyDescriptor.containingDeclaration } .properties .add(propertyDescriptor) } functions.forEach { functionDescriptor -> classesWithMembers .first { it.classDescriptor == functionDescriptor.containingDeclaration } .functions .add(functionDescriptor) } signals.forEach { propertyDescriptor -> classesWithMembers .first { it.classDescriptor == propertyDescriptor.containingDeclaration } .signals .add(propertyDescriptor) } return classesWithMembers } ================================================ FILE: godot-kotlin/godot-library/build.gradle.kts ================================================ import godot.tasks.GenerateApiTask import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget import com.jfrog.bintray.gradle.tasks.BintrayUploadTask import org.gradle.api.publish.maven.internal.artifact.FileBasedMavenArtifact plugins { kotlin("multiplatform") `maven-publish` } //TODO: this needs to be properly configured! This is just a basic setup to be able to implement the annotations kotlin { // we don't have godot-library in the mobile targets yet, limit these to desktop for now //has to be change in `GodotPlugin` of `godot-gradle-plugin` as well macosX64("macos") linuxX64("linux") mingwX64("windows") // val internalSourceSet = sourceSets.create("nativeInternal") // val coreSourceSet = sourceSets.create("nativeCore") { dependsOn(internalSourceSet) } // val generatedSourceSet = sourceSets.create("nativeGen") { dependsOn(coreSourceSet) } // val publicSourceSet = sourceSets.create("nativePublic") { dependsOn(generatedSourceSet) } targets.withType { compilations.getByName("main") { defaultSourceSet { // dependsOn(internalSourceSet) // dependsOn(generatedSourceSet) // dependsOn(coreSourceSet) // dependsOn(publicSourceSet) kotlin.srcDirs( listOf( "nativeInternal", "nativeCore", "nativeGen", "nativePublic" ).map { "src/$it/kotlin" }) } val gdnative by cinterops.creating { defFile("src/nativeInterop/cinterop/godot.def") includeDirs("$rootDir/godot-kotlin/godot-headers/", "src/nativeInterop/cinterop") } } } sourceSets { all { languageSettings.enableLanguageFeature("InlineClasses") } } } val generateAPI by tasks.creating(GenerateApiTask::class) { source.set(project.file("$rootDir/godot-kotlin/godot-headers/api.json")) outputDirectory.set(project.file("$rootDir/godot-kotlin/godot-library/src/nativeGen/kotlin/")) } tasks.withType { dependsOn(generateAPI) } tasks { build { finalizedBy(publishToMavenLocal) } // workaround to upload gradle metadata file // https://github.com/bintray/gradle-bintray-plugin/issues/229 withType { doFirst { publishing.publications.withType { buildDir.resolve("publications/$name/module.json").also { if (it.exists()) { artifact(object: FileBasedMavenArtifact(it) { override fun getDefaultExtension() = "module" }) } } } } } } //TODO: See how to do with mobile platforms project.extra["artifacts"] = when (currentOS) { OS.LINUX -> arrayOf("kotlinMultiplatform", "metadata", "linux") OS.WINDOWS -> arrayOf("windows") OS.MACOS -> arrayOf("macos") } apply { plugin(BintrayPublish::class.java) } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/ClassHandle.kt ================================================ package godot.core import godot.MultiplayerAPI.RPCMode import godot.Object import godot.gdnative.* import godot.internal.type.nullSafe import kotlinx.cinterop.* @PublishedApi internal class ClassHandle( private val nativescriptHandle: COpaquePointer, private val className: String, private val parentClassName: String, private val factory: () -> T, private val isTool: Boolean ) { private val disposables = mutableListOf() fun wrap(instance: COpaquePointer): T { return Godot.instantiateWith(instance, factory) } fun init() { memScoped { val methodData = StableRef.create(this@ClassHandle).asCPointer() // register constructor and destructor val create = cValue { create_func = staticCFunction(::createInstance) free_func = staticCFunction(::disposeClassHandle) method_data = methodData } val destroy = cValue { destroy_func = staticCFunction(::destroyInstance) method_data = methodData } val registerMethod = if (isTool) { Godot.nativescript.godot_nativescript_register_tool_class } else { Godot.nativescript.godot_nativescript_register_class } nullSafe(registerMethod)( nativescriptHandle, className.cstr.ptr, parentClassName.cstr.ptr, create, destroy ) } } fun registerFunction(methodName: String, methodRef: COpaquePointer, rpcMode: RPCMode) { disposables.add(methodRef) memScoped { val attribs = cValue { rpc_type = toGodotRpcMode(rpcMode) } val instanceMethod = cValue { method_data = methodRef this.method = staticCFunction(::invokeMethod) } nullSafe(Godot.nativescript.godot_nativescript_register_method)( nativescriptHandle, className.cstr.ptr, methodName.camelToSnakeCase().cstr.ptr, //not using `camelcaseToUnderscore` to prevent a call to godot for each function attribs, instanceMethod ) } } private fun toGodotRpcMode(rpcMode: RPCMode): godot_method_rpc_mode { return when (rpcMode) { RPCMode.DISABLED -> GODOT_METHOD_RPC_MODE_DISABLED RPCMode.REMOTE -> GODOT_METHOD_RPC_MODE_REMOTE RPCMode.MASTER -> GODOT_METHOD_RPC_MODE_MASTER RPCMode.PUPPET -> GODOT_METHOD_RPC_MODE_PUPPET RPCMode.REMOTESYNC -> GODOT_METHOD_RPC_MODE_REMOTESYNC RPCMode.MASTERSYNC -> GODOT_METHOD_RPC_MODE_MASTERSYNC RPCMode.PUPPETSYNC -> GODOT_METHOD_RPC_MODE_PUPPETSYNC RPCMode.SLAVE -> throw IllegalArgumentException("RPCMode.SLAVE is deprecated in godot! Use RPCMode.PUPPET instead") RPCMode.SYNC -> throw IllegalArgumentException("RPCMode.SYNC is deprecated in godot! Use one of the other sync enums instead") } } @ExperimentalUnsignedTypes fun registerSignal(signalName: String, parameters: Map) { memScoped { val gdSignal = alloc { val argInfos = allocArray(parameters.size) parameters.keys.forEachIndexed { index, key -> val argInfo = argInfos[index] val value = parameters.getValue(key) // argument name nullSafe(Godot.gdnative.godot_string_parse_utf8)(argInfo.name.ptr, key.cstr.ptr) // argument type argInfo.type = value.value.toInt() } args = argInfos.getPointer(this@memScoped) nullSafe(Godot.gdnative.godot_string_parse_utf8)(name.ptr, signalName.removePrefix("signal").decapitalize().camelToSnakeCase().cstr.ptr) //not using `camelcaseToUnderscore` to prevent a call to godot for each signal num_args = parameters.size } nullSafe(Godot.nativescript.godot_nativescript_register_signal)( nativescriptHandle, className.cstr.ptr, gdSignal.ptr ) } } @ExperimentalUnsignedTypes fun registerProperty( propertyName: String, propertyHandleRef: COpaquePointer, propertyType: Variant.Type, default: Variant?, isVisibleInEditor: Boolean, rpcMode: RPCMode, hintType: godot_property_hint, hintString: String ) { disposables.add(propertyHandleRef) memScoped { val usageFlags = if (isVisibleInEditor) { GODOT_PROPERTY_USAGE_DEFAULT } else { GODOT_PROPERTY_USAGE_NOEDITOR } val attribs = alloc { rset_type = toGodotRpcMode(rpcMode) usage = usageFlags type = propertyType.value.toInt() this.hint = hintType nullSafe(Godot.gdnative.godot_string_parse_utf8)(hint_string.ptr, hintString.cstr.ptr) if (default != null) { nullSafe(Godot.gdnative.godot_variant_new_copy)(default_value.ptr, default._handle.ptr) } } val getter = cValue { method_data = propertyHandleRef get_func = staticCFunction(::getProperty) } val setter = cValue { method_data = propertyHandleRef set_func = staticCFunction(::setProperty) } nullSafe(Godot.nativescript.godot_nativescript_register_property)( nativescriptHandle, className.cstr.ptr, propertyName.camelToSnakeCase().cstr.ptr, //not using `camelcaseToUnderscore` to prevent a call to godot for each property attribs.ptr, setter, getter ) } } fun dispose() { disposables.forEach { it.asStableRef().dispose() } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/ClassRegistry.kt ================================================ package godot.core import godot.Object import kotlinx.cinterop.COpaquePointer class ClassRegistry(private val nativescriptHandle: COpaquePointer) { fun registerClass( name: String, parent: String, factory: () -> T, isTool: Boolean, builder: ClassBuilder.() -> Unit ) { val handle = ClassHandle(nativescriptHandle, name, parent, factory, isTool) handle.init() TypeManager.registerUserType(nativescriptHandle, name, factory) builder(ClassBuilder(handle)) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/Godot.kt ================================================ package godot.core import godot.Object import godot.gdnative.* import godot.internal.type.nullSafe import godot.registerEngineTypes import kotlinx.cinterop.* import kotlin.native.concurrent.AtomicInt import kotlin.native.concurrent.AtomicReference object Godot { private val gdnativeWrapper = AtomicReference?>(null) private val nativescriptWrapper = AtomicReference?>(null) internal val gdnative: godot_gdnative_core_api_struct get() = nullSafe(gdnativeWrapper.value).pointed internal val gdnative11: godot_gdnative_core_1_1_api_struct get() = nullSafe(gdnative.next).reinterpret().pointed internal val gdnative12: godot_gdnative_core_1_2_api_struct get() = nullSafe(gdnative11.next).reinterpret().pointed @PublishedApi internal val nativescript: godot_gdnative_ext_nativescript_api_struct get() = nullSafe(nativescriptWrapper.value).pointed @PublishedApi internal val nativescript11: godot_gdnative_ext_nativescript_1_1_api_struct get() = nullSafe(nativescript.next).reinterpret().pointed internal val languageIndex: Int get() = languageIndexRef.value private val languageIndexRef = AtomicInt(-1) private var shouldInit = AtomicInt(1) fun init(options: godot_gdnative_init_options) { val gdnative = nullSafe(options.api_struct) val extensionCount = gdnative.pointed.num_extensions.toInt() val extensions = nullSafe(gdnative.pointed.extensions) lateinit var nativescript: CPointer (0 until extensionCount).forEach { i -> val extension = nullSafe(extensions[i]) val type = extension.pointed.type when (GDNATIVE_API_TYPES.byValue(type)) { GDNATIVE_API_TYPES.GDNATIVE_EXT_NATIVESCRIPT -> { nativescript = extension.reinterpret() } else -> { } } } gdnativeWrapper.compareAndSwap(null, gdnative) nativescriptWrapper.compareAndSwap(null, nativescript) } fun nativescriptInit(handle: COpaquePointer) { memScoped { val info = cValue() { alloc_instance_binding_data = staticCFunction(::createWrapper) free_instance_binding_data = staticCFunction(::destroyWrapper) } val index = nullSafe(nativescript11.godot_nativescript_register_instance_binding_data_functions)( info ) languageIndexRef.compareAndSet(languageIndexRef.value, index) } TypeManager.registerEngineTypes() } fun nativescriptTerminate(handle: COpaquePointer) { TypeManager.dispose() nullSafe(nativescript11.godot_nativescript_unregister_instance_binding_data_functions)(languageIndex) } fun terminate(options: godot_gdnative_terminate_options) { gdnativeWrapper.compareAndSwap(gdnativeWrapper.value, null) nativescriptWrapper.compareAndSwap(nativescriptWrapper.value, null) } /** * Check if the we should initialized the ptr to an object. It also reverts the value of shouldInit * to true. This method is used in conjunction with [instantiateWith] to provide us a mechanism to provide * our own ptr when instantiating an object. */ fun shouldInitPtr(): Boolean { val current = shouldInit.value shouldInit.compareAndSet(current, 0) return current == 0 } fun instantiateWith(ptr: COpaquePointer, constructor: () -> T): T { shouldInit.compareAndSet(shouldInit.value, 1) val instance = constructor() instance.ptr = ptr return instance } internal fun print(message: String) { memScoped { nullSafe(gdnative.godot_print)(message.toGDString().value.ptr) } } internal fun printWarning(description: String, function: String, file: String, line: Int) { memScoped { nullSafe(gdnative.godot_print_warning)(description.cstr.ptr, function.cstr.ptr, file.cstr.ptr, line) } } internal fun printError(description: String, function: String, file: String, line: Int) { memScoped { nullSafe(gdnative.godot_print_error)(description.cstr.ptr, function.cstr.ptr, file.cstr.ptr, line) } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/IndexedIterator.kt ================================================ package godot.core internal class IndexedIterator( private val length: Int, private val getter: (Int) -> T ) : Iterator { private var index = 0 override fun hasNext(): Boolean { return index < length } override fun next(): T { return getter(index++) } } data class Entry(val key: K, val value: V) internal class MapIterator( private val keyIterator: Iterator, private val getter: (K) -> V ) : Iterator> { override fun hasNext(): Boolean { return keyIterator.hasNext() } override fun next(): Entry { val key = keyIterator.next() val value = getter(key) return Entry(key, value) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/MethodBindCache.kt ================================================ package godot.core import godot.gdnative.godot_method_bind import kotlinx.cinterop.CPointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped @ThreadLocal internal object MethodBindCache { private const val KEY_SEPARATOR = "#" private val cache = mutableMapOf>() fun getMethodBind(className: String, methodName: String): CPointer { return cache.getOrPut(makeKey(className, methodName)) { memScoped { Godot.gdnative.godot_method_bind_get_method!!.invoke(className.cstr.getPointer(this), methodName.cstr.ptr) ?: throw NotImplementedError("Cannot get method bind for $methodName in $className") } } } private fun makeKey(className: String, methodName: String) = "$className$KEY_SEPARATOR$methodName" } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/TypeManager.kt ================================================ package godot.core import godot.ClassDB import godot.Object import godot.internal.type.nullSafe import kotlinx.cinterop.* import kotlin.native.concurrent.AtomicReference import kotlin.native.concurrent.freeze internal object TypeManager { private val tags = AtomicReference(mutableListOf().freeze()) /** * Register a user defined type. */ fun registerUserType(nativescriptHandle: COpaquePointer, className: String, factory: () -> Object) { val ref = createAndRegisterTag(factory) memScoped { nullSafe(Godot.nativescript11.godot_nativescript_set_type_tag)( nativescriptHandle, className.cstr.ptr, ref ) } } /** * Register an engine type (i.e Node, Spatial, etc ...). */ fun registerEngineType(className: String, factory: () -> Object) { val ref = createAndRegisterTag(factory) memScoped { nullSafe(Godot.nativescript11.godot_nativescript_set_global_type_tag)( Godot.languageIndex, className.cstr.ptr, ref ) } } /** * Must be called when binding is exiting, this method will cleanup all native resources used by this class. */ fun dispose() { // stable refs need manual cleanup tags.value.map { it.asStableRef<() -> Object>() } .forEach { it.dispose() } } /** * Wrap a native pointer to godot object into the appropriate kotlin type. Returns a generic [godot.core.Object] * if [ptr] does not have any tag information. */ fun wrap(ptr: COpaquePointer): Object { val tag = getTagFromInstancePtr(ptr) val factory = tag ?: ::Object return Godot.instantiateWith(ptr, factory) } private fun createAndRegisterTag(factory: () -> Object): COpaquePointer { val tag = StableRef.create(factory).asCPointer() val copy = mutableListOf() copy.addAll(tags.value) copy.add(tag) tags.compareAndSet(tags.value, copy.freeze()) return tag } private fun getTagFromInstancePtr(ptr: COpaquePointer): (() -> Object)? { return memScoped { val obj = Godot.instantiateWith(ptr, ::Object) val className = obj.getClass() // user defined type // this should be first otherwise casting to a user defined type won't work! var tag = nullSafe(Godot.nativescript11.godot_nativescript_get_type_tag)(ptr) // engine type if (tag == null) { tag = nullSafe(Godot.nativescript11.godot_nativescript_get_global_type_tag)( Godot.languageIndex, className.cstr.ptr ) } // parent class of an engine type (this is here for types not exposed by gdnative) // traverse the type hierarchy to find a tag that we can use if (tag == null) { var parentClass = ClassDB.getParentClass(className) while (parentClass.isNotEmpty()) { tag = nullSafe(Godot.nativescript11.godot_nativescript_get_global_type_tag)( Godot.languageIndex, parentClass.cstr.ptr ) if (tag != null) { break } parentClass = ClassDB.getParentClass(parentClass) } } return tag?.asStableRef<() -> Object>()?.get() } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/Wrapper.kt ================================================ package godot.core import godot.internal.type.nullSafe import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.StableRef import kotlinx.cinterop.asStableRef // I have no idea why this exist, just copied it over from the cpp binding when implementing the cast system. class Wrapped(val instance: COpaquePointer, val tag: COpaquePointer) fun createWrapper(data: COpaquePointer?, tag: COpaquePointer?, instance: COpaquePointer?): COpaquePointer? { val wrapped = Wrapped( nullSafe(instance), nullSafe(tag) ) return StableRef.create(wrapped).asCPointer() } fun destroyWrapper(data: COpaquePointer?, wrapper: COpaquePointer?) { wrapper?.asStableRef()?.dispose() } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/bridge.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_variant import godot.internal.type.nullSafe import kotlinx.cinterop.* fun createInstance(instance: COpaquePointer?, methodData: COpaquePointer?): COpaquePointer? { val classHandle = nullSafe(methodData).asStableRef>() .get() val kotlinInstance = classHandle.wrap(nullSafe(instance)) kotlinInstance._onInit() val stableRef = StableRef.create(kotlinInstance) return stableRef.asCPointer() } fun disposeClassHandle(ref: COpaquePointer?) { val handle = nullSafe(ref).asStableRef>() handle.get().dispose() handle.dispose() } fun destroyInstance(instance: COpaquePointer?, methodData: COpaquePointer?, classData: COpaquePointer?) { val kotlinInstanceRef = nullSafe(classData).asStableRef() val kotlinInstance = kotlinInstanceRef.get() kotlinInstance._onDestroy() kotlinInstanceRef.dispose() } fun invokeMethod( instance: COpaquePointer?, methodData: COpaquePointer?, classData: COpaquePointer?, numArgs: Int, args: CPointer>? ): CValue { val kotlinInstanceRef = nullSafe(classData).asStableRef() val kotlinInstance = kotlinInstanceRef.get() val methodHandleRef = nullSafe(methodData).asStableRef>() val methodHandle = methodHandleRef.get() check(methodHandle.parameterCount == numArgs) { "Invalid number of arguments, $numArgs passed but ${methodHandle.parameterCount} expected." } val variantArgs = if (numArgs == 0) { emptyList() } else { requireNotNull(args) { "args is null!" } val tmp = mutableListOf() for (i in 0 until numArgs) { tmp.add(Variant(args[i]!!.pointed.readValue())) } tmp.toList() } return methodHandle(kotlinInstance, variantArgs)._handle } fun getProperty( instance: COpaquePointer?, methodData: COpaquePointer?, classData: COpaquePointer? ): CValue { val kotlinInstanceRef = nullSafe(classData).asStableRef() val kotlinInstance = kotlinInstanceRef.get() val propertyHandleRef = nullSafe(methodData).asStableRef>() val propertyHandler = propertyHandleRef.get() return propertyHandler.get(kotlinInstance)._handle } fun setProperty( instance: COpaquePointer?, methodData: COpaquePointer?, classData: COpaquePointer?, value: CPointer? ) { val kotlinInstanceRef = nullSafe(classData).asStableRef() val kotlinInstance = kotlinInstanceRef.get() val propertyHandleRef = nullSafe(methodData).asStableRef>() val propertyHandler = propertyHandleRef.get() val arg = if (value == null) { Variant() } else { Variant(value.pointed.readValue()) } propertyHandler.set(kotlinInstance, arg) } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/caseConverterExt.kt ================================================ package godot.core fun String.camelToSnakeCase(): String { return "(?<=[a-zA-Z])[A-Z]".toRegex().replace(this) { "_${it.value}" }.toLowerCase() } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/classBuilderDsl.kt ================================================ @file:Suppress("EXPERIMENTAL_API_USAGE") package godot.core import godot.MultiplayerAPI.RPCMode import godot.Object import godot.gdnative.godot_property_hint import godot.internal.type.toNaturalT import kotlinx.cinterop.StableRef import kotlin.reflect.KMutableProperty1 @DslMarker @Target(AnnotationTarget.CLASS) @Retention(AnnotationRetention.SOURCE) annotation class ClassBuilderDSL @ClassBuilderDSL class ClassBuilder internal constructor(val classHandle: ClassHandle) { fun function( name: String, rpcMode: RPCMode, body: T.() -> R, typeToVariantConverter: (R) -> Variant ) { val function = Function0(body, typeToVariantConverter) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function1(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0, P1) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function2(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0, P1, P2) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function3(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0, P1, P2, P3) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function4(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0, P1, P2, P3, P4) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function5(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0, P1, P2, P3, P4, P5) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function6(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0, P1, P2, P3, P4, P5, P6) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function7(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0, P1, P2, P3, P4, P5, P6, P7) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function8(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0, P1, P2, P3, P4, P5, P6, P7, P8) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function9(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun function( name: String, rpcMode: RPCMode, body: T.(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R, typeToVariantConverter: (R) -> Variant, variantToTypeConverters: List<(Variant) -> Any?> ) { val function = Function10(body, typeToVariantConverter, variantToTypeConverters) classHandle.registerFunction(name, StableRef.create(function).asCPointer(), rpcMode) } fun signal(name: String, parameters: Map) { classHandle.registerSignal(name, parameters) } fun property( name: String, property: KMutableProperty1, typeToVariantConverter: (K) -> Variant, variantToTypeConverter: (Variant) -> Any?, type: Variant.Type, default: Variant? = null, isVisibleInEditor: Boolean = true, rpcMode: RPCMode, hintType: godot_property_hint = godot_property_hint.GODOT_PROPERTY_HINT_NONE, hintString: String = "" ) { val propertyHandler = MutablePropertyHandler(property, typeToVariantConverter, variantToTypeConverter) classHandle.registerProperty( name, StableRef.create(propertyHandler).asCPointer(), type, default, isVisibleInEditor, rpcMode, hintType, hintString ) } inline fun > enumProperty( name: String, property: KMutableProperty1, default: Variant? = null, isVisibleInEditor: Boolean = true, rpcMode: RPCMode ) { val propertyHandler = MutableEnumPropertyHandler(property) { ord -> enumValues()[ord] } classHandle.registerProperty( name, StableRef.create(propertyHandler).asCPointer(), Variant.Type.STRING, default, isVisibleInEditor, rpcMode, godot_property_hint.GODOT_PROPERTY_HINT_ENUM, enumValues().joinToString { it.name } ) } inline fun > enumListProperty( name: String, property: KMutableProperty1>, default: EnumArray? = null, isVisibleInEditor: Boolean = true, rpcMode: RPCMode ) { val variantArray = IntVariantArray() if (default != null) { default.forEach { variantArray.append(it.ordinal.toNaturalT()) } } val propertyHandler = MutablePropertyHandler( property, typeToVariantConversionFunctions[Int::class] ?: error("Could not find intToVariant conversion function. This should never happen. Was it removed/renamed recently?"), variantToTypeConversionFunctions[Int::class] as (Variant) -> Int? ) classHandle.registerProperty( name, StableRef.create(propertyHandler).asCPointer(), Variant.Type.ARRAY, Variant(variantArray), isVisibleInEditor, rpcMode, godot_property_hint.GODOT_PROPERTY_HINT_ENUM, "2/3:${enumValues().joinToString(",") { it.name }}" //2 = Variant.Type.Int.ordinal | 3 = PropertyHint.PROPERTY_HINT_ENUM.ordinal ) } inline fun > enumFlagProperty( name: String, property: KMutableProperty1>, default: Set>? = null, isVisibleInEditor: Boolean = true, rpcMode: RPCMode ) { var intFlag = 0 default?.forEach { enum -> intFlag += 1 shl enum.ordinal } val propertyHandler = MutableEnumFlagPropertyHandler(property) { ord -> enumValues().firstOrNull { it.ordinal == ord } } classHandle.registerProperty( name, StableRef.create(propertyHandler).asCPointer(), Variant.Type.INT, Variant(intFlag), isVisibleInEditor, rpcMode, godot_property_hint.GODOT_PROPERTY_HINT_FLAGS, enumValues().joinToString { it.name } ) } @Suppress("UNCHECKED_CAST") inline fun getTypeToVariantConversionFunction(): (CONVERTED) -> Variant = (typeToVariantConversionFunctions[CONVERTED::class] ?: throw IllegalArgumentException("There is no variant conversion function from type ${CONVERTED::class}")) @Suppress("UNCHECKED_CAST") inline fun getVariantToTypeConversionFunction(): (Variant) -> CONVERTED? = (variantToTypeConversionFunctions[CONVERTED::class] ?: throw IllegalArgumentException("There is no type conversion function for type ${CONVERTED::class}")) as (Variant) -> CONVERTED? } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/functions.kt ================================================ package godot.core import godot.Object abstract class Function( val parameterCount: Int ) { abstract operator fun invoke(instance: T, args: List): Variant } class Function0( val method: T.() -> R, val typeToVariantConverter: (R) -> Variant ) : Function(0) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance ) ) } } class Function1( val method: T.(P0) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(1) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0 ) ) } } class Function2( val method: T.(P0, P1) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(2) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0, variantToTypeConverters[1].invoke(args[1]) as P1 ) ) } } class Function3( val method: T.(P0, P1, P2) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(3) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0, variantToTypeConverters[1].invoke(args[1]) as P1, variantToTypeConverters[2].invoke(args[2]) as P2 ) ) } } class Function4( val method: T.(P0, P1, P2, P3) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(4) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0, variantToTypeConverters[1].invoke(args[1]) as P1, variantToTypeConverters[2].invoke(args[2]) as P2, variantToTypeConverters[3].invoke(args[3]) as P3 ) ) } } class Function5( val method: T.(P0, P1, P2, P3, P4) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(5) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0, variantToTypeConverters[1].invoke(args[1]) as P1, variantToTypeConverters[2].invoke(args[2]) as P2, variantToTypeConverters[3].invoke(args[3]) as P3, variantToTypeConverters[4].invoke(args[4]) as P4 ) ) } } class Function6( val method: T.(P0, P1, P2, P3, P4, P5) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(6) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0, variantToTypeConverters[1].invoke(args[1]) as P1, variantToTypeConverters[2].invoke(args[2]) as P2, variantToTypeConverters[3].invoke(args[3]) as P3, variantToTypeConverters[4].invoke(args[4]) as P4, variantToTypeConverters[5].invoke(args[5]) as P5 ) ) } } class Function7( val method: T.(P0, P1, P2, P3, P4, P5, P6) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(7) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0, variantToTypeConverters[1].invoke(args[1]) as P1, variantToTypeConverters[2].invoke(args[2]) as P2, variantToTypeConverters[3].invoke(args[3]) as P3, variantToTypeConverters[4].invoke(args[4]) as P4, variantToTypeConverters[5].invoke(args[5]) as P5, variantToTypeConverters[6].invoke(args[6]) as P6 ) ) } } class Function8( val method: T.(P0, P1, P2, P3, P4, P5, P6, P7) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(8) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0, variantToTypeConverters[1].invoke(args[1]) as P1, variantToTypeConverters[2].invoke(args[2]) as P2, variantToTypeConverters[3].invoke(args[3]) as P3, variantToTypeConverters[4].invoke(args[4]) as P4, variantToTypeConverters[5].invoke(args[5]) as P5, variantToTypeConverters[6].invoke(args[6]) as P6, variantToTypeConverters[7].invoke(args[7]) as P7 ) ) } } class Function9( val method: T.(P0, P1, P2, P3, P4, P5, P6, P7, P8) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(9) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0, variantToTypeConverters[1].invoke(args[1]) as P1, variantToTypeConverters[2].invoke(args[2]) as P2, variantToTypeConverters[3].invoke(args[3]) as P3, variantToTypeConverters[4].invoke(args[4]) as P4, variantToTypeConverters[5].invoke(args[5]) as P5, variantToTypeConverters[6].invoke(args[6]) as P6, variantToTypeConverters[7].invoke(args[7]) as P7, variantToTypeConverters[8].invoke(args[8]) as P8 ) ) } } class Function10( val method: T.(P0, P1, P2, P3, P4, P5, P6, P7, P8, P9) -> R, val typeToVariantConverter: (R) -> Variant, val variantToTypeConverters: List<(Variant) -> Any?> ) : Function(10) { override fun invoke(instance: T, args: List): Variant { return typeToVariantConverter.invoke( method( instance, variantToTypeConverters[0].invoke(args[0]) as P0, variantToTypeConverters[1].invoke(args[1]) as P1, variantToTypeConverters[2].invoke(args[2]) as P2, variantToTypeConverters[3].invoke(args[3]) as P3, variantToTypeConverters[4].invoke(args[4]) as P4, variantToTypeConverters[5].invoke(args[5]) as P5, variantToTypeConverters[6].invoke(args[6]) as P6, variantToTypeConverters[7].invoke(args[7]) as P7, variantToTypeConverters[8].invoke(args[8]) as P8, variantToTypeConverters[9].invoke(args[9]) as P9 ) ) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/properties.kt ================================================ package godot.core import godot.Object import kotlin.reflect.KMutableProperty1 open class MutablePropertyHandler( protected val property: KMutableProperty1, val typeToVariantConverter: (R) -> Variant?, val variantToTypeConverter: (Variant) -> Any? ) { open fun get(instance: T): Variant { return typeToVariantConverter( property.get(instance) ) ?: Variant() } open fun set(instance: T, value: Variant) { property.set(instance, variantToTypeConverter(value) as R) } } class MutableEnumPropertyHandler>( property: KMutableProperty1, private val converter: (Int) -> R ) : MutablePropertyHandler( property, typeToVariantConversionFunctions[Int::class] ?: error("Could not find intToVariant conversion function. This should never happen. Was it removed/renamed recently?"), { {null} } ) { override fun get(instance: T): Variant { return Variant( property.get(instance).ordinal ) } override fun set(instance: T, value: Variant) { property.set(instance, converter(value.asInt())) } } class MutableEnumFlagPropertyHandler>( property: KMutableProperty1>, private val converter: (Int) -> R? ) : MutablePropertyHandler>( property, typeToVariantConversionFunctions[Int::class] ?: error("Could not find intToVariant conversion function. This should never happen. Was it removed/renamed recently?"), variantToTypeConversionFunctions[Int::class] as (Variant) -> Int? ) { override fun get(instance: T): Variant { var intFlag = 0 property.get(instance).forEach { enum -> intFlag += 1 shl enum.ordinal } return Variant( intFlag ) } override fun set(instance: T, value: Variant) { val intFlag = value.asInt() val enums = mutableSetOf() var bit = 1 for (i in 0 until Int.SIZE_BITS) { if ((intFlag and bit) > 0) { val element = converter(i) if (element != null) { enums.add(element) } } bit = bit shl 1 if (bit > intFlag) break } property.set(instance, enums) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/signalProviders.kt ================================================ package godot.core import godot.Object import kotlin.reflect.KProperty class SignalDelegate(val factory: () -> T) { @PublishedApi internal var signal: T? = null inline operator fun getValue(thisRef: Object, property: KProperty<*>): T { if (signal == null) { signal = factory() } return signal!! } } class SignalDelegateProvider(private val factory: (String) -> T) { operator fun provideDelegate(thisRef: Object, property: KProperty<*>): SignalDelegate { // not using `camelcaseToUnderscore` to prevent a call to godot for each signal emission return SignalDelegate { factory(property.name.camelToSnakeCase()) } } } fun signal(): SignalDelegateProvider { return SignalDelegateProvider(::Signal0) } @Suppress("UNUSED_PARAMETER") fun signal(p0: String): SignalDelegateProvider> { return SignalDelegateProvider(::Signal1) } @Suppress("UNUSED_PARAMETER") fun signal(p0: String, p1: String): SignalDelegateProvider> { return SignalDelegateProvider(::Signal2) } @Suppress("UNUSED_PARAMETER") fun signal(p0: String, p1: String, p2: String): SignalDelegateProvider> { return SignalDelegateProvider(::Signal3) } @Suppress("UNUSED_PARAMETER") fun signal( p0: String, p1: String, p2: String, p3: String ): SignalDelegateProvider> { return SignalDelegateProvider(::Signal4) } @Suppress("UNUSED_PARAMETER") fun signal( p0: String, p1: String, p2: String, p3: String, p4: String ): SignalDelegateProvider> { return SignalDelegateProvider(::Signal5) } @Suppress("UNUSED_PARAMETER") fun signal( p0: String, p1: String, p2: String, p3: String, p4: String, p5: String ): SignalDelegateProvider> { return SignalDelegateProvider(::Signal6) } @Suppress("UNUSED_PARAMETER") fun signal( p0: String, p1: String, p2: String, p3: String, p4: String, p5: String, p6: String ): SignalDelegateProvider> { return SignalDelegateProvider(::Signal7) } @Suppress("UNUSED_PARAMETER") fun signal( p0: String, p1: String, p2: String, p3: String, p4: String, p5: String, p6: String, p7: String ): SignalDelegateProvider> { return SignalDelegateProvider(::Signal8) } @Suppress("UNUSED_PARAMETER") fun signal( p0: String, p1: String, p2: String, p3: String, p4: String, p5: String, p6: String, p7: String, p8: String ): SignalDelegateProvider> { return SignalDelegateProvider(::Signal9) } @Suppress("UNUSED_PARAMETER") fun signal( p0: String, p1: String, p2: String, p3: String, p4: String, p5: String, p6: String, p7: String, p8: String, p9: String ): SignalDelegateProvider> { return SignalDelegateProvider(::Signal10) } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/signals.kt ================================================ package godot.core import godot.Object abstract class Signal( val name: String ) { protected fun emitSignal(instance: Object, vararg args: Any?) { instance.emitSignal(name, *args) } @PublishedApi internal fun connect( instance: Object, target: Object, method: String, binds: VariantArray?, flags: Long ) { instance.connect(name, target, method, binds ?: VariantArray(), flags) } } class Signal0(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object) { emitSignal(instance) } } class Signal1(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object, p0: P0) { emitSignal( instance, p0 ) } } class Signal2(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object, p0: P0, p1: P1) { emitSignal( instance, p0, p1 ) } } class Signal3(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object, p0: P0, p1: P1, p2: P2) { emitSignal( instance, p0, p1, p2 ) } } class Signal4(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object, p0: P0, p1: P1, p2: P2, p3: P3) { emitSignal( instance, p0, p1, p2, p3 ) } } class Signal5(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object, p0: P0, p1: P1, p2: P2, p3: P3, p4: P4) { emitSignal( instance, p0, p1, p2, p3, p4 ) } } class Signal6(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object, p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) { emitSignal( instance, p0, p1, p2, p3, p4, p5 ) } } class Signal7(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object, p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) { emitSignal( instance, p0, p1, p2, p3, p4, p5, p6 ) } } class Signal8(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object, p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) { emitSignal( instance, p0, p1, p2, p3, p4, p5, p6, p7 ) } } class Signal9(name: String) : Signal(name) { @PublishedApi internal fun emit(instance: Object, p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8) { emitSignal( instance, p0, p1, p2, p3, p4, p5, p6, p7, p8 ) } } class Signal10(name: String) : Signal(name) { @PublishedApi internal fun emit( instance: Object, p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 ) { emitSignal( instance, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 ) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/AABB.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_aabb import godot.gdnative.godot_aabb_layout import godot.internal.type.CMP_EPSILON import godot.internal.type.CoreType import godot.internal.type.RealT import godot.internal.type.toGodotReal import kotlinx.cinterop.* class AABB( p_position: Vector3, p_size: Vector3 ) : CoreType { @PublishedApi internal var _position = Vector3(p_position) @PublishedApi internal var _size = Vector3(p_size) //PROPERTIES /** Return a copy of the position Vector3 * Warning: Writing position.x = 2 will only modify a copy, not the actual object. * To modify it, use position(). * */ var position get() = Vector3(_position) set(value) { _position = Vector3(value) } inline fun position(block: Vector3.() -> T): T { return _position.block() } /** Return a copy of the size Vector3 * Warning: Writing size.x = 2 will only modify a copy, not the actual object. * To modify it, use size(). * */ var size get() = Vector3(_size) set(value) { _size = Vector3(value) } inline fun size(block: Vector3.() -> T): T{ return _size.block() } /** Return a copy of the end Vector3 * Warning: Writing end.x = 2 will only modify a copy, not the actual object. * To modify it, use end(). * */ inline var end: Vector3 get() = _position + _size set(value) { _size = value - _position } inline fun end(block: Vector3.() -> T): T{ val vec = end val ret = vec.block() end = vec return ret } //CONSTRUCTOR constructor() : this(Vector3(), Vector3()) constructor(other: AABB) : this(other._position, other._size) internal constructor(native: CValue) : this() { memScoped { this@AABB.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { position.x = this@AABB._position.x.toGodotReal() position.y = this@AABB._position.y.toGodotReal() position.z = this@AABB._position.z.toGodotReal() size.x = this@AABB._size.x.toGodotReal() size.y = this@AABB._size.y.toGodotReal() size.z = this@AABB._size.z.toGodotReal() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed _position.setRawMemory(value.position.ptr) _size.setRawMemory(value.size.ptr) } //API /** * Returns true if this AABB completely encloses another one. */ fun encloses(other: AABB): Boolean { val srcMin = _position val srcMax = _position + _size val dstMin = other._position val dstMax = other._position + other._size return ((srcMin.x <= dstMin.x) && (srcMax.x > dstMax.x) && (srcMin.y <= dstMin.y) && (srcMax.y > dstMax.y) && (srcMin.z <= dstMin.z) && (srcMax.z > dstMax.z)) } /** * Returns this AABB expanded to include a given point. */ fun expand(p_vector: Vector3): AABB { val aabb = this aabb.expandTo(p_vector) return aabb } internal fun expandTo(vector: Vector3) { val begin = _position val end = _position + _size if (vector.x < begin.x) { begin.x = vector.x } if (vector.y < begin.y) { begin.y = vector.y } if (vector.z < begin.z) { begin.z = vector.z } if (vector.x > end.x) { end.x = vector.x } if (vector.y > end.y) { end.y = vector.y } if (vector.z > end.z) { end.z = vector.z } _position = begin _size = end - begin } /** * Returns the volume of the AABB. */ fun getArea(): RealT { return _size.x * _size.y * _size.z } /** * Gets the position of the 8 endpoints of the AABB in space. */ fun getEndpoint(point: Int): Vector3 { return when (point) { 0 -> Vector3(_position.x, _position.y, _position.z) 1 -> Vector3(_position.x, _position.y, _position.z + _size.z) 2 -> Vector3(_position.x, _position.y + _size.y, _position.z) 3 -> Vector3(_position.x, _position.y + _size.y, _position.z + _size.z) 4 -> Vector3(_position.x + _size.x, _position.y, _position.z) 5 -> Vector3(_position.x + _size.x, _position.y, _position.z + _size.z) 6 -> Vector3(_position.x + _size.x, _position.y + _size.y, _position.z) 7 -> Vector3(_position.x + _size.x, _position.y + _size.y, _position.z + _size.z) else -> Vector3() } } /** * Returns the normalized longest axis of the AABB. */ fun getLongestAxis(): Vector3 { var axis = Vector3(1.0, 0.0, 0.0) var maxSize = _size.x if (_size.y > maxSize) { axis = Vector3(0.0, 1.0, 0.0) maxSize = _size.y } if (_size.z > maxSize) { axis = Vector3(0.0, 0.0, 1.0) } return axis } /** * Returns the index of the longest axis of the AABB (according to Vector3’s AXIS_* constants). */ fun getLongestAxisIndex(): Int { var axis = 0 var maxSize = _size.x if (_size.y > maxSize) { axis = 1 maxSize = _size.y } if (_size.z > maxSize) { axis = 2 } return axis } /** * Returns the scalar length of the longest axis of the AABB. */ fun getLongestAxisSize(): RealT { var maxSize = _size.x if (_size.y > maxSize) { maxSize = _size.y } if (_size.z > maxSize) { maxSize = _size.z } return maxSize } /** * Returns the scalar length of the longest axis of the AABB. */ fun getShortestAxis(): Vector3 { var axis = Vector3(1.0, 0.0, 0.0) var minSize = _size.x if (_size.y < minSize) { axis = Vector3(0.0, 1.0, 0.0) minSize = _size.y } if (_size.z < minSize) { axis = Vector3(0.0, 0.0, 1.0) } return axis } /** * Gets the position of the 8 endpoints of the AABB in space. */ fun getShortestAxisIndex(): Int { var axis = 0 var maxSize = _size.x if (_size.y < maxSize) { axis = 1 maxSize = _size.y } if (_size.z < maxSize) { axis = 2 } return axis } /** * Gets the position of the 8 endpoints of the AABB in space. */ fun getShortestAxisSize(): RealT { var minSize = _size.x if (_size.y < minSize) { minSize = _size.y } if (_size.z < minSize) { minSize = _size.z } return minSize } /** * Returns the support point in a given direction. This is useful for collision detection algorithms. */ fun getSupport(normal: Vector3): Vector3 { val halfExtents = _size * 0.5 val ofs = _position + halfExtents return Vector3( if (normal.x > 0.0) -halfExtents.x else halfExtents.x, if (normal.y > 0.0) -halfExtents.y else halfExtents.y, if (normal.z > 0.0) -halfExtents.z else halfExtents.z ) + ofs } /** * Returns a copy of the AABB grown a given amount of units towards all the sides. */ fun grow(p_by: RealT): AABB { val aabb = this aabb.growBy(p_by) return aabb } internal fun growBy(amount: RealT) { _position.x -= amount _position.y -= amount _position.z -= amount _size.x += 2.0 * amount _size.y += 2.0 * amount _size.z += 2.0 * amount } /** * Returns true if the AABB is flat or empty. */ fun hasNoArea(): Boolean { return (_size.x <= CMP_EPSILON || _size.y <= CMP_EPSILON || _size.z <= CMP_EPSILON) } /** * Returns true if the AABB is empty. */ fun hasNoSurface(): Boolean { return (_size.x <= CMP_EPSILON && _size.y <= CMP_EPSILON && _size.z <= CMP_EPSILON) } /** * Returns true if the AABB contains a point. */ fun hasPoint(point: Vector3): Boolean { return when { point.x < _position.x -> false point.y < _position.y -> false point.z < _position.z -> false point.x > _position.x + _size.x -> false point.y > _position.y + _size.y -> false point.z > _position.z + _size.z -> false else -> true } } /** * Returns the intersection between two AABB. An empty AABB (size 0,0,0) is returned on failure. */ fun intersection(other: AABB): AABB { val srcMin = _position val srcMax = _position + _size val dstMin = other._position val dstMax = other._position + other._size val min = Vector3() val max = Vector3() if (srcMin.x > dstMax.x || srcMax.x < dstMin.x) { return AABB() } else { min.x = if (srcMin.x > dstMin.x) srcMin.x else dstMin.x max.x = if (srcMax.x < dstMax.x) srcMax.x else dstMax.x } if (srcMin.y > dstMax.y || srcMax.y < dstMin.y) { return AABB() } else { min.y = if (srcMin.y > dstMin.y) srcMin.y else dstMin.y max.y = if (srcMax.y < dstMax.y) srcMax.y else dstMax.y } if (srcMin.z > dstMax.z || srcMax.z < dstMin.z) { return AABB() } else { min.z = if (srcMin.z > dstMin.z) srcMin.z else dstMin.z max.z = if (srcMax.z < dstMax.z) srcMax.z else dstMax.z } return AABB(min, max - min) } /** * Returns true if the AABB overlaps with another. */ fun intersects(other: AABB): Boolean { return when { _position.x >= (other._position.x + other._size.x) -> false (_position.x + _size.x) <= other._position.x -> false _position.y >= (other._position.y + other._size.y) -> false (_position.y + _size.y) <= other._position.y -> false _position.z >= (other._position.z + other._size.z) -> false (_position.z + _size.z) <= other._position.z -> false else -> true } } /** * Returns true if the AABB is on both sides of a plane. */ fun intersectsPlane(p_plane: Plane): Boolean { val points = arrayOf( Vector3(_position.x, _position.y, _position.z), Vector3(_position.x, _position.y, _position.z + _size.z), Vector3(_position.x, _position.y + _size.y, _position.z), Vector3(_position.x, _position.y + _size.y, _position.z + _size.z), Vector3(_position.x + _size.x, _position.y, _position.z), Vector3(_position.x + _size.x, _position.y, _position.z + _size.z), Vector3(_position.x + _size.x, _position.y + _size.y, _position.z), Vector3(_position.x + _size.x, _position.y + _size.y, _position.z + _size.z) ) var over = false var under = false for (i in 0..7) { if (p_plane.distanceTo(points[i]) > 0) over = true else under = true } return under && over } /** * Returns true if the AABB intersects the line segment between from and to. */ fun intersectsSegment(from: Vector3, to: Vector3): Boolean { var min = 0.0 var max = 0.0 for (i in 0..2) { val segFrom = from[i] val segTo = to[i] val boxBegin = _position[i] val boxEnd = boxBegin + _size[i] val cmin: RealT val cmax: RealT if (segFrom < segTo) { if (segFrom > boxEnd || segTo < boxBegin) { return false } val length = segTo - segFrom cmin = if (segFrom < boxBegin) ((boxBegin - segFrom) / length) else 0.0 cmax = if (segTo > boxEnd) ((boxEnd - segFrom) / length) else 1.0 } else { if (segTo > boxEnd || segFrom < boxBegin) { return false } val length = segTo - segFrom cmin = if (segFrom > boxEnd) (boxEnd - segFrom) / length else 0.0 cmax = if (segTo < boxBegin) (boxBegin - segFrom) / length else 1.0 } if (cmin > min) { min = cmin } if (cmax < max) max = cmax if (max < min) { return false } } return true } /** * Returns true if this AABB and aabb are approximately equal, by running isEqualApprox on each component. */ fun isEqualApprox(other: AABB): Boolean { return this._position.isEqualApprox(other._position) && this._size.isEqualApprox(other._size) } /** * Returns a larger AABB that contains both this AABB and with. */ fun merge(p_with: AABB): AABB { val aabb = this aabb.mergeWith(p_with) return aabb } internal fun mergeWith(other: AABB) { val beg1 = _position val beg2 = other._position val end1 = _position + _size val end2 = other._position + other._size val min = Vector3() val max = Vector3() min.x = if (beg1.x < beg2.x) beg1.x else beg2.x min.y = if (beg1.y < beg2.y) beg1.y else beg2.y min.z = if (beg1.z < beg2.z) beg1.z else beg2.z max.x = if (end1.x > end2.x) end1.x else end2.x max.y = if (end1.y > end2.y) end1.y else end2.y max.z = if (end1.z > end2.z) end1.z else end2.z _position = min _size = max - min } //UTILITIES override fun toVariant() = Variant(this) override fun equals(other: Any?): Boolean = when (other) { is AABB -> (_position == other._position && _size == other._size) else -> false } override fun toString(): String { return "AABB(position=$_position, size=$_size)" } override fun hashCode(): Int { var result = _position.hashCode() result = 31 * result + _size.hashCode() return result } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Basis.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_basis import godot.gdnative.godot_basis_layout import godot.internal.type.* import kotlinx.cinterop.* import kotlin.math.* class Basis() : CoreType { @PublishedApi internal var _x = Vector3() @PublishedApi internal var _y = Vector3() @PublishedApi internal var _z = Vector3() init { _x.x = 1.0 _x.y = 0.0 _x.z = 0.0 _y.x = 0.0 _y.y = 1.0 _y.z = 0.0 _z.x = 0.0 _z.y = 0.1 _z.z = 1.0 } //CONSTANTS companion object { val IDENTITY: Basis get() = Basis(1, 0, 0, 0, 1, 0, 0, 0, 1) val FLIP_X: Basis get() = Basis(-1, 0, 0, 0, 1, 0, 0, 0, 1) val FLIP_Y: Basis get() = Basis(1, 0, 0, 0, -1, 0, 0, 0, 1) val FLIP_Z: Basis get() = Basis(1, 0, 0, 0, 1, 0, 0, 0, -1) //used internally by a few methods private val orthoBases: Array = arrayOf( Basis(1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0), Basis(0.0, -1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0), Basis(-1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 1.0), Basis(0.0, 1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, 1.0), Basis(1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, 1.0, 0.0), Basis(0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0), Basis(-1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0), Basis(0.0, 0.0, -1.0, -1.0, 0.0, 0.0, 0.0, 1.0, 0.0), Basis(1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, -1.0), Basis(0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, -1.0), Basis(-1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, -1.0), Basis(0.0, -1.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.0, -1.0), Basis(1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, -1.0, 0.0), Basis(0.0, 0.0, -1.0, 1.0, 0.0, 0.0, 0.0, -1.0, 0.0), Basis(-1.0, 0.0, 0.0, 0.0, 0.0, -1.0, 0.0, -1.0, 0.0), Basis(0.0, 0.0, 1.0, -1.0, 0.0, 0.0, 0.0, -1.0, 0.0), Basis(0.0, 0.0, 1.0, 0.0, 1.0, 0.0, -1.0, 0.0, 0.0), Basis(0.0, -1.0, 0.0, 0.0, 0.0, 1.0, -1.0, 0.0, 0.0), Basis(0.0, 0.0, -1.0, 0.0, -1.0, 0.0, -1.0, 0.0, 0.0), Basis(0.0, 1.0, 0.0, 0.0, 0.0, -1.0, -1.0, 0.0, 0.0), Basis(0.0, 0.0, 1.0, 0.0, -1.0, 0.0, 1.0, 0.0, 0.0), Basis(0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0), Basis(0.0, 0.0, -1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0), Basis(0.0, -1.0, 0.0, 0.0, 0.0, -1.0, 1.0, 0.0, 0.0) ) } //CONSTRUCTOR constructor(other: Basis) : this() { _x.x = other._x.x _x.y = other._x.y _x.z = other._x.z _y.x = other._y.x _y.y = other._y.y _y.z = other._y.z _z.x = other._z.x _z.y = other._z.y _z.z = other._z.z } constructor( xx: Number, xy: Number, xz: Number, yx: Number, yy: Number, yz: Number, zx: Number, zy: Number, zz: Number ) : this() { _x[0] = xx.toRealT() _x[1] = xy.toRealT() _x[2] = xz.toRealT() _y[0] = yx.toRealT() _y[1] = yy.toRealT() _y[2] = yz.toRealT() _z[0] = zx.toRealT() _z[1] = zy.toRealT() _z[2] = zz.toRealT() } constructor(from: Vector3) : this() { setEuler(from) } constructor(quat: Quat) : this() { val d = quat.lengthSquared() val s = 2.0 / d val xs = quat.x * s val ys = quat.y * s val zs = quat.z * s val wx = quat.w * xs val wy = quat.w * ys val wz = quat.w * zs val xx = quat.x * xs val xy = quat.x * ys val xz = quat.x * zs val yy = quat.y * ys val yz = quat.y * zs val zz = quat.z * zs set( 1.0 - (yy + zz), xy - wz, xz + wy, xy + wz, 1.0 - (xx + zz), yz - wx, xz - wy, yz + wx, 1.0 - (xx + yy) ) } constructor(axis: Vector3, phi: RealT) : this() { // Rotation matrix from axis and angle, see https://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle val axisq = Vector3(axis.x * axis.x, axis.y * axis.y, axis.z * axis.z) val cosine: RealT = cos(phi) val sine: RealT = sin(phi) apply { _x.x = axisq.x + cosine * (1.0 - axisq.x) _x.y = axis.x * axis.y * (1.0 - cosine) - axis.z * sine _x.z = axis.z * axis.x * (1.0 - cosine) + axis.y * sine _y.x = axis.x * axis.y * (1.0 - cosine) + axis.z * sine _y.y = axisq.y + cosine * (1.0 - axisq.y) _y.z = axis.y * axis.z * (1.0 - cosine) - axis.x * sine _z.x = axis.z * axis.x * (1.0 - cosine) - axis.y * sine _z.y = axis.y * axis.z * (1.0 - cosine) + axis.x * sine _z.z = axisq.z + cosine * (1.0 - axisq.z) } } internal constructor(native: CValue) : this() { memScoped { this@Basis.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { x.x = this@Basis._x.x.toGodotReal() x.y = this@Basis._x.y.toGodotReal() x.z = this@Basis._x.z.toGodotReal() y.x = this@Basis._y.x.toGodotReal() y.y = this@Basis._y.y.toGodotReal() y.z = this@Basis._y.z.toGodotReal() z.x = this@Basis._z.x.toGodotReal() z.y = this@Basis._z.y.toGodotReal() z.z = this@Basis._z.z.toGodotReal() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed _x.setRawMemory(value.x.ptr) _y.setRawMemory(value.y.ptr) _z.setRawMemory(value.z.ptr) } //API /** * Returns the determinant of the matrix. */ fun determinant(): RealT { return this._x.x * (this._y.y * this._z.z - this._z.y * this._y.z) - this._y.x * (this._x.y * this._z.z - this._z.y * this._x.z) + this._z.x * (this._x.y * this._y.z - this._y.y * this._x.z) } /** * */ fun getEuler(): Vector3 { return getEulerYxz() } /** * getEulerXyz returns a vector containing the Euler angles in the format * (a1,a2,a3), where a3 is the angle of the first rotation, and a1 is the last * (following the convention they are commonly defined in the literature). * * The current implementation uses XYZ convention (Z is the first rotation), * so euler.z is the angle of the (first) rotation around Z axis and so on, * * And thus, assuming the matrix is a rotation matrix, this function returns * @return the angles in the decomposition R = X(a1).Y(a2).Z(a3) where Z(a) rotates */ internal fun getEulerXyz(): Vector3 { // Euler angles in XYZ convention. // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // // rot = cy*cz -cy*sz sy // cz*sx*sy+cx*sz cx*cz-sx*sy*sz -cy*sx // -cx*cz*sy+sx*sz cz*sx+cx*sy*sz cx*cy val euler = Vector3() if (!isRotation()) return euler val sy = this._x.z if (sy < 1.0) { if (sy > -1.0) { // is this a pure Y rotation? if (isEqualApprox(this._y.x, 0.0) && isEqualApprox(this._x.y, 0.0) && isEqualApprox(this._y.z, 0.0) && isEqualApprox(this._z.y, 0.0) && isEqualApprox(this._y.y, 1.0) ) { // return the simplest form (human friendlier in editor and scripts) euler.x = 0.0 euler.y = atan2(this._x.z, this._x.x) euler.z = 0.0 } else { euler.x = atan2(-this._y.z, this._z.z) euler.y = asin(sy) euler.z = atan2(-this._x.y, this._x.x) } } else { euler.x = -atan2(this._x.y, this._y.y) euler.y = (-PI).toRealT() / 2.0 euler.z = 0.0 } } else { euler.x = atan2(this._x.y, this._y.y) euler.y = PI.toRealT() / 2.0 euler.z = 0.0 } return euler } /** * getEulerYxz returns a vector containing the Euler angles in the YXZ convention, * as in first-Z, then-X, last-Y. The angles for X, Y, and Z rotations are returned * as the x, y, and z components of a Vector3 respectively. */ internal fun getEulerYxz(): Vector3 { // Euler angles in YXZ convention. // See https://en.wikipedia.org/wiki/Euler_angles#Rotation_matrix // // rot = cy*cz+sy*sx*sz cz*sy*sx-cy*sz cx*sy // cx*sz cx*cz -sx // cy*sx*sz-cz*sy cy*cz*sx+sy*sz cy*cx val euler = Vector3() if (!isRotation()) return euler val m12 = this._y.z if (m12 < 1.0) { if (m12 > -1.0) { // is this a pure X rotation? if (isEqualApprox(this._y.x, 0.0) && isEqualApprox(this._x.y, 0.0) && isEqualApprox( this._x.z, 0.0 ) && isEqualApprox(this._z.x, 0.0) && isEqualApprox(this._x.x, 1.0) ) { // return the simplest form (human friendlier in editor and scripts) euler.x = atan2(-m12, this._y.y) euler.y = 0.0 euler.z = 0.0 } else { euler.x = asin(-m12) euler.y = atan2(this._x.z, this._z.z) euler.z = atan2(this._y.x, this._y.y) } } else { // m12 == -1 euler.x = PI.toRealT() * 0.5 euler.y = -atan2(-this._x.y, this._x.x) euler.z = 0.0 } } else { // m12 == 1 euler.x = (-PI).toRealT() * 0.5 euler.y = -atan2(-this._x.y, this._x.x) euler.z = 0.0 } return euler } private fun isOrthogonal(): Boolean { val id = Basis() val m = this.transposed() return m.isEqualApprox(id) } private fun isRotation(): Boolean = abs(determinant() - 1) < CMP_EPSILON && isOrthogonal() /** * This function considers a discretization of rotations into 24 points on unit sphere, * lying along the vectors (x,y,z) with each component being either -1,0 or 1, * and returns the index of the point best representing the orientation of the object. * It is mainly used by the grid map editor. For further details, refer to Godot source code. */ fun getOrthogonalIndex(): Int { val orth = this for (i in 0..2) { for (j in 0..2) { var v = orth._get(i)[j] v = when { v > 0.5 -> 1.0 v < -0.5 -> -1.0 else -> 0.0 } orth._get(i)[j] = v } } for (i in 0..23) { if (orthoBases[i] == orth) { return i } } return 0 } /** * */ fun getRotationQuat(): Quat { // Assumes that the matrix can be decomposed into a proper rotation and scaling matrix as M = R.S, // and returns the Euler angles corresponding to the rotation part, complementing get_scale(). // See the comment in get_scale() for further information. val m = orthonormalized() val det: RealT = m.determinant().toRealT() if (det < 0) { // Ensure that the determinant is 1, such that result is a proper rotation matrix which can be represented by Euler angles. m.scale(Vector3(-1, -1, -1)) } return Quat(m) } /** * Assuming that the matrix is the combination of a rotation and scaling, * return the absolute value of scaling factors along each axis. */ fun getScale(): Vector3 { // We are assuming M = R.S, and performing a polar decomposition to extract R and S. // FIXME: We eventually need a proper polar decomposition. // As a cheap workaround until then, to ensure that R is a proper rotation matrix with determinant +1 // (such that it can be represented by a Quat or Euler angles), we absorb the sign flip into the scaling matrix. // As such, it works in conjuction with getRotation(). val detSign: RealT = if (determinant() > 0) 1.0 else -1.0 return detSign * Vector3( Vector3(this._x.x, this._y.x, this._z.x).length(), Vector3(this._x.y, this._y.y, this._z.y).length(), Vector3(this._x.z, this._y.z, this._z.z).length() ) } /** * Returns the inverse of the matrix. */ fun inverse(): Basis { val b = Basis(this) b.invert() return b } internal fun invert() { inline fun cofac(row1: Int, col1: Int, row2: Int, col2: Int): RealT { return this._get(row1)[col1] * this._get(row2)[col2] - this._get(row1)[col2] * this._get(row2)[col1] } val co1 = _y.y * _z.z - _y.z * _z.y val co2 = _y.z * _z.x - _y.x - _z.z val co3 = _y.x * _z.y - _y.y * _z.x val det: RealT = this._x.x * co1 + this._x.y * co2 + this._x.z * co3 if (isEqualApprox(det, 0.0)) { Godot.printError("determinant = 0", "invert", "Basis.kt", 372) return } val s = 1.0 / det set( co1 * s, (_x.z * _z.y - _x.y * _z.z) * s, (_x.y * _y.z - _x.z * _y.y) * s, co2 * s, (_x.x * _z.z - _x.z * _z.x) * s, (_x.z * _y.x - _x.x * _y.z) * s, co3 * s, (_x.y * _z.x - _x.x * _z.y) * s, (_x.x * _y.y - _x.y * _y.x) * s ) } fun getQuat(): Quat { require(isRotation()) { "Basis must be normalized in order to be casted to a Quaternion. Use get_rotation_quat() or call orthonormalized() instead." } val trace = this._x.x + this._y.y + this._z.z val temp: Array if (trace > 0.0) { var s = sqrt(trace + 1.0) val temp3 = s * 0.5 s = 0.5 / s temp = arrayOf( ((this._z.y - this._y.z) * s), ((this._x.z - this._z.x) * s), ((this._y.x - this._x.y) * s), temp3 ) } else { temp = arrayOf(0.0, 0.0, 0.0, 0.0) val i = if (this._x.x < this._y.y) { if (this._y.y < this._z.z) 2 else 1 } else { if (this._x.x < this._z.z) 2 else 0 } val j = (i + 1) % 3 val k = (i + 2) % 3 var s = sqrt(this._get(i)[i] - this._get(j)[j] - this._get(k)[k] + 1.0) temp[i] = s * 0.5 s = 0.5 / s temp[3] = (this._get(k)[j] - this._get(j)[k]) * s temp[j] = (this._get(j)[i] + this._get(i)[j]) * s temp[k] = (this._get(k)[i] + this._get(i)[k]) * s } return Quat(temp[0], temp[1], temp[2], temp[3]); } /** * */ fun isEqualApprox(a: Basis, epsilon: RealT = CMP_EPSILON): Boolean { if (isEqualApprox(this._x.x, a._x.x, epsilon)) return false if (isEqualApprox(this._x.y, a._x.y, epsilon)) return false if (isEqualApprox(this._x.z, a._x.z, epsilon)) return false if (isEqualApprox(this._y.x, a._y.x, epsilon)) return false if (isEqualApprox(this._y.y, a._y.y, epsilon)) return false if (isEqualApprox(this._y.x, a._y.x, epsilon)) return false if (isEqualApprox(this._z.x, a._z.x, epsilon)) return false if (isEqualApprox(this._z.y, a._z.y, epsilon)) return false if (isEqualApprox(this._z.z, a._z.z, epsilon)) return false return true } /** * Returns the orthonormalized version of the matrix (useful to call from time to time to avoid rounding error for orthogonal matrices). * This performs a Gram-Schmidt orthonormalization on the basis of the matrix. */ fun orthonormalized(): Basis { val b = Basis(this) b.orthonormalize() return b } internal fun orthonormalize() { if (isEqualApprox(determinant(), 0.0)) { Godot.printError("determinant == 0\n", "orthonormalize()", "Basis.kt", 375) return } val x = getAxis(0) var y = getAxis(1) var z = getAxis(2) x.normalize() y = (y - x * (x.dot(y))) y.normalize() z = (z - x * (x.dot(z)) - y * (y.dot(z))) z.normalize() setAxis(0, x) setAxis(1, y) setAxis(2, z) } private fun getAxis(axis: Int): Vector3 = Vector3(this._x[axis], this._y[axis], this._z[axis]) private fun setAxis(axis: Int, value: Vector3) { this._x[axis] = value.x this._y[axis] = value.y this._z[axis] = value.z } /** * Introduce an additional rotation around the given axis by phi (radians). The axis must be a normalized vector. */ fun rotated(axis: Vector3, phi: RealT): Basis { return Basis(axis, phi) * this } internal fun rotate(axis: Vector3, phi: RealT) { val ret = rotated(axis, phi) this._x = ret._x this._y = ret._y this._z = ret._z } /** * Introduce an additional scaling specified by the given 3D scaling factor. */ fun scaled(scale: Vector3): Basis { val b = Basis(this) b.scale(scale) return b } internal fun scale(scale: Vector3) { this._x.x *= scale.x this._x.y *= scale.x this._x.z *= scale.x this._y.x *= scale.y this._y.y *= scale.y this._y.z *= scale.y this._z.x *= scale.z this._z.y *= scale.z this._z.z *= scale.z } /** * */ fun setEuler(p_euler: Vector3) { setEulerYxz(p_euler) } /** * setEulerXyz expects a vector containing the Euler angles in the format * (ax,ay,az), where ax is the angle of rotation around x axis, * and similar for other axes. * The current implementation uses XYZ convention (Z is the first rotation). */ internal fun setEulerXyz(euler: Vector3) { var c: RealT = cos(euler.x) var s: RealT = sin(euler.x) val xmat = Basis(1.0, 0.0, 0.0, 0.0, c, -s, 0.0, s, c) c = cos(euler.y) s = sin(euler.y) val ymat = Basis(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c) c = cos(euler.z) s = sin(euler.z) val zmat = Basis(c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0) //optimizer will optimize away all this anyway val ret = xmat * (ymat * zmat) this._x = ret._x this._y = ret._y this._z = ret._z } /** * setEulerYxz expects a vector containing the Euler angles in the format * (ax,ay,az), where ax is the angle of rotation around x axis, * and similar for other axes. * The current implementation uses YXZ convention (Z is the first rotation). */ internal fun setEulerYxz(euler: Vector3) { var c: RealT = cos(euler.x) var s: RealT = sin(euler.x) val xmat = Basis(1.0, 0.0, 0.0, 0.0, c, -s, 0.0, s, c) c = cos(euler.y) s = sin(euler.y) val ymat = Basis(c, 0.0, s, 0.0, 1.0, 0.0, -s, 0.0, c) c = cos(euler.z) s = sin(euler.z) val zmat = Basis(c, -s, 0.0, s, c, 0.0, 0.0, 0.0, 1.0) val ret = ymat * xmat * zmat this._x = ret._x this._y = ret._y this._z = ret._z } /** * */ fun setOrthogonalIndex(index: Int) { if (index >= 24) { Godot.printError("index >= 24", "setOrthogonalIndex($index)", "Basis.kt", 493) return } val ret = orthoBases[index] this._x = ret._x this._y = ret._y this._z = ret._z } /** * Assuming that the matrix is a proper rotation matrix, slerp performs a spherical-linear interpolation with another rotation matrix. */ fun slerp(b: Basis, t: RealT): Basis { if (!this.isRotation()) { Godot.printError("Basis is not a rotation", "slerp()", "Basis.kt", 504) } val from = Quat(this) val to = Quat(b) val ret = Basis(from.slerp(to, t)) ret._x *= (b._x.length() - this._x.length()) * t ret._y *= (b._y.length() - this._y.length()) * t ret._z *= (b._z.length() - this._z.length()) * t return ret; } /** * Transposed dot product with the x axis of the matrix. */ fun tdotx(v: Vector3): RealT { return this._x.x * v.x + this._y.x * v.y + this._z.x * v.z } /** * Transposed dot product with the y axis of the matrix. */ fun tdoty(v: Vector3): RealT { return this._x.y * v.x + this._y.y * v.y + this._z.y * v.z } /** * Transposed dot product with the z axis of the matrix. */ fun tdotz(v: Vector3): RealT { return this._x.z * v.x + this._y.z * v.y + this._z.z * v.z } /** * Returns the transposed version of the matrix. */ fun transposed(): Basis { val b = Basis(this) b.transpose() return b } internal fun transpose() { this._x.y = this._y.x.also { this._y.x = this._x.y } this._x.z = this._z.x.also { this._z.x = this._x.z } this._y.z = this._z.y.also { this._z.y = this._y.z } } /** * Returns a vector transformed (multiplied) by the matrix. */ fun xform(vector: Vector3): Vector3 = Vector3( this._x.dot(vector), this._y.dot(vector), this._z.dot(vector) ) /** * Returns a vector transformed (multiplied) by the transposed matrix. * Note that this results in a multiplication by the inverse of the matrix only if it represents a rotation-reflection. */ fun xformInv(vector: Vector3): Vector3 = Vector3( (this._x.x * vector.x) + (this._y.x * vector.y) + (this._z.x * vector.z), (this._x.y * vector.x) + (this._y.y * vector.y) + (this._z.y * vector.z), (this._x.z * vector.x) + (this._y.z * vector.y) + (this._z.z * vector.z) ) //UTILITIES override fun toVariant() = Variant(this) internal fun _get(n: Int): Vector3 { return when (n) { 0 -> _x 1 -> _y 2 -> _z else -> throw IndexOutOfBoundsException() } } internal fun _set(n: Int, f: Vector3) { when (n) { 0 -> _x = f 1 -> _y = f 2 -> _z = f else -> throw IndexOutOfBoundsException() } } fun set( xx: RealT, xy: RealT, xz: RealT, yx: RealT, yy: RealT, yz: RealT, zx: RealT, zy: RealT, zz: RealT ) { _x.x = xx; _x.y = xy; _x.z = xz _y.x = yx; _y.y = yy; _y.z = yz _z.x = zx; _z.y = zy; _z.z = zz } operator fun plus(matrix: Basis) = Basis().also { it._x = this._x + matrix._x it._y = this._y + matrix._y it._z = this._z + matrix._z } operator fun minus(matrix: Basis) = Basis().also { it._x = this._x - matrix._x it._y = this._y - matrix._y it._z = this._z - matrix._z } operator fun times(matrix: Basis) = Basis( matrix.tdotx(this._x), matrix.tdoty(this._x), matrix.tdotz(this._x), matrix.tdotx(this._y), matrix.tdoty(this._y), matrix.tdotz(this._y), matrix.tdotx(this._z), matrix.tdoty(this._z), matrix.tdotz(this._z) ) operator fun times(scalar: Int) = Basis().also { it._x = this._x * scalar it._y = this._y * scalar it._z = this._z * scalar } operator fun times(scalar: Long) = Basis().also { it._x = this._x * scalar it._y = this._y * scalar it._z = this._z * scalar } operator fun times(scalar: Float) = Basis().also { it._x = this._x * scalar it._y = this._y * scalar it._z = this._z * scalar } operator fun times(scalar: Double) = Basis().also { it._x = this._x * scalar it._y = this._y * scalar it._z = this._z * scalar } override fun toString(): String { return buildString { append("${this@Basis._x.x}, ${this@Basis._x.y}, ${this@Basis._x.z}, ") append("${this@Basis._y.x}, ${this@Basis._y.y}, ${this@Basis._y.z}, ") append("${this@Basis._z.x}, ${this@Basis._z.y}, ${this@Basis._z.z}") } } override fun equals(other: Any?): Boolean = when (other) { is Basis -> (this._x.x == other._x.x && this._x.y == other._x.y && this._x.z == other._x.z && this._y.x == other._y.x && this._y.y == other._y.y && this._y.z == other._y.z && this._z.x == other._z.x && this._z.y == other._z.y && this._z.z == other._z.z) else -> throw IllegalArgumentException() } override fun hashCode(): Int { var result = _x.hashCode() result = 31 * result + _y.hashCode() result = 31 * result + _z.hashCode() return result } fun set(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) { setAxis(0, xAxis) setAxis(1, yAxis) setAxis(2, zAxis) } /* * GDScript related members */ constructor(xAxis: Vector3, yAxis: Vector3, zAxis: Vector3) : this() { set(xAxis, yAxis, zAxis) } //PROPERTIES /** Return a copy of the x Vector3 * Warning: Writing x.x = 2 will only modify a copy, not the actual object. * To modify it, use x(). * */ var x get() = getAxis(0) set(value) { setAxis(0, value) } inline fun x(block: Vector3.() -> T): T { return _x.block() } /** Return a copy of the y Vector3 * Warning: Writing y.x = 2 will only modify a copy, not the actual object. * To modify it, use y(). * */ var y get() = getAxis(1) set(value) { setAxis(1, value) } inline fun y(block: Vector3.() -> T): T { return _y.block() } /** Return a copy of the z Vector3 * Warning: Writing z.x = 2 will only modify a copy, not the actual object. * To modify it, use z(). * */ var z get() = getAxis(2) set(value) { setAxis(2, value) } inline fun z(block: Vector3.() -> T): T { return _z.block() } operator fun get(index: Int): Vector3 { return getAxis(index) } operator fun set(index: Int, value: Vector3) { return setAxis(index, value) } } operator fun Int.times(basis: Basis) = basis * this operator fun Long.times(basis: Basis) = basis * this operator fun Float.times(basis: Basis) = basis * this operator fun Double.times(basis: Basis) = basis * this ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Color.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_color import godot.gdnative.godot_color_layout import godot.internal.type.CoreType import godot.internal.type.RealT import godot.internal.type.isEqualApprox import godot.internal.type.toRealT import kotlinx.cinterop.* import kotlin.math.* class Color( var r: RealT, var g: RealT, var b: RealT, var a: RealT ) : Comparable, CoreType { //PROPERTIES var r8: Int get() = (r * 255).roundToInt() set(value) { r = value.toRealT() / 255f } var g8: Int get() = (g * 255).roundToInt() set(value) { g = value.toRealT() / 255f } var b8: Int get() = (b * 255).roundToInt() set(value) { b = value.toRealT() / 255f } var a8: Int get() = (a * 255).roundToInt() set(value) { a = value.toRealT() / 255f } var h: RealT get() { var min: RealT = min(r, g) min = min(min, b) var max: RealT = max(r, g) max = max(max, b) val delta = max - min if (delta == 0.0) return 0.0 var h: RealT h = when { r == max -> ((g - b) / delta) // between yellow & magenta g == max -> (2 + (b - r) / delta) // between cyan & yellow else -> (4 + (r - g) / delta) // between magenta & cyan } h /= 6.0f if (h < 0) { h += 1.0f } return h } set(value) { setHSV(value, s, v, a) } var s: RealT get() { var min: RealT = min(r, g) min = min(min, b) var max: RealT = max(r, g) max = max(max, b) val delta = max - min return if (max != 0.0) (delta / max).toRealT() else 0.0 } set(value) { setHSV(h, value, v, a) } var v: RealT get() { var max: RealT = max(r, g) max = max(max, b) return max.toRealT() } set(value) { setHSV(h, s, value, a) } private fun setHSV(h: RealT, s: RealT, v: RealT, alpha: RealT) { val i = floor(h).toInt() val f: RealT val p = v * (1 - s) val q: RealT val t: RealT a = alpha if (s == 0.0) { // acp_chromatic (grey) r = v g = v b = v return } var h2 = h * 6.0 h2 = h2.rem(6.0) f = h2 - i q = v * (1 - s * f) t = v * (1 - s * (1 - f)) when (i) { 0 -> { // Red is the dominant color r = v g = t b = p } 1 -> { // Green is the dominant color r = q g = v b = p } 2 -> { r = p g = v b = t } 3 -> { // Blue is the dominant color r = p g = q b = v } 4 -> { r = t g = p b = v } else -> { // (5) Red is the dominant color r = v g = p b = q } } } //CONSTANTS private enum class ColorByte(val size: Int, val shift: Int) { BITS32(255, 8), BITS64(65535, 16) } companion object { inline val aliceblue: Color get() = Color(0.94, 0.97, 1.00) inline val antiquewhite: Color get() = Color(0.98, 0.92, 0.84) inline val aqua: Color get() = Color(0.00, 1.00, 1.00) inline val aquamarine: Color get() = Color(0.50, 1.00, 0.83) inline val azure: Color get() = Color(0.94, 1.00, 1.00) inline val beige: Color get() = Color(0.96, 0.96, 0.86) inline val bisque: Color get() = Color(1.00, 0.89, 0.77) inline val black: Color get() = Color(0.00, 0.00, 0.00) inline val blanchedalmond: Color get() = Color(1.00, 0.92, 0.80) inline val blue: Color get() = Color(0.00, 0.00, 1.00) inline val blueviolet: Color get() = Color(0.54, 0.17, 0.89) inline val brown: Color get() = Color(0.65, 0.16, 0.16) inline val burlywood: Color get() = Color(0.87, 0.72, 0.53) inline val cadetblue: Color get() = Color(0.37, 0.62, 0.63) inline val chartreuse: Color get() = Color(0.50, 1.00, 0.00) inline val chocolate: Color get() = Color(0.82, 0.41, 0.12) inline val coral: Color get() = Color(1.00, 0.50, 0.31) inline val cornflower: Color get() = Color(0.39, 0.58, 0.93) inline val cornsilk: Color get() = Color(1.00, 0.97, 0.86) inline val crimson: Color get() = Color(0.86, 0.08, 0.24) inline val cyan: Color get() = Color(0.00, 1.00, 1.00) inline val darkblue: Color get() = Color(0.00, 0.00, 0.55) inline val darkcyan: Color get() = Color(0.00, 0.55, 0.55) inline val darkgoldenrod: Color get() = Color(0.72, 0.53, 0.04) inline val darkgray: Color get() = Color(0.66, 0.66, 0.66) inline val darkgreen: Color get() = Color(0.00, 0.39, 0.00) inline val darkkhaki: Color get() = Color(0.74, 0.72, 0.42) inline val darkmagenta: Color get() = Color(0.55, 0.00, 0.55) inline val darkolivegreen: Color get() = Color(0.33, 0.42, 0.18) inline val darkorange: Color get() = Color(1.00, 0.55, 0.00) inline val darkorchid: Color get() = Color(0.60, 0.20, 0.80) inline val darkred: Color get() = Color(0.55, 0.00, 0.00) inline val darksalmon: Color get() = Color(0.91, 0.59, 0.48) inline val darkseagreen: Color get() = Color(0.56, 0.74, 0.56) inline val darkslateblue: Color get() = Color(0.28, 0.24, 0.55) inline val darkslategray: Color get() = Color(0.18, 0.31, 0.31) inline val darkturquoise: Color get() = Color(0.00, 0.81, 0.82) inline val darkviolet: Color get() = Color(0.58, 0.00, 0.83) inline val deeppink: Color get() = Color(1.00, 0.08, 0.58) inline val deepskyblue: Color get() = Color(0.00, 0.75, 1.00) inline val dimgray: Color get() = Color(0.41, 0.41, 0.41) inline val dodgerblue: Color get() = Color(0.12, 0.56, 1.00) inline val firebrick: Color get() = Color(0.70, 0.13, 0.13) inline val floralwhite: Color get() = Color(1.00, 0.98, 0.94) inline val forestgreen: Color get() = Color(0.13, 0.55, 0.13) inline val fuchsia: Color get() = Color(1.00, 0.00, 1.00) inline val gainsboro: Color get() = Color(0.86, 0.86, 0.86) inline val ghostwhite: Color get() = Color(0.97, 0.97, 1.00) inline val gold: Color get() = Color(1.00, 0.84, 0.00) inline val goldenrod: Color get() = Color(0.85, 0.65, 0.13) inline val gray: Color get() = Color(0.75, 0.75, 0.75) inline val webgray: Color get() = Color(0.50, 0.50, 0.50) inline val green: Color get() = Color(0.00, 1.00, 0.00) inline val webgreen: Color get() = Color(0.00, 0.50, 0.00) inline val greenyellow: Color get() = Color(0.68, 1.00, 0.18) inline val honeydew: Color get() = Color(0.94, 1.00, 0.94) inline val hotpink: Color get() = Color(1.00, 0.41, 0.71) inline val indianred: Color get() = Color(0.80, 0.36, 0.36) inline val indigo: Color get() = Color(0.29, 0.00, 0.51) inline val ivory: Color get() = Color(1.00, 1.00, 0.94) inline val khaki: Color get() = Color(0.94, 0.90, 0.55) inline val lavender: Color get() = Color(0.90, 0.90, 0.98) inline val lavenderblush: Color get() = Color(1.00, 0.94, 0.96) inline val lawngreen: Color get() = Color(0.49, 0.99, 0.00) inline val lemonchiffon: Color get() = Color(1.00, 0.98, 0.80) inline val lightblue: Color get() = Color(0.68, 0.85, 0.90) inline val lightcoral: Color get() = Color(0.94, 0.50, 0.50) inline val lightcyan: Color get() = Color(0.88, 1.00, 1.00) inline val lightgoldenrod: Color get() = Color(0.98, 0.98, 0.82) inline val lightgray: Color get() = Color(0.83, 0.83, 0.83) inline val lightgreen: Color get() = Color(0.56, 0.93, 0.56) inline val lightpink: Color get() = Color(1.00, 0.71, 0.76) inline val lightsalmon: Color get() = Color(1.00, 0.63, 0.48) inline val lightseagreen: Color get() = Color(0.13, 0.70, 0.67) inline val lightskyblue: Color get() = Color(0.53, 0.81, 0.98) inline val lightslategray: Color get() = Color(0.47, 0.53, 0.60) inline val lightsteelblue: Color get() = Color(0.69, 0.77, 0.87) inline val lightyellow: Color get() = Color(1.00, 1.00, 0.88) inline val lime: Color get() = Color(0.00, 1.00, 0.00) inline val limegreen: Color get() = Color(0.20, 0.80, 0.20) inline val linen: Color get() = Color(0.98, 0.94, 0.90) inline val magenta: Color get() = Color(1.00, 0.00, 1.00) inline val maroon: Color get() = Color(0.69, 0.19, 0.38) inline val webmaroon: Color get() = Color(0.50, 0.00, 0.00) inline val mediumaquamarine: Color get() = Color(0.40, 0.80, 0.67) inline val mediumblue: Color get() = Color(0.00, 0.00, 0.80) inline val mediumorchid: Color get() = Color(0.73, 0.33, 0.83) inline val mediumpurple: Color get() = Color(0.58, 0.44, 0.86) inline val mediumseagreen: Color get() = Color(0.24, 0.70, 0.44) inline val mediumslateblue: Color get() = Color(0.48, 0.41, 0.93) inline val mediumspringgreen: Color get() = Color(0.00, 0.98, 0.60) inline val mediumturquoise: Color get() = Color(0.28, 0.82, 0.80) inline val mediumvioletred: Color get() = Color(0.78, 0.08, 0.52) inline val midnightblue: Color get() = Color(0.10, 0.10, 0.44) inline val mintcream: Color get() = Color(0.96, 1.00, 0.98) inline val mistyrose: Color get() = Color(1.00, 0.89, 0.88) inline val moccasin: Color get() = Color(1.00, 0.89, 0.71) inline val navajowhite: Color get() = Color(1.00, 0.87, 0.68) inline val navyblue: Color get() = Color(0.00, 0.00, 0.50) inline val oldlace: Color get() = Color(0.99, 0.96, 0.90) inline val olive: Color get() = Color(0.50, 0.50, 0.00) inline val olivedrab: Color get() = Color(0.42, 0.56, 0.14) inline val orange: Color get() = Color(1.00, 0.65, 0.00) inline val orangered: Color get() = Color(1.00, 0.27, 0.00) inline val orchid: Color get() = Color(0.85, 0.44, 0.84) inline val palegoldenrod: Color get() = Color(0.93, 0.91, 0.67) inline val palegreen: Color get() = Color(0.60, 0.98, 0.60) inline val paleturquoise: Color get() = Color(0.69, 0.93, 0.93) inline val palevioletred: Color get() = Color(0.86, 0.44, 0.58) inline val papayawhip: Color get() = Color(1.00, 0.94, 0.84) inline val peachpuff: Color get() = Color(1.00, 0.85, 0.73) inline val peru: Color get() = Color(0.80, 0.52, 0.25) inline val pink: Color get() = Color(1.00, 0.75, 0.80) inline val plum: Color get() = Color(0.87, 0.63, 0.87) inline val powderblue: Color get() = Color(0.69, 0.88, 0.90) inline val purple: Color get() = Color(0.63, 0.13, 0.94) inline val webpurple: Color get() = Color(0.50, 0.00, 0.50) inline val rebeccapurple: Color get() = Color(0.40, 0.20, 0.60) inline val red: Color get() = Color(1.00, 0.00, 0.00) inline val rosybrown: Color get() = Color(0.74, 0.56, 0.56) inline val royalblue: Color get() = Color(0.25, 0.41, 0.88) inline val saddlebrown: Color get() = Color(0.55, 0.27, 0.07) inline val salmon: Color get() = Color(0.98, 0.50, 0.45) inline val sandybrown: Color get() = Color(0.96, 0.64, 0.38) inline val seagreen: Color get() = Color(0.18, 0.55, 0.34) inline val seashell: Color get() = Color(1.00, 0.96, 0.93) inline val sienna: Color get() = Color(0.63, 0.32, 0.18) inline val silver: Color get() = Color(0.75, 0.75, 0.75) inline val skyblue: Color get() = Color(0.53, 0.81, 0.92) inline val slateblue: Color get() = Color(0.42, 0.35, 0.80) inline val slategray: Color get() = Color(0.44, 0.50, 0.56) inline val snow: Color get() = Color(1.00, 0.98, 0.98) inline val springgreen: Color get() = Color(0.00, 1.00, 0.50) inline val steelblue: Color get() = Color(0.27, 0.51, 0.71) inline val tan: Color get() = Color(0.82, 0.71, 0.55) inline val teal: Color get() = Color(0.00, 0.50, 0.50) inline val thistle: Color get() = Color(0.85, 0.75, 0.85) inline val tomato: Color get() = Color(1.00, 0.39, 0.28) inline val turquoise: Color get() = Color(0.25, 0.88, 0.82) inline val transparent: Color get() = Color(1.00, 1.00, 1.00, 0.00) inline val violet: Color get() = Color(0.93, 0.51, 0.93) inline val wheat: Color get() = Color(0.96, 0.87, 0.70) inline val white: Color get() = Color(1.00, 1.00, 1.00) inline val whitesmoke: Color get() = Color(0.96, 0.96, 0.96) inline val yellow: Color get() = Color(1.00, 1.00, 0.00) inline val yellowgreen: Color get() = Color(0.60, 0.80, 0.20) internal fun parseCol(p_str: String, p_ofs: Int): RealT { var ig = 0.0 for (i in 0..1) { var v: Int when (val c: Char = p_str[i + p_ofs]) { in '0'..'9' -> v = c.toInt() - '0'.toInt() in 'a'..'f' -> { v = c.toInt() - 'a'.toInt() v += 10 } in 'A'..'F' -> { v = c.toInt() - 'A'.toInt() v += 10 } else -> return -1.0 } ig += if (i == 0) v * 16 else v } return ig } } //CONSTRUCTOR constructor() : this(0.0, 0.0, 0.0, 1.0) constructor(other: Color) : this(other.r, other.g, other.b, other.a) constructor(r: Number, g: Number, b: Number, a: Number = 1.0) : this(r.toRealT(), g.toRealT(), b.toRealT(), a.toRealT()) constructor(from: String) : this() { var color = from if (color.isEmpty()) return if (color[0] == '#') color = color.substring(1, color.length - 1) val alpha = when { color.length == 8 -> true color.length == 6 -> false else -> return } var a = 255 if (alpha) { a = parseCol(color, 0).toInt() if (a < 0) { return } } val p = if (alpha) 2 else 0 val r = parseCol(color, p + 0).toInt() val g = parseCol(color, p + 2).toInt() val b = parseCol(color, p + 4).toInt() if (r < 0 || g < 0 || b < 0) { return } this.r = r / 255.0 this.g = g / 255.0 this.b = b / 255.0 this.a = a / 255.0 } constructor(from: Int) : this() { a = (from and 0xFF) / 255.0 var hex = from shr 8 b = (hex and 0xFF) / 255.0 hex = hex shr 8 g = (hex and 0xFF) / 255.0 hex = hex shr 8 r = (hex and 0xFF) / 255.0 } internal constructor(native: CValue) : this() { memScoped { this@Color.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { r = this@Color.r.toFloat() g = this@Color.g.toFloat() b = this@Color.b.toFloat() a = this@Color.a.toFloat() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed r = value.r.toRealT() g = value.g.toRealT() b = value.b.toRealT() a = value.a.toRealT() } //API /** * Returns a new color resulting from blending this color over another. * If the color is opaque, the result is also opaque. The second color may have a range of alpha values. */ fun blend(over: Color): Color { val res = Color() val sa = 1.0 - over.a if (res.a == 0.0) { return Color(0.0, 0.0, 0.0, 0.0) } else { res.r = (r * a * sa + over.r * over.a) / res.a res.g = (g * a * sa + over.g * over.a) / res.a res.b = (b * a * sa + over.b * over.a) / res.a } return res } /** * Returns the most contrasting color. */ fun contrasted(): Color { val c = Color(r, g, b, a) c.contrast() return c } internal fun contrast() { r = (r + 0.5).rem(1.0) g = (g + 0.5).rem(1.0) b = (b + 0.5).rem(1.0) } /** * Returns a new color resulting from making this color darker by the specified percentage (ratio from 0 to 1). */ fun darkened(amount: RealT): Color { return Color( r * (1.0 - amount), g * (1.0 - amount), b * (1.0 - amount), a ) } /** * Constructs a color from an HSV profile. h, s, and v are values between 0 and 1. */ fun fromHsv(h: RealT, s: RealT, v: RealT, a: RealT): Color { var h2 = (h * 360.0).rem(360.0) if (h2 < 0) h2 += 360 val finalH = h2 / 60 val c = v * s val x = c * (1.0 - (finalH.rem(2) - 1)) val rgbTriple = when (finalH.toInt()) { 0 -> Triple(c, x, 0.0) 1 -> Triple(x, c, 0.0) 2 -> Triple(0.0, c, x) 3 -> Triple(0.0, x, c) 4 -> Triple(x, 0.0, c) 5 -> Triple(c, 0.0, x) else -> Triple(0.0, 0.0, 0.0) } val m = v - c return Color(m + rgbTriple.first, m + rgbTriple.second, m + rgbTriple.third, a) } /** * Returns the color’s grayscale representation. * The gray value is calculated as (r + g + b) / 3. */ fun gray(): RealT = (r + g + b) / 3.0 /** * Returns the inverted color (1 - r, 1 - g, 1 - b, a). */ fun inverted(): Color { val c = Color(r, g, b, a) c.invert() return c } internal fun invert() { r = 1.0 - r g = 1.0 - g b = 1.0 - b } /** * Returns true if this color and color are approximately equal, by running isEqualApprox on each component. */ fun isEqualApprox(color: Color): Boolean { return isEqualApprox(r, color.r) && isEqualApprox(g, color.g) && isEqualApprox(b, color.b) && isEqualApprox(a, color.a) } /** * Returns a new color resulting from making this color lighter by the specified percentage (ratio from 0 to 1). */ fun lightened(amount: RealT): Color { return Color( r + (1.0 - r) * amount, g + (1.0 - g) * amount, b + (1.0 - b) * amount, a ) } /** * Returns the linear interpolation with another color. The interpolation factor t is between 0 and 1. */ fun linearInterpolate(otherColor: Color, t: RealT): Color { val res = Color(r, g, b, a) res.r += (t * (otherColor.r - r)) res.g += (t * (otherColor.g - g)) res.b += (t * (otherColor.b - b)) res.a += (t * (otherColor.a - a)) return res } /** * Returns the color’s 32-bit integer in ABGR format (each byte represents a component of the ABGR profile). * ABGR is the reversed version of the default format. */ fun toABGR32(): Int = toByteColorCode(a, b, g, r, ColorByte.BITS32).toInt() /** * Returns the color’s 64-bit integer in ABGR format (each word represents a component of the ABGR profile). * ABGR is the reversed version of the default format. */ fun toABGR64(): Long = toByteColorCode(a, b, g, r, ColorByte.BITS64) /** * Returns the color’s 32-bit integer in ARGB format (each byte represents a component of the ARGB profile). * ARGB is more compatible with DirectX. */ fun toARGB32(): Int = toByteColorCode(a, r, g, b, ColorByte.BITS32).toInt() /** * Returns the color’s 64-bit integer in ARGB format (each word represents a component of the ARGB profile). * ARGB is more compatible with DirectX. */ fun toARGB64(): Long = toByteColorCode(a, r, g, b, ColorByte.BITS64) /** * Returns the color’s 32-bit integer in RGBA format (each byte represents a component of the RGBA profile). * RGBA is Godot’s default format. */ fun toRGBA32(): Int = toByteColorCode(r, g, b, a, ColorByte.BITS32).toInt() /** Returns the color’s 64-bit integer in RGBA format (each word represents a component of the RGBA profile). RGBA is Godot’s default format. */ fun toRGBA64(): Long = toByteColorCode(r, g, b, a, ColorByte.BITS64) private fun toByteColorCode(first: RealT, second: RealT, third: RealT, fourth: RealT, colorByte: ColorByte): Long { val size = colorByte.size val shift = colorByte.shift var c: Long = (first * size).roundToLong() c = c shl shift c = c or (second * size).roundToLong() c = c shl shift c = c or (third * size).roundToLong() c = c shl shift c = c or (fourth * size).roundToLong() return c } /** * Returns the color’s HTML hexadecimal color string in ARGB format (ex: ff34f822). * Setting with_alpha to false excludes alpha from the hexadecimal string. */ fun toHtml(alpha: Boolean): String { var txt = "" txt += toHex(r) txt += toHex(g) txt += toHex(b) if (alpha) { txt = toHex(a) + txt } return txt } private fun toHex(p_val: RealT): String { var v = (p_val * 255).toInt() v = when { v < 0 -> 0 v > 255 -> 255 else -> v } var ret = "" for (i in 0..1) { val c = shortArrayOf(0, 0) val lv = v and 0xF if (lv < 10) { c[0] = ('0'.toInt() + lv).toShort() } else { c[0] = ('a'.toInt() + lv - 10).toShort() } v = v shr 4 val cs = String(charArrayOf(c[0].toChar())) ret = cs + ret } return ret } //Utilities override fun toVariant() = Variant(this) operator fun plus(c: Color) = Color(r + c.r, g + c.g, b + c.b, a + c.a) operator fun plus(scalar: Float) = Color(r + scalar, g + scalar, b + scalar, a + scalar) operator fun plus(scalar: Double) = Color(r + scalar, g + scalar, b + scalar, a + scalar) operator fun minus(c: Color) = Color(r - c.r, g - c.g, b - c.b, a - c.a) operator fun minus(scalar: Float) = Color(r - scalar, g - scalar, b - scalar, a - scalar) operator fun minus(scalar: Double) = Color(r - scalar, g - scalar, b - scalar, a - scalar) operator fun times(c: Color) = Color(r * c.r, g * c.g, b * c.b, a * c.a) operator fun times(scalar: Float) = Color(r * scalar, g * scalar, b * scalar, a * scalar) operator fun times(scalar: Double) = Color(r * scalar, g * scalar, b * scalar, a * scalar) operator fun div(c: Color) = Color(r / c.r, g / c.g, b / c.b, a / c.a) operator fun div(scalar: Float) = Color(r / scalar, g / scalar, b / scalar, a / scalar) operator fun div(scalar: Double) = Color(r / scalar, g / scalar, b / scalar, a / scalar) override fun compareTo(other: Color): Int { return when { r == other.r -> when { g == other.g -> when { b == other.b -> when { a < other.a -> -1 a == other.a -> 0 else -> 1 } b < other.b -> -1 else -> 1 } g < other.g -> -1 else -> 1 } r < other.r -> -1 else -> 1 } } override fun toString(): String { return "$r, $g, $b, $a" } override fun hashCode(): Int { var result = r.hashCode() result = 31 * result + g.hashCode() result = 31 * result + b.hashCode() result = 31 * result + a.hashCode() return result } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Dictionary.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_dictionary_layout import godot.internal.type.* import kotlinx.cinterop.* @ExperimentalUnsignedTypes class Dictionary : NativeCoreType, Iterable> { //PROPERTIES val size: Int get() = this.size() val keys: VariantArray get() = this.keys() val values: VariantArray get() = this.values() //CONSTRUCTOR constructor() { _handle = cValue {} callNative { nullSafe(Godot.gdnative.godot_dictionary_new)(it) } } internal constructor(native: CValue) { memScoped { this@Dictionary.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //API /** * Clear the dictionary, removing all key/value pairs. */ fun clear() { callNative { nullSafe(Godot.gdnative.godot_dictionary_clear)(it) } } /** * Creates a copy of the dictionary, and returns it. * The deep parameter causes inner dictionaries and arrays to be copied recursively, but does not apply to objects. */ fun duplicate(deep: Boolean = false) { callNative { nullSafe(Godot.gdnative12.godot_dictionary_duplicate)(it, deep) } } /** * Returns true if the dictionary is empty. */ fun empty(): Boolean { return callNative { nullSafe(Godot.gdnative.godot_dictionary_empty)(it) } } /** * Erase a dictionary key/value pair by key. Doesn't return a Boolean like the GDScript version because the GDNative function doesn't return anything */ fun erase(key: Variant) { callNative { nullSafe(Godot.gdnative.godot_dictionary_erase)(it, key._handle.ptr) } } fun erase(key: Int) = erase(Variant(key)) fun erase(key: Float) = erase(Variant(key)) fun erase(key: String) = erase(Variant(key)) fun erase(key: Boolean) = erase(Variant(key)) fun erase(key: Object) = erase(key.toVariant()) fun erase(key: CoreType) = erase(key.toVariant()) /** * Returns the current value for the specified key in the Dictionary. * If the key does not exist, the method returns the value of the optional default argument, or null if it is omitted. */ fun get(key: Variant, default: Variant = Variant()): Variant { return Variant( callNative { nullSafe(Godot.gdnative11.godot_dictionary_get_with_default)( it, key._handle.ptr, default._handle.ptr ) } ) } fun get(key: NaturalT, default: Variant = Variant()) = get(Variant(key), default) fun get(key: NaturalT, default: NaturalT) = get(Variant(key), Variant(default)) fun get(key: NaturalT, default: RealT) = get(Variant(key), Variant(default)) fun get(key: NaturalT, default: String) = get(Variant(key), Variant(default)) fun get(key: NaturalT, default: Boolean) = get(Variant(key), Variant(default)) fun get(key: NaturalT, default: Object) = get(Variant(key), default.toVariant()) fun get(key: NaturalT, default: CoreType) = get(Variant(key), default.toVariant()) fun get(key: RealT, default: Variant = Variant()) = get(Variant(key), default) fun get(key: RealT, default: NaturalT) = get(Variant(key), Variant(default)) fun get(key: RealT, default: RealT) = get(Variant(key), Variant(default)) fun get(key: RealT, default: String) = get(Variant(key), Variant(default)) fun get(key: RealT, default: Boolean) = get(Variant(key), Variant(default)) fun get(key: RealT, default: Object) = get(Variant(key), default.toVariant()) fun get(key: RealT, default: CoreType) = get(Variant(key), default.toVariant()) fun get(key: String, default: Variant = Variant()) = get(Variant(key), default) fun get(key: String, default: NaturalT) = get(Variant(key), Variant(default)) fun get(key: String, default: RealT) = get(Variant(key), Variant(default)) fun get(key: String, default: String) = get(Variant(key), Variant(default)) fun get(key: String, default: Boolean) = get(Variant(key), Variant(default)) fun get(key: String, default: Object) = get(Variant(key), default.toVariant()) fun get(key: String, default: CoreType) = get(Variant(key), default.toVariant()) fun get(key: Boolean, default: Variant = Variant()) = get(Variant(key), default) fun get(key: Boolean, default: NaturalT) = get(Variant(key), Variant(default)) fun get(key: Boolean, default: RealT) = get(Variant(key), Variant(default)) fun get(key: Boolean, default: String) = get(Variant(key), Variant(default)) fun get(key: Boolean, default: Boolean) = get(Variant(key), Variant(default)) fun get(key: Boolean, default: Object) = get(Variant(key), default.toVariant()) fun get(key: Boolean, default: CoreType) = get(Variant(key), default.toVariant()) fun get(key: Object, default: Variant = Variant()) = get(key.toVariant(), default) fun get(key: Object, default: NaturalT) = get(key.toVariant(), Variant(default)) fun get(key: Object, default: RealT) = get(key.toVariant(), Variant(default)) fun get(key: Object, default: String) = get(key.toVariant(), Variant(default)) fun get(key: Object, default: Boolean) = get(key.toVariant(), Variant(default)) fun get(key: Object, default: Object) = get(key.toVariant(), default.toVariant()) fun get(key: Object, default: CoreType) = get(key.toVariant(), default.toVariant()) fun get(key: CoreType, default: Variant = Variant()) = get(key.toVariant(), default) fun get(key: CoreType, default: NaturalT) = get(key.toVariant(), Variant(default)) fun get(key: CoreType, default: RealT) = get(key.toVariant(), Variant(default)) fun get(key: CoreType, default: String) = get(key.toVariant(), Variant(default)) fun get(key: CoreType, default: Boolean) = get(key.toVariant(), Variant(default)) fun get(key: CoreType, default: Object) = get(key.toVariant(), default.toVariant()) fun get(key: CoreType, default: CoreType) = get(key.toVariant(), default.toVariant()) /** * Returns true if the dictionary has a given key. * Note: This is equivalent to using the in operator as follows: */ fun has(key: Variant): Boolean { return callNative { nullSafe(Godot.gdnative.godot_dictionary_has)(it, key._handle.ptr) } } fun has(key: NaturalT) = has(Variant(key)) fun has(key: RealT) = has(Variant(key)) fun has(key: String) = has(Variant(key)) fun has(key: Boolean) = has(Variant(key)) fun has(key: Object) = has(key.toVariant()) fun has(key: CoreType) = has(key.toVariant()) /** * Returns true if the dictionary has all of the keys in the given array. */ fun hasAll(keys: VariantArray): Boolean { return callNative { nullSafe(Godot.gdnative.godot_dictionary_has_all)(it, keys._handle.ptr) } } /** * Returns a hashed integer value representing the dictionary contents. This can be used to compare dictionaries by value */ fun hash(): Int { return callNative { nullSafe(Godot.gdnative.godot_dictionary_hash)(it) } } /** * Returns the list of keys in the Dictionary. */ fun keys(): VariantArray { return VariantArray( callNative { nullSafe(Godot.gdnative.godot_dictionary_keys)(it) } ) } /** * Returns the size of the dictionary (in pairs). */ fun size(): Int { return callNative { nullSafe(Godot.gdnative.godot_dictionary_size)(it) } } /** * Returns the list of values in the Dictionary. */ fun values(): VariantArray { return VariantArray( callNative { nullSafe(Godot.gdnative.godot_dictionary_values)(it) } ) } //UTILITIES operator fun get(key: Variant): Variant { return Variant( callNative { nullSafe(Godot.gdnative.godot_dictionary_get)(it, key._handle.ptr) } ) } operator fun get(key: NaturalT) = get(Variant(key)) operator fun get(key: RealT) = get(Variant(key)) operator fun get(key: String) = get(Variant(key)) operator fun get(key: Boolean) = get(Variant(key)) operator fun get(key: Object) = get(key.toVariant()) operator fun get(key: CoreType) = get(key.toVariant()) operator fun set(key: Variant, value: Variant) { callNative { nullSafe(Godot.gdnative.godot_dictionary_set)(it, key._handle.ptr, value._handle.ptr) } } operator fun set(key: NaturalT, value: Variant) = set(Variant(key), value) operator fun set(key: NaturalT, value: NaturalT) = set(Variant(key), Variant(value)) operator fun set(key: NaturalT, value: RealT) = set(Variant(key), Variant(value)) operator fun set(key: NaturalT, value: String) = set(Variant(key), Variant(value)) operator fun set(key: NaturalT, value: Boolean) = set(Variant(key), Variant(value)) operator fun set(key: NaturalT, value: Object) = set(Variant(key), value.toVariant()) operator fun set(key: NaturalT, value: CoreType) = set(Variant(key), value.toVariant()) operator fun set(key: RealT, value: Variant) = set(Variant(key), value) operator fun set(key: RealT, value: NaturalT) = set(Variant(key), Variant(value)) operator fun set(key: RealT, value: RealT) = set(Variant(key), Variant(value)) operator fun set(key: RealT, value: String) = set(Variant(key), Variant(value)) operator fun set(key: RealT, value: Boolean) = set(Variant(key), Variant(value)) operator fun set(key: RealT, value: Object) = set(Variant(key), value.toVariant()) operator fun set(key: RealT, value: CoreType) = set(Variant(key), value.toVariant()) operator fun set(key: String, value: Variant) = set(Variant(key), value) operator fun set(key: String, value: NaturalT) = set(Variant(key), Variant(value)) operator fun set(key: String, value: RealT) = set(Variant(key), Variant(value)) operator fun set(key: String, value: String) = set(Variant(key), Variant(value)) operator fun set(key: String, value: Boolean) = set(Variant(key), Variant(value)) operator fun set(key: String, value: Object) = set(Variant(key), value.toVariant()) operator fun set(key: String, value: CoreType) = set(Variant(key), value.toVariant()) operator fun set(key: Boolean, value: Variant) = set(Variant(key), value) operator fun set(key: Boolean, value: NaturalT) = set(Variant(key), Variant(value)) operator fun set(key: Boolean, value: RealT) = set(Variant(key), Variant(value)) operator fun set(key: Boolean, value: String) = set(Variant(key), Variant(value)) operator fun set(key: Boolean, value: Boolean) = set(Variant(key), Variant(value)) operator fun set(key: Boolean, value: Object) = set(Variant(key), value.toVariant()) operator fun set(key: Boolean, value: CoreType) = set(Variant(key), value.toVariant()) operator fun set(key: Object, value: Variant) = set(key.toVariant(), value) operator fun set(key: Object, value: NaturalT) = set(Variant(key), Variant(value)) operator fun set(key: Object, value: RealT) = set(Variant(key), Variant(value)) operator fun set(key: Object, value: String) = set(Variant(key), Variant(value)) operator fun set(key: Object, value: Boolean) = set(Variant(key), Variant(value)) operator fun set(key: Object, value: Object) = set(Variant(key), value.toVariant()) operator fun set(key: Object, value: CoreType) = set(Variant(key), value.toVariant()) operator fun set(key: CoreType, value: Variant) = set(key.toVariant(), value) operator fun set(key: CoreType, value: NaturalT) = set(key.toVariant(), Variant(value)) operator fun set(key: CoreType, value: RealT) = set(key.toVariant(), Variant(value)) operator fun set(key: CoreType, value: String) = set(key.toVariant(), Variant(value)) operator fun set(key: CoreType, value: Boolean) = set(key.toVariant(), Variant(value)) operator fun set(key: CoreType, value: Object) = set(key.toVariant(), value.toVariant()) operator fun set(key: CoreType, value: CoreType) = set(key.toVariant(), value.toVariant()) operator fun contains(key: Variant): Boolean = has(Variant(key)) operator fun contains(key: NaturalT): Boolean = has(Variant(key)) operator fun contains(key: RealT): Boolean = has(Variant(key)) operator fun contains(key: String): Boolean = has(Variant(key)) operator fun contains(key: Boolean): Boolean = has(Variant(key)) operator fun contains(key: Object): Boolean = has(key.toVariant()) operator fun contains(key: CoreType): Boolean = has(key.toVariant()) override fun toVariant(): Variant = Variant(this) override fun equals(other: Any?): Boolean { if (other == null || other !is Dictionary) { return false } return callNative { nullSafe(Godot.gdnative.godot_dictionary_operator_equal)(it, other._handle.ptr) } } override fun hashCode(): Int { return _handle.hashCode() } override fun toString(): String { return "Dictionary($size)" } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } override fun iterator(): Iterator> { return MapIterator(keys().iterator(), this::get) } } /** * Create a shallow copy of the Dictionary */ fun Dictionary(other: Dictionary) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/GdString.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_string import godot.gdnative.godot_string_layout import godot.internal.type.nullSafe import kotlinx.cinterop.* inline class GdString(val value: CValue) { internal fun toKString(): String { return memScoped { val charString = nullSafe(Godot.gdnative.godot_string_utf8)(this@GdString.value.ptr) val charPtr = charString.ptr val ret = nullSafe(Godot.gdnative.godot_char_string_get_data)(charPtr)?.toKString() ?: throw NullPointerException("Failed to convert Godot-string to Kotlin-string") nullSafe(Godot.gdnative.godot_char_string_destroy)(charPtr) destroy(this@memScoped) ret } } internal fun destroy(memScope: MemScope) = nullSafe(Godot.gdnative.godot_string_destroy)(this.value.getPointer(memScope)) } //From Godot to Kotlin internal fun GdString(ptr: COpaquePointer) = GdString(ptr.reinterpret()) internal fun GdString(ptr: CPointer) = GdString(ptr.pointed.readValue()) //From Kotlin to Godot internal fun String.getRawMemory(memScope: MemScope) = this.toGDString().value.getPointer(memScope) internal fun String.toGDString() = memScoped { GdString(cValue { val ptr = this.ptr nullSafe(Godot.gdnative.godot_string_new)(ptr) nullSafe(Godot.gdnative.godot_string_parse_utf8)( ptr, this@toGDString.cstr.ptr ) }) } internal fun String.asGDString(block: MemScope.(GdString) -> T): T { return memScoped { val gdString = GdString(cValue { val ptr = this.ptr nullSafe(Godot.gdnative.godot_string_new)(ptr) nullSafe(Godot.gdnative.godot_string_parse_utf8)( ptr, this@asGDString.cstr.ptr ) }) val ret: T = block(this, gdString) nullSafe(Godot.gdnative.godot_string_destroy)(gdString.value.ptr) ret } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/GodotArray.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_array_layout import godot.internal.type.* import kotlinx.cinterop.* abstract class GodotArray internal constructor() : NativeCoreType(), Iterable { //PROPERTIES val size: Int get() = this.size() //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //COMMON API /** * Clears the array. This is equivalent to using resize with a size of 0. */ fun clear() { callNative { nullSafe(Godot.gdnative.godot_array_clear)(it) } } /** * Returns true if the array is empty. */ fun empty(): Boolean { return callNative { nullSafe(Godot.gdnative.godot_array_empty)(it) } } /** * Returns a hashed integer value representing the array contents. */ fun hash(): NaturalT { return callNative { nullSafe(Godot.gdnative.godot_array_hash)(it) }.toNaturalT() } /** * Reverses the order of the elements in the array. */ fun invert() { return callNative { nullSafe(Godot.gdnative.godot_array_invert)(it) } } /** * Removes an element from the array by index. */ fun remove(position: Int) { return callNative { nullSafe(Godot.gdnative.godot_array_remove)(it, position) } } /** * Resizes the array to contain a different number of elements. * If the array size is smaller, elements are cleared, if bigger, new elements are null. */ fun resize(size: Int) { return callNative { nullSafe(Godot.gdnative.godot_array_resize)(it, size) } } /** * Shuffles the array such that the items will have a random order. * This method uses the global random number generator common to methods such as @randi. * Call @randomize to ensure that a new seed will be used each time if you want non-reproducible shuffling. */ fun shuffle() { return callNative { nullSafe(Godot.gdnative11.godot_array_shuffle)(it) } } /** * Returns the number of elements in the array. */ fun size(): Int { return callNative { nullSafe(Godot.gdnative.godot_array_size)(it) } } /** * Sorts the array. */ fun sort() { return callNative { nullSafe(Godot.gdnative.godot_array_sort)(it) } } /** * Sorts the array using a custom method. The arguments are an object that holds the method and the name of such method. * The custom method receives two arguments (a pair of elements from the array) and must return either true or false. */ fun sortCustom(obj: Object, func: String) { return callNative { nullSafe(Godot.gdnative.godot_array_sort_custom)(it, obj.ptr, func.toGDString().value.ptr) } } //API /** * Appends an element at the end of the array (alias of push_back). */ abstract fun append(value: T) /** * Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search. * Optionally, a before specifier can be passed. * If false, the returned index comes after all existing entries of the value in the array. * Note: Calling bsearch on an unsorted array results in unexpected behavior. */ abstract fun bsearch(value: T, before: Boolean = true): Int /** * Finds the index of an existing value (or the insertion index that maintains sorting order, if the value is not yet present in the array) using binary search and a custom comparison method. * Optionally, a before specifier can be passed. * If false, the returned index comes after all existing entries of the value in the array. * The custom method receives two arguments (an element from the array and the value searched for) and must return true if the first argument is less than the second, and return false otherwise. * Note: Calling bsearch on an unsorted array results in unexpected behavior. */ abstract fun bsearchCustom(value: T, obj: Object, func: String, before: Boolean = true): Int /** * Returns the number of times an element is in the array. */ abstract fun count(value: T): Int /** * Returns a copy of the array. * If deep is true, a deep copy is performed: * all nested arrays and dictionaries are duplicated and will not be shared with the original array. * If false, a shallow copy is made and references to the original nested arrays and dictionaries are kept, so that modifying a sub-array or dictionary in the copy will also impact those referenced in the source array. */ abstract fun duplicate(deep: Boolean = false): GodotArray /** * Removes the first occurrence of a value from the array. */ abstract fun erase(value: T) /** * Searches the array for a value and returns its index or -1 if not found. * Optionally, the initial search index can be passed. */ abstract fun find(what: T, from: Int = 0): Int /** * Searches the array in reverse order for a value and returns its index or -1 if not found. */ abstract fun findLast(value: T): Int /** * Returns the first element of the array, or null if the array is empty. */ abstract fun front(): T /** * Returns true if the array contains the given value. */ abstract fun has(value: T): Boolean /** * Inserts a new element at a given position in the array. * The position must be valid, or at the end of the array (pos == size()). */ abstract fun insert(position: Int, value: T) /** * Returns the maximum value contained in the array if all elements are of comparable types. * If the elements can't be compared, null is returned. */ abstract fun max(): T /** * Returns the minimum value contained in the array if all elements are of comparable types. * If the elements can't be compared, null is returned. */ abstract fun min(): T /** * Removes and returns the last element of the array. * Returns null if the array is empty. */ abstract fun popBack(): T /** * Removes and returns the first element of the array. * Returns null if the array is empty. */ abstract fun popFront(): T /** * Appends an element at the end of the array. */ abstract fun pushBack(value: T) /** * Adds an element at the beginning of the array */ abstract fun pushFront(value: T) /** * Searches the array in reverse order. * Optionally, a start search index can be passed. * If negative, the start index is considered relative to the end of the array. */ abstract fun rfind(what: T, from: Int = -1): Int /** * Searches the array in reverse order. * Optionally, a start search index can be passed. * If negative, the start index is considered relative to the end of the array. */ abstract fun slice(begin: Int, end: Int, step: Int = 1, deep: Boolean = false): GodotArray //UTILITIES override fun toVariant() = Variant(this) /** * Changes the element at the given index. */ abstract operator fun set(idx: Int, data: T) /** * Retrieve the element at the given index. */ abstract operator fun get(idx: Int): T abstract operator fun plus(other: T) /** * WARNING: no equals function is available in the Gdnative API for this Coretype. * This methods implementation works but is not the fastest one. */ override fun equals(other: Any?): Boolean { return if (other is GodotArray<*>) { val list1 = this.toList() val list2 = other.toList() list1 == list2 } else { false } } override fun hashCode(): Int { return _handle.hashCode() } override fun toString(): String { return "Array(${size()})" } internal inline fun callNative(block: MemScope.(CPointer) -> C): C { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/NodePath.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_node_path_layout import godot.internal.type.NativeCoreType import godot.internal.type.callNative import godot.internal.type.nullSafe import kotlinx.cinterop.* class NodePath : NativeCoreType { //PROPERTIES val path: String get() { return callNative { GdString(nullSafe(Godot.gdnative.godot_node_path_as_string)(it)) }.toKString() } //CONSTRUCTOR constructor() { _handle = cValue {} callNative { nullSafe(Godot.gdnative.godot_node_path_new)(it, "".toGDString().value.ptr) } } constructor(from: String) { _handle = cValue {} callNative { nullSafe(Godot.gdnative.godot_node_path_new)(it, from.toGDString().value.ptr) } } constructor(from: NodePath) { _handle = cValue {} callNative { val str = nullSafe(Godot.gdnative.godot_node_path_as_string)(from._handle.ptr) nullSafe(Godot.gdnative.godot_node_path_new)(it, str.ptr) } } internal constructor(native: CValue) { _handle = cValue {} callNative { nullSafe(Godot.gdnative.godot_node_path_new_copy)(it, native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //API /** * Get the node name indicated by idx (0 to get_name_count) */ fun getName(idx: Int): String { return callNative { GdString(nullSafe(Godot.gdnative.godot_node_path_get_name)(it, idx)) }.toKString() } /** * Get the number of node names which make up the path. */ fun getNameCount(): Int { return callNative { nullSafe(Godot.gdnative.godot_node_path_get_name_count)(it) } } /** * Get the path’s property name, or an empty string if the path doesn’t have a property. */ fun getProperty(): String { return NodePath( callNative { nullSafe(Godot.gdnative11.godot_node_path_get_as_property_path)(it) }).toString() } /** * Get the resource name indicated by idx (0 to get_subname_count) */ fun getSubname(idx: Int): String { return callNative { GdString(nullSafe(Godot.gdnative.godot_node_path_get_subname)(it, idx)).toKString() } } /** * Get the number of resource names in the path. */ fun getSubnameCount(): Int { return callNative { nullSafe(Godot.gdnative.godot_node_path_get_subname_count)(it) } } /** * Return true if the node path is absolute (not relative). */ fun isAbsolute(): Boolean { return callNative { nullSafe(Godot.gdnative.godot_node_path_is_absolute)(it) } } /** * Return true if the node path is empty. */ fun isEmpty(): Boolean { return callNative { nullSafe(Godot.gdnative.godot_node_path_is_empty)(it) } } /** * */ fun getConcatenatedSubnames(): String { return callNative { GdString(nullSafe(Godot.gdnative.godot_node_path_get_concatenated_subnames)(it)).toKString() } } //UTILITIES override fun toVariant() = Variant(this) override fun equals(other: Any?): Boolean { return if (other is NodePath) { callNative { nullSafe(Godot.gdnative.godot_node_path_operator_equal)(it, other._handle.ptr) } } else { false } } override fun hashCode(): Int { return _handle.hashCode() } override fun toString(): String { return "NodePath($path)" } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Plane.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_plane import godot.gdnative.godot_plane_layout import godot.internal.type.* import kotlinx.cinterop.* import kotlin.math.abs class Plane( p_normal: Vector3, var d: RealT = 0.0 ) : CoreType { @PublishedApi internal var _normal = Vector3(p_normal) //PROPERTIES /** Return a copy of the normal Vector3 * Warning: Writing normal.x = 2 will only modify a copy, not the actual object. * To modify it, use normal(). * */ var normal get() = Vector3(_normal) set(value) { _normal = Vector3(value) } inline fun normal(block: Vector3.() -> T): T { return _normal.block() } //CONSTANTS companion object { val PLANE_YZ: Plane get() = Plane(1, 0, 0, 0) val PLANE_XZ: Plane get() = Plane(0, 1, 0, 0) val PLANE_XY: Plane get() = Plane(0, 0, 1, 0) } //CONSTRUCTOR constructor() : this(Vector3(0, 0, 0), 0) constructor(other: Plane) : this(other._normal, other.d) constructor(p1: Number, p2: Number, p3: Number, p4: Number) : this(Vector3(p1.toRealT(), p2.toRealT(), p3.toRealT()), p4.toRealT()) constructor(point1: Vector3, point2: Vector3, point3: Vector3) : this() { _normal = (point1 - point3).cross(point1 - point2) _normal.normalize() d = _normal.dot(point1) } constructor(normal: Vector3, d: Number) : this(normal, d.toRealT()) constructor(point: Vector3, normal: Vector3) : this(normal, normal.dot(point)) internal constructor(native: CValue) : this() { memScoped { this@Plane.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { normal.x = this@Plane._normal.x.toFloat() normal.y = this@Plane._normal.y.toFloat() normal.z = this@Plane._normal.z.toFloat() d = this@Plane.d.toFloat() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed _normal.setRawMemory(value.normal.ptr) d = value.d.toRealT() } //API /** * Returns the center of the plane. */ fun center(): Vector3 { return _normal * d; } /** * Returns the shortest distance from the plane to the position point. */ fun distanceTo(point: Vector3): RealT { return _normal.dot(point) - d } /** * Returns a point on the plane. */ fun getAnyPoint(): Vector3 { return _normal * d } /** * Returns a normal of the plane. */ fun getAnyPerpendicularNormal(): Vector3 { val p1 = Vector3(1, 0, 0) val p2 = Vector3(0, 1, 0) var p = if (abs(_normal.dot(p1)) > 0.99) p2 else p1 p -= _normal * _normal.dot(p) p.normalize() return p } /** * Returns true if point is inside the plane (by a very minimum epsilon threshold). */ fun hasPoint(point: Vector3, epsilon: RealT): Boolean { val dist = abs(_normal.dot(point) - d) return dist <= epsilon } /** * Returns the intersection point of the three planes b, c and this plane. * If no intersection is found, null is returned. */ fun intersect3(plane1: Plane, plane2: Plane): Vector3? { val plane0 = this val normal0 = plane0._normal val normal1 = plane1._normal val normal2 = plane2._normal val denom = normal0.cross(normal1).dot(normal2) if (abs(denom) <= CMP_EPSILON) { return null } val result: Vector3? result = (normal1.cross(normal2) * plane0.d) + (normal2.cross(normal0) * plane1.d) + (normal0.cross(normal1) * plane2.d) / denom return result } /** * Returns the intersection point of a ray consisting of the position from and the direction normal dir with this plane. * If no intersection is found, null is returned. */ fun intersectsRay(from: Vector3, dir: Vector3): Vector3? { val den = _normal.dot(dir) if (abs(den) <= CMP_EPSILON) { return null } val dist = (_normal.dot(from) - d) / den if (dist > CMP_EPSILON) { return null } return from + dir * (-dist) } /** * Returns the intersection point of a segment from position begin to position end with this plane. * If no intersection is found, null is returned. */ fun intersectsSegment(p_begin: Vector3, p_end: Vector3): Vector3? { val segment = p_begin - p_end val den = _normal.dot(segment) if (abs(den) <= CMP_EPSILON) { return null } val dist = (_normal.dot(p_begin) - d) / den if (dist < -CMP_EPSILON || dist > (1.0 + CMP_EPSILON)) { return null } return p_begin + segment * (-dist) } /** * Returns true if this plane and plane are approximately equal, by running isEqualApprox on each component. */ fun isEqualApprox(other: Plane): Boolean { return this._normal.isEqualApprox(other._normal) && isEqualApprox( this.d, other.d ) } /** * Returns true if point is located above the plane. */ fun isPointOver(point: Vector3): Boolean { return _normal.dot(point) > d } /** * Returns a copy of the plane, normalized. */ fun normalized(): Plane { val p = this p.normalize() return p } internal fun normalize() { val l = _normal.length() if (isEqualApprox(l, 0.0)) { this._normal = Vector3() this.d = 0.0 return } _normal /= l d /= l } /** * Returns the orthogonal projection of point p into a point in the plane. */ fun project(point: Vector3): Vector3 { return point - _normal * distanceTo(point) } //UTILITIES override fun toVariant() = Variant(this) override fun toString(): String { return "Plane(normal=$_normal, d=$d)" } override fun equals(other: Any?): Boolean { return when (other) { is Plane -> _normal == other._normal && d == other.d else -> false } } override fun hashCode(): Int { var result = _normal.hashCode() result = 31 * result + d.hashCode() return result } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Quat.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_quat import godot.gdnative.godot_quat_layout import godot.internal.type.* import kotlinx.cinterop.* import kotlin.math.* class Quat( var x: RealT, var y: RealT, var z: RealT, var w: RealT ) : CoreType { //CONSTANTS companion object { val IDENTITY: Quat get() = Quat(0.0, 0.0, 0.0, 1.0) } //CONSTRUCTOR constructor() : this(0.0, 0.0, 0.0, 1.0) constructor(other: Quat) : this(other.x, other.y, other.z, other.w) constructor(x: Number, y: Number, z: Number, w: Number = 1.0) : this(x.toRealT(), y.toRealT(), z.toRealT(), w.toRealT()) constructor(axis: Vector3, angle: RealT) : this() { val d: RealT = axis.length() if (d == 0.0) { set(0.0, 0.0, 0.0, 0.0) } else { val sinAngle: RealT = sin(angle * 0.5) val cosAngle: RealT = cos(angle * 0.5) val s: RealT = sinAngle / d set(axis.x * s, axis.y * s, axis.z * s, cosAngle) } } constructor(v0: Vector3, v1: Vector3) : this() { val c = v0.cross(v1) val d = v0.dot(v1) if (d < -1.0 + CMP_EPSILON) { x = 0.0 y = 1.0 z = 0.0 w = 0.0 } else { val s = sqrt((1.0 + d) * 2.0) val rs = 1.0 / s x = c.x * rs y = c.y * rs z = c.z * rs w = s * 0.5 } } internal constructor(native: CValue) : this() { memScoped { this@Quat.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { x = this@Quat.x.toGodotReal() y = this@Quat.y.toGodotReal() z = this@Quat.z.toGodotReal() w = this@Quat.w.toGodotReal() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed x = value.x.toRealT() y = value.y.toRealT() z = value.z.toRealT() w = value.w.toRealT() } //API /** * Performs a cubic spherical-linear interpolation with another quaternion. */ fun cubicSlerp(q: Quat, prep: Quat, postq: Quat, t: RealT): Quat { val t2: RealT = (1.0 - t) * t * 2 val sp = this.slerp(q, t) val sq = prep.slerpni(postq, t) return sp.slerpni(sq, t2) } /** * Returns the dot product of two quaternions.5 */ fun dot(q: Quat): RealT { return x * q.x + y * q.y + z * q.z + w * q.w } /** * Returns Euler angles (in the YXZ convention: first Z, then X, and Y last) corresponding to the rotation represented by the unit quaternion. Returned vector contains the rotation angles in the format (X angle, Y angle, Z angle). */ fun getEuler(): Vector3 { return getEulerYxz() } /** * getEulerYxz returns a vector containing the Euler angles in the format *(ax,ay,az), where ax is the angle of rotation around x axis, * and similar for other axes. * This implementation uses YXZ convention (Z is the first rotation). */ internal fun getEulerYxz(): Vector3 { val m = Basis(this) return m.getEulerYxz() } internal fun getEulerXyz(): Vector3 { val m = Basis(this) return m.getEulerXyz() } /** * Returns the inverse of the quaternion. */ fun inverse(): Quat { return Quat(-x, -y, -z, -w) } /** * Returns true if this quaterion and quat are approximately equal, by running isEqualApprox on each component. */ fun isEqualApprox(other: Quat): Boolean { return isEqualApprox(other.x, x) && isEqualApprox(other.y, y) && isEqualApprox(other.z, z) && isEqualApprox(other.w, w) } /** * Returns whether the quaternion is normalized or not. */ fun isNormalized(): Boolean { return abs(lengthSquared() - 1.0) < CMP_EPSILON } /** * Returns the length of the quaternion. */ fun length(): RealT { return sqrt(this.lengthSquared()) } /** * Returns the length of the quaternion, squared. */ fun lengthSquared(): RealT { return dot(this) } /** * Returns a copy of the quaternion, normalized to unit length. */ fun normalized(): Quat { return this / this.length() } internal fun normalize() { val l = this.length() x /= l y /= l z /= l w /= l } /** * Sets the quaternion to a rotation which rotates around axis by the specified angle, in radians. The axis must be a normalized vector. */ fun setAxisAndAngle(axis: Vector3, angle: RealT) { if (!axis.isNormalized()) { Godot.printError("Vector $axis is not normalized", "setAxisAndAngle", "Quat.kt", 192) } val d = axis.length() if (isEqualApprox(d, 0.0)) { set(0.0, 0.0, 0.0, 0.0) } else { val sin = sin(angle * 0.5) val cos = cos(angle * 0.5) val s = sin / d set(axis.x * s, axis.y * s, axis.z * s, cos) } } /** * Sets the quaternion to a rotation specified by Euler angles (in the YXZ convention: first Z, then X, and Y last), given in the vector format as (X angle, Y angle, Z angle). */ fun setEuler(p_euler: Vector3) { setEulerYxz(p_euler) } /** * setEulerXyz expects a vector containing the Euler angles in the format * (ax,ay,az), where ax is the angle of rotation around x axis, * and similar for other axes. * This implementation uses XYZ convention (Z is the first rotation). */ internal fun setEulerXyz(p_euler: Vector3) { val half1: RealT = p_euler.x * 0.5 val half2: RealT = p_euler.y * 0.5 val half3: RealT = p_euler.z * 0.5 // R = X(a1).Y(a2).Z(a3) convention for Euler angles. // Conversion to quaternion as listed in https://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19770024290.pdf (page A-2) // a3 is the angle of the first rotation, following the notation in this reference. val cos1: RealT = cos(half1) val cos2: RealT = cos(half2) val cos3: RealT = cos(half3) val sin1: RealT = sin(half1) val sin2: RealT = sin(half2) val sin3: RealT = sin(half3) set( sin1 * cos2 * sin3 + cos1 * sin2 * cos3, sin1 * cos2 * cos3 - cos1 * sin2 * sin3, -sin1 * sin2 * cos3 + cos1 * sin2 * sin3, sin1 * sin2 * sin3 + cos1 * cos2 * cos3 ) } internal fun setEulerYxz(p_euler: Vector3) { val half1: RealT = p_euler.y * 0.5 val half2: RealT = p_euler.x * 0.5 val half3: RealT = p_euler.z * 0.5 // R = X(a1).Y(a2).Z(a3) convention for Euler angles. // Conversion to quaternion as listed in https://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19770024290.pdf (page A-2) // a3 is the angle of the first rotation, following the notation in this reference. val cos1: RealT = cos(half1) val cos2: RealT = cos(half2) val cos3: RealT = cos(half3) val sin1: RealT = sin(half1) val sin2: RealT = sin(half2) val sin3: RealT = sin(half3) set( sin1 * cos2 * sin3 + cos1 * sin2 * cos3, sin1 * cos2 * cos3 - cos1 * sin2 * sin3, -sin1 * sin2 * cos3 + cos1 * sin2 * sin3, sin1 * sin2 * sin3 + cos1 * cos2 * cos3 ) } /** * Performs a spherical-linear interpolation with another quaternion. */ fun slerp(q: Quat, t: RealT): Quat { val to1 = Quat() val omega: RealT var cosom: RealT val sinom: RealT val scale0: RealT val scale1: RealT cosom = dot(q) if (cosom < 0) { cosom = -cosom to1.x = -q.x to1.y = -q.y to1.z = -q.z to1.w = -q.w } else { to1.x = q.x to1.y = q.y to1.z = q.z to1.w = q.w } if ((1.0 - cosom) > CMP_EPSILON) { // standard case (slerp) omega = acos(cosom) sinom = sin(omega) scale0 = sin((1.0 - t) * omega) / sinom scale1 = sin(t * omega) / sinom } else { // "from" and "to" quaternions are very close // ... so we can do a linear interpolation scale0 = 1.0 - t scale1 = t } // calculate final values return Quat( scale0 * x + scale1 * to1.x, scale0 * y + scale1 * to1.y, scale0 * z + scale1 * to1.z, scale0 * w + scale1 * to1.w ) } /** * Performs a spherical-linear interpolation with another quaterion without checking if the rotation path is not bigger than 90°. */ fun slerpni(q: Quat, t: RealT): Quat { val from = this val dot: RealT = from.dot(q) if (abs(dot) > 0.9999) return from val theta = acos(dot) val sinT = 1.0 / sin(theta) val newFactor: RealT = sin(t * theta) * sinT val invFactor: RealT = sin((1.0 - t) * theta) * sinT return Quat( invFactor * from.x + newFactor * q.x, invFactor * from.y + newFactor * q.y, invFactor * from.z + newFactor * q.z, invFactor * from.w + newFactor * q.w ) } /** * Transforms the vector v by this quaternion. */ fun xform(v: Vector3): Vector3 { var q = this * v q *= this.inverse() return Vector3(q.x, q.y, q.z) } //UTILITIES override fun toVariant() = Variant(this) fun set(px: RealT, py: RealT, pz: RealT, pw: RealT) { x = px y = py z = pz w = pw } operator fun times(v: Vector3) = Quat( w * v.x + y * v.z - z * v.y, w * v.y + z * v.x - x * v.z, w * v.z + x * v.y - y * v.x, -x * v.x - y * v.y - z * v.z ) operator fun plus(q2: Quat) = Quat(this.x + q2.x, this.y + q2.y, this.z + q2.z, this.w + q2.w) operator fun minus(q2: Quat) = Quat(this.x - q2.x, this.y - q2.y, this.z - q2.z, this.w - q2.w) operator fun times(q2: Quat) = Quat(this.x * q2.x, this.y * q2.y, this.z * q2.z, this.w * q2.w) operator fun times(scalar: Int) = Quat(x * scalar, y * scalar, z * scalar, w * scalar) operator fun times(scalar: Long) = Quat(x * scalar, y * scalar, z * scalar, w * scalar) operator fun times(scalar: Float) = Quat(x * scalar, y * scalar, z * scalar, w * scalar) operator fun times(scalar: Double) = Quat(x * scalar, y * scalar, z * scalar, w * scalar) operator fun div(f: RealT) = Quat(x / f, y / f, z / f, w / f) operator fun unaryMinus() = Quat(-this.x, -this.y, -this.z, -this.w) override fun equals(other: Any?): Boolean = when (other) { is Quat -> (x == other.x && y == other.y && z == other.z && w == other.w) else -> false } override fun toString(): String { return "($x, $y, $z, $w)" } override fun hashCode(): Int { var result = x.hashCode() result = 31 * result + y.hashCode() result = 31 * result + z.hashCode() result = 31 * result + w.hashCode() return result } /* * GDScript related members */ constructor(from: Basis) : this() { from.getQuat().also { set(it.x, it.y, it.z, it.w) } } } operator fun Int.times(quat: Quat) = quat * this operator fun Long.times(quat: Quat) = quat * this operator fun Float.times(quat: Quat) = quat * this operator fun Double.times(quat: Quat) = quat * this ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/RID.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.Object import godot.gdnative.godot_rid_layout import godot.internal.type.NativeCoreType import godot.internal.type.callNative import godot.internal.type.nullSafe import kotlinx.cinterop.* class RID : NativeCoreType, Comparable { //PROPERTIES val id: Int get() = getID() //CONSTRUCTOR constructor() { _handle = cValue {} callNative { nullSafe(Godot.gdnative.godot_rid_new)(it) } } constructor(from: Object) { _handle = cValue {} callNative { nullSafe(Godot.gdnative.godot_rid_new_with_resource)(it, from.ptr) } } internal constructor(native: CValue) { memScoped { this@RID.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //API /** * Returns the ID of the referenced resource. */ fun getID(): Int { return callNative { nullSafe(Godot.gdnative.godot_rid_get_id)(it) } } //UTILITIES override fun toVariant() = Variant(this) override fun compareTo(other: RID): Int { return when { this == other -> 0 callNative { nullSafe(Godot.gdnative.godot_rid_operator_less)(it, other._handle.ptr) } -> -1 else -> 1 } } override fun equals(other: Any?): Boolean { return when (other) { is RID -> callNative { nullSafe(Godot.gdnative.godot_rid_operator_equal)(it, other._handle.ptr) } else -> false } } override fun hashCode(): Int { return _handle.hashCode() } override fun toString(): String { return "RID($id)" } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Rect2.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_rect2 import godot.gdnative.godot_rect2_layout import godot.internal.type.CoreType import godot.internal.type.RealT import godot.internal.type.toGodotReal import kotlinx.cinterop.* import kotlin.math.max import kotlin.math.min class Rect2( p_position: Vector2, p_size: Vector2 ) : CoreType { @PublishedApi internal var _position = Vector2(p_position) @PublishedApi internal var _size = Vector2(p_size) //PROPERTIES /** Return a copy of the position Vector3 * Warning: Writing position.x = 2 will only modify a copy, not the actual object. * To modify it, use position(). * */ var position get() = Vector2(_position) set(value) { _position = Vector2(value) } inline fun position(block: Vector2.() -> T): T { return _position.block() } /** Return a copy of the size Vector2 * Warning: Writing size.x = 2 will only modify a copy, not the actual object. * To modify it, use size(). * */ var size get() = Vector2(_size) set(value) { _size = Vector2(value) } inline fun size(block: Vector2.() -> T): T { return _size.block() } /** Return a copy of the end Vector2 * Warning: Writing end.x = 2 will only modify a copy, not the actual object. * To modify it, use end(). * */ inline var end: Vector2 get() = _position + _size set(value) { _size = value - _position } inline fun end(block: Vector2.() -> T): T { val vec = end val ret = vec.block() end = vec return ret } //CONSTANTS enum class Margin(val value: Int) { LEFT(0), TOP(1), RIGHT(2), BOTTOM(3) } companion object { val MARGIN_LEFT = Margin.LEFT.value val MARGIN_TOP = Margin.TOP.value val MARGIN_RIGHT = Margin.RIGHT.value val MARGIN_BOTTOM = Margin.BOTTOM.value } //CONSTRUCTOR constructor() : this(Vector2(), Vector2()) constructor(other: Rect2) : this(other._position, other._size) constructor(x: RealT, y: RealT, width: RealT, height: RealT) : this(Vector2(x, y), Vector2(width, height)) internal constructor(native: CValue) : this() { memScoped { this@Rect2.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { position.x = this@Rect2._position.x.toGodotReal() position.y = this@Rect2._position.y.toGodotReal() size.x = this@Rect2._size.x.toGodotReal() size.y = this@Rect2._size.y.toGodotReal() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed _position.setRawMemory(value.position.ptr) _size.setRawMemory(value.size.ptr) } //API /** *Returns a Rect2 with equivalent position and area, modified so that * the top-left corner is the origin and width and height are positive. */ fun abs(): Rect2 { return Rect2( _position.x - min(_size.x, 0.0), _position.x - min(_size.x, 0.0), kotlin.math.abs(_size.x), kotlin.math.abs(_size.y) ) } /** * Returns the intersection of this Rect2 and b. */ fun clip(b: Rect2): Rect2 { if (!intersects(b)) return Rect2() b._position.x = max(b._position.x, _position.x) b._position.y = max(b._position.y, _position.y) val rectEnd = b._position + b._size val end = _position + _size b._size.x = min(rectEnd.x, end.x) - b._position.x b._size.y = min(rectEnd.y, end.y) - b._position.y return b } /** * Returns true if this Rect2 completely encloses another one. */ fun encloses(b: Rect2): Boolean { return (b._position.x >= _position.x) && (b._position.y >= _position.y) && ((b._position.x + b._size.x) < (_position.x + _size.x)) && ((b._position.y + b._size.y) < (_position.y + _size.y)) } /** * Returns this Rect2 expanded to include a given point. */ fun expand(vector: Vector2): Rect2 { val r = Rect2(this._position, this._size) r.expandTo(vector) return r } internal fun expandTo(vector: Vector2) { val begin = _position val end = _position + _size if (vector.x < begin.x) { begin.x = vector.x } if (vector.y < begin.y) { begin.y = vector.y } if (vector.x > end.x) { end.x = vector.x } if (vector.y > end.y) { end.y = vector.y } _position = begin _size = end - begin } /** * Returns the area of the Rect2. */ fun getArea(): RealT { return _size.x * _size.y } /** * Returns a copy of the Rect2 grown a given amount of units towards all the sides. */ fun grow(by: RealT): Rect2 { val g = Rect2(this._position, this._size) g._position.x -= by g._position.y -= by g._size.x += by * 2 g._size.y += by * 2 return g } /** * Returns a copy of the Rect2 grown a given amount of units towards all the sides. */ fun growIndividual(left: RealT, top: RealT, right: RealT, bottom: RealT): Rect2 { val g = Rect2(this._position, this._size) g._position.x -= left g._position.y -= top g._size.x += left + right g._size.y += top + bottom return g } /** * Returns a copy of the Rect2 grown a given amount of units towards all the sides. */ fun growMargin(margin: Margin, by: RealT): Rect2 { val g = Rect2(this._position, this._size) when (margin) { Margin.LEFT -> { g._position.x -= by g._size.x += by } Margin.RIGHT -> { g._size.x += by } Margin.TOP -> { g._position.y -= by g._size.y += by } Margin.BOTTOM -> { g._size.y += by } } return g } /** * Returns true if the Rect2 is flat or empty. */ fun hasNoArea(): Boolean { return _size.x <= 0 || _size.y <= 0 } /** * Returns true if the Rect2 contains a point. */ fun hasPoint(point: Vector2): Boolean { return when { point.x < _position.x -> false point.y < _position.y -> false point.x >= (_position.x + _size.x) -> false point.y >= (_position.y + _size.y) -> false else -> true } } /** * Returns true if the Rect2 overlaps with b (i.e. they have at least one point in common). * If include_borders is true, they will also be considered overlapping if their borders touch, even without intersection. */ fun intersects(b: Rect2, includeBorders: Boolean = false): Boolean { if (includeBorders) { return when { _position.x > (b._position.x + b._size.x) -> false (_position.x + _size.x) < b._position.x -> false _position.y > (b._position.y + b._size.y) -> false (_position.y + _size.y) < b._position.y -> false else -> true } } else { return when { _position.x >= (b._position.x + b._size.x) -> false (_position.x + _size.x) <= b._position.x -> false _position.y >= (b._position.y + b._size.y) -> false (_position.y + _size.y) <= b._position.y -> false else -> true } } } /** * Returns true if this Rect2 and rect are approximately equal, by calling is_equal_approx on each component. */ fun isEqualApprox(b: Rect2): Boolean { return b._position.isEqualApprox(this._position) && b._size.isEqualApprox(this._size) } /** * Returns a larger Rect2 that contains this Rect2 and b. */ fun merge(b: Rect2): Rect2 { val ret = Rect2() ret._position.x = min(b._position.x, _position.x) ret._position.y = min(b._position.y, _position.y) ret._size.x = max(b._position.x + b._size.x, _position.x + _size.x) ret._size.y = max(b._position.y + b._size.y, _position.y + _size.y) ret._size = b._size - b._position //make relative again return ret } //UTILITIES override fun toVariant() = Variant(this) override fun equals(other: Any?): Boolean { return when (other) { is Rect2 -> _position == other._position && _size == other._size else -> false } } override fun toString(): String { return "$_position, $_size" } override fun hashCode(): Int { var result = _position.hashCode() result = 31 * result + _size.hashCode() return result } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Transform.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_transform import godot.gdnative.godot_transform_layout import godot.internal.type.CoreType import godot.internal.type.RealT import godot.internal.type.toGodotReal import kotlinx.cinterop.* class Transform( p_basis: Basis, p_origin: Vector3 = Vector3() ) : CoreType { @PublishedApi internal var _basis = Basis(p_basis) @PublishedApi internal var _origin = Vector3(p_origin) //PROPERTIES /** Return a copy of the basis Basis. * Warning: Writing basis.x = 2 will only modify a copy, not the actual object. * To modify it, use basis(). * */ var basis get() = Basis(_basis) set(value) { _basis = Basis(value) } inline fun basis(block: Basis.() -> T): T { return _basis.block() } /** Return a copy of the origin Vector3 * Warning: Writing origin.x = 2 will only modify a copy, not the actual object. * To modify it, use origin(). * */ var origin get() = Vector3(_origin) set(value) { _origin = Vector3(value) } inline fun origin(block: Vector3.() -> T): T { return _origin.block() } //CONSTANTS companion object { inline val IDENTITY: Transform get() = Transform(Basis(1, 0, 0, 0, 1, 0, 0, 0, 1), Vector3(0, 0, 0)) inline val FLIP_X: Transform get() = Transform(Basis(-1, 0, 0, 0, 1, 0, 0, 0, 1), Vector3(0, 0, 0)) inline val FLIP_Y: Transform get() = Transform(Basis(1, 0, 0, 0, -1, 0, 0, 0, 1), Vector3(0, 0, 0)) inline val FLIP_Z: Transform get() = Transform(Basis(1, 0, 0, 0, 1, 0, 0, 0, -1), Vector3(0, 0, 0)) } //CONSTRUCTOR constructor() : this(Basis(), Vector3(0, 0, 0)) constructor(other: Transform) : this(other._basis, other._origin) constructor( xx: Number, xy: Number, xz: Number, yx: Number, yy: Number, yz: Number, zx: Number, zy: Number, zz: Number, tx: Number, ty: Number, tz: Number ) : this(Basis(xx, xy, xz, yx, yy, yz, zx, zy, zz), Vector3(tx, ty, tz)) constructor(from: Quat) : this(Basis(from)) internal constructor(native: CValue) : this() { _basis = Basis() _origin = Vector3() memScoped { this@Transform.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { _basis = Basis() _origin = Vector3() this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { basis.x.x = this@Transform._basis._x.x.toGodotReal() basis.x.y = this@Transform._basis._x.y.toGodotReal() basis.x.z = this@Transform._basis._x.z.toGodotReal() basis.y.x = this@Transform._basis._y.x.toGodotReal() basis.y.y = this@Transform._basis._y.y.toGodotReal() basis.y.z = this@Transform._basis._y.z.toGodotReal() basis.z.x = this@Transform._basis._z.x.toGodotReal() basis.z.y = this@Transform._basis._z.y.toGodotReal() basis.z.z = this@Transform._basis._z.z.toGodotReal() origin.x = this@Transform._origin.x.toGodotReal() origin.y = this@Transform._origin.y.toGodotReal() origin.z = this@Transform._origin.z.toGodotReal() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed _basis.setRawMemory(value.basis.ptr) _origin.setRawMemory(value.origin.ptr) } //API /** * Returns the inverse of the transform, under the assumption that the transformation is composed of rotation, scaling and translation. */ fun affineInverse(): Transform { val ret = Transform(this._basis, this._origin) ret.affineInvert() return ret } internal fun affineInvert() { _basis.invert() _origin = _basis.xform(-_origin) } /** * Interpolates the transform to other Transform by weight amount (0-1). */ fun interpolateWith(transform: Transform, c: RealT): Transform { val srcScale = _basis.getScale() val srcRot = Quat(_basis) val srcLoc = _origin val dstScale = transform._basis.getScale() val dstRot = Quat(transform._basis) val dstLoc = transform._origin val dst = Transform() dst._basis = Basis(srcRot.slerp(dstRot, c)) dst._basis.scale(srcScale.linearInterpolate(dstScale, c)) dst._origin = srcLoc.linearInterpolate(dstLoc, c) return dst } /** * Returns the inverse of the transform, under the assumption that the transformation is composed of rotation and translation (no scaling, use affine_inverse for transforms with scaling). */ fun inverse(): Transform { val ret = Transform(this._basis, this._origin) ret.invert() return ret } internal fun invert() { _basis.transpose() _origin = _basis.xform(-_origin) } /** * Returns true if this transform and transform are approximately equal, by calling is_equal_approx on each component. */ fun isEqualApprox(transform: Transform): Boolean { return transform._basis.isEqualApprox(this._basis) && transform._origin.isEqualApprox(this._origin) } /** * Returns a copy of the transform rotated such that its -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. */ fun lookingAt(target: Vector3, up: Vector3): Transform { val t = Transform(this._basis, this._origin) t.setLookAt(_origin, target, up) return t } internal fun setLookAt(eye: Vector3, target: Vector3, up: Vector3) { val x: Vector3 var y = up val z = eye - target z.normalize() x = y.cross(z) y = z.cross(x) x.normalize() y.normalize() // on cpp, this calls basis.set(x, y, z) // which basically does: // setAxis(0, x) // setAxis(1, y) // setAxis(2, z) _basis.set(x, y, z) _origin = Vector3(eye) } /** * Returns the transform with the basis orthogonal (90 degrees), and normalized axis vectors. */ fun orthonormalized(): Transform { val t = Transform(this._basis, this._origin) t.orthonormalize() return t } internal fun orthonormalize() { _basis.orthonormalize() } /** * Rotates the transform around the given axis by the given angle (in radians), using matrix multiplication. The axis must be a normalized vector. */ fun rotated(axis: Vector3, phi: RealT): Transform { return Transform(Basis(axis, phi), Vector3()) * this } internal fun rotate(axis: Vector3, phi: RealT) { val t = rotated(axis, phi) this._basis = t._basis this._origin = t._origin } /** * Scales basis and origin of the transform by the given scale factor, using matrix multiplication. */ fun scaled(scale: Vector3): Transform { val t = Transform(this._basis, this._origin) t.scale(scale) return t } fun scale(scale: Vector3) { _basis.scale(scale) _origin *= scale } /** * Translates the transform by the given offset, relative to the transform’s basis vectors. * Unlike rotated and scaled, this does not use matrix multiplication. */ fun translated(translation: Vector3): Transform { val t = Transform(this._basis, this._origin) t.translate(translation) return t } fun translate(translation: Vector3) { _origin.x += _basis._x.dot(translation) _origin.y += _basis._y.dot(translation) _origin.z += _basis._z.dot(translation) } /** * Transforms the given Vector3 by this transform. */ fun xform(vector: Vector3): Vector3 = Vector3( _basis._x.dot(vector) + _origin.x, _basis._y.dot(vector) + _origin.y, _basis._z.dot(vector) + _origin.z ) /** * Transforms the given AABB by this transform. */ fun xform(aabb: AABB): AABB { val x = _basis._x * aabb._size.x val y = _basis._y * aabb._size.y val z = _basis._z * aabb._size.z val pos = xform(aabb._position) val newAabb = AABB() newAabb._position = pos newAabb.expandTo(pos + x) newAabb.expandTo(pos + y) newAabb.expandTo(pos + z) newAabb.expandTo(pos + x + y) newAabb.expandTo(pos + x + z) newAabb.expandTo(pos + y + z) newAabb.expandTo(pos + x + y + z) return newAabb } /** * Transforms the given Plane by this transform. */ fun xform(plane: Plane): Plane { var point = plane._normal * plane.d var pointDir = point + plane._normal point = xform(point) pointDir = xform(pointDir) val normal = pointDir - point normal.normalize() return Plane(normal, normal.dot(point)) } /** * Inverse-transforms the given Vector3 by this transform. */ fun xformInv(vector: Vector3): Vector3 { val v = vector - _origin return Vector3( (_basis._x.x * v.x) + (_basis._y.x * v.y) + (_basis._z.x * v.z), (_basis._x.y * v.x) + (_basis._y.y * v.y) + (_basis._z.y * v.z), (_basis._x.z * v.x) + (_basis._y.z * v.y) + (_basis._z.z * v.z) ) } /** * Inverse-transforms the given Plane by this transform. */ fun xformInv(plane: Plane): Plane { var point = plane._normal * plane.d var pointDir = point + plane._normal point = xformInv(point) pointDir = xformInv(pointDir) val normal = pointDir - point normal.normalize() return Plane(normal, normal.dot(point)) } /** * Inverse-transforms the given AABB by this transform. */ fun xformInv(aabb: AABB): AABB { val vertices = arrayOf( Vector3(aabb._position.x + aabb._size.x, aabb._position.y + aabb._size.y, aabb._position.z + aabb._size.z), Vector3(aabb._position.x + aabb._size.x, aabb._position.y + aabb._size.y, aabb._position.z), Vector3(aabb._position.x + aabb._size.x, aabb._position.y, aabb._position.z + aabb._size.z), Vector3(aabb._position.x + aabb._size.x, aabb._position.y, aabb._position.z), Vector3(aabb._position.x, aabb._position.y + aabb._size.y, aabb._position.z + aabb._size.z), Vector3(aabb._position.x, aabb._position.y + aabb._size.y, aabb._position.z), Vector3(aabb._position.x, aabb._position.y, aabb._position.z + aabb._size.z), Vector3(aabb._position.x, aabb._position.y, aabb._position.z) ) val ret = AABB() ret._position = xformInv(vertices[0]) for (i in 1..7) ret.expandTo(xformInv(vertices[i])) return ret } //UTILITIES override fun toVariant() = Variant(this) operator fun times(transform: Transform): Transform { val t = this t._origin = xform(transform._origin) t._basis *= transform._basis return t } override fun equals(other: Any?): Boolean { return when (other) { is Transform -> _basis == other._basis && _origin == other._origin else -> false } } override fun toString(): String { return "$_basis - $_origin" } override fun hashCode(): Int { var result = _basis.hashCode() result = 31 * result + _origin.hashCode() return result } /* * GDScript related members */ constructor(x: Vector3, y: Vector3, z: Vector3, origin: Vector3) : this(Basis(x, y, z), origin) } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Transform2D.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_transform2d import godot.gdnative.godot_transform2d_layout import godot.internal.type.* import kotlinx.cinterop.* import kotlin.math.acos import kotlin.math.atan2 import kotlin.math.cos import kotlin.math.sin class Transform2D( p_x: Vector2, p_y: Vector2, p_origin: Vector2 ) : CoreType { @PublishedApi internal var _x = Vector2(p_x) @PublishedApi internal var _y = Vector2(p_y) @PublishedApi internal var _origin = Vector2(p_origin) //PROPERTIES /** Return a copy of the x Vector2 * Warning: Writing x.x = 2 will only modify a copy, not the actual object. * To modify it, use x(). * */ var x get() = Vector2(_x) set(value) { _x = Vector2(value) } inline fun x(block: Vector2.() -> T): T { return _x.block() } /** Return a copy of the y Vector2 * Warning: Writing y.x = 2 will only modify a copy, not the actual object. * To modify it, use y(). * */ var y get() = Vector2(_y) set(value) { _y = Vector2(value) } inline fun y(block: Vector2.() -> T): T { return _y.block() } /** Return a copy of the origin Vector2 * Warning: Writing origin.x = 2 will only modify a copy, not the actual object. * To modify it, use origin(). * */ var origin get() = Vector2(_origin) set(value) { _origin = Vector2(value) } inline fun origin(block: Vector2.() -> T): T { return _origin.block() } //CONSTANTS companion object { inline val IDENTITY: Transform2D get() = Transform2D(1, 0, 0, 1, 0, 0) inline val FLIP_X: Transform2D get() = Transform2D(-1, 0, 0, 1, 0, 0) inline val FLIP_Y: Transform2D get() = Transform2D(1, 0, 0, -1, 0, 0) } //CONSTRUCTOR constructor() : this(Vector2(1, 0), Vector2(0, 1), Vector2()) constructor(other: Transform2D) : this(other._x, other._y, other._origin) constructor(xx: Number, xy: Number, yx: Number, yy: Number, ox: Number, oy: Number) : this( Vector2(xx.toRealT(), xy.toRealT()), Vector2(yx.toRealT(), yy.toRealT()), Vector2(ox.toRealT(), oy.toRealT()) ) constructor(rot: Number, pos: Vector2) : this( Vector2(cos(rot.toRealT()), sin(rot.toRealT())), Vector2(-sin(rot.toRealT()), cos(rot.toRealT())), pos ) internal constructor(native: CValue) : this() { memScoped { this@Transform2D.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { x.x = this@Transform2D._x.x.toGodotReal() x.y = this@Transform2D._x.y.toGodotReal() y.x = this@Transform2D._y.x.toGodotReal() y.y = this@Transform2D._y.y.toGodotReal() origin.x = this@Transform2D._origin.x.toGodotReal() origin.y = this@Transform2D._origin.y.toGodotReal() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed _x.setRawMemory(value.x.ptr) _x.setRawMemory(value.y.ptr) _x.setRawMemory(value.origin.ptr) } //API /** * Returns the inverse of the matrix. */ fun affineInverse(): Transform2D { val inv = Transform2D(this._x, this._y, this._origin) inv.affineInvert() return inv } /** * Returns the inverse of the matrix. */ internal fun affineInvert() { val det = basisDeterminant() if (isEqualApprox(det, 0.0)) { Godot.printError("determinant == 0", "affineInvert()", "Transform2D.kt", 84) return } val idet = -1.0 / det val copy = _x.x _x.x = _y.y _y.y = copy this._x *= Vector2(idet, -idet) this._y *= Vector2(-idet, idet) this._origin = basisXform(-this._origin) } private fun basisDeterminant(): RealT { return this._x.x * this._y.y - this._x.y * this._y.x } /** * Transforms the given vector by this transform’s basis (no translation). */ fun basisXform(v: Vector2) = Vector2(tdotx(v), tdoty(v)) /** * Inverse-transforms the given vector by this transform’s basis (no translation). */ fun basisXformInv(v: Vector2) = Vector2(this._x.dot(v), this._y.dot(v)) /** * Returns the transform’s origin (translation). */ fun getOrigin() = this._origin /** * Returns the transform’s rotation (in radians). */ fun getRotation(): RealT { val det = basisDeterminant() val m = orthonormalized() if (det < 0) { m.scaleBasis(Vector2(-1, -1)) } return atan2(m._x.y, m._x.x) } /** * Returns the scale. */ fun getScale(): Vector2 { val detSign: RealT = if (basisDeterminant() > 0.0) 1.0 else -1.0 return detSign * Vector2(this._x.length(), this._y.length()) } /** * Returns a transform interpolated between this transform and another by a given weight (0-1). */ fun interpolateWith(transform: Transform2D, c: RealT): Transform2D { val p1 = getOrigin() val p2 = transform.getOrigin() val r1 = getRotation() val r2 = transform.getRotation() val s1 = getScale() val s2 = transform.getScale() val v1 = Vector2(cos(r1), sin(r1)) val v2 = Vector2(cos(r2), sin(r2)) var dot = v1.dot(v2) dot = when { dot < -1.0 -> -1.0 dot > 1.0 -> 1.0 else -> dot } val v = if (dot > 0.9995) (Vector2::linearInterpolate)(v1, v2, c).normalized() else { val angle = c * acos(dot) val v3 = (v2 - v1 * dot).normalized() v1 * cos(angle) + v3 * sin(angle) } val res = Transform2D(atan2(v.y, v.x), (Vector2::linearInterpolate)(p1, p2, c)) res.scaleBasis((Vector2::linearInterpolate)(s1, s2, c)) return res } /** * Returns the inverse of the transform, under the assumption that the transformation is composed of rotation and translation (no scaling, use affine_inverse for transforms with scaling). */ fun inverse(): Transform2D { val inv = Transform2D(this._x, this._y, this._origin) inv.invert() return inv } internal fun invert() { val copy = _x.y _x.y = _y.x _y.x = copy _origin = basisXform(-_origin) } /** * Returns true if this transform and transform are approximately equal, by calling is_equal_approx on each component. */ fun isEqualApprox(transform: Transform2D): Boolean { return transform._x.isEqualApprox(this._x) && transform._y.isEqualApprox(this._y) && transform._origin.isEqualApprox(this._origin) } /** * Returns the transform with the basis orthogonal (90 degrees), and normalized axis vectors. */ fun orthonormalized(): Transform2D { val on = Transform2D(this._x, this._y, this._origin) on.orthonormalize() return on } internal fun orthonormalize() { val x = this._x var y = this._y x.normalize() y = (y - x * (x.dot(y))) y.normalize() this._x = x this._y = y } /** * Rotates the transform by the given angle (in radians), using matrix multiplication. */ fun rotated(phi: RealT): Transform2D { val copy = Transform2D(this._x, this._y, this._origin) copy.rotate(phi) return copy } internal fun rotate(phi: RealT) { val transform2D = Transform2D(phi, Vector2()) * this this._x = transform2D._x this._y = transform2D._y this._origin = transform2D._origin } /** * Scales the transform by the given scale factor, using matrix multiplication. */ fun scaled(scale: Vector2): Transform2D { val copy = Transform2D(this._x, this._y, this._origin) copy.scale(scale) return copy } internal fun scale(scale: Vector2) { scaleBasis(scale) this._origin *= scale } /** * Translates the transform by the given offset, relative to the transform’s basis vectors. * Unlike rotated and scaled, this does not use matrix multiplication. */ fun translated(offset: Vector2): Transform2D { val copy = Transform2D(this._x, this._y, this._origin) copy.translate(offset) return copy } internal fun translate(offset: Vector2) { this._origin += offset } private fun scaleBasis(scale: Vector2) { _x.x *= scale.x _x.y *= scale.y this._y[0] *= scale.x _y.y *= scale.y } /** * Transforms the given Vector2 by this transform. */ fun xform(v: Vector2): Vector2 { return Vector2(tdotx(v), tdoty(v)) + this._origin } /** * Transforms the given Rect2 by this transform. */ fun xform(rect: Rect2): Rect2 { val x = this._x * rect._size.x val y = this._y * rect._size.y val pos = xform(rect._position) val newRect = Rect2() newRect._position = pos newRect.expandTo(pos + x) newRect.expandTo(pos + y) newRect.expandTo(pos + x + y) return newRect } /** * Inverse-transforms the given Vector2 by this transform. */ fun xformInv(vec: Vector2): Vector2 { val v = vec - this._origin return Vector2(this._x.dot(v), this._y.dot(v)) } /** * Inverse-transforms the given Rect2 by this transform. */ fun xformInv(rect: Rect2): Rect2 { val ends = arrayOf( xformInv(rect._position), xformInv(Vector2(rect._position.x, rect._position.y + rect._size.y)), xformInv(Vector2(rect._position.x + rect._size.x, rect._position.y + rect._size.y)), xformInv(Vector2(rect._position.x + rect._size.x, rect._position.y)) ) val newRect = Rect2() newRect._position = ends[0] newRect.expandTo(ends[1]) newRect.expandTo(ends[2]) newRect.expandTo(ends[3]) return newRect } private fun tdotx(v: Vector2): RealT { return _x.x * v.x + _y.x * v.y } private fun tdoty(v: Vector2): RealT { return _x.y * v.x + _y.y * v.y } //UTILITIES override fun toVariant() = Variant(this) operator fun times(other: Transform2D): Transform2D { val origin = xform(other._origin) val x0 = tdotx(other._x) val x1 = tdoty(other._x) val y0 = tdotx(other._y) val y1 = tdoty(other._y) return Transform2D(x0, x1, y0, y1, origin.x, origin.y) } override fun toString(): String { return "${this._x}, ${this._y}, ${this._origin}" } override fun equals(other: Any?): Boolean { return when (other) { is Transform2D -> this._x == other._x && this._y == other._y && this._origin == other._origin else -> false } } override fun hashCode(): Int { var result = _x.hashCode() result = 31 * result + _y.hashCode() result = 31 * result + _origin.hashCode() return result } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Variant.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_variant import godot.gdnative.godot_variant_type import godot.internal.type.CoreType import godot.internal.type.NaturalT import godot.internal.type.nullSafe import godot.internal.type.toNaturalT import kotlinx.cinterop.* @Suppress("NON_PUBLIC_PRIMARY_CONSTRUCTOR_OF_INLINE_CLASS", "IMPLICIT_CAST_TO_ANY") @ExperimentalUnsignedTypes inline class Variant internal constructor(internal val _handle: CValue) { //PROPERTIES val type: Type get() { return memScoped { Type.from(nullSafe(Godot.gdnative.godot_variant_get_type)(_handle.ptr).value.toNaturalT()) } } //INTEROP fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } //TYPE enum class Type(val value: NaturalT) { NIL(godot_variant_type.GODOT_VARIANT_TYPE_NIL.value.toNaturalT()), BOOL(godot_variant_type.GODOT_VARIANT_TYPE_BOOL.value.toNaturalT()), INT(godot_variant_type.GODOT_VARIANT_TYPE_INT.value.toNaturalT()), REAL(godot_variant_type.GODOT_VARIANT_TYPE_REAL.value.toNaturalT()), STRING(godot_variant_type.GODOT_VARIANT_TYPE_STRING.value.toNaturalT()), VECTOR2(godot_variant_type.GODOT_VARIANT_TYPE_VECTOR2.value.toNaturalT()), RECT2(godot_variant_type.GODOT_VARIANT_TYPE_RECT2.value.toNaturalT()), VECTOR3(godot_variant_type.GODOT_VARIANT_TYPE_VECTOR3.value.toNaturalT()), TRANSFORM2D(godot_variant_type.GODOT_VARIANT_TYPE_TRANSFORM2D.value.toNaturalT()), PLANE(godot_variant_type.GODOT_VARIANT_TYPE_PLANE.value.toNaturalT()), QUAT(godot_variant_type.GODOT_VARIANT_TYPE_QUAT.value.toNaturalT()), AABB(godot_variant_type.GODOT_VARIANT_TYPE_AABB.value.toNaturalT()), BASIS(godot_variant_type.GODOT_VARIANT_TYPE_BASIS.value.toNaturalT()), TRANSFORM(godot_variant_type.GODOT_VARIANT_TYPE_TRANSFORM.value.toNaturalT()), COLOR(godot_variant_type.GODOT_VARIANT_TYPE_COLOR.value.toNaturalT()), NODE_PATH(godot_variant_type.GODOT_VARIANT_TYPE_NODE_PATH.value.toNaturalT()), RID(godot_variant_type.GODOT_VARIANT_TYPE_RID.value.toNaturalT()), OBJECT(godot_variant_type.GODOT_VARIANT_TYPE_OBJECT.value.toNaturalT()), DICTIONARY(godot_variant_type.GODOT_VARIANT_TYPE_DICTIONARY.value.toNaturalT()), ARRAY(godot_variant_type.GODOT_VARIANT_TYPE_ARRAY.value.toNaturalT()), POOL_BYTE_ARRAY(godot_variant_type.GODOT_VARIANT_TYPE_POOL_BYTE_ARRAY.value.toNaturalT()), POOL_INT_ARRAY(godot_variant_type.GODOT_VARIANT_TYPE_POOL_INT_ARRAY.value.toNaturalT()), POOL_REAL_ARRAY(godot_variant_type.GODOT_VARIANT_TYPE_POOL_REAL_ARRAY.value.toNaturalT()), POOL_STRING_ARRAY(godot_variant_type.GODOT_VARIANT_TYPE_POOL_STRING_ARRAY.value.toNaturalT()), POOL_COLOR_ARRAY(godot_variant_type.GODOT_VARIANT_TYPE_POOL_COLOR_ARRAY.value.toNaturalT()), POOL_VECTOR2_ARRAY(godot_variant_type.GODOT_VARIANT_TYPE_POOL_VECTOR2_ARRAY.value.toNaturalT()), POOL_VECTOR3_ARRAY(godot_variant_type.GODOT_VARIANT_TYPE_POOL_VECTOR3_ARRAY.value.toNaturalT()); companion object { private val types = mapOf( NIL.value to NIL, BOOL.value to BOOL, INT.value to INT, REAL.value to REAL, STRING.value to STRING, VECTOR2.value to VECTOR2, RECT2.value to RECT2, VECTOR3.value to VECTOR3, TRANSFORM2D.value to TRANSFORM2D, PLANE.value to PLANE, QUAT.value to QUAT, AABB.value to AABB, BASIS.value to BASIS, TRANSFORM.value to TRANSFORM, COLOR.value to COLOR, NODE_PATH.value to NODE_PATH, RID.value to RID, OBJECT.value to OBJECT, DICTIONARY.value to DICTIONARY, ARRAY.value to ARRAY, POOL_BYTE_ARRAY.value to POOL_BYTE_ARRAY, POOL_INT_ARRAY.value to POOL_INT_ARRAY, POOL_REAL_ARRAY.value to POOL_REAL_ARRAY, POOL_STRING_ARRAY.value to POOL_STRING_ARRAY, POOL_VECTOR2_ARRAY.value to POOL_VECTOR2_ARRAY, POOL_VECTOR3_ARRAY.value to POOL_VECTOR3_ARRAY, POOL_COLOR_ARRAY.value to POOL_COLOR_ARRAY ) fun from(value: NaturalT): Type { return types[value] ?: throw NoSuchElementException("Unknown value: $value") } } } enum class Operator(val id: NaturalT) { OP_EQUAL(0), OP_NOT_EQUAL(1), OP_LESS(2), OP_LESS_EQUAL(3), OP_GREATER(4), OP_GREATER_EQUAL(5), OP_ADD(6), OP_SUBSTRACT(7), OP_MULTIPLY(8), OP_DIVIDE(9), OP_NEGATE(10), OP_POSITIVE(11), OP_MODULE(12), OP_STRING_CONCAT(13), OP_SHIFT_LEFT(14), OP_SHIFT_RIGHT(15), OP_BIT_AND(16), OP_BIT_OR(17), OP_BIT_XOR(18), OP_BIT_NEGATE(19), OP_AND(20), OP_OR(21), OP_XOR(22), OP_NOT(23), OP_IN(24), OP_MAX(25); companion object { fun from(value: NaturalT) = when (value) { 0L -> OP_EQUAL 1L -> OP_NOT_EQUAL 2L -> OP_LESS 3L -> OP_LESS_EQUAL 4L -> OP_GREATER 5L -> OP_GREATER_EQUAL 6L -> OP_ADD 7L -> OP_SUBSTRACT 8L -> OP_MULTIPLY 9L -> OP_DIVIDE 10L -> OP_NEGATE 11L -> OP_POSITIVE 12L -> OP_MODULE 13L -> OP_STRING_CONCAT 14L -> OP_SHIFT_LEFT 15L -> OP_SHIFT_RIGHT 16L -> OP_BIT_AND 17L -> OP_BIT_OR 18L -> OP_BIT_XOR 19L -> OP_BIT_NEGATE 20L -> OP_AND 21L -> OP_OR 22L -> OP_XOR 23L -> OP_NOT 24L -> OP_IN 25L -> OP_MAX else -> throw AssertionError("Unknown operator: $value") } } } companion object { @PublishedApi internal inline fun typeForClass(): Type { return when (T::class) { Int::class -> Type.INT Long::class -> Type.INT Float::class -> Type.REAL Double::class -> Type.REAL String::class -> Type.STRING Boolean::class -> Type.BOOL AABB::class -> Type.AABB GodotArray::class -> Type.ARRAY Basis::class -> Type.BASIS Color::class -> Type.COLOR Dictionary::class -> Type.DICTIONARY NodePath::class -> Type.NODE_PATH Plane::class -> Type.PLANE PoolByteArray::class -> Type.POOL_BYTE_ARRAY PoolColorArray::class -> Type.POOL_COLOR_ARRAY PoolIntArray::class -> Type.POOL_INT_ARRAY PoolRealArray::class -> Type.POOL_REAL_ARRAY PoolStringArray::class -> Type.POOL_STRING_ARRAY PoolVector2Array::class -> Type.POOL_VECTOR2_ARRAY PoolVector3Array::class -> Type.POOL_VECTOR3_ARRAY Quat::class -> Type.QUAT Rect2::class -> Type.RECT2 RID::class -> Type.RID Transform::class -> Type.TRANSFORM Transform2D::class -> Type.TRANSFORM2D Vector2::class -> Type.VECTOR2 Vector3::class -> Type.VECTOR3 Object::class -> Type.OBJECT // assume it's null because incompatible with Godot else -> Type.NIL } } //WRAPPING fun wrap(obj: Any?): Variant { if (obj == null) { return Variant() } return when (obj) { is Unit -> Variant() is Boolean -> Variant(obj) is Int -> Variant(obj.toLong()) is Long -> Variant(obj) is Float -> Variant(obj.toDouble()) is Double -> Variant(obj) is String -> Variant(obj) is CoreType -> obj.toVariant() is Variant -> obj is Object -> Variant(obj) else -> throw UnsupportedOperationException("Can't convert type ${obj::class} to Variant") } } } //UNWRAPPING /** * cast the variant to the right type. Warning: It's unsafe */ fun unwrap(): T { val ret = when (type) { Type.NIL -> null Type.BOOL -> asBoolean() Type.INT -> asInt() Type.REAL -> asFloat() Type.STRING -> asString() Type.VECTOR2 -> asVector2() Type.RECT2 -> asRect2() Type.VECTOR3 -> asVector3() Type.TRANSFORM2D -> asTransform2D() Type.PLANE -> asPlane() Type.QUAT -> asQuat() Type.AABB -> asAABB() Type.BASIS -> asBasis() Type.TRANSFORM -> asTransform() Type.COLOR -> asColor() Type.NODE_PATH -> asNodePath() Type.RID -> asRID() Type.OBJECT -> asObject() Type.DICTIONARY -> asDictionary() Type.ARRAY -> asVariantArray() Type.POOL_BYTE_ARRAY -> asPoolByteArray() Type.POOL_INT_ARRAY -> asPoolIntArray() Type.POOL_REAL_ARRAY -> asPoolRealArray() Type.POOL_STRING_ARRAY -> asPoolStringArray() Type.POOL_VECTOR2_ARRAY -> asPoolVector2Array() Type.POOL_VECTOR3_ARRAY -> asPoolVector3Array() Type.POOL_COLOR_ARRAY -> asPoolColorArray() } return ret as T } /** * Cast the Variant to a Boolean. */ fun asBoolean(): Boolean { return memScoped { nullSafe(Godot.gdnative.godot_variant_as_bool)(_handle.ptr) } } /** * Cast the Variant to a Int. */ fun asInt(): Int { return asLong().toInt() } /** * Cast the Variant to a Long. */ fun asLong(): Long { return memScoped { nullSafe(Godot.gdnative.godot_variant_as_int)(_handle.ptr) } } /** * Cast the Variant to a Float. */ fun asFloat(): Float { return asDouble().toFloat() } /** * Cast the Variant to a Double. */ fun asDouble(): Double { return memScoped { nullSafe(Godot.gdnative.godot_variant_as_real)(_handle.ptr) } } /** * Cast the Variant to an Enum. */ inline fun > asEnum(): E { val i = asInt() val values = enumValues() return values.first { it.ordinal == i } } /** * Cast the Variant to a String. */ fun asString(): String { return memScoped { val gdString = GdString(nullSafe(Godot.gdnative.godot_variant_as_string)(_handle.ptr)) gdString.toKString() } } /** * Cast the Variant to a Vector2. */ fun asVector2(): Vector2 { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_vector2)(_handle.ptr) } return Vector2(value) } /** * Cast the Variant to a Rect2. */ fun asRect2(): Rect2 { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_rect2)(_handle.ptr) } return Rect2(value) } /** * Cast the Variant to a Vector3. */ fun asVector3(): Vector3 { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_vector3)(_handle.ptr) } return Vector3(value) } /** * Cast the Variant to a Transform2D. */ fun asTransform2D(): Transform2D { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_transform2d)(_handle.ptr) } return Transform2D(value) } /** * Cast the Variant to a Plane. */ fun asPlane(): Plane { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_plane)(_handle.ptr) } return Plane(value) } /** * Cast the Variant to a Quat. */ fun asQuat(): Quat { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_quat)(_handle.ptr) } return Quat(value) } /** * Cast the Variant to a AABB. */ fun asAABB(): AABB { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_aabb)(_handle.ptr) } return AABB(value) } /** * Cast the Variant to a Basis. */ fun asBasis(): Basis { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_basis)(_handle.ptr) } return Basis(value) } /** * Cast the Variant to a Transform. */ fun asTransform(): Transform { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_transform)(_handle.ptr) } return Transform(value) } /** * Cast the Variant to a Color. */ fun asColor(): Color { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_color)(_handle.ptr) } return Color(value) } /** * Cast the Variant to a NodePath. */ fun asNodePath(): NodePath { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_node_path)(_handle.ptr) } return NodePath(value) } /** * Cast the Variant to a RiD. */ fun asRID(): RID { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_rid)(_handle.ptr) } return RID(value) } /** * Cast the Variant to a Godot Object. */ fun asObject(): Object? { return memScoped { val ptr = nullSafe(Godot.gdnative.godot_variant_as_object)(_handle.ptr) if (ptr == null) { null } else { TypeManager.wrap(ptr) } } } /** * Cast the Variant to a Dictionary. */ fun asDictionary(): Dictionary { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_dictionary)(_handle.ptr) } return Dictionary(value) } /** * Cast the Variant to a VariantArray */ fun asVariantArray(): VariantArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return VariantArray(value) } /** * Cast the Variant to a AABBArray */ fun asAABBArray(): AABBArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return AABBArray(value) } /** * Cast the Variant to a BoolVariantArray */ fun asBasisArray(): BasisArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return BasisArray(value) } /** * Cast the Variant to a BoolVariantArray */ fun asColorArray(): ColorArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return ColorArray(value) } /** * Cast the Variant to a BoolVariantArray */ fun asNodePathArray(): NodePathArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return NodePathArray(value) } /** * Cast the Variant to a BoolVariantArray */ fun asPlaneArray(): PlaneArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return PlaneArray(value) } /** * Cast the Variant to a BoolVariantArray */ fun asQuatArray(): QuatArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return QuatArray(value) } /** * Cast the Variant to a BoolVariantArray */ fun asRect2Array(): Rect2Array { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return Rect2Array(value) } /** * Cast the Variant to a BoolVariantArray */ fun asRIDArray(): RIDArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return RIDArray(value) } /** * Cast the Variant to a BoolVariantArray */ fun asTransform2DArray(): Transform2DArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return Transform2DArray(value) } /** * Cast the Variant to a BoolVariantArray */ fun asTransformArray(): TransformArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return TransformArray(value) } /** * Cast the Variant to a BoolVariantArray */ fun asVector2Array(): Vector2Array { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return Vector2Array(value) } /** * Cast the Variant to a BoolVariantArray */ fun asVector3Array(): Vector3Array { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return Vector3Array(value) } /** * Cast the Variant to a BoolVariantArray */ fun asBoolVariantArray(): BoolVariantArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return BoolVariantArray(value) } /** * Cast the Variant to a IntVariantArray */ fun asIntVariantArray(): IntVariantArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return IntVariantArray(value) } /** * Cast the Variant to a RealVariantArray */ fun asRealVariantArray(): RealVariantArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return RealVariantArray(value) } /** * Cast the Variant to a StringVariantArray */ fun asStringVariantArray(): StringVariantArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_array)(_handle.ptr) } return StringVariantArray(value) } /** * Cast the Variant to a PoolByteArray. */ fun asPoolByteArray(): PoolByteArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_pool_byte_array)(_handle.ptr) } return PoolByteArray(value) } /** * Cast the Variant to a PoolColorArray. */ fun asPoolColorArray(): PoolColorArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_pool_color_array)(_handle.ptr) } return PoolColorArray(value) } /** * Cast the Variant to a PoolIntArray. */ fun asPoolIntArray(): PoolIntArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_pool_int_array)(_handle.ptr) } return PoolIntArray(value) } /** * Cast the Variant to a PoolRealArray. */ fun asPoolRealArray(): PoolRealArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_pool_real_array)(_handle.ptr) } return PoolRealArray(value) } /** * Cast the Variant to a PoolStringArray. */ fun asPoolStringArray(): PoolStringArray { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_pool_string_array)(_handle.ptr) } return PoolStringArray(value) } /** * Cast the Variant to a PoolVector2Array. */ fun asPoolVector2Array(): PoolVector2Array { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_pool_vector2_array)(_handle.ptr) } return PoolVector2Array(value) } /** * Cast the Variant to a PoolVector3Array. */ fun asPoolVector3Array(): PoolVector3Array { val value = memScoped { nullSafe(Godot.gdnative.godot_variant_as_pool_vector3_array)(_handle.ptr) } return PoolVector3Array(value) } //UTILITIES fun toVariant() = this // hack to get default values of core types // nil variants will always attempt to convert to a sane value of the // target type internal inline fun defaultValue(): T { val nil = Variant() return when (T::class) { AABB::class -> nil.asAABB() GodotArray::class -> nil.asVariantArray() Basis::class -> nil.asBasis() Color::class -> nil.asColor() Dictionary::class -> nil.asDictionary() NodePath::class -> nil.asNodePath() Plane::class -> nil.asPlane() PoolByteArray::class -> nil.asPoolByteArray() PoolColorArray::class -> nil.asPoolColorArray() PoolIntArray::class -> nil.asPoolIntArray() PoolRealArray::class -> nil.asPoolRealArray() PoolStringArray::class -> nil.asPoolStringArray() PoolVector2Array::class -> nil.asPoolVector2Array() PoolVector3Array::class -> nil.asPoolVector3Array() Quat::class -> nil.asQuat() Rect2::class -> nil.asRect2() RID::class -> nil.asRID() Transform::class -> nil.asTransform() Transform2D::class -> nil.asTransform2D() Vector2::class -> nil.asVector2() Vector3::class -> nil.asVector3() else -> throw UnsupportedOperationException("Unknown variant class ${T::class}") } as T } } //FAKE CONSTRUCTORS. Necessary because inline classes don't support secondary constructors yet. //NULL fun Variant() = Variant( memScoped { cValue { nullSafe(Godot.gdnative.godot_variant_new_nil)(this.ptr) } } ) //PRIMITIVES fun Variant(from: Boolean) = Variant( memScoped { cValue { nullSafe(Godot.gdnative.godot_variant_new_bool)(this.ptr, from) } } ) fun Variant(from: Int) = Variant( memScoped { cValue { nullSafe(Godot.gdnative.godot_variant_new_int)(this.ptr, from.toLong()) } } ) fun > Variant(from: Enum) = Variant( memScoped { cValue { nullSafe(Godot.gdnative.godot_variant_new_int)(this.ptr, from.ordinal.toLong()) } } ) fun Variant(from: Long) = Variant( memScoped { cValue { nullSafe(Godot.gdnative.godot_variant_new_int)(this.ptr, from) } } ) fun Variant(from: Float) = Variant( memScoped { cValue { nullSafe(Godot.gdnative.godot_variant_new_real)(this.ptr, from.toDouble()) } } ) fun Variant(from: Double) = Variant( memScoped { cValue { nullSafe(Godot.gdnative.godot_variant_new_real)(this.ptr, from) } } ) fun Variant(from: String) = Variant( memScoped { cValue { nullSafe(Godot.gdnative.godot_variant_new_string)(this.ptr, from.toGDString().value.ptr) } } ) //OBJECT fun Variant(from: Object) = Variant( memScoped { cValue { nullSafe(Godot.gdnative.godot_variant_new_object)(this.ptr, from.ptr) } } ) /** * Helper for the core Variant constructors */ internal fun wrapCore( block: CPointer?, CPointer?) -> Unit>>?, core: CoreType ): Variant { return Variant( memScoped { val ptr = core.getRawMemory(this).reinterpret() cValue { nullSafe(block)(this.ptr, ptr) } } ) } //CORE fun Variant(from: AABB) = wrapCore(Godot.gdnative.godot_variant_new_aabb, from) fun Variant(from: Basis) = wrapCore(Godot.gdnative.godot_variant_new_basis, from) fun Variant(from: Color) = wrapCore(Godot.gdnative.godot_variant_new_color, from) fun Variant(from: NodePath) = wrapCore(Godot.gdnative.godot_variant_new_node_path, from) fun Variant(from: Plane) = wrapCore(Godot.gdnative.godot_variant_new_plane, from) fun Variant(from: Quat) = wrapCore(Godot.gdnative.godot_variant_new_quat, from) fun Variant(from: RID) = wrapCore(Godot.gdnative.godot_variant_new_rid, from) fun Variant(from: Vector2) = wrapCore(Godot.gdnative.godot_variant_new_vector2, from) fun Variant(from: Vector3) = wrapCore(Godot.gdnative.godot_variant_new_vector3, from) fun Variant(from: Transform2D) = wrapCore(Godot.gdnative.godot_variant_new_transform2d, from) fun Variant(from: Transform) = wrapCore(Godot.gdnative.godot_variant_new_transform, from) fun Variant(from: Rect2) = wrapCore(Godot.gdnative.godot_variant_new_rect2, from) fun Variant(from: Dictionary) = wrapCore(Godot.gdnative.godot_variant_new_dictionary, from) fun Variant(from: Variant) = from //CONTAINER CORE fun Variant(from: PoolByteArray) = wrapCore(Godot.gdnative.godot_variant_new_pool_byte_array, from) fun Variant(from: PoolColorArray) = wrapCore(Godot.gdnative.godot_variant_new_pool_color_array, from) fun Variant(from: PoolIntArray) = wrapCore(Godot.gdnative.godot_variant_new_pool_int_array, from) fun Variant(from: PoolRealArray) = wrapCore(Godot.gdnative.godot_variant_new_pool_real_array, from) fun Variant(from: PoolStringArray) = wrapCore(Godot.gdnative.godot_variant_new_pool_string_array, from) fun Variant(from: PoolVector2Array) = wrapCore(Godot.gdnative.godot_variant_new_pool_vector2_array, from) fun Variant(from: PoolVector3Array) = wrapCore(Godot.gdnative.godot_variant_new_pool_vector3_array, from) fun Variant(from: GodotArray) = wrapCore(Godot.gdnative.godot_variant_new_array, from) internal fun Variant(from: CPointer) = Variant(from.pointed.readValue()) //Throw an exception for the types not supported by Godot fun Variant(from: Any?): Variant = throw UnsupportedOperationException("Unknown variant class") //EXTENSION METHOD TO CAST PRIMITIVES TO VARIANT fun Any?.toVariant() = Variant(this) fun Boolean.toVariant() = Variant(this) fun Int.toVariant() = Variant(this) fun Long.toVariant() = Variant(this) fun Float.toVariant() = Variant(this) fun Double.toVariant() = Variant(this) fun String.toVariant() = Variant(this) fun > Enum.toVariant() = Variant(this) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Vector2.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_vector2 import godot.gdnative.godot_vector2_layout import godot.internal.type.* import kotlinx.cinterop.* import kotlin.math.* class Vector2( var x: RealT, var y: RealT ) : Comparable, CoreType { //CONSTANTS enum class Axis(val value: Int) { X(0), Y(1); companion object { fun from(value: Int) = when (value) { 0 -> X 1 -> Y else -> throw AssertionError("Unknown axis for Vector2: $value") } } } companion object { val AXIS_X = Axis.X.value val AXIS_Y = Axis.Y.value val ZERO: Vector2 get() = Vector2(0, 0) val ONE: Vector2 get() = Vector2(1, 1) val INF: Vector2 get() = Vector2(RealT.POSITIVE_INFINITY, RealT.POSITIVE_INFINITY) val LEFT: Vector2 get() = Vector2(-1, 0) val RIGHT: Vector2 get() = Vector2(1, 0) val UP: Vector2 get() = Vector2(0, -1) val DOWN: Vector2 get() = Vector2(0, 1) } //CONSTRUCTOR constructor() : this(0.0, 0.0) constructor(vec: Vector2) : this(vec.x, vec.y) constructor(x: Number, y: Number) : this(x.toRealT(), y.toRealT()) internal constructor(native: CValue) : this(0.0, 0.0) { memScoped { this@Vector2.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { x = this@Vector2.x.toFloat() y = this@Vector2.y.toFloat() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed x = value.x.toRealT() y = value.y.toRealT() } //API /** * Returns a new vector with all components in absolute values (i.e. positive). */ fun abs(): Vector2 { return Vector2(abs(x), abs(y)) } /** * Returns the vector’s angle in radians with respect to the x-axis, or (1, 0) vector. * Equivalent to the result of atan2 when called with the vector’s x and y as parameters: atan2(x, y). */ fun angle(): RealT { return atan2(y, x) } /** * Returns the angle in radians between the two vectors. */ fun angleTo(to: Vector2): RealT { return atan2(cross(to), dot(to)) } /** * Returns the angle in radians between the line connecting the two points and the x coordinate. */ fun angleToPoint(other: Vector2): RealT { return atan2(y - other.y, x - other.x) } /** * Returns the ratio of x to y. */ fun aspect(): RealT { return this.x / this.y } /** * Returns the vector “bounced off” from a plane defined by the given normal. */ fun bounce(n: Vector2): Vector2 { return -reflect(n) } /** * Returns the vector with all components rounded up. */ fun ceil(): Vector2 { return Vector2(ceil(x), ceil(y)) } /** * Returns the vector with a maximum length. */ fun clamped(len: RealT): Vector2 { val l: RealT = this.length() var v = Vector2(this) if (l > 0 && len < l) { v /= l v *= len } return v } /** * Returns the 2 dimensional analog of the cross product with the given vector. */ fun cross(other: Vector2): RealT { return x * other.y - y * other.x } /** * Cubicly interpolates between this vector and b using pre_a and post_b as handles, and returns the result at position t. * t is in the range of 0.0 - 1.0, representing the amount of interpolation. */ fun cubicInterpolate(v: Vector2, pre: Vector2, post: Vector2, t: RealT): Vector2 { val p0: Vector2 = pre val p1: Vector2 = this val p2: Vector2 = v val p3: Vector2 = post val t2: RealT = t * t val t3: RealT = t2 * t return ((p1 * 2.0) + (-p0 + p2) * t + (p0 * 2.0 - p1 * 5.0 + p2 * 4.0 - p3) * t2 + (-p0 + p1 * 3.0 - p2 * 3.0 + p3) * t3) * 0.5 } /** * Returns the normalized vector pointing from this vector to b. */ fun directionTo(other: Vector2): Vector2 { val ret = Vector2(other.x - x, other.y - y) ret.normalize() return ret } /** * Returns the squared distance to vector b. * Prefer this function over distance_to if you need to sort vectors or need the squared distance for some formula. */ fun distanceSquaredTo(other: Vector2): RealT { return (x - other.x) * (x - other.x) + (y - other.y) * (y - other.y) } /** * Returns the distance to vector b. */ fun distanceTo(other: Vector2): RealT { return sqrt((x - other.x) * (x - other.x) + (y - other.y) * (y - other.y)) } /** * Returns the dot product with vector b. */ fun dot(other: Vector2): RealT { return x * other.x + y * other.y } /** * Returns the vector with all components rounded down. */ fun floor(): Vector2 { return Vector2(floor(x), floor(y)) } /** * Returns true if this vector and v are approximately equal, by running isEqualApprox on each component. */ fun isEqualApprox(other: Vector2): Boolean { return isEqualApprox( other.x, x ) && isEqualApprox(other.y, y) } /** * Returns true if the vector is normalized. */ fun isNormalized(): Boolean { return isEqualApprox(this.length(), 1.0) } /** * Returns the vector’s length. */ fun length(): RealT { return sqrt(x * x + y * y) } /** * Returns the vector’s length squared. * Prefer this method over length if you need to sort vectors or need the squared length for some formula. */ fun lengthSquared(): RealT { return x * x + y * y } /** * Returns the result of the linear interpolation between this vector and b by amount t. * t is in the range of 0.0 - 1.0, representing the amount of interpolation. */ fun linearInterpolate(v: Vector2, t: RealT): Vector2 { val res = Vector2(this) res.x += (t * (v.x - x)) res.y += (t * (v.y - y)) return res } /** * Moves the vector toward to by the fixed delta amount. */ fun moveToward(to: Vector2, delta: RealT): Vector2 { val vd = to - this val len = vd.length() return if (len <= delta || len < CMP_EPSILON) to else this + vd / len * delta } /** * Returns the vector scaled to unit length. Equivalent to v / v.length(). */ fun normalized(): Vector2 { val v: Vector2 = Vector2(this) v.normalize() return v } internal fun normalize() { val l: RealT = length() if (isEqualApprox(l, 0.0)) { x = 0.0 y = 0.0 } else { x /= l y /= l } } /** * Returns a vector composed of the fposmod of this vector’s components and mod. */ fun posmod(mod: RealT): Vector2 { return Vector2(x.rem(mod), y.rem(mod)) } /** * Returns a vector composed of the fposmod of this vector’s components and modv’s components. */ fun posmodv(modv: Vector2): Vector2 { return Vector2(x.rem(modv.x), y.rem(modv.y)) } /** * Returns the vector projected onto the vector b. */ fun project(vec: Vector2): Vector2 { val v1: Vector2 = vec val v2: Vector2 = this return v2 * (v1.dot(v2) / v2.dot(v2)) } /** * Returns the vector reflected from a plane defined by the given normal. */ fun reflect(vec: Vector2): Vector2 { return vec * this.dot(vec) * 2.0 - this } /** * Returns the vector rotated by phi radians. */ fun rotated(by: RealT): Vector2 { var v = Vector2(0.0, 0.0) v.rotate(this.angle() + by) v *= length() return v } internal fun rotate(radians: RealT) { x = cos(radians) y = sin(radians) } /** * Returns the vector with all components rounded to the nearest integer, with halfway cases rounded away from zero. */ fun round(): Vector2 { return Vector2(round(x), round(y)) } /** * Returns the vector with each component set to one or negative one, depending on the signs of the components. */ fun sign(): Vector2 { return Vector2(sign(x), sign(y)) } /** * Returns the result of spherical linear interpolation between this vector and b, by amount t. * t is in the range of 0.0 - 1.0, representing the amount of interpolation. * * Note: Both vectors must be normalized. */ fun slerp(b: Vector2, t: RealT): Vector2 { if (!this.isNormalized() || !b.isNormalized()) { Godot.printError("Vectors not normalized", "slerp()", "Vector2.kt", 240) } val theta: RealT = angleTo(b) return rotated((theta * t)) } /** * Returns the component of the vector along a plane defined by the given normal. */ fun slide(vec: Vector2): Vector2 { return vec - this * this.dot(vec) } /** * Returns the vector snapped to a grid with the given size. */ fun snapped(by: Vector2): Vector2 { val newX = if (isEqualApprox(by.x, 0.0)) { floor(x / by.x + 0.5).toRealT() } else { x } val newY = if (isEqualApprox(by.x, 0.0)) { floor(y / by.y + 0.5).toRealT() } else { y } return Vector2(newX, newY) } /** * Returns a perpendicular vector. */ fun tangent(): Vector2 { return Vector2(y, -x) } //UTILITIES override fun toVariant() = Variant(this) operator fun get(idx: Int): RealT = when (idx) { 0 -> x 1 -> y else -> throw IndexOutOfBoundsException() } operator fun set(n: Int, f: RealT) = when (n) { 0 -> x = f 1 -> y = f else -> throw IndexOutOfBoundsException() } operator fun plus(v: Vector2) = Vector2(x + v.x, y + v.y) operator fun plus(scalar: Int) = Vector2(x + scalar, y + scalar) operator fun plus(scalar: Long) = Vector2(x + scalar, y + scalar) operator fun plus(scalar: Float) = Vector2(x + scalar, y + scalar) operator fun plus(scalar: Double) = Vector2(x + scalar, y + scalar) operator fun minus(v: Vector2) = Vector2(x - v.x, y - v.y) operator fun minus(scalar: Int) = Vector2(x - scalar, y - scalar) operator fun minus(scalar: Long) = Vector2(x - scalar, y - scalar) operator fun minus(scalar: Float) = Vector2(x - scalar, y - scalar) operator fun minus(scalar: Double) = Vector2(x - scalar, y - scalar) operator fun times(v1: Vector2) = Vector2(x * v1.x, y * v1.y) operator fun times(scalar: Int) = Vector2(x * scalar, y * scalar) operator fun times(scalar: Long) = Vector2(x * scalar, y * scalar) operator fun times(scalar: Float) = Vector2(x * scalar, y * scalar) operator fun times(scalar: Double) = Vector2(x * scalar, y * scalar) operator fun div(v1: Vector2) = Vector2(x / v1.x, y / v1.y) operator fun div(scalar: Int) = Vector2(x / scalar, y / scalar) operator fun div(scalar: Long) = Vector2(x / scalar, y / scalar) operator fun div(scalar: Float) = Vector2(x / scalar, y / scalar) operator fun div(scalar: Double) = Vector2(x / scalar, y / scalar) operator fun unaryMinus() = Vector2(-x, -y) override fun equals(other: Any?): Boolean = when (other) { is Vector2 -> (isEqualApprox(x, other.x) && isEqualApprox(y, other.y)) else -> false } override fun compareTo(other: Vector2): Int = if (isEqualApprox(x, other.x)) { when { y < other.y -> -1 isEqualApprox(y, other.y) -> 0 else -> 1 } } else { when { x < other.x -> -1 else -> 1 } } override fun hashCode(): Int { var result = x.hashCode() result = 31 * result + y.hashCode() return result } override fun toString(): String { return "($x, $y)" } } operator fun Int.plus(vec: Vector2) = vec + this operator fun Long.plus(vec: Vector2) = vec + this operator fun Float.plus(vec: Vector2) = vec + this operator fun Double.plus(vec: Vector2) = vec + this operator fun Int.minus(vec: Vector2) = Vector2(this - vec.x, this - vec.y) operator fun Long.minus(vec: Vector2) = Vector2(this - vec.x, this - vec.y) operator fun Float.minus(vec: Vector2) = Vector2(this - vec.x, this - vec.y) operator fun Double.minus(vec: Vector2) = Vector2(this - vec.x, this - vec.y) operator fun Int.times(vec: Vector2) = vec * this operator fun Long.times(vec: Vector2) = vec * this operator fun Float.times(vec: Vector2) = vec * this operator fun Double.times(vec: Vector2) = vec * this ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/Vector3.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_vector3 import godot.gdnative.godot_vector3_layout import godot.internal.type.* import kotlinx.cinterop.* import kotlin.math.* class Vector3( var x: RealT, var y: RealT, var z: RealT ) : Comparable, CoreType { //CONSTANTS enum class Axis(val value: NaturalT) { X(0), Y(1), Z(2); companion object { fun from(value: NaturalT) = when (value) { 0L -> X 1L -> Y 2L -> Z else -> throw AssertionError("Unknown axis for Vector3: $value") } } } companion object { val AXIS_X = Axis.X.value val AXIS_Y = Axis.Y.value val AXIS_Z = Axis.Z.value val ZERO: Vector3 get() = Vector3(0, 0, 0) val ONE: Vector3 get() = Vector3(1, 1, 1) val INF: Vector3 get() = Vector3(RealT.POSITIVE_INFINITY, RealT.POSITIVE_INFINITY, RealT.POSITIVE_INFINITY) val LEFT: Vector3 get() = Vector3(-1, 0, 0) val RIGHT: Vector3 get() = Vector3(1, 0, 0) val UP: Vector3 get() = Vector3(0, 1, 0) val DOWN: Vector3 get() = Vector3(0, -1, 0) val FORWARD: Vector3 get() = Vector3(0, 0, -1) val BACK: Vector3 get() = Vector3(0, 0, 1) } //CONSTRUCTOR constructor() : this(0.0, 0.0, 0.0) constructor(vec: Vector3) : this(vec.x, vec.y, vec.z) constructor(x: Number, y: Number, z: Number) : this(x.toRealT(), y.toRealT(), z.toRealT()) internal constructor(native: CValue) : this() { memScoped { this@Vector3.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) : this() { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { val value = cValue { x = this@Vector3.x.toFloat() y = this@Vector3.y.toFloat() z = this@Vector3.z.toFloat() } return value.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { val value = mem.reinterpret().pointed x = value.x.toRealT() y = value.y.toRealT() z = value.z.toRealT() } //API /** * Returns a new vector with all components in absolute values (i.e. positive). */ fun abs(): Vector3 { return Vector3(abs(x), abs(y), abs(z)) } /** * Returns the minimum angle to the given vector. */ fun angleTo(to: Vector3): RealT { return atan2(cross(to).length(), dot(to)) } /** * Returns the vector “bounced off” from a plane defined by the given normal. */ fun bounce(n: Vector3): Vector3 { return -reflect(n) } /** * Returns a new vector with all components rounded up. */ fun ceil(): Vector3 { return Vector3(ceil(x), ceil(y), ceil(z)) } /** * Returns the cross product with b. */ fun cross(b: Vector3): Vector3 { return Vector3((y * b.z) - (z * b.y), (z * b.x) - (x * b.z), (x * b.y) - (y * b.x)) } /** * Performs a cubic interpolation between vectors pre_a, a, b, post_b (a is current), by the given amount t. * t is in the range of 0.0 - 1.0, representing the amount of interpolation. */ fun cubicInterpolate(b: Vector3, pre: Vector3, post: Vector3, t: RealT): Vector3 { val p0: Vector3 = pre val p1: Vector3 = this val p2: Vector3 = b val p3: Vector3 = post val t2 = t * t val t3 = t2 * t return ((p1 * 2.0) + (-p0 + p2) * t + (p0 * 2.0 - p1 * 5.0 + p2 * 4.0 - p3) * t2 + (-p0 + p1 * 3.0 - p2 * 3.0 + p3) * t3) * 0.5 } /** * Returns the normalized vector pointing from this vector to b. */ fun directionTo(other: Vector3): Vector3 { val ret = Vector3(other.x - x, other.y - y, other.z - z) ret.normalize() return ret } /** * Returns the squared distance to b. * Prefer this function over distance_to if you need to sort vectors or need the squared distance for some formula. */ fun distanceSquaredTo(other: Vector3): RealT { return (other - this).lengthSquared() } /** * Returns the distance to b. */ fun distanceTo(other: Vector3): RealT { return (other - this).length() } /** * Returns the dot product with b. */ fun dot(b: Vector3): RealT { return x * b.x + y * b.y + z * b.z } /** * Returns a new vector with all components rounded down. */ fun floor(): Vector3 { return Vector3(floor(x), floor(y), floor(z)) } /** * Returns the inverse of the vector. This is the same as Vector3( 1.0 / v.x, 1.0 / v.y, 1.0 / v.z ). */ fun inverse(): Vector3 { return Vector3(1.0 / x, 1.0 / y, 1.0 / z) } /** * Returns true if this vector and v are approximately equal, by running isEqualApprox on each component. */ fun isEqualApprox(other: Vector3): Boolean { return godot.internal.type.isEqualApprox( other.x, x ) && godot.internal.type.isEqualApprox( other.y, y ) && godot.internal.type.isEqualApprox(other.z, z) } /** * Returns true if the vector is normalized. */ fun isNormalized(): Boolean { return godot.internal.type.isEqualApprox(this.length(), 1.0) } /** * Returns the vector’s length. */ fun length(): RealT { return sqrt(x * x + y * y + z * z) } /** * Returns the vector’s length squared. * Prefer this function over length if you need to sort vectors or need the squared length for some formula. */ fun lengthSquared(): RealT { return x * x + y * y + z * z } /** * Returns the result of the linear interpolation between this vector and b by amount t. * t is in the range of 0.0 - 1.0, representing the amount of interpolation. */ fun linearInterpolate(b: Vector3, t: RealT): Vector3 { return Vector3(x + (t * (b.x - x)), y + (t * (b.y - y)), z + (t * (b.z - z))) } /** * Returns the axis of the vector’s largest value. See AXIS_* constants. */ fun maxAxis(): Int { return if (x < y) { if (y < z) { 2 } else { 1 } } else { if (x < z) { 2 } else { 0 } } } /** * Returns the axis of the vector’s smallest value. See AXIS_* constants. */ fun minAxis(): Int { return if (x < y) { if (x < z) { 0 } else { 2 } } else { if (y < z) { 1 } else { 2 } } } /** * Moves the vector toward to by the fixed delta amount. */ fun moveToward(to: Vector3, delta: RealT): Vector3 { val vd = to - this val len = vd.length() return if (len <= delta || len < CMP_EPSILON) { to } else { this + vd / len * delta } } /** * Returns the vector scaled to unit length. Equivalent to v / v.length(). */ fun normalized(): Vector3 { val v: Vector3 = Vector3(this) v.normalize() return v } internal fun normalize() { val l = this.length() if (isEqualApprox(l, 0.0)) { x = 0.0 y = 0.0 z = 0.0 } else { x /= l y /= l z /= l } } /** * Returns the outer product with b. */ fun outer(b: Vector3) = Basis( Vector3(x * b.x, x * b.y, x * b.z), Vector3(y * b.x, y * b.y, y * b.z), Vector3(z * b.x, z * b.y, z * b.z) ) /** * Returns a vector composed of the fposmod of this vector’s components and mod. */ fun posmod(mod: RealT): Vector3 { return Vector3(x.rem(mod), y.rem(mod), z.rem(mod)) } /** * Returns a vector composed of the fposmod of this vector’s components and modv’s components. */ fun posmodv(modv: Vector3): Vector3 { return Vector3(x.rem(modv.x), y.rem(modv.y), z.rem(modv.z)) } /** * Returns the vector projected onto the vector b. */ fun project(vec: Vector3): Vector3 { val v1: Vector3 = vec val v2: Vector3 = this return v2 * (v1.dot(v2) / v2.dot(v2)) } /** * Returns the vector reflected from a plane defined by the given normal. */ fun reflect(by: Vector3): Vector3 { return by - this * this.dot(by) * 2.0 } /** * Rotates the vector around a given axis by phi radians. The axis must be a normalized vector. */ fun rotated(axis: Vector3, phi: RealT): Vector3 { if (!axis.isNormalized()) { Godot.printError("Axis not normalized", "rotated()", "Vector3.kt", 251) } val v = Vector3(this) v.rotate(axis, phi) return v } internal fun rotate(axis: Vector3, phi: RealT) { val ret = Basis(axis, phi).xform(this) this.x = ret.x this.y = ret.y this.z = ret.z } /** * Returns the vector with all components rounded to the nearest integer, with halfway cases rounded away from zero. */ fun round(): Vector3 { return Vector3(round(x), round(y), round(z)) } /** * Returns the vector with each component set to one or negative one, depending on the signs of the components. */ fun sign(): Vector3 { return Vector3(sign(x), sign(y), sign(z)) } /** * Returns the result of spherical linear interpolation between this vector and b, by amount t. * t is in the range of 0.0 - 1.0, representing the amount of interpolation. * * Note: Both vectors must be normalized. */ fun slerp(b: Vector3, t: RealT): Vector3 { if (!this.isNormalized() || !b.isNormalized()) { Godot.printError("Vectors not normalized", "slerp()", "Vector3.kt", 275) } val theta: RealT = angleTo(b) return rotated(cross(b).normalized(), theta * t) } /** * Returns the component of the vector along a plane defined by the given normal. */ fun slide(vec: Vector3): Vector3 { return vec - this * this.dot(vec) } /** * Returns a copy of the vector snapped to the lowest neared multiple. */ fun snapped(by: RealT): Vector3 { val v: Vector3 = Vector3(this) v.snap(by) return v } internal fun snap(vecal: RealT) { if (isEqualApprox(vecal, 0.0)) { x = (floor(x / vecal + 0.5) * vecal) y = (floor(y / vecal + 0.5) * vecal) z = (floor(z / vecal + 0.5) * vecal) } } /** * Returns a diagonal matrix with the vector as main diagonal. */ fun toDiagonalMatrix(): Basis { return Basis() } //UTILITIES override fun toVariant() = Variant(this) operator fun get(n: Int): RealT = when (n) { 0 -> x 1 -> y 2 -> z else -> throw IndexOutOfBoundsException() } operator fun set(n: Int, f: RealT): Unit = when (n) { 0 -> x = f 1 -> y = f 2 -> z = f else -> throw IndexOutOfBoundsException() } operator fun plus(vec: Vector3) = Vector3(x + vec.x, y + vec.y, z + vec.z) operator fun plus(scalar: Int) = Vector3(x + scalar, y + scalar, z + scalar) operator fun plus(scalar: Long) = Vector3(x + scalar, y + scalar, z + scalar) operator fun plus(scalar: Float) = Vector3(x + scalar, y + scalar, z + scalar) operator fun plus(scalar: Double) = Vector3(x + scalar, y + scalar, z + scalar) operator fun minus(vec: Vector3) = Vector3(x - vec.x, y - vec.y, z - vec.z) operator fun minus(scalar: Int) = Vector3(x - scalar, y - scalar, z - scalar) operator fun minus(scalar: Long) = Vector3(x - scalar, y - scalar, z - scalar) operator fun minus(scalar: Float) = Vector3(x - scalar, y - scalar, z - scalar) operator fun minus(scalar: Double) = Vector3(x - scalar, y - scalar, z - scalar) operator fun times(vec: Vector3) = Vector3(x * vec.x, y * vec.y, z * vec.z) operator fun times(scalar: Int) = Vector3(x * scalar, y * scalar, z * scalar) operator fun times(scalar: Long) = Vector3(x * scalar, y * scalar, z * scalar) operator fun times(scalar: Float) = Vector3(x * scalar, y * scalar, z * scalar) operator fun times(scalar: Double) = Vector3(x * scalar, y * scalar, z * scalar) operator fun div(vec: Vector3) = Vector3(x / vec.x, y / vec.y, z / vec.z) operator fun div(scalar: Int) = Vector3(x / scalar, y / scalar, z / scalar) operator fun div(scalar: Long) = Vector3(x / scalar, y / scalar, z / scalar) operator fun div(scalar: Float) = Vector3(x / scalar, y / scalar, z / scalar) operator fun div(scalar: Double) = Vector3(x / scalar, y / scalar, z / scalar) operator fun unaryMinus() = Vector3(-x, -y, -z) override fun equals(other: Any?): Boolean = when (other) { is Vector3 -> (x == other.x && y == other.y && z == other.z) else -> false } override fun compareTo(other: Vector3): Int { if (x == other.x) { return if (y == other.y) when { z < other.z -> -1 z == other.z -> 0 else -> 1 } else when { y < other.y -> -1 else -> 1 } } else return when { x < other.x -> -1 else -> 1 } } override fun toString(): String { return "($x, $y, $z)" } override fun hashCode(): Int { return this.toString().hashCode() } } operator fun Int.plus(vec: Vector3) = vec + this operator fun Long.plus(vec: Vector3) = vec + this operator fun Float.plus(vec: Vector3) = vec + this operator fun Double.plus(vec: Vector3) = vec + this operator fun Int.minus(vec: Vector3) = Vector3(this - vec.x, this - vec.y, this - vec.z) operator fun Long.minus(vec: Vector3) = Vector3(this - vec.x, this - vec.y, this - vec.z) operator fun Float.minus(vec: Vector3) = Vector3(this - vec.x, this - vec.y, this - vec.z) operator fun Double.minus(vec: Vector3) = Vector3(this - vec.x, this - vec.y, this - vec.z) operator fun Int.times(vec: Vector3) = vec * this operator fun Long.times(vec: Vector3) = vec * this operator fun Float.times(vec: Vector3) = vec * this operator fun Double.times(vec: Vector3) = vec * this ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/EnumArray.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_array import godot.internal.type.nullSafe import kotlinx.cinterop.* class EnumArray>(val mapper: (Int) -> E) : GodotArray() { //CONSTRUCTOR init { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new)(it) } } internal constructor(native: CValue, mapper: (Int) -> E) : this(mapper) { memScoped { this@EnumArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer, mapper: (Int) -> E) : this(mapper) { this.setRawMemory(mem) } //API override fun append(value: E) { return callNative { nullSafe(Godot.gdnative.godot_array_append)(it, value.toVariant()._handle.ptr) } } override fun bsearch(value: E, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch)(it, value.toVariant()._handle.ptr, before) } } override fun bsearchCustom(value: E, obj: Object, func: String, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch_custom)( it, value.toVariant()._handle.ptr, obj.ptr, func.toGDString().value.ptr, before ) } } override fun count(value: E): Int { return callNative { nullSafe(Godot.gdnative.godot_array_count)(it, value.toVariant()._handle.ptr) } } override fun duplicate(deep: Boolean): EnumArray { return EnumArray( callNative { nullSafe(Godot.gdnative11.godot_array_duplicate)(it, deep) }, mapper ) } override fun erase(value: E) { callNative { nullSafe(Godot.gdnative.godot_array_erase)(it, value.toVariant()._handle.ptr) } } override fun find(what: E, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find)(it, what.toVariant()._handle.ptr, from) } } override fun findLast(value: E): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find_last)(it, value.toVariant()._handle.ptr) } } override fun front(): E { return enum(Variant( callNative { nullSafe(Godot.gdnative.godot_array_front)(it) } )) } override fun has(value: E): Boolean { return callNative { nullSafe(Godot.gdnative.godot_array_has)(it, value.toVariant()._handle.ptr) } } override fun insert(position: Int, value: E) { return callNative { nullSafe(Godot.gdnative.godot_array_insert)(it, position, value.toVariant()._handle.ptr) } } override fun max(): E { return enum(Variant( callNative { nullSafe(Godot.gdnative11.godot_array_max)(it) } )) } override fun min(): E { return enum(Variant( callNative { nullSafe(Godot.gdnative11.godot_array_min)(it) } )) } override fun popBack(): E { return enum(Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_back)(it) } )) } override fun popFront(): E { return enum(Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_front)(it) } )) } override fun pushBack(value: E) { return callNative { nullSafe(Godot.gdnative.godot_array_push_back)(it, value.toVariant()._handle.ptr) } } override fun pushFront(value: E) { return callNative { nullSafe(Godot.gdnative.godot_array_push_front)(it, value.toVariant()._handle.ptr) } } override fun rfind(what: E, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_rfind)(it, what.toVariant()._handle.ptr, from) } } override fun slice(begin: Int, end: Int, step: Int, deep: Boolean): EnumArray { return EnumArray( callNative { nullSafe(Godot.gdnative12.godot_array_slice)( it, begin, end, step, deep ) }, mapper ) } //UTILITIES private fun enum(variant: Variant): E { return mapper(variant.asInt()) } override operator fun set(idx: Int, data: E) { callNative { nullSafe(Godot.gdnative.godot_array_set)(it, idx, Variant(data)._handle.ptr) } } override operator fun get(idx: Int): E { return enum(Variant( callNative { nullSafe(Godot.gdnative.godot_array_get)(it, idx) } )) } override fun plus(other: E) { this.append(other) } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } } /** * Build an EnumArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ fun > enumVariantArrayOf(mapper: (Int) -> E, vararg elements: E): EnumArray { return EnumArray(mapper).also { for (arg in elements) { it.append(arg) } } } /** * Convert an iterable into an EnumArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun > Iterable.toVariantArray(mapper: (Int) -> E) = EnumArray(mapper).also { for (arg in this) { it.append(arg) } } /** * Build a EnumArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun > EnumArray(iter: Iterable, mapper: (Int) -> E) = iter.toVariantArray(mapper) /** * Create a shallow copy of the EnumVariabtArray */ fun > EnumArray(other: EnumArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/ObjectArray.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_array import godot.internal.type.nullSafe import kotlinx.cinterop.* @ExperimentalUnsignedTypes class ObjectArray : GodotArray { //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new)(it) } } internal constructor(native: CValue) { memScoped { this@ObjectArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //API override fun append(value: T) { callNative { nullSafe(Godot.gdnative.godot_array_append)(it, value.toVariant()._handle.ptr) } } override fun bsearch(value: T, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch)(it, value.toVariant()._handle.ptr, before) } } override fun bsearchCustom(value: T, obj: Object, func: String, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch_custom)( it, value.toVariant()._handle.ptr, obj.ptr, func.toGDString().value.ptr, before ) } } override fun count(value: T): Int { return callNative { nullSafe(Godot.gdnative.godot_array_count)(it, value.toVariant()._handle.ptr) } } override fun duplicate(deep: Boolean): ObjectArray { return ObjectArray( callNative { nullSafe(Godot.gdnative11.godot_array_duplicate)(it, deep) } ) } override fun erase(value: T) { callNative { nullSafe(Godot.gdnative.godot_array_erase)(it, value.toVariant()._handle.ptr) } } override fun find(what: T, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find)(it, what.toVariant()._handle.ptr, from) } } override fun findLast(value: T): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find_last)(it, value.toVariant()._handle.ptr) } } override fun front(): T { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_front)(it) } ).asObject() as T } override fun has(value: T): Boolean { return callNative { nullSafe(Godot.gdnative.godot_array_has)(it, value.toVariant()._handle.ptr) } } override fun insert(position: Int, value: T) { return callNative { nullSafe(Godot.gdnative.godot_array_insert)(it, position, value.toVariant()._handle.ptr) } } override fun max(): T { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_max)(it) } ).asObject() as T } override fun min(): T { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_min)(it) } ).asObject() as T } override fun popBack(): T { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_back)(it) } ).asObject() as T } override fun popFront(): T { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_front)(it) } ).asObject() as T } override fun pushBack(value: T) { return callNative { nullSafe(Godot.gdnative.godot_array_push_back)(it, value.toVariant()._handle.ptr) } } override fun pushFront(value: T) { return callNative { nullSafe(Godot.gdnative.godot_array_push_front)(it, value.toVariant()._handle.ptr) } } override fun rfind(what: T, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_rfind)(it, what.toVariant()._handle.ptr, from) } } override fun slice(begin: Int, end: Int, step: Int, deep: Boolean): ObjectArray { return ObjectArray( callNative { nullSafe(Godot.gdnative12.godot_array_slice)(it, begin, end, step, deep) } ) } //UTILITIES override operator fun set(idx: Int, data: T) { callNative { nullSafe(Godot.gdnative.godot_array_set)(it, idx, Variant(data)._handle.ptr) } } override operator fun get(idx: Int): T { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_get)(it, idx) } ).asObject() as T } override fun plus(other: T) { this.append(other) } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } } /** * Build an AABBArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun ObjectArrayOf(vararg elements: T) = ObjectArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an ObjectArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = ObjectArray().also { for (arg in this) { it.append(arg) } } /** * Build a ObjectArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun ObjectArray(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun ObjectArray(other: ObjectArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/VariantArray.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_array import godot.internal.type.CoreType import godot.internal.type.nullSafe import kotlinx.cinterop.* @ExperimentalUnsignedTypes class VariantArray : GodotArray { //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new)(it) } } constructor(other: PoolByteArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_byte_array)(it, other._handle.ptr) } } constructor(other: PoolColorArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_color_array)(it, other._handle.ptr) } } constructor(other: PoolIntArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_int_array)(it, other._handle.ptr) } } constructor(other: PoolRealArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_real_array)(it, other._handle.ptr) } } constructor(other: PoolStringArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_string_array)(it, other._handle.ptr) } } constructor(other: PoolVector2Array) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_vector2_array)(it, other._handle.ptr) } } constructor(other: PoolVector3Array) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_vector3_array)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@VariantArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //API override fun append(value: Variant) { callNative { nullSafe(Godot.gdnative.godot_array_append)(it, value._handle.ptr) } } fun append(value: Int) = append(Variant(value)) fun append(value: Float) = append(Variant(value)) fun append(value: Boolean) = append(Variant(value)) fun append(value: String) = append(Variant(value)) fun append(value: Dictionary) = append(value.toVariant()) fun append(value: GodotArray) = append(value.toVariant()) fun append(value: Object) = append(value.toVariant()) fun append(value: CoreType) = append(value.toVariant()) override fun bsearch(value: Variant, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch)(it, value._handle.ptr, before) } } fun bsearch(value: Int, before: Boolean = true) = bsearch(Variant(value), before) fun bsearch(value: Float, before: Boolean = true) = bsearch(Variant(value), before) fun bsearch(value: String, before: Boolean = true) = bsearch(Variant(value), before) fun bsearch(value: Boolean, before: Boolean = true) = bsearch(Variant(value), before) fun bsearch(value: Dictionary, before: Boolean = true) = bsearch(Variant(value), before) fun bsearch(value: GodotArray, before: Boolean = true) = bsearch(Variant(value), before) fun bsearch(value: Object, before: Boolean = true) = bsearch(value.toVariant(), before) fun bsearch(value: CoreType, before: Boolean = true) = bsearch(value.toVariant(), before) override fun bsearchCustom(value: Variant, obj: Object, func: String, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch_custom)( it, value._handle.ptr, obj.ptr, func.toGDString().value.ptr, before ) } } fun bsearchCustom(value: Int, obj: Object, func: String, before: Boolean) = bsearchCustom(Variant(value), obj, func, before) fun bsearchCustom(value: Float, obj: Object, func: String, before: Boolean) = bsearchCustom(Variant(value), obj, func, before) fun bsearchCustom(value: String, obj: Object, func: String, before: Boolean) = bsearchCustom(Variant(value), obj, func, before) fun bsearchCustom(value: Boolean, obj: Object, func: String, before: Boolean) = bsearchCustom(Variant(value), obj, func, before) fun bsearchCustom(value: Dictionary, obj: Object, func: String, before: Boolean) = bsearchCustom(Variant(value), obj, func, before) fun bsearchCustom(value: GodotArray, obj: Object, func: String, before: Boolean) = bsearchCustom(Variant(value), obj, func, before) fun bsearchCustom(value: Object, obj: Object, func: String, before: Boolean) = bsearchCustom(value.toVariant(), obj, func, before) fun bsearchCustom(value: CoreType, obj: Object, func: String, before: Boolean) = bsearchCustom(value.toVariant(), obj, func, before) override fun count(value: Variant): Int { return callNative { nullSafe(Godot.gdnative.godot_array_count)(it, value._handle.ptr) } } fun count(value: Int) = count(Variant(value)) fun count(value: Float) = count(Variant(value)) fun count(value: String) = count(Variant(value)) fun count(value: Boolean) = count(Variant(value)) fun count(value: Dictionary) = count(Variant(value)) fun count(value: GodotArray) = count(Variant(value)) fun count(value: Object) = count(value.toVariant()) fun count(value: CoreType) = count(value.toVariant()) override fun duplicate(deep: Boolean): VariantArray { return VariantArray( callNative { nullSafe(Godot.gdnative11.godot_array_duplicate)(it, deep) } ) } override fun erase(value: Variant) { callNative { nullSafe(Godot.gdnative.godot_array_erase)(it, value._handle.ptr) } } fun erase(value: Int) = erase(Variant(value)) fun erase(value: Float) = erase(Variant(value)) fun erase(value: String) = erase(Variant(value)) fun erase(value: Boolean) = erase(Variant(value)) fun erase(value: Dictionary) = erase(Variant(value)) fun erase(value: GodotArray) = erase(Variant(value)) fun erase(value: Object) = erase(value.toVariant()) fun erase(value: CoreType) = erase(value.toVariant()) override fun find(what: Variant, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find)(it, what._handle.ptr, from) } } fun find(value: Int, from: Int = 0) = find(Variant(value)) fun find(value: Float, from: Int = 0) = find(Variant(value)) fun find(value: String, from: Int = 0) = find(Variant(value)) fun find(value: Boolean, from: Int = 0) = find(Variant(value)) fun find(value: Dictionary, from: Int = 0) = find(Variant(value)) fun find(value: GodotArray, from: Int = 0) = find(Variant(value)) fun find(value: Object, from: Int = 0) = find(value.toVariant()) fun find(value: CoreType, from: Int = 0) = find(value.toVariant()) override fun findLast(value: Variant): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find_last)(it, value._handle.ptr) } } fun findLast(value: Int) = findLast(Variant(value)) fun findLast(value: Float) = findLast(Variant(value)) fun findLast(value: String) = findLast(Variant(value)) fun findLast(value: Boolean) = findLast(Variant(value)) fun findLast(value: Dictionary) = findLast(Variant(value)) fun findLast(value: GodotArray) = findLast(Variant(value)) fun findLast(value: Object) = findLast(value.toVariant()) fun findLast(value: CoreType) = findLast(value.toVariant()) override fun front(): Variant { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_front)(it) } ) } override fun has(value: Variant): Boolean { return callNative { nullSafe(Godot.gdnative.godot_array_has)(it, value._handle.ptr) } } fun has(value: Int) = has(Variant(value)) fun has(value: Float) = has(Variant(value)) fun has(value: String) = has(Variant(value)) fun has(value: Boolean) = has(Variant(value)) fun has(value: Dictionary) = has(Variant(value)) fun has(value: GodotArray) = has(Variant(value)) fun has(value: Object) = has(value.toVariant()) fun has(value: CoreType) = has(value.toVariant()) override fun insert(position: Int, value: Variant) { return callNative { nullSafe(Godot.gdnative.godot_array_insert)(it, position, value._handle.ptr) } } fun insert(index: Int, value: Int) = insert(index, Variant(value)) fun insert(index: Int, value: Float) = insert(index, Variant(value)) fun insert(index: Int, value: String) = insert(index, Variant(value)) fun insert(index: Int, value: Boolean) = insert(index, Variant(value)) fun insert(index: Int, value: Dictionary) = insert(index, Variant(value)) fun insert(index: Int, value: GodotArray) = insert(index, Variant(value)) fun insert(index: Int, value: Object) = insert(index, value.toVariant()) fun insert(index: Int, value: CoreType) = insert(index, value.toVariant()) override fun max(): Variant { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_max)(it) } ) } override fun min(): Variant { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_min)(it) } ) } override fun popBack(): Variant { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_back)(it) } ) } override fun popFront(): Variant { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_front)(it) } ) } override fun pushBack(value: Variant) { return callNative { nullSafe(Godot.gdnative.godot_array_push_back)(it, value._handle.ptr) } } fun pushBack(value: Int) = pushBack(Variant(value)) fun pushBack(value: Float) = pushBack(Variant(value)) fun pushBack(value: String) = pushBack(Variant(value)) fun pushBack(value: Boolean) = pushBack(Variant(value)) fun pushBack(value: Dictionary) = pushBack(Variant(value)) fun pushBack(value: GodotArray) = pushBack(Variant(value)) fun pushBack(value: Object) = pushBack(value.toVariant()) fun pushBack(value: CoreType) = pushBack(value.toVariant()) override fun pushFront(value: Variant) { return callNative { nullSafe(Godot.gdnative.godot_array_push_front)(it, value._handle.ptr) } } fun pushFront(value: Int) = pushFront(Variant(value)) fun pushFront(value: Float) = pushFront(Variant(value)) fun pushFront(value: String) = pushFront(Variant(value)) fun pushFront(value: Boolean) = pushFront(Variant(value)) fun pushFront(value: Dictionary) = pushFront(Variant(value)) fun pushFront(value: GodotArray) = pushFront(Variant(value)) fun pushFront(value: Object) = pushFront(value.toVariant()) fun pushFront(value: CoreType) = pushFront(value.toVariant()) override fun rfind(what: Variant, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_rfind)(it, what._handle.ptr, from) } } fun rfind(what: Int, from: Int) = rfind(Variant(what), from) fun rfind(what: Float, from: Int) = rfind(Variant(what), from) fun rfind(what: String, from: Int) = rfind(Variant(what), from) fun rfind(what: Boolean, from: Int) = rfind(Variant(what), from) fun rfind(what: Dictionary, from: Int) = rfind(Variant(what), from) fun rfind(what: GodotArray, from: Int) = rfind(Variant(what), from) fun rfind(what: Object, from: Int) = rfind(what.toVariant(), from) fun rfind(what: CoreType, from: Int) = rfind(what.toVariant(), from) override fun slice(begin: Int, end: Int, step: Int, deep: Boolean): VariantArray { return VariantArray( callNative { nullSafe(Godot.gdnative12.godot_array_slice)(it, begin, end, step, deep) } ) } //UTILITIES override fun toVariant() = Variant(this) override operator fun set(idx: Int, data: Variant) { callNative { nullSafe(Godot.gdnative.godot_array_set)(it, idx, data._handle.ptr) } } operator fun set(idx: Int, data: Int) = set(idx, Variant(data)) operator fun set(idx: Int, data: Float) = set(idx, Variant(data)) operator fun set(idx: Int, data: String) = set(idx, Variant(data)) operator fun set(idx: Int, data: Boolean) = set(idx, Variant(data)) operator fun set(idx: Int, data: Dictionary) = set(idx, Variant(data)) operator fun set(idx: Int, data: GodotArray) = set(idx, Variant(data)) operator fun set(idx: Int, data: Object) = set(idx, data.toVariant()) operator fun set(idx: Int, data: CoreType) = set(idx, data.toVariant()) override operator fun get(idx: Int): Variant { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_get)(it, idx) } ) } override operator fun plus(other: Variant) { this.append(other) } operator fun plus(data: Int) = plus(Variant(data)) operator fun plus(data: Float) = plus(Variant(data)) operator fun plus(data: String) = plus(Variant(data)) operator fun plus(data: Boolean) = plus(Variant(data)) operator fun plus(data: Dictionary) = plus(Variant(data)) operator fun plus(data: GodotArray) = plus(Variant(data)) operator fun plus(data: Object) = plus(data.toVariant()) operator fun plus(data: CoreType) = plus(data.toVariant()) fun asIntVariantArray() = IntVariantArray(_handle) fun asFloatVariantArray() = RealVariantArray(_handle) fun asStringVariantArray() = StringVariantArray(_handle) fun asBoolVariantArray() = BoolVariantArray(_handle) fun asObjectArray() = ObjectArray(_handle) fun > asObjectArray(mapper: (Int) -> E) = EnumArray(_handle, mapper) fun asAABBArray() = AABBArray(_handle) fun asBasisArray() = BasisArray(_handle) fun asColorArray() = ColorArray(_handle) fun asNodePathArray() = NodePathArray(_handle) fun asPlaneArray() = PlaneArray(_handle) fun asQatArray() = QuatArray(_handle) fun asRect2Array() = Rect2Array(_handle) fun asRIDArray() = RIDArray(_handle) fun asTransformArray() = TransformArray(_handle) fun asTransform2DArray() = Transform2DArray(_handle) fun asVector2Array() = Vector2Array(_handle) fun asVector3Array() = Vector3Array(_handle) override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } } /** * Create a shallow copy of the Array */ fun VariantArray(other: VariantArray) = other.duplicate(false) inline fun variantArrayOf( p0: P0 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) return ret } inline fun variantArrayOf( p0: P0, p1: P1 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) ret.append(Variant.wrap(p1)) return ret } inline fun variantArrayOf( p0: P0, p1: P1, p2: P2 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) ret.append(Variant.wrap(p1)) ret.append(Variant.wrap(p2)) return ret } inline fun variantArrayOf( p0: P0, p1: P1, p2: P2, p3: P3 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) ret.append(Variant.wrap(p1)) ret.append(Variant.wrap(p2)) ret.append(Variant.wrap(p3)) return ret } inline fun variantArrayOf( p0: P0, p1: P1, p2: P2, p3: P3, p4: P4 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) ret.append(Variant.wrap(p1)) ret.append(Variant.wrap(p2)) ret.append(Variant.wrap(p3)) ret.append(Variant.wrap(p4)) return ret } inline fun variantArrayOf( p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) ret.append(Variant.wrap(p1)) ret.append(Variant.wrap(p2)) ret.append(Variant.wrap(p3)) ret.append(Variant.wrap(p4)) ret.append(Variant.wrap(p5)) return ret } inline fun variantArrayOf( p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) ret.append(Variant.wrap(p1)) ret.append(Variant.wrap(p2)) ret.append(Variant.wrap(p3)) ret.append(Variant.wrap(p4)) ret.append(Variant.wrap(p5)) ret.append(Variant.wrap(p6)) return ret } inline fun variantArrayOf( p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) ret.append(Variant.wrap(p1)) ret.append(Variant.wrap(p2)) ret.append(Variant.wrap(p3)) ret.append(Variant.wrap(p4)) ret.append(Variant.wrap(p5)) ret.append(Variant.wrap(p6)) ret.append(Variant.wrap(p7)) return ret } inline fun variantArrayOf( p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) ret.append(Variant.wrap(p1)) ret.append(Variant.wrap(p2)) ret.append(Variant.wrap(p3)) ret.append(Variant.wrap(p4)) ret.append(Variant.wrap(p5)) ret.append(Variant.wrap(p6)) ret.append(Variant.wrap(p7)) ret.append(Variant.wrap(p8)) return ret } inline fun variantArrayOf( p0: P0, p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9 ): VariantArray { val ret = VariantArray() ret.append(Variant.wrap(p0)) ret.append(Variant.wrap(p1)) ret.append(Variant.wrap(p2)) ret.append(Variant.wrap(p3)) ret.append(Variant.wrap(p4)) ret.append(Variant.wrap(p5)) ret.append(Variant.wrap(p6)) ret.append(Variant.wrap(p7)) ret.append(Variant.wrap(p8)) ret.append(Variant.wrap(p9)) return ret } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/AABBArray.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class AABBArray : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): AABB = value.asAABB() override fun getCoreArray(value: CValue) = AABBArray(value) } /** * Build an AABBArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun AABBArrayOf(vararg elements: AABB) = AABBArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an AABBArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = AABBArray().also { for (arg in this) { it.append(arg) } } /** * Build a AABBArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun AABBArray(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun AABBArray(other: AABBArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/BasisArray.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class BasisArray : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): Basis = value.asBasis() override fun getCoreArray(value: CValue) = BasisArray(value) } /** * Build an BasisArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun BasisArrayOf(vararg elements: Basis) = BasisArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an BasisArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = BasisArray().also { for (arg in this) { it.append(arg) } } /** * Build a BasisArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun BasisArray(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun BasisArray(other: BasisArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/ColorArray.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class ColorArray : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): Color = value.asColor() override fun getCoreArray(value: CValue) = ColorArray(value) } /** * Build an ColorArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun ColorArrayOf(vararg elements: Color) = ColorArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an ColorArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = ColorArray().also { for (arg in this) { it.append(arg) } } /** * Build a ColorArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun ColorArray(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun ColorArray(other: ColorArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/CoreArray.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_array import godot.internal.type.* import kotlinx.cinterop.* @ExperimentalUnsignedTypes abstract class CoreArray : GodotArray { //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new)(it) } } constructor(other: CoreArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_copy)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@CoreArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //API override fun append(value: T) { callNative { nullSafe(Godot.gdnative.godot_array_append)(it, value.toVariant()._handle.ptr) } } override fun bsearch(value: T, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch)(it, value.toVariant()._handle.ptr, before) } } override fun bsearchCustom(value: T, obj: Object, func: String, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch_custom)( it, value.toVariant()._handle.ptr, obj.ptr, func.toGDString().value.ptr, before ) } } override fun count(value: T): Int { return callNative { nullSafe(Godot.gdnative.godot_array_count)(it, value.toVariant()._handle.ptr) } } override fun duplicate(deep: Boolean): CoreArray { return getCoreArray( callNative { nullSafe(Godot.gdnative11.godot_array_duplicate)(it, deep) } ) } override fun erase(value: T) { callNative { nullSafe(Godot.gdnative.godot_array_erase)(it, value.toVariant()._handle.ptr) } } override fun find(what: T, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find)(it, what.toVariant()._handle.ptr, from) } } override fun findLast(value: T): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find_last)(it, value.toVariant()._handle.ptr) } } override fun front(): T { return getCore( Variant( callNative { nullSafe(Godot.gdnative.godot_array_front)(it) } ) ) } override fun has(value: T): Boolean { return callNative { nullSafe(Godot.gdnative.godot_array_has)(it, value.toVariant()._handle.ptr) } } override fun insert(position: Int, value: T) { return callNative { nullSafe(Godot.gdnative.godot_array_insert)(it, position, value.toVariant()._handle.ptr) } } override fun max(): T { return getCore( Variant( callNative { nullSafe(Godot.gdnative11.godot_array_max)(it) } ) ) } override fun min(): T { return getCore( Variant( callNative { nullSafe(Godot.gdnative11.godot_array_min)(it) } ) ) } override fun popBack(): T { return getCore( Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_back)(it) } ) ) } override fun popFront(): T { return getCore( Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_front)(it) } ) ) } override fun pushBack(value: T) { return callNative { nullSafe(Godot.gdnative.godot_array_push_back)(it, value.toVariant()._handle.ptr) } } override fun pushFront(value: T) { return callNative { nullSafe(Godot.gdnative.godot_array_push_front)(it, value.toVariant()._handle.ptr) } } override fun rfind(what: T, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_rfind)(it, what.toVariant()._handle.ptr, from) } } override fun slice(begin: Int, end: Int, step: Int, deep: Boolean): CoreArray { return getCoreArray( callNative { nullSafe(Godot.gdnative12.godot_array_slice)(it, begin, end, step, deep) } ) } //UTILITIES protected abstract fun getCore(value: Variant): T protected abstract fun getCoreArray(value: CValue): CoreArray override operator fun set(idx: Int, data: T) { callNative { nullSafe(Godot.gdnative.godot_array_set)(it, idx, data.toVariant()._handle.ptr) } } override operator fun get(idx: Int): T { return getCore( Variant( callNative { nullSafe(Godot.gdnative.godot_array_get)(it, idx) } ) ) } override fun plus(other: T) { this.append(other) } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/NodePathArray.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class NodePathArray : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): NodePath = value.asNodePath() override fun getCoreArray(value: CValue) = NodePathArray(value) } /** * Build an NodePathArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun NodePathArrayOf(vararg elements: NodePath) = NodePathArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an NodePathArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = NodePathArray().also { for (arg in this) { it.append(arg) } } /** * Build a NodePathArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun NodePathArray(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun NodePathArray(other: NodePathArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/PlaneArray.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class PlaneArray : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): Plane = value.asPlane() override fun getCoreArray(value: CValue) = PlaneArray(value) } /** * Build an PlaneArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun PlaneArrayOf(vararg elements: Plane) = PlaneArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an PlaneArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = PlaneArray().also { for (arg in this) { it.append(arg) } } /** * Build a PlaneArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun PlaneArray(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun PlaneArray(other: PlaneArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/QuatArray.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class QuatArray : CoreArray { constructor() : super() constructor(other: QuatArray) : super(other) internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): Quat = value.asQuat() override fun getCoreArray(value: CValue) = QuatArray(value) } /** * Build an QuatArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun QuatArrayOf(vararg elements: Quat) = QuatArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an QuatArray * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = QuatArray().also { for (arg in this) { it.append(arg) } } /** * Build a QuatArray based on an Iterable * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun QuatArray(iter: Iterable) = iter.toVariantArray() ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/RIDArray.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class RIDArray : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): RID = value.asRID() override fun getCoreArray(value: CValue) = RIDArray(value) } /** * Build an RIDArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun RIDArrayOf(vararg elements: RID) = RIDArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an RIDArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = RIDArray().also { for (arg in this) { it.append(arg) } } /** * Build a RIDArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun RIDArray(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun RIDArray(other: RIDArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/Rect2Array.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class Rect2Array : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): Rect2 = value.asRect2() override fun getCoreArray(value: CValue) = Rect2Array(value) } /** * Build an Rect2Array based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Rect2ArrayOf(vararg elements: Rect2) = Rect2Array().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an Rect2Array * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = Rect2Array().also { for (arg in this) { it.append(arg) } } /** * Build a Rect2Array based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Rect2Array(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun Rect2Array(other: Rect2Array) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/Transform2DArray.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class Transform2DArray : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): Transform2D = value.asTransform2D() override fun getCoreArray(value: CValue) = Transform2DArray(value) } /** * Build an Transform2DArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Transform2DArrayOf(vararg elements: Transform2D) = Transform2DArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an Transform2DArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = Transform2DArray().also { for (arg in this) { it.append(arg) } } /** * Build a Transform2DArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Transform2DArray(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun Transform2DArray(other: Transform2DArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/TransformArray.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class TransformArray : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): Transform = value.asTransform() override fun getCoreArray(value: CValue) = TransformArray(value) } /** * Build an TransformArray based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun TransformArrayOf(vararg elements: Transform) = TransformArray().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an TransformArray * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = TransformArray().also { for (arg in this) { it.append(arg) } } /** * Build a TransformArray based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun TransformArray(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun TransformArray(other: TransformArray) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/Vector2Array.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class Vector2Array : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): Vector2 = value.asVector2() override fun getCoreArray(value: CValue) = Vector2Array(value) } /** * Build an Vector2Array based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Vector2ArrayOf(vararg elements: Vector2) = Vector2Array().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an Vector2Array * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = Vector2Array().also { for (arg in this) { it.append(arg) } } /** * Build a Vector2Array based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Vector2Array(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun Vector2Array(other: Vector2Array) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/core/Vector3Array.kt ================================================ package godot.core import godot.gdnative.godot_array import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.CValue @ExperimentalUnsignedTypes class Vector3Array : CoreArray { constructor() : super() internal constructor(native: CValue) : super(native) internal constructor(mem: COpaquePointer) : super(mem) override fun getCore(value: Variant): Vector3 = value.asVector3() override fun getCoreArray(value: CValue) = Vector3Array(value) } /** * Build an Vector3Array based on the vararg arguments. * Warning: Might be slow with a lot of arguments because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Vector3ArrayOf(vararg elements: Vector3) = Vector3Array().also { for (arg in elements) { it.append(arg) } } /** * Convert an iterable into an Vector3Array * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Iterable.toVariantArray() = Vector3Array().also { for (arg in this) { it.append(arg) } } /** * Build a Vector3Array based on an Iterable * Warning: Might be slow if the iterable contains a lot of items because GDNative can only append items one by one */ @ExperimentalUnsignedTypes fun Vector3Array(iter: Iterable) = iter.toVariantArray() /** * Create a shallow copy of the Array */ fun Vector3Array(other: Vector3Array) = other.duplicate(false) ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/primitive/BoolVariantArray.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_array import godot.internal.type.nullSafe import kotlinx.cinterop.* class BoolVariantArray : GodotArray { //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new)(it) } } constructor(other: BoolVariantArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_copy)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@BoolVariantArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //API override fun append(value: Boolean) { callNative { nullSafe(Godot.gdnative.godot_array_append)(it, value.toVariant()._handle.ptr) } } override fun bsearch(value: Boolean, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch)(it, value.toVariant()._handle.ptr, before) } } override fun bsearchCustom(value: Boolean, obj: Object, func: String, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch_custom)( it, value.toVariant()._handle.ptr, obj.ptr, func.toGDString().value.ptr, before ) } } override fun count(value: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_count)(it, value.toVariant()._handle.ptr) } } override fun duplicate(deep: Boolean): BoolVariantArray { return BoolVariantArray( callNative { nullSafe(Godot.gdnative11.godot_array_duplicate)(it, deep) } ) } override fun erase(value: Boolean) { callNative { nullSafe(Godot.gdnative.godot_array_erase)(it, value.toVariant()._handle.ptr) } } override fun find(what: Boolean, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find)(it, what.toVariant()._handle.ptr, from) } } override fun findLast(value: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find_last)(it, value.toVariant()._handle.ptr) } } override fun front(): Boolean { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_front)(it) } ).asBoolean() } override fun has(value: Boolean): Boolean { return callNative { nullSafe(Godot.gdnative.godot_array_has)(it, value.toVariant()._handle.ptr) } } override fun insert(position: Int, value: Boolean) { return callNative { nullSafe(Godot.gdnative.godot_array_insert)(it, position, value.toVariant()._handle.ptr) } } override fun max(): Boolean { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_max)(it) } ).asBoolean() } override fun min(): Boolean { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_min)(it) } ).asBoolean() } override fun popBack(): Boolean { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_back)(it) } ).asBoolean() } override fun popFront(): Boolean { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_front)(it) } ).asBoolean() } override fun pushBack(value: Boolean) { return callNative { nullSafe(Godot.gdnative.godot_array_push_back)(it, value.toVariant()._handle.ptr) } } override fun pushFront(value: Boolean) { return callNative { nullSafe(Godot.gdnative.godot_array_push_front)(it, value.toVariant()._handle.ptr) } } override fun rfind(what: Boolean, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_rfind)(it, what.toVariant()._handle.ptr, from) } } override fun slice(begin: Int, end: Int, step: Int, deep: Boolean): BoolVariantArray { return BoolVariantArray( callNative { nullSafe(Godot.gdnative12.godot_array_slice)( it, begin, end, step, deep ) } ) } //UTILITIES override operator fun set(idx: Int, data: Boolean) { callNative { nullSafe(Godot.gdnative.godot_array_set)(it, idx, Variant(data)._handle.ptr) } } override operator fun get(idx: Int): Boolean { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_get)(it, idx) } ).asBoolean() } override fun plus(other: Boolean) { this.append(other) } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } } fun booleanVariantArrayOf(vararg elements: Boolean): BoolVariantArray { return BoolVariantArray().also { for (arg in elements) { it.append(arg) } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/primitive/IntVariantArray.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_array import godot.internal.type.NaturalT import godot.internal.type.nullSafe import godot.internal.type.toNaturalT import kotlinx.cinterop.* class IntVariantArray : GodotArray { //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new)(it) } } constructor(other: IntVariantArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_copy)(it, other._handle.ptr) } } constructor(other: PoolByteArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_byte_array)(it, other._handle.ptr) } } constructor(other: PoolIntArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_int_array)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@IntVariantArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //API override fun append(value: NaturalT) { return callNative { nullSafe(Godot.gdnative.godot_array_append)(it, value.toVariant()._handle.ptr) } } override fun bsearch(value: NaturalT, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch)(it, value.toVariant()._handle.ptr, before) } } override fun bsearchCustom(value: NaturalT, obj: Object, func: String, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch_custom)( it, value.toVariant()._handle.ptr, obj.ptr, func.toGDString().value.ptr, before ) } } override fun count(value: NaturalT): Int { return callNative { nullSafe(Godot.gdnative.godot_array_count)(it, value.toVariant()._handle.ptr) } } override fun duplicate(deep: Boolean): IntVariantArray { return IntVariantArray( callNative { nullSafe(Godot.gdnative11.godot_array_duplicate)(it, deep) } ) } override fun erase(value: NaturalT) { callNative { nullSafe(Godot.gdnative.godot_array_erase)(it, value.toVariant()._handle.ptr) } } override fun find(what: NaturalT, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find)(it, what.toVariant()._handle.ptr, from) } } override fun findLast(value: NaturalT): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find_last)(it, value.toVariant()._handle.ptr) } } override fun front(): NaturalT { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_front)(it) } ).asLong().toNaturalT() } override fun has(value: NaturalT): Boolean { return callNative { nullSafe(Godot.gdnative.godot_array_has)(it, value.toVariant()._handle.ptr) } } override fun insert(position: Int, value: NaturalT) { return callNative { nullSafe(Godot.gdnative.godot_array_insert)(it, position, value.toVariant()._handle.ptr) } } override fun max(): NaturalT { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_max)(it) } ).asLong().toNaturalT() } override fun min(): NaturalT { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_min)(it) } ).asInt().toNaturalT() } override fun popBack(): NaturalT { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_back)(it) } ).asInt().toNaturalT() } override fun popFront(): NaturalT { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_front)(it) } ).asInt().toNaturalT() } override fun pushBack(value: NaturalT) { return callNative { nullSafe(Godot.gdnative.godot_array_push_back)(it, value.toVariant()._handle.ptr) } } override fun pushFront(value: NaturalT) { return callNative { nullSafe(Godot.gdnative.godot_array_push_front)(it, value.toVariant()._handle.ptr) } } override fun rfind(what: NaturalT, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_rfind)(it, what.toVariant()._handle.ptr, from) } } override fun slice(begin: Int, end: Int, step: Int, deep: Boolean): IntVariantArray { return IntVariantArray( callNative { nullSafe(Godot.gdnative12.godot_array_slice)( it, begin, end, step, deep ) } ) } //UTILITIES override operator fun set(idx: Int, data: NaturalT) { callNative { nullSafe(Godot.gdnative.godot_array_set)(it, idx, Variant(data)._handle.ptr) } } override operator fun get(idx: Int): NaturalT { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_get)(it, idx) } ).asInt().toNaturalT() } override fun plus(other: NaturalT) { this.append(other) } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } } fun intVariantArrayOf(vararg elements: NaturalT): IntVariantArray { return IntVariantArray().also { for (arg in elements) { it.append(arg) } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/primitive/RealVariantArray.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_array import godot.internal.type.RealT import godot.internal.type.nullSafe import godot.internal.type.toRealT import kotlinx.cinterop.* class RealVariantArray : GodotArray { //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new)(it) } } constructor(other: RealVariantArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_copy)(it, other._handle.ptr) } } constructor(other: PoolRealArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_real_array)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@RealVariantArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //API override fun append(value: RealT) { callNative { nullSafe(Godot.gdnative.godot_array_append)(it, value.toVariant()._handle.ptr) } } override fun bsearch(value: RealT, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch)(it, value.toVariant()._handle.ptr, before) } } override fun bsearchCustom(value: RealT, obj: Object, func: String, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch_custom)( it, value.toVariant()._handle.ptr, obj.ptr, func.toGDString().value.ptr, before ) } } override fun count(value: RealT): Int { return callNative { nullSafe(Godot.gdnative.godot_array_count)(it, value.toVariant()._handle.ptr) } } override fun duplicate(deep: Boolean): RealVariantArray { return RealVariantArray( callNative { nullSafe(Godot.gdnative11.godot_array_duplicate)(it, deep) } ) } override fun erase(value: RealT) { callNative { nullSafe(Godot.gdnative.godot_array_erase)(it, value.toVariant()._handle.ptr) } } override fun find(what: RealT, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find)(it, what.toVariant()._handle.ptr, from) } } override fun findLast(value: RealT): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find_last)(it, value.toVariant()._handle.ptr) } } override fun front(): RealT { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_front)(it) } ).asDouble().toRealT() } override fun has(value: RealT): Boolean { return callNative { nullSafe(Godot.gdnative.godot_array_has)(it, value.toVariant()._handle.ptr) } } override fun insert(position: Int, value: RealT) { return callNative { nullSafe(Godot.gdnative.godot_array_insert)(it, position, value.toVariant()._handle.ptr) } } override fun max(): RealT { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_max)(it) } ).asDouble().toRealT() } override fun min(): RealT { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_min)(it) } ).asDouble().toRealT() } override fun popBack(): RealT { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_back)(it) } ).asDouble().toRealT() } override fun popFront(): RealT { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_front)(it) } ).asDouble().toRealT() } override fun pushBack(value: RealT) { return callNative { nullSafe(Godot.gdnative.godot_array_push_back)(it, value.toVariant()._handle.ptr) } } override fun pushFront(value: RealT) { return callNative { nullSafe(Godot.gdnative.godot_array_push_front)(it, value.toVariant()._handle.ptr) } } override fun rfind(what: RealT, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_rfind)(it, what.toVariant()._handle.ptr, from) } } override fun slice(begin: Int, end: Int, step: Int, deep: Boolean): RealVariantArray { return RealVariantArray( callNative { nullSafe(Godot.gdnative12.godot_array_slice)( it, begin, end, step, deep ) } ) } //UTILITIES override operator fun set(idx: Int, data: RealT) { callNative { nullSafe(Godot.gdnative.godot_array_set)(it, idx, Variant(data)._handle.ptr) } } override operator fun get(idx: Int): RealT { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_get)(it, idx) } ).asDouble().toRealT() } override fun plus(other: RealT) { this.append(other) } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } } fun realVariantArrayOf(vararg elements: RealT): RealVariantArray { return RealVariantArray().also { for (arg in elements) { it.append(arg) } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/array/primitive/StringVariantArray.kt ================================================ package godot.core import godot.Object import godot.gdnative.godot_array import godot.internal.type.nullSafe import kotlinx.cinterop.* class StringVariantArray : GodotArray { //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new)(it) } } constructor(other: StringVariantArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_copy)(it, other._handle.ptr) } } constructor(other: PoolStringArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_array_new_pool_string_array)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@StringVariantArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //API override fun append(value: String) { callNative { nullSafe(Godot.gdnative.godot_array_append)(it, value.toVariant()._handle.ptr) } } override fun bsearch(value: String, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch)(it, value.toVariant()._handle.ptr, before) } } override fun bsearchCustom(value: String, obj: Object, func: String, before: Boolean): Int { return callNative { nullSafe(Godot.gdnative.godot_array_bsearch_custom)( it, value.toVariant()._handle.ptr, obj.ptr, func.toGDString().value.ptr, before ) } } override fun count(value: String): Int { return callNative { nullSafe(Godot.gdnative.godot_array_count)(it, value.toVariant()._handle.ptr) } } override fun duplicate(deep: Boolean): StringVariantArray { return StringVariantArray( callNative { nullSafe(Godot.gdnative11.godot_array_duplicate)(it, deep) } ) } override fun erase(value: String) { callNative { nullSafe(Godot.gdnative.godot_array_erase)(it, value.toVariant()._handle.ptr) } } override fun find(what: String, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find)(it, what.toVariant()._handle.ptr, from) } } override fun findLast(value: String): Int { return callNative { nullSafe(Godot.gdnative.godot_array_find_last)(it, value.toVariant()._handle.ptr) } } override fun front(): String { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_front)(it) } ).asString() } override fun has(value: String): Boolean { return callNative { nullSafe(Godot.gdnative.godot_array_has)(it, value.toVariant()._handle.ptr) } } override fun insert(position: Int, value: String) { return callNative { nullSafe(Godot.gdnative.godot_array_insert)(it, position, value.toVariant()._handle.ptr) } } override fun max(): String { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_max)(it) } ).asString() } override fun min(): String { return Variant( callNative { nullSafe(Godot.gdnative11.godot_array_min)(it) } ).asString() } override fun popBack(): String { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_back)(it) } ).asString() } override fun popFront(): String { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_pop_front)(it) } ).asString() } override fun pushBack(value: String) { return callNative { nullSafe(Godot.gdnative.godot_array_push_back)(it, value.toVariant()._handle.ptr) } } override fun pushFront(value: String) { return callNative { nullSafe(Godot.gdnative.godot_array_push_front)(it, value.toVariant()._handle.ptr) } } override fun rfind(what: String, from: Int): Int { return callNative { nullSafe(Godot.gdnative.godot_array_rfind)(it, what.toVariant()._handle.ptr, from) } } override fun slice(begin: Int, end: Int, step: Int, deep: Boolean): StringVariantArray { return StringVariantArray( callNative { nullSafe(Godot.gdnative12.godot_array_slice)( it, begin, end, step, deep ) } ) } //UTILITIES override operator fun set(idx: Int, data: String) { callNative { nullSafe(Godot.gdnative.godot_array_set)(it, idx, Variant(data)._handle.ptr) } } override operator fun get(idx: Int): String { return Variant( callNative { nullSafe(Godot.gdnative.godot_array_get)(it, idx) } ).asString() } override fun plus(other: String) { this.append(other) } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } } fun stringVariantArrayOf(vararg elements: String): StringVariantArray { return StringVariantArray().also { for (arg in elements) { it.append(arg) } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/pool/PoolByteArray.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_pool_byte_array_layout import godot.internal.type.* import kotlinx.cinterop.* class PoolByteArray : NativeCoreType, Iterable { //PROPERTIES val size: Int get() = this.size() //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_new)(it) } } constructor(other: PoolByteArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_new_copy)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@PoolByteArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //POOL ARRAY API SHARED /** * Appends an element at the end of the array (alias of push_back). */ fun append(byte: UByte) { callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_append)(it, byte) } } /** * Appends a PoolByteArray at the end of this array. */ fun appendArray(array: PoolByteArray) { callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_append_array)(it, array._handle.ptr) } } /** * Returns true if the array is empty. */ fun empty() { callNative { nullSafe(Godot.gdnative12.godot_pool_byte_array_empty)(it) } } /** * Retrieve the element at the given index. */ operator fun get(idx: Int): UByte { return callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_get)(it, idx) } } /** * Inserts a new element at a given position in the array. * The position must be valid, or at the end of the array (idx == size()). */ fun insert(idx: Int, data: UByte) { callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_insert)(it, idx, data) } } /** * Reverses the order of the elements in the array. */ fun invert() { callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_invert)(it) } } /** * Appends a value to the array. */ fun pushBack(data: UByte) { callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_push_back)(it, data) } } /** * Removes an element from the array by index. */ fun remove(idx: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_remove)(it, idx) } } /** * Sets the size of the array. If the array is grown, reserves elements at the end of the array. * If the array is shrunk, truncates the array to the new size. */ fun resize(size: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_resize)(it, size) } } /** * Changes the Byte at the given index. */ operator fun set(idx: Int, data: UByte) { callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_set)(it, idx, data) } } /** * Returns the size of the array. */ fun size(): Int { return callNative { nullSafe(Godot.gdnative.godot_pool_byte_array_size)(it) } } //POOL ARRAY UNIQUE API /** * Not available in the Gdnative API and no workaround for now */ private fun compress(compressionMode: Int = 0): PoolByteArray { throw NotImplementedError("Not available in the Gdnative API and no workaround for now") } /** * Not available in the Gdnative API and no workaround for now */ private fun decompress(bufferSize: Int, compressionMode: Int = 0): PoolByteArray { throw NotImplementedError("Not available in the Gdnative API and no workaround for now") } /** * Not available in the Gdnative API and no workaround for now */ private fun getStringFromAscii(): String { throw NotImplementedError("Not available in the Gdnative API and no workaround for now") } /** * Not available in the Gdnative API and no workaround for now */ private fun getStringFromUtf8(): String { throw NotImplementedError("Not available in the Gdnative API and no workaround for now") } //UTILITIES override fun toVariant() = Variant(this) operator fun plus(other: UByte) { this.append(other) } operator fun plus(other: PoolByteArray) { this.appendArray(other) } override fun toString(): String { return "PoolByteArray(${size()})" } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } /** * WARNING: no equals function is available in the Gdnative API for this Coretype. * This methods implementation works but is not the fastest one. */ override fun equals(other: Any?): Boolean { return if (other is PoolByteArray) { val list1 = this.toList() val list2 = other.toList() list1 == list2 } else { false } } override fun hashCode(): Int { return _handle.hashCode() } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/pool/PoolColorArray.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_pool_color_array_layout import godot.internal.type.* import kotlinx.cinterop.* class PoolColorArray : NativeCoreType, Iterable { //PROPERTIES val size: Int get() = this.size() //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_color_array_new)(it) } } internal constructor(native: CValue) { memScoped { this@PoolColorArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //POOL ARRAY API SHARED /** * Appends an element at the end of the array (alias of push_back). */ fun append(color: Color) { callNative { nullSafe(Godot.gdnative.godot_pool_color_array_append)(it, color.getRawMemory(this).reinterpret()) } } /** * Appends a PoolColorArray at the end of this array. */ fun appendArray(array: PoolColorArray) { callNative { nullSafe(Godot.gdnative.godot_pool_color_array_append_array)(it, array._handle.ptr) } } /** * Returns true if the array is empty. */ fun empty() { callNative { nullSafe(Godot.gdnative12.godot_pool_color_array_empty)(it) } } /** * Retrieve the element at the given index. */ operator fun get(idx: Int): Color { return Color( callNative { nullSafe(Godot.gdnative.godot_pool_color_array_get)(it, idx) } ) } /** * Inserts a new element at a given position in the array. * The position must be valid, or at the end of the array (idx == size()). */ fun insert(idx: Int, data: Color) { callNative { nullSafe(Godot.gdnative.godot_pool_color_array_insert)(it, idx, data.getRawMemory(this).reinterpret()) } } /** * Reverses the order of the elements in the array. */ fun invert() { callNative { nullSafe(Godot.gdnative.godot_pool_color_array_invert)(it) } } /** * Appends a value to the array. */ fun pushBack(data: Color) { callNative { nullSafe(Godot.gdnative.godot_pool_color_array_push_back)(it, data.getRawMemory(this).reinterpret()) } } /** * Removes an element from the array by index. */ fun remove(idx: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_color_array_remove)(it, idx) } } /** * Sets the size of the array. If the array is grown, reserves elements at the end of the array. * If the array is shrunk, truncates the array to the new size. */ fun resize(size: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_color_array_resize)(it, size) } } /** * Changes the color at the given index. */ operator fun set(idx: Int, data: Color) { callNative { nullSafe(Godot.gdnative.godot_pool_color_array_set)(it, idx, data.getRawMemory(this).reinterpret()) } } /** * Returns the size of the array. */ fun size(): Int { return callNative { nullSafe(Godot.gdnative.godot_pool_color_array_size)(it) } } //UTILITIES override fun toVariant() = Variant(this) operator fun plus(other: Color) { this.append(other) } operator fun plus(other: PoolColorArray) { this.appendArray(other) } override fun toString(): String { return "PoolColorArray(${size()})" } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } /** * WARNING: no equals function is available in the Gdnative API for this Coretype. * This methods implementation works but is not the fastest one. */ override fun equals(other: Any?): Boolean { return if (other is PoolColorArray) { val list1 = this.toList() val list2 = other.toList() list1 == list2 } else { false } } override fun hashCode(): Int { return _handle.hashCode() } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/pool/PoolIntArray.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_pool_int_array_layout import godot.internal.type.* import kotlinx.cinterop.* class PoolIntArray : NativeCoreType, Iterable { //PROPERTIES val size: Int get() = this.size() //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_int_array_new)(it) } } internal constructor(native: CValue) { memScoped { this@PoolIntArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //POOL ARRAY API SHARED /** * Appends an element at the end of the array (alias of push_back). */ fun append(i: NaturalT) { callNative { nullSafe(Godot.gdnative.godot_pool_int_array_append)(it, i.toGodotNatural()) } } /** * Appends a PoolIntArray at the end of this array. */ fun appendArray(array: PoolIntArray) { callNative { nullSafe(Godot.gdnative.godot_pool_int_array_append_array)(it, array._handle.ptr) } } /** * Returns true if the array is empty. */ fun empty() { callNative { nullSafe(Godot.gdnative12.godot_pool_int_array_empty)(it) } } /** * Retrieve the element at the given index. */ operator fun get(idx: Int): NaturalT { return callNative { nullSafe(Godot.gdnative.godot_pool_int_array_get)(it, idx).toNaturalT() } } /** * Inserts a new element at a given position in the array. * The position must be valid, or at the end of the array (idx == size()). */ fun insert(idx: Int, data: NaturalT) { callNative { nullSafe(Godot.gdnative.godot_pool_int_array_insert)(it, idx, data.toGodotNatural()) } } /** * Reverses the order of the elements in the array. */ fun invert() { callNative { nullSafe(Godot.gdnative.godot_pool_int_array_invert)(it) } } /** * Appends a value to the array. */ fun pushBack(data: NaturalT) { callNative { nullSafe(Godot.gdnative.godot_pool_int_array_push_back)(it, data.toGodotNatural()) } } /** * Removes an element from the array by index. */ fun remove(idx: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_int_array_remove)(it, idx) } } /** * Sets the size of the array. If the array is grown, reserves elements at the end of the array. * If the array is shrunk, truncates the array to the new size. */ fun resize(size: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_int_array_resize)(it, size) } } /** * Changes the integer at the given index. */ operator fun set(idx: Int, data: NaturalT) { callNative { nullSafe(Godot.gdnative.godot_pool_int_array_set)(it, idx, data.toGodotNatural()) } } /** * Returns the size of the array. */ fun size(): Int { return callNative { nullSafe(Godot.gdnative.godot_pool_int_array_size)(it) } } //UTILITIES override fun toVariant() = Variant(this) operator fun plus(other: NaturalT) { this.append(other) } operator fun plus(other: PoolIntArray) { this.appendArray(other) } override fun toString(): String { return "PoolIntArray(${size()})" } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } /** * WARNING: no equals function is available in the Gdnative API for this Coretype. * This methods implementation works but is not the fastest one. */ override fun equals(other: Any?): Boolean { return if (other is PoolIntArray) { val list1 = this.toList() val list2 = other.toList() list1 == list2 } else { false } } override fun hashCode(): Int { return _handle.hashCode() } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/pool/PoolRealArray.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_pool_real_array_layout import godot.internal.type.* import kotlinx.cinterop.* class PoolRealArray : NativeCoreType, Iterable { //PROPERTIES val size: Int get() = this.size() //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_real_array_new)(it) } } internal constructor(native: CValue) { memScoped { this@PoolRealArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //POOL ARRAY API SHARED /** * Appends an element at the end of the array (alias of push_back). */ fun append(real: RealT) { callNative { nullSafe(Godot.gdnative.godot_pool_real_array_append)(it, real.toFloat()) } } /** * Appends a PoolRealArray at the end of this array. */ fun appendArray(array: PoolRealArray) { callNative { nullSafe(Godot.gdnative.godot_pool_real_array_append_array)(it, array._handle.ptr) } } /** * Returns true if the array is empty. */ fun empty() { callNative { nullSafe(Godot.gdnative12.godot_pool_real_array_empty)(it) } } /** * Retrieve the element at the given index. */ operator fun get(idx: Int): RealT { return callNative { nullSafe(Godot.gdnative.godot_pool_real_array_get)(it, idx) }.toRealT() } /** * Inserts a new element at a given position in the array. * The position must be valid, or at the end of the array (idx == size()). */ fun insert(idx: Int, data: RealT) { callNative { nullSafe(Godot.gdnative.godot_pool_real_array_insert)(it, idx, data.toFloat()) } } /** * Reverses the order of the elements in the array. */ fun invert() { callNative { nullSafe(Godot.gdnative.godot_pool_real_array_invert)(it) } } /** * Appends a value to the array. */ fun pushBack(data: RealT) { callNative { nullSafe(Godot.gdnative.godot_pool_real_array_push_back)(it, data.toFloat()) } } /** * Removes an element from the array by index. */ fun remove(idx: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_real_array_remove)(it, idx) } } /** * Sets the size of the array. If the array is grown, reserves elements at the end of the array. * If the array is shrunk, truncates the array to the new size. */ fun resize(size: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_real_array_resize)(it, size) } } /** * Changes the real at the given index. */ operator fun set(idx: Int, data: RealT) { callNative { nullSafe(Godot.gdnative.godot_pool_real_array_set)(it, idx, data.toFloat()) } } /** * Returns the size of the array. */ fun size(): Int { return callNative { nullSafe(Godot.gdnative.godot_pool_real_array_size)(it) } } //UTILITIES override fun toVariant() = Variant(this) operator fun plus(other: RealT) { this.append(other) } operator fun plus(other: PoolRealArray) { this.appendArray(other) } override fun toString(): String { return "PoolRealArray(${size()})" } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } /** * WARNING: no equals function is available in the Gdnative API for this Coretype. * This methods implementation works but is not the fastest one. */ override fun equals(other: Any?): Boolean { return if (other is PoolRealArray) { val list1 = this.toList() val list2 = other.toList() list1 == list2 } else { false } } override fun hashCode(): Int { return _handle.hashCode() } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/pool/PoolStringArray.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_pool_string_array_layout import godot.internal.type.* import kotlinx.cinterop.* class PoolStringArray : NativeCoreType, Iterable { //PROPERTIES val size: Int get() = this.size() //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_string_array_new)(it) } } constructor(other: PoolStringArray) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_string_array_new_copy)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@PoolStringArray.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //POOL ARRAY API SHARED /** * Appends an element at the end of the array (alias of push_back). */ fun append(s: String) { callNative { nullSafe(Godot.gdnative.godot_pool_string_array_append)(it, s.toGDString().value.ptr) } } /** * Appends a PoolStringlArray at the end of this array. */ fun appendArray(array: PoolStringArray) { callNative { nullSafe(Godot.gdnative.godot_pool_string_array_append_array)(it, array._handle.ptr) } } /** * Returns true if the array is empty. */ fun empty() { callNative { nullSafe(Godot.gdnative12.godot_pool_string_array_empty)(it) } } /** * Retrieve the element at the given index. */ operator fun get(idx: Int): String { return callNative { GdString(nullSafe(Godot.gdnative.godot_pool_string_array_get)(it, idx)) }.toKString() } /** * Inserts a new element at a given position in the array. * The position must be valid, or at the end of the array (idx == size()). */ fun insert(idx: Int, data: String) { callNative { nullSafe(Godot.gdnative.godot_pool_string_array_insert)(it, idx, data.toGDString().value.ptr) } } /** * Reverses the order of the elements in the array. */ fun invert() { callNative { nullSafe(Godot.gdnative.godot_pool_string_array_invert)(it) } } /** * Appends a value to the array. */ fun pushBack(data: String) { callNative { nullSafe(Godot.gdnative.godot_pool_string_array_push_back)(it, data.toGDString().value.ptr) } } /** * Removes an element from the array by index. */ fun remove(idx: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_string_array_remove)(it, idx) } } /** * Sets the size of the array. If the array is grown, reserves elements at the end of the array. * If the array is shrunk, truncates the array to the new size. */ fun resize(size: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_string_array_resize)(it, size) } } /** * Changes the s at the given index. */ operator fun set(idx: Int, data: String) { callNative { nullSafe(Godot.gdnative.godot_pool_string_array_set)(it, idx, data.toGDString().value.ptr) } } /** * Returns the size of the array. */ fun size(): Int { return callNative { nullSafe(Godot.gdnative.godot_pool_string_array_size)(it) } } //UTILITIES override fun toVariant() = Variant(this) operator fun plus(other: String) { this.append(other) } operator fun plus(other: PoolStringArray) { this.appendArray(other) } override fun toString(): String { return "PoolStringArray(${size()})" } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } /** * WARNING: no equals function is available in the Gdnative API for this Coretype. * This methods implementation works but is not the fastest one. */ override fun equals(other: Any?): Boolean { return if (other is PoolStringArray) { val list1 = this.toList() val list2 = other.toList() list1 == list2 } else { false } } override fun hashCode(): Int { return _handle.hashCode() } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/pool/PoolVector2Array.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_pool_vector2_array_layout import godot.internal.type.* import kotlinx.cinterop.* class PoolVector2Array : NativeCoreType, Iterable { //PROPERTIES val size: Int get() = this.size() //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_new)(it) } } constructor(other: PoolVector2Array) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_new_copy)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@PoolVector2Array.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //POOL ARRAY API SHARED /** * Appends an element at the end of the array (alias of push_back). */ fun append(vector: Vector2) { callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_append)(it, vector.getRawMemory(this).reinterpret()) } } /** * Appends a PoolVector2Array at the end of this array. */ fun appendArray(array: PoolVector2Array) { callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_append_array)(it, array._handle.ptr) } } /** * Returns true if the array is empty. */ fun empty() { callNative { nullSafe(Godot.gdnative12.godot_pool_vector2_array_empty)(it) } } /** * Retrieve the element at the given index. */ operator fun get(idx: Int): Vector2 { return Vector2( callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_get)(it, idx) } ) } /** * Inserts a new element at a given position in the array. * The position must be valid, or at the end of the array (idx == size()). */ fun insert(idx: Int, data: Vector2) { callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_insert)(it, idx, data.getRawMemory(this).reinterpret()) } } /** * Reverses the order of the elements in the array. */ fun invert() { callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_invert)(it) } } /** * Appends a value to the array. */ fun pushBack(data: Vector2) { callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_push_back)(it, data.getRawMemory(this).reinterpret()) } } /** * Removes an element from the array by index. */ fun remove(idx: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_remove)(it, idx) } } /** * Sets the size of the array. If the array is grown, reserves elements at the end of the array. * If the array is shrunk, truncates the array to the new size. */ fun resize(size: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_resize)(it, size) } } /** * Changes the vector at the given index. */ operator fun set(idx: Int, data: Vector2) { callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_set)(it, idx, data.getRawMemory(this).reinterpret()) } } /** * Returns the size of the array. */ fun size(): Int { return callNative { nullSafe(Godot.gdnative.godot_pool_vector2_array_size)(it) } } //UTILITIES override fun toVariant() = Variant(this) operator fun plus(other: Vector2) { this.append(other) } operator fun plus(other: PoolVector2Array) { this.appendArray(other) } override fun toString(): String { return "PoolVector2Array(${size()})" } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } /** * WARNING: no equals function is available in the Gdnative API for this Coretype. * This methods implementation works but is not the fastest one. */ override fun equals(other: Any?): Boolean { return if (other is PoolVector2Array) { val list1 = this.toList() val list2 = other.toList() list1 == list2 } else { false } } override fun hashCode(): Int { return _handle.hashCode() } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/pool/PoolVector3Array.kt ================================================ @file:Suppress("unused", "MemberVisibilityCanBePrivate") package godot.core import godot.gdnative.godot_pool_vector3_array_layout import godot.internal.type.* import kotlinx.cinterop.* class PoolVector3Array : NativeCoreType, Iterable { //PROPERTIES val size: Int get() = this.size() //CONSTRUCTOR constructor() { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_new)(it) } } constructor(other: PoolVector3Array) { _handle = cValue{} callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_new_copy)(it, other._handle.ptr) } } internal constructor(native: CValue) { memScoped { this@PoolVector3Array.setRawMemory(native.ptr) } } internal constructor(mem: COpaquePointer) { this.setRawMemory(mem) } //INTEROP override fun getRawMemory(memScope: MemScope): COpaquePointer { return _handle.getPointer(memScope) } override fun setRawMemory(mem: COpaquePointer) { _handle = mem.reinterpret().pointed.readValue() } //POOL ARRAY API SHARED /** * Appends an element at the end of the array (alias of push_back). */ fun append(vector: Vector3) { callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_append)(it, vector.getRawMemory(this).reinterpret()) } } /** * Appends a PoolVector3Array at the end of this array. */ fun appendArray(array: PoolVector3Array) { callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_append_array)(it, array._handle.ptr) } } /** * Returns true if the array is empty. */ fun empty() { callNative { nullSafe(Godot.gdnative12.godot_pool_vector3_array_empty)(it) } } /** * Retrieve the element at the given index. */ operator fun get(idx: Int): Vector3 { return Vector3( callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_get)(it, idx) } ) } /** * Inserts a new element at a given position in the array. * The position must be valid, or at the end of the array (idx == size()). */ fun insert(idx: Int, data: Vector3) { callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_insert)(it, idx, data.getRawMemory(this).reinterpret()) } } /** * Reverses the order of the elements in the array. */ fun invert() { callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_invert)(it) } } /** * Appends a value to the array. */ fun pushBack(data: Vector3) { callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_push_back)(it, data.getRawMemory(this).reinterpret()) } } /** * Removes an element from the array by index. */ fun remove(idx: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_remove)(it, idx) } } /** * Sets the size of the array. If the array is grown, reserves elements at the end of the array. * If the array is shrunk, truncates the array to the new size. */ fun resize(size: Int) { callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_resize)(it, size) } } /** * Changes the vector at the given index. */ operator fun set(idx: Int, data: Vector3) { callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_set)(it, idx, data.getRawMemory(this).reinterpret()) } } /** * Returns the size of the array. */ fun size(): Int { return callNative { nullSafe(Godot.gdnative.godot_pool_vector3_array_size)(it) } } //UTILITIES override fun toVariant() = Variant(this) operator fun plus(other: Vector3) { this.append(other) } operator fun plus(other: PoolVector3Array) { this.appendArray(other) } override fun toString(): String { return "PoolVector3Array(${size()})" } override fun iterator(): Iterator { return IndexedIterator(size(), this::get) } /** * WARNING: no equals function is available in the Gdnative API for this Coretype. * This methods implementation works but is not the fastest one. */ override fun equals(other: Any?): Boolean { return if (other is PoolVector3Array) { val list1 = this.toList() val list2 = other.toList() list1 == list2 } else { false } } override fun hashCode(): Int { return _handle.hashCode() } internal inline fun callNative(block: MemScope.(CPointer) -> T): T { return callNative(this, block) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/string/File.kt ================================================ package godot.core import godot.internal.type.nullSafe import kotlinx.cinterop.invoke /** If the string is a valid file path, returns the base directory name. */ fun String.getBaseDir() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_get_base_dir)(it.value.ptr)).toKString() } /** If the string is a valid file path, returns the full file path without the extension. */ fun String.getBaseName() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_get_basename)(it.value.ptr)).toKString() } /** If the string is a valid file path, returns the extension. */ fun String.getExtension() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_get_extension)(it.value.ptr)).toKString() } /** If the string is a valid file path, returns the filename. */ fun String.getFile() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_get_file)(it.value.ptr)).toKString() } /** If the string is a path to a file or directory, returns true if the path is absolute. */ fun String.isAbsolutePath(): Boolean = asGDString { nullSafe(Godot.gdnative.godot_string_is_abs_path)(it.value.ptr) } /** If the string is a path to a file or directory, returns true if the path is relative. */ fun String.isRelativePath(): Boolean = asGDString { nullSafe(Godot.gdnative.godot_string_is_rel_path)(it.value.ptr) } /** Return true if the string is a path to a Godot resource. */ fun String.isResourceFile(): Boolean = asGDString { nullSafe(Godot.gdnative.godot_string_is_resource_file)(it.value.ptr) } /** Simplify the path if there is redundant relative paths inside. */ fun String.simplifyPath() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_simplify_path)(it.value.ptr)).toKString() } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/string/Hash.kt ================================================ package godot.core import godot.internal.type.nullSafe import kotlinx.cinterop.invoke /** Hashes the string and returns a 32-bit integer. */ fun String.hash() = asGDString { nullSafe(Godot.gdnative.godot_string_hash)(it.value.ptr).toInt() } /** Hashes the string and returns a 64-bit integer. */ fun String.hash64() = asGDString { nullSafe(Godot.gdnative.godot_string_hash64)(it.value.ptr).toLong() } /** Returns the MD5 hash of the string as an array of bytes. */ fun String.md5Buffer() = asGDString { PoolByteArray(nullSafe(Godot.gdnative.godot_string_md5_buffer)(it.value.ptr)) } /** Returns the MD5 hash of the string as a string. */ fun String.md5Text() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_md5_text)(it.value.ptr)).toKString() } /** Returns the SHA-256 hash of the string as an array of bytes. */ fun String.sha256Buffer() = asGDString { PoolByteArray(nullSafe(Godot.gdnative.godot_string_sha256_buffer)(it.value.ptr)) } /** Returns the SHA-256 hash of the string as a string. */ fun String.sha256Text() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_sha256_text)(it.value.ptr)).toKString() } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/string/UnEscape.kt ================================================ package godot.core import godot.internal.type.nullSafe import kotlinx.cinterop.invoke /** Returns a copy of the string with special characters escaped using the C language standard. */ fun String.cEscape() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_c_escape)(it.value.ptr)).toKString() } /** Returns a copy of the string with special characters escaped using the C language standard. */ fun String.cUnescapeMulti() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_c_escape_multiline)(it.value.ptr)).toKString() } /** Returns a copy of the string with escaped characters replaced by their meanings according to the C language standard. */ fun String.cUnescape() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_c_unescape)(it.value.ptr)).toKString() } /** Escapes (encodes) a string to URL friendly format. Also referred to as 'URL encode'. */ fun String.httpEscape() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_http_escape)(it.value.ptr)).toKString() } /** Unescapes (decodes) a string in URL encoded format. Also referred to as 'URL decode'. */ fun String.httpUnescape() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_http_unescape)(it.value.ptr)).toKString() } /** Returns a copy of the string with special characters escaped using the JSON standard. */ fun String.jsonEscape() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_json_escape)(it.value.ptr)).toKString() } /** Returns a copy of the string with special characters escaped using the XML standard.. */ fun String.xmlEscape() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_xml_escape)(it.value.ptr)).toKString() } /** Returns a copy of the string with special characters escaped using the XML standard. */ fun String.xlmEscapeWithQuotes() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_xml_escape_with_quotes)(it.value.ptr)).toKString() } /** Returns a copy of the string with escaped characters replaced by their meanings according to the XML standard. */ fun String.xmlUnescape() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_xml_unescape)(it.value.ptr)).toKString() } /** Decode a percent-encoded string. See percent_encode. */ fun String.percentDecode() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_percent_decode)(it.value.ptr)).toKString() } /** Percent-encodes a string. Encodes parameters in a URL when sending a HTTP GET request (and bodies of form-urlencoded POST requests). */ fun String.percentEncode() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_percent_encode)(it.value.ptr)).toKString() } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/string/Util.kt ================================================ package godot.core.type.string import godot.core.GdString import godot.core.Godot import godot.core.asGDString import godot.internal.type.nullSafe import godot.internal.type.toRealT import kotlinx.cinterop.invoke /** Returns the similarity index of the text compared to this string. 1 means totally similar and 0 means totally dissimilar. */ fun String.similarity(other: String) = asGDString { first -> other.asGDString { second -> nullSafe(Godot.gdnative.godot_string_similarity)(first.value.ptr, second.value.ptr).toRealT() } } /** Convert a CamelCase string to a Snake_Case one */ fun String.camelcaseToUnderscore() = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_camelcase_to_underscore)(it.value.ptr)).toKString() } /** Convert a CamelCase string to a snake_case one */ fun String.camelcaseToUnderscoreLowercased(other: String) = asGDString { GdString(nullSafe(Godot.gdnative.godot_string_camelcase_to_underscore_lowercased)(it.value.ptr)).toKString() } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/type/string/Validation.kt ================================================ package godot.core import godot.internal.type.nullSafe import kotlinx.cinterop.invoke /** Returns true if this string contains a valid float. */ fun String.isValidFloat(): Boolean = asGDString { nullSafe(Godot.gdnative.godot_string_is_valid_float)(it.value.ptr) } /** Returns true if this string contains a valid hexadecimal number. * If with_prefix is true, then a validity of the hexadecimal number is determined by 0x prefix, for instance: 0xDEADC0DE. * */ fun String.isValidHex(withPrefix: Boolean): Boolean = asGDString { nullSafe(Godot.gdnative.godot_string_is_valid_hex_number)(it.value.ptr, withPrefix) } /** Returns true if this string contains a valid color in hexadecimal HTML notation. * Other HTML notations such as named colors or hsl() colors aren't considered valid by this method and will return false. */ fun String.isValidHtmlColor(): Boolean = asGDString { nullSafe(Godot.gdnative.godot_string_is_valid_html_color)(it.value.ptr) } /** Returns true if this string is a valid identifier. * A valid identifier may contain only letters, digits and underscores (_) and the first character may not be a digit. */ fun String.isValidIdentifier(): Boolean = asGDString { nullSafe(Godot.gdnative.godot_string_is_valid_identifier)(it.value.ptr) } /** Returns true if this string contains a valid integer. */ fun String.isValidInteger(): Boolean = asGDString { nullSafe(Godot.gdnative.godot_string_is_valid_integer)(it.value.ptr) } /** Returns true if this string contains a valid IP address. */ fun String.isValidAdress(): Boolean = asGDString { nullSafe(Godot.gdnative.godot_string_is_valid_ip_address)(it.value.ptr) } ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/typealias.kt ================================================ package godot.core import godot.gdnative.godot_error typealias GodotError = godot_error ================================================ FILE: godot-kotlin/godot-library/src/nativeCore/kotlin/godot/core/variantTypeMapping.kt ================================================ @file:Suppress("EXPERIMENTAL_API_USAGE") package godot.core import godot.Object import godot.internal.type.CoreType import kotlin.reflect.KClass fun directConversionToVariant(obj: Any?) = obj?.let { Variant(obj) } ?: Variant() fun intToVariant(obj: Any?) = obj?.let { Variant((obj as Int).toLong()) } ?: Variant() fun floatToVariant(obj: Any?) = obj?.let { Variant((obj as Float).toDouble()) } ?: Variant() fun variantToVariant(obj: Any?) = obj?.let { obj as Variant } ?: Variant() fun coreTypeToVariant(obj: Any?) = obj?.let { (obj as CoreType).toVariant() } ?: Variant() @PublishedApi internal val typeToVariantConversionFunctions: Map, (Any?) -> Variant> = mapOf( Boolean::class to ::directConversionToVariant, Int::class to ::intToVariant, Long::class to ::directConversionToVariant, Float::class to ::floatToVariant, Double::class to ::directConversionToVariant, String::class to ::directConversionToVariant, CoreType::class to ::coreTypeToVariant, Variant::class to ::variantToVariant, Object::class to ::directConversionToVariant ) @PublishedApi internal val variantToTypeConversionFunctions: Map, (Variant) -> Any?> = mapOf( Boolean::class to Variant::asBoolean, Int::class to Variant::asInt, Long::class to Variant::asLong, Float::class to Variant::asFloat, Double::class to Variant::asDouble, String::class to Variant::asString, Vector2::class to Variant::asVector2, Rect2::class to Variant::asRect2, Vector3::class to Variant::asVector3, Transform2D::class to Variant::asTransform2D, Plane::class to Variant::asPlane, Quat::class to Variant::asQuat, AABB::class to Variant::asAABB, Basis::class to Variant::asBasis, Transform::class to Variant::asTransform, Color::class to Variant::asColor, NodePath::class to Variant::asNodePath, RID::class to Variant::asRID, Object::class to Variant::asObject, Dictionary::class to Variant::asDictionary, VariantArray::class to Variant::asVariantArray, BoolVariantArray::class to Variant::asBoolVariantArray, IntVariantArray::class to Variant::asIntVariantArray, RealVariantArray::class to Variant::asRealVariantArray, StringVariantArray::class to Variant::asStringVariantArray, AABBArray::class to Variant::asAABBArray, BasisArray::class to Variant::asBasisArray, ColorArray::class to Variant::asColorArray, NodePathArray::class to Variant::asNodePathArray, PlaneArray::class to Variant::asPlaneArray, QuatArray::class to Variant::asQuatArray, Rect2Array::class to Variant::asRect2Array, RIDArray::class to Variant::asRIDArray, Transform2DArray::class to Variant::asTransform2DArray, TransformArray::class to Variant::asTransformArray, Vector2Array::class to Variant::asVector2Array, Vector3Array::class to Variant::asVector3Array, PoolByteArray::class to Variant::asPoolByteArray, PoolIntArray::class to Variant::asPoolIntArray, PoolRealArray::class to Variant::asPoolRealArray, PoolStringArray::class to Variant::asPoolStringArray, PoolVector2Array::class to Variant::asPoolVector2Array, PoolVector3Array::class to Variant::asPoolVector3Array, PoolColorArray::class to Variant::asPoolColorArray ) ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ARVRAnchor.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Plane import godot.core.Signal1 import godot.core.Vector3 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Mesh import godot.icalls._icall_Plane import godot.icalls._icall_String import godot.icalls._icall_Unit_Long import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class ARVRAnchor : Spatial() { val meshUpdated: Signal1 by signal("mesh") open var anchorId: Long get() { val mb = getMethodBind("ARVRAnchor","get_anchor_id") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVRAnchor","set_anchor_id") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ARVRAnchor", "ARVRAnchor") open fun getAnchorId(): Long { val mb = getMethodBind("ARVRAnchor","get_anchor_id") return _icall_Long( mb, this.ptr) } open fun getAnchorName(): String { val mb = getMethodBind("ARVRAnchor","get_anchor_name") return _icall_String( mb, this.ptr) } open fun getIsActive(): Boolean { val mb = getMethodBind("ARVRAnchor","get_is_active") return _icall_Boolean( mb, this.ptr) } open fun getMesh(): Mesh { val mb = getMethodBind("ARVRAnchor","get_mesh") return _icall_Mesh( mb, this.ptr) } open fun getPlane(): Plane { val mb = getMethodBind("ARVRAnchor","get_plane") return _icall_Plane( mb, this.ptr) } open fun getSize(): Vector3 { val mb = getMethodBind("ARVRAnchor","get_size") return _icall_Vector3( mb, this.ptr) } open fun setAnchorId(anchorId: Long) { val mb = getMethodBind("ARVRAnchor","set_anchor_id") _icall_Unit_Long( mb, this.ptr, anchorId) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ARVRCamera.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class ARVRCamera : Camera() { override fun __new(): COpaquePointer = invokeConstructor("ARVRCamera", "ARVRCamera") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ARVRController.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.ARVRPositionalTracker import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Mesh import godot.icalls._icall_String import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class ARVRController : Spatial() { val buttonPressed: Signal1 by signal("button") val buttonRelease: Signal1 by signal("button") val meshUpdated: Signal1 by signal("mesh") open var controllerId: Long get() { val mb = getMethodBind("ARVRController","get_controller_id") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVRController","set_controller_id") _icall_Unit_Long(mb, this.ptr, value) } open var rumble: Double get() { val mb = getMethodBind("ARVRController","get_rumble") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVRController","set_rumble") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ARVRController", "ARVRController") open fun getControllerId(): Long { val mb = getMethodBind("ARVRController","get_controller_id") return _icall_Long( mb, this.ptr) } open fun getControllerName(): String { val mb = getMethodBind("ARVRController","get_controller_name") return _icall_String( mb, this.ptr) } open fun getHand(): ARVRPositionalTracker.TrackerHand { val mb = getMethodBind("ARVRController","get_hand") return ARVRPositionalTracker.TrackerHand.from( _icall_Long( mb, this.ptr)) } open fun getIsActive(): Boolean { val mb = getMethodBind("ARVRController","get_is_active") return _icall_Boolean( mb, this.ptr) } open fun getJoystickAxis(axis: Long): Double { val mb = getMethodBind("ARVRController","get_joystick_axis") return _icall_Double_Long( mb, this.ptr, axis) } open fun getJoystickId(): Long { val mb = getMethodBind("ARVRController","get_joystick_id") return _icall_Long( mb, this.ptr) } open fun getMesh(): Mesh { val mb = getMethodBind("ARVRController","get_mesh") return _icall_Mesh( mb, this.ptr) } open fun getRumble(): Double { val mb = getMethodBind("ARVRController","get_rumble") return _icall_Double( mb, this.ptr) } open fun isButtonPressed(button: Long): Long { val mb = getMethodBind("ARVRController","is_button_pressed") return _icall_Long_Long( mb, this.ptr, button) } open fun setControllerId(controllerId: Long) { val mb = getMethodBind("ARVRController","set_controller_id") _icall_Unit_Long( mb, this.ptr, controllerId) } open fun setRumble(rumble: Double) { val mb = getMethodBind("ARVRController","set_rumble") _icall_Unit_Double( mb, this.ptr, rumble) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ARVRInterface.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.ARVRInterface import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class ARVRInterface internal constructor() : Reference() { open var arIsAnchorDetectionEnabled: Boolean get() { val mb = getMethodBind("ARVRInterface","get_anchor_detection_is_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVRInterface","set_anchor_detection_is_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var interfaceIsInitialized: Boolean get() { val mb = getMethodBind("ARVRInterface","is_initialized") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVRInterface","set_is_initialized") _icall_Unit_Boolean(mb, this.ptr, value) } open var interfaceIsPrimary: Boolean get() { val mb = getMethodBind("ARVRInterface","is_primary") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVRInterface","set_is_primary") _icall_Unit_Boolean(mb, this.ptr, value) } open fun getAnchorDetectionIsEnabled(): Boolean { val mb = getMethodBind("ARVRInterface","get_anchor_detection_is_enabled") return _icall_Boolean( mb, this.ptr) } open fun getCameraFeedId(): Long { val mb = getMethodBind("ARVRInterface","get_camera_feed_id") return _icall_Long( mb, this.ptr) } open fun getCapabilities(): Long { val mb = getMethodBind("ARVRInterface","get_capabilities") return _icall_Long( mb, this.ptr) } open fun getName(): String { val mb = getMethodBind("ARVRInterface","get_name") return _icall_String( mb, this.ptr) } open fun getRenderTargetsize(): Vector2 { val mb = getMethodBind("ARVRInterface","get_render_targetsize") return _icall_Vector2( mb, this.ptr) } open fun getTrackingStatus(): ARVRInterface.Tracking_status { val mb = getMethodBind("ARVRInterface","get_tracking_status") return ARVRInterface.Tracking_status.from( _icall_Long( mb, this.ptr)) } open fun initialize(): Boolean { val mb = getMethodBind("ARVRInterface","initialize") return _icall_Boolean( mb, this.ptr) } open fun isInitialized(): Boolean { val mb = getMethodBind("ARVRInterface","is_initialized") return _icall_Boolean( mb, this.ptr) } open fun isPrimary(): Boolean { val mb = getMethodBind("ARVRInterface","is_primary") return _icall_Boolean( mb, this.ptr) } open fun isStereo(): Boolean { val mb = getMethodBind("ARVRInterface","is_stereo") return _icall_Boolean( mb, this.ptr) } open fun setAnchorDetectionIsEnabled(enable: Boolean) { val mb = getMethodBind("ARVRInterface","set_anchor_detection_is_enabled") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setIsInitialized(initialized: Boolean) { val mb = getMethodBind("ARVRInterface","set_is_initialized") _icall_Unit_Boolean( mb, this.ptr, initialized) } open fun setIsPrimary(enable: Boolean) { val mb = getMethodBind("ARVRInterface","set_is_primary") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun uninitialize() { val mb = getMethodBind("ARVRInterface","uninitialize") _icall_Unit( mb, this.ptr) } enum class Tracking_status( id: Long ) { ARVR_NORMAL_TRACKING(0), ARVR_EXCESSIVE_MOTION(1), ARVR_INSUFFICIENT_FEATURES(2), ARVR_UNKNOWN_TRACKING(3), ARVR_NOT_TRACKING(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Eyes( id: Long ) { EYE_MONO(0), EYE_LEFT(1), EYE_RIGHT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Capabilities( id: Long ) { ARVR_NONE(0), ARVR_MONO(1), ARVR_STEREO(2), ARVR_AR(4), ARVR_EXTERNAL(8); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ARVRInterfaceGDNative.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class ARVRInterfaceGDNative : ARVRInterface() { override fun __new(): COpaquePointer = invokeConstructor("ARVRInterfaceGDNative", "ARVRInterfaceGDNative") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ARVROrigin.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class ARVROrigin : Spatial() { open var worldScale: Double get() { val mb = getMethodBind("ARVROrigin","get_world_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVROrigin","set_world_scale") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ARVROrigin", "ARVROrigin") open fun getWorldScale(): Double { val mb = getMethodBind("ARVROrigin","get_world_scale") return _icall_Double( mb, this.ptr) } open fun setWorldScale(worldScale: Double) { val mb = getMethodBind("ARVROrigin","set_world_scale") _icall_Unit_Double( mb, this.ptr, worldScale) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ARVRPositionalTracker.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.ARVRPositionalTracker import godot.ARVRServer import godot.core.Basis import godot.core.Transform import godot.core.Vector3 import godot.icalls._icall_Basis import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Mesh import godot.icalls._icall_String import godot.icalls._icall_Transform_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class ARVRPositionalTracker : Object() { open var rumble: Double get() { val mb = getMethodBind("ARVRPositionalTracker","get_rumble") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVRPositionalTracker","set_rumble") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ARVRPositionalTracker", "ARVRPositionalTracker") open fun _setJoyId(joyId: Long) { } open fun _setMesh(mesh: Mesh) { } open fun _setName(name: String) { } open fun _setOrientation(orientation: Basis) { } open fun _setRwPosition(rwPosition: Vector3) { } open fun _setType(type: Long) { } open fun getHand(): ARVRPositionalTracker.TrackerHand { val mb = getMethodBind("ARVRPositionalTracker","get_hand") return ARVRPositionalTracker.TrackerHand.from( _icall_Long( mb, this.ptr)) } open fun getJoyId(): Long { val mb = getMethodBind("ARVRPositionalTracker","get_joy_id") return _icall_Long( mb, this.ptr) } open fun getMesh(): Mesh { val mb = getMethodBind("ARVRPositionalTracker","get_mesh") return _icall_Mesh( mb, this.ptr) } open fun getName(): String { val mb = getMethodBind("ARVRPositionalTracker","get_name") return _icall_String( mb, this.ptr) } open fun getOrientation(): Basis { val mb = getMethodBind("ARVRPositionalTracker","get_orientation") return _icall_Basis( mb, this.ptr) } open fun getPosition(): Vector3 { val mb = getMethodBind("ARVRPositionalTracker","get_position") return _icall_Vector3( mb, this.ptr) } open fun getRumble(): Double { val mb = getMethodBind("ARVRPositionalTracker","get_rumble") return _icall_Double( mb, this.ptr) } open fun getTrackerId(): Long { val mb = getMethodBind("ARVRPositionalTracker","get_tracker_id") return _icall_Long( mb, this.ptr) } open fun getTracksOrientation(): Boolean { val mb = getMethodBind("ARVRPositionalTracker","get_tracks_orientation") return _icall_Boolean( mb, this.ptr) } open fun getTracksPosition(): Boolean { val mb = getMethodBind("ARVRPositionalTracker","get_tracks_position") return _icall_Boolean( mb, this.ptr) } open fun getTransform(adjustByReferenceFrame: Boolean): Transform { val mb = getMethodBind("ARVRPositionalTracker","get_transform") return _icall_Transform_Boolean( mb, this.ptr, adjustByReferenceFrame) } open fun getType(): ARVRServer.TrackerType { val mb = getMethodBind("ARVRPositionalTracker","get_type") return ARVRServer.TrackerType.from( _icall_Long( mb, this.ptr)) } open fun setRumble(rumble: Double) { val mb = getMethodBind("ARVRPositionalTracker","set_rumble") _icall_Unit_Double( mb, this.ptr, rumble) } enum class TrackerHand( id: Long ) { TRACKER_HAND_UNKNOWN(0), TRACKER_LEFT_HAND(1), TRACKER_RIGHT_HAND(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ARVRServer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.core.Signal1 import godot.core.Signal3 import godot.core.Transform import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_ARVRInterface import godot.icalls._icall_ARVRInterface_Long import godot.icalls._icall_ARVRInterface_String import godot.icalls._icall_ARVRPositionalTracker_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Transform import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_VariantArray import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object ARVRServer : Object() { val interfaceAdded: Signal1 by signal("interface_name") val interfaceRemoved: Signal1 by signal("interface_name") val trackerAdded: Signal3 by signal("tracker_name", "type", "id") val trackerRemoved: Signal3 by signal("tracker_name", "type", "id") var primaryInterface: ARVRInterface get() { val mb = getMethodBind("ARVRServer","get_primary_interface") return _icall_ARVRInterface(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVRServer","set_primary_interface") _icall_Unit_Object(mb, this.ptr, value) } var worldScale: Double get() { val mb = getMethodBind("ARVRServer","get_world_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ARVRServer","set_world_scale") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("ARVRServer".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton ARVRServer" } ptr } fun centerOnHmd(rotationMode: Long, keepHeight: Boolean) { val mb = getMethodBind("ARVRServer","center_on_hmd") _icall_Unit_Long_Boolean( mb, this.ptr, rotationMode, keepHeight) } fun findInterface(name: String): ARVRInterface { val mb = getMethodBind("ARVRServer","find_interface") return _icall_ARVRInterface_String( mb, this.ptr, name) } fun getHmdTransform(): Transform { val mb = getMethodBind("ARVRServer","get_hmd_transform") return _icall_Transform( mb, this.ptr) } fun getInterface(idx: Long): ARVRInterface { val mb = getMethodBind("ARVRServer","get_interface") return _icall_ARVRInterface_Long( mb, this.ptr, idx) } fun getInterfaceCount(): Long { val mb = getMethodBind("ARVRServer","get_interface_count") return _icall_Long( mb, this.ptr) } fun getInterfaces(): VariantArray { val mb = getMethodBind("ARVRServer","get_interfaces") return _icall_VariantArray( mb, this.ptr) } fun getLastCommitUsec(): Long { val mb = getMethodBind("ARVRServer","get_last_commit_usec") return _icall_Long( mb, this.ptr) } fun getLastFrameUsec(): Long { val mb = getMethodBind("ARVRServer","get_last_frame_usec") return _icall_Long( mb, this.ptr) } fun getLastProcessUsec(): Long { val mb = getMethodBind("ARVRServer","get_last_process_usec") return _icall_Long( mb, this.ptr) } fun getPrimaryInterface(): ARVRInterface { val mb = getMethodBind("ARVRServer","get_primary_interface") return _icall_ARVRInterface( mb, this.ptr) } fun getReferenceFrame(): Transform { val mb = getMethodBind("ARVRServer","get_reference_frame") return _icall_Transform( mb, this.ptr) } fun getTracker(idx: Long): ARVRPositionalTracker { val mb = getMethodBind("ARVRServer","get_tracker") return _icall_ARVRPositionalTracker_Long( mb, this.ptr, idx) } fun getTrackerCount(): Long { val mb = getMethodBind("ARVRServer","get_tracker_count") return _icall_Long( mb, this.ptr) } fun getWorldScale(): Double { val mb = getMethodBind("ARVRServer","get_world_scale") return _icall_Double( mb, this.ptr) } fun setPrimaryInterface(_interface: ARVRInterface) { val mb = getMethodBind("ARVRServer","set_primary_interface") _icall_Unit_Object( mb, this.ptr, _interface) } fun setWorldScale(arg0: Double) { val mb = getMethodBind("ARVRServer","set_world_scale") _icall_Unit_Double( mb, this.ptr, arg0) } enum class RotationMode( id: Long ) { RESET_FULL_ROTATION(0), RESET_BUT_KEEP_TILT(1), DONT_RESET_ROTATION(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class TrackerType( id: Long ) { TRACKER_CONTROLLER(1), TRACKER_BASESTATION(2), TRACKER_ANCHOR(4), TRACKER_ANY_KNOWN(127), TRACKER_UNKNOWN(128), TRACKER_ANY(255); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AStar.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolIntArray import godot.core.PoolVector3Array import godot.core.VariantArray import godot.core.Vector3 import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_Long_Long_Boolean import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Vector3_Boolean import godot.icalls._icall_PoolIntArray_Long import godot.icalls._icall_PoolIntArray_Long_Long import godot.icalls._icall_PoolVector3Array_Long_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Long_Boolean import godot.icalls._icall_Unit_Long_Vector3 import godot.icalls._icall_Unit_Long_Vector3_Double import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector3_Long import godot.icalls._icall_Vector3_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class AStar : Reference() { override fun __new(): COpaquePointer = invokeConstructor("AStar", "AStar") open fun _computeCost(fromId: Long, toId: Long): Double { throw NotImplementedError("_compute_cost is not implemented for AStar") } open fun _estimateCost(fromId: Long, toId: Long): Double { throw NotImplementedError("_estimate_cost is not implemented for AStar") } open fun addPoint( id: Long, position: Vector3, weightScale: Double = 1.0 ) { val mb = getMethodBind("AStar","add_point") _icall_Unit_Long_Vector3_Double( mb, this.ptr, id, position, weightScale) } open fun arePointsConnected( id: Long, toId: Long, bidirectional: Boolean = true ): Boolean { val mb = getMethodBind("AStar","are_points_connected") return _icall_Boolean_Long_Long_Boolean( mb, this.ptr, id, toId, bidirectional) } open fun clear() { val mb = getMethodBind("AStar","clear") _icall_Unit( mb, this.ptr) } open fun connectPoints( id: Long, toId: Long, bidirectional: Boolean = true ) { val mb = getMethodBind("AStar","connect_points") _icall_Unit_Long_Long_Boolean( mb, this.ptr, id, toId, bidirectional) } open fun disconnectPoints( id: Long, toId: Long, bidirectional: Boolean = true ) { val mb = getMethodBind("AStar","disconnect_points") _icall_Unit_Long_Long_Boolean( mb, this.ptr, id, toId, bidirectional) } open fun getAvailablePointId(): Long { val mb = getMethodBind("AStar","get_available_point_id") return _icall_Long( mb, this.ptr) } open fun getClosestPoint(toPosition: Vector3, includeDisabled: Boolean = false): Long { val mb = getMethodBind("AStar","get_closest_point") return _icall_Long_Vector3_Boolean( mb, this.ptr, toPosition, includeDisabled) } open fun getClosestPositionInSegment(toPosition: Vector3): Vector3 { val mb = getMethodBind("AStar","get_closest_position_in_segment") return _icall_Vector3_Vector3( mb, this.ptr, toPosition) } open fun getIdPath(fromId: Long, toId: Long): PoolIntArray { val mb = getMethodBind("AStar","get_id_path") return _icall_PoolIntArray_Long_Long( mb, this.ptr, fromId, toId) } open fun getPointCapacity(): Long { val mb = getMethodBind("AStar","get_point_capacity") return _icall_Long( mb, this.ptr) } open fun getPointConnections(id: Long): PoolIntArray { val mb = getMethodBind("AStar","get_point_connections") return _icall_PoolIntArray_Long( mb, this.ptr, id) } open fun getPointCount(): Long { val mb = getMethodBind("AStar","get_point_count") return _icall_Long( mb, this.ptr) } open fun getPointPath(fromId: Long, toId: Long): PoolVector3Array { val mb = getMethodBind("AStar","get_point_path") return _icall_PoolVector3Array_Long_Long( mb, this.ptr, fromId, toId) } open fun getPointPosition(id: Long): Vector3 { val mb = getMethodBind("AStar","get_point_position") return _icall_Vector3_Long( mb, this.ptr, id) } open fun getPointWeightScale(id: Long): Double { val mb = getMethodBind("AStar","get_point_weight_scale") return _icall_Double_Long( mb, this.ptr, id) } open fun getPoints(): VariantArray { val mb = getMethodBind("AStar","get_points") return _icall_VariantArray( mb, this.ptr) } open fun hasPoint(id: Long): Boolean { val mb = getMethodBind("AStar","has_point") return _icall_Boolean_Long( mb, this.ptr, id) } open fun isPointDisabled(id: Long): Boolean { val mb = getMethodBind("AStar","is_point_disabled") return _icall_Boolean_Long( mb, this.ptr, id) } open fun removePoint(id: Long) { val mb = getMethodBind("AStar","remove_point") _icall_Unit_Long( mb, this.ptr, id) } open fun reserveSpace(numNodes: Long) { val mb = getMethodBind("AStar","reserve_space") _icall_Unit_Long( mb, this.ptr, numNodes) } open fun setPointDisabled(id: Long, disabled: Boolean = true) { val mb = getMethodBind("AStar","set_point_disabled") _icall_Unit_Long_Boolean( mb, this.ptr, id, disabled) } open fun setPointPosition(id: Long, position: Vector3) { val mb = getMethodBind("AStar","set_point_position") _icall_Unit_Long_Vector3( mb, this.ptr, id, position) } open fun setPointWeightScale(id: Long, weightScale: Double) { val mb = getMethodBind("AStar","set_point_weight_scale") _icall_Unit_Long_Double( mb, this.ptr, id, weightScale) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AStar2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolIntArray import godot.core.PoolVector2Array import godot.core.VariantArray import godot.core.Vector2 import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_Long_Long import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Vector2_Boolean import godot.icalls._icall_PoolIntArray_Long import godot.icalls._icall_PoolIntArray_Long_Long import godot.icalls._icall_PoolVector2Array_Long_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Long_Boolean import godot.icalls._icall_Unit_Long_Vector2 import godot.icalls._icall_Unit_Long_Vector2_Double import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector2_Long import godot.icalls._icall_Vector2_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class AStar2D : Reference() { override fun __new(): COpaquePointer = invokeConstructor("AStar2D", "AStar2D") open fun _computeCost(fromId: Long, toId: Long): Double { throw NotImplementedError("_compute_cost is not implemented for AStar2D") } open fun _estimateCost(fromId: Long, toId: Long): Double { throw NotImplementedError("_estimate_cost is not implemented for AStar2D") } open fun addPoint( id: Long, position: Vector2, weightScale: Double = 1.0 ) { val mb = getMethodBind("AStar2D","add_point") _icall_Unit_Long_Vector2_Double( mb, this.ptr, id, position, weightScale) } open fun arePointsConnected(id: Long, toId: Long): Boolean { val mb = getMethodBind("AStar2D","are_points_connected") return _icall_Boolean_Long_Long( mb, this.ptr, id, toId) } open fun clear() { val mb = getMethodBind("AStar2D","clear") _icall_Unit( mb, this.ptr) } open fun connectPoints( id: Long, toId: Long, bidirectional: Boolean = true ) { val mb = getMethodBind("AStar2D","connect_points") _icall_Unit_Long_Long_Boolean( mb, this.ptr, id, toId, bidirectional) } open fun disconnectPoints(id: Long, toId: Long) { val mb = getMethodBind("AStar2D","disconnect_points") _icall_Unit_Long_Long( mb, this.ptr, id, toId) } open fun getAvailablePointId(): Long { val mb = getMethodBind("AStar2D","get_available_point_id") return _icall_Long( mb, this.ptr) } open fun getClosestPoint(toPosition: Vector2, includeDisabled: Boolean = false): Long { val mb = getMethodBind("AStar2D","get_closest_point") return _icall_Long_Vector2_Boolean( mb, this.ptr, toPosition, includeDisabled) } open fun getClosestPositionInSegment(toPosition: Vector2): Vector2 { val mb = getMethodBind("AStar2D","get_closest_position_in_segment") return _icall_Vector2_Vector2( mb, this.ptr, toPosition) } open fun getIdPath(fromId: Long, toId: Long): PoolIntArray { val mb = getMethodBind("AStar2D","get_id_path") return _icall_PoolIntArray_Long_Long( mb, this.ptr, fromId, toId) } open fun getPointCapacity(): Long { val mb = getMethodBind("AStar2D","get_point_capacity") return _icall_Long( mb, this.ptr) } open fun getPointConnections(id: Long): PoolIntArray { val mb = getMethodBind("AStar2D","get_point_connections") return _icall_PoolIntArray_Long( mb, this.ptr, id) } open fun getPointCount(): Long { val mb = getMethodBind("AStar2D","get_point_count") return _icall_Long( mb, this.ptr) } open fun getPointPath(fromId: Long, toId: Long): PoolVector2Array { val mb = getMethodBind("AStar2D","get_point_path") return _icall_PoolVector2Array_Long_Long( mb, this.ptr, fromId, toId) } open fun getPointPosition(id: Long): Vector2 { val mb = getMethodBind("AStar2D","get_point_position") return _icall_Vector2_Long( mb, this.ptr, id) } open fun getPointWeightScale(id: Long): Double { val mb = getMethodBind("AStar2D","get_point_weight_scale") return _icall_Double_Long( mb, this.ptr, id) } open fun getPoints(): VariantArray { val mb = getMethodBind("AStar2D","get_points") return _icall_VariantArray( mb, this.ptr) } open fun hasPoint(id: Long): Boolean { val mb = getMethodBind("AStar2D","has_point") return _icall_Boolean_Long( mb, this.ptr, id) } open fun isPointDisabled(id: Long): Boolean { val mb = getMethodBind("AStar2D","is_point_disabled") return _icall_Boolean_Long( mb, this.ptr, id) } open fun removePoint(id: Long) { val mb = getMethodBind("AStar2D","remove_point") _icall_Unit_Long( mb, this.ptr, id) } open fun reserveSpace(numNodes: Long) { val mb = getMethodBind("AStar2D","reserve_space") _icall_Unit_Long( mb, this.ptr, numNodes) } open fun setPointDisabled(id: Long, disabled: Boolean = true) { val mb = getMethodBind("AStar2D","set_point_disabled") _icall_Unit_Long_Boolean( mb, this.ptr, id, disabled) } open fun setPointPosition(id: Long, position: Vector2) { val mb = getMethodBind("AStar2D","set_point_position") _icall_Unit_Long_Vector2( mb, this.ptr, id, position) } open fun setPointWeightScale(id: Long, weightScale: Double) { val mb = getMethodBind("AStar2D","set_point_weight_scale") _icall_Unit_Long_Double( mb, this.ptr, id, weightScale) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AcceptDialog.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Button import godot.icalls._icall_Button_String import godot.icalls._icall_Button_String_Boolean_String import godot.icalls._icall_Label import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.String import kotlinx.cinterop.COpaquePointer open class AcceptDialog : WindowDialog() { val confirmed: Signal0 by signal() val customAction: Signal1 by signal("action") open var dialogAutowrap: Boolean get() { val mb = getMethodBind("AcceptDialog","has_autowrap") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AcceptDialog","set_autowrap") _icall_Unit_Boolean(mb, this.ptr, value) } open var dialogHideOnOk: Boolean get() { val mb = getMethodBind("AcceptDialog","get_hide_on_ok") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AcceptDialog","set_hide_on_ok") _icall_Unit_Boolean(mb, this.ptr, value) } open var dialogText: String get() { val mb = getMethodBind("AcceptDialog","get_text") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AcceptDialog","set_text") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AcceptDialog", "AcceptDialog") open fun _builtinTextEntered(arg0: String) { } open fun _customAction(arg0: String) { } open fun _ok() { } open fun addButton( text: String, right: Boolean = false, action: String = "" ): Button { val mb = getMethodBind("AcceptDialog","add_button") return _icall_Button_String_Boolean_String( mb, this.ptr, text, right, action) } open fun addCancel(name: String): Button { val mb = getMethodBind("AcceptDialog","add_cancel") return _icall_Button_String( mb, this.ptr, name) } open fun getHideOnOk(): Boolean { val mb = getMethodBind("AcceptDialog","get_hide_on_ok") return _icall_Boolean( mb, this.ptr) } open fun getLabel(): Label { val mb = getMethodBind("AcceptDialog","get_label") return _icall_Label( mb, this.ptr) } open fun getOk(): Button { val mb = getMethodBind("AcceptDialog","get_ok") return _icall_Button( mb, this.ptr) } open fun getText(): String { val mb = getMethodBind("AcceptDialog","get_text") return _icall_String( mb, this.ptr) } open fun hasAutowrap(): Boolean { val mb = getMethodBind("AcceptDialog","has_autowrap") return _icall_Boolean( mb, this.ptr) } open fun registerTextEnter(lineEdit: Node) { val mb = getMethodBind("AcceptDialog","register_text_enter") _icall_Unit_Object( mb, this.ptr, lineEdit) } open fun setAutowrap(autowrap: Boolean) { val mb = getMethodBind("AcceptDialog","set_autowrap") _icall_Unit_Boolean( mb, this.ptr, autowrap) } open fun setHideOnOk(enabled: Boolean) { val mb = getMethodBind("AcceptDialog","set_hide_on_ok") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setText(text: String) { val mb = getMethodBind("AcceptDialog","set_text") _icall_Unit_String( mb, this.ptr, text) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimatedSprite.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_SpriteFrames import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Boolean import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class AnimatedSprite : Node2D() { val animationFinished: Signal0 by signal() val frameChanged: Signal0 by signal() open var animation: String get() { val mb = getMethodBind("AnimatedSprite","get_animation") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite","set_animation") _icall_Unit_String(mb, this.ptr, value) } open var centered: Boolean get() { val mb = getMethodBind("AnimatedSprite","is_centered") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite","set_centered") _icall_Unit_Boolean(mb, this.ptr, value) } open var flipH: Boolean get() { val mb = getMethodBind("AnimatedSprite","is_flipped_h") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite","set_flip_h") _icall_Unit_Boolean(mb, this.ptr, value) } open var flipV: Boolean get() { val mb = getMethodBind("AnimatedSprite","is_flipped_v") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite","set_flip_v") _icall_Unit_Boolean(mb, this.ptr, value) } open var frame: Long get() { val mb = getMethodBind("AnimatedSprite","get_frame") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite","set_frame") _icall_Unit_Long(mb, this.ptr, value) } open var frames: SpriteFrames get() { val mb = getMethodBind("AnimatedSprite","get_sprite_frames") return _icall_SpriteFrames(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite","set_sprite_frames") _icall_Unit_Object(mb, this.ptr, value) } open var offset: Vector2 get() { val mb = getMethodBind("AnimatedSprite","get_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite","set_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var speedScale: Double get() { val mb = getMethodBind("AnimatedSprite","get_speed_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite","set_speed_scale") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimatedSprite", "AnimatedSprite") open fun offset(schedule: Vector2.() -> Unit): Vector2 = offset.apply{ schedule(this) offset = this } open fun _isPlaying(): Boolean { throw NotImplementedError("_is_playing is not implemented for AnimatedSprite") } open fun _resChanged() { } open fun _setPlaying(playing: Boolean) { } open fun getAnimation(): String { val mb = getMethodBind("AnimatedSprite","get_animation") return _icall_String( mb, this.ptr) } open fun getFrame(): Long { val mb = getMethodBind("AnimatedSprite","get_frame") return _icall_Long( mb, this.ptr) } open fun getOffset(): Vector2 { val mb = getMethodBind("AnimatedSprite","get_offset") return _icall_Vector2( mb, this.ptr) } open fun getSpeedScale(): Double { val mb = getMethodBind("AnimatedSprite","get_speed_scale") return _icall_Double( mb, this.ptr) } open fun getSpriteFrames(): SpriteFrames { val mb = getMethodBind("AnimatedSprite","get_sprite_frames") return _icall_SpriteFrames( mb, this.ptr) } open fun isCentered(): Boolean { val mb = getMethodBind("AnimatedSprite","is_centered") return _icall_Boolean( mb, this.ptr) } open fun isFlippedH(): Boolean { val mb = getMethodBind("AnimatedSprite","is_flipped_h") return _icall_Boolean( mb, this.ptr) } open fun isFlippedV(): Boolean { val mb = getMethodBind("AnimatedSprite","is_flipped_v") return _icall_Boolean( mb, this.ptr) } open fun isPlaying(): Boolean { val mb = getMethodBind("AnimatedSprite","is_playing") return _icall_Boolean( mb, this.ptr) } open fun play(anim: String = "", backwards: Boolean = false) { val mb = getMethodBind("AnimatedSprite","play") _icall_Unit_String_Boolean( mb, this.ptr, anim, backwards) } open fun setAnimation(animation: String) { val mb = getMethodBind("AnimatedSprite","set_animation") _icall_Unit_String( mb, this.ptr, animation) } open fun setCentered(centered: Boolean) { val mb = getMethodBind("AnimatedSprite","set_centered") _icall_Unit_Boolean( mb, this.ptr, centered) } open fun setFlipH(flipH: Boolean) { val mb = getMethodBind("AnimatedSprite","set_flip_h") _icall_Unit_Boolean( mb, this.ptr, flipH) } open fun setFlipV(flipV: Boolean) { val mb = getMethodBind("AnimatedSprite","set_flip_v") _icall_Unit_Boolean( mb, this.ptr, flipV) } open fun setFrame(frame: Long) { val mb = getMethodBind("AnimatedSprite","set_frame") _icall_Unit_Long( mb, this.ptr, frame) } open fun setOffset(offset: Vector2) { val mb = getMethodBind("AnimatedSprite","set_offset") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun setSpeedScale(speedScale: Double) { val mb = getMethodBind("AnimatedSprite","set_speed_scale") _icall_Unit_Double( mb, this.ptr, speedScale) } open fun setSpriteFrames(spriteFrames: SpriteFrames) { val mb = getMethodBind("AnimatedSprite","set_sprite_frames") _icall_Unit_Object( mb, this.ptr, spriteFrames) } open fun stop() { val mb = getMethodBind("AnimatedSprite","stop") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimatedSprite3D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_SpriteFrames import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimatedSprite3D : SpriteBase3D() { val frameChanged: Signal0 by signal() open var animation: String get() { val mb = getMethodBind("AnimatedSprite3D","get_animation") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite3D","set_animation") _icall_Unit_String(mb, this.ptr, value) } open var frame: Long get() { val mb = getMethodBind("AnimatedSprite3D","get_frame") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite3D","set_frame") _icall_Unit_Long(mb, this.ptr, value) } open var frames: SpriteFrames get() { val mb = getMethodBind("AnimatedSprite3D","get_sprite_frames") return _icall_SpriteFrames(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedSprite3D","set_sprite_frames") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimatedSprite3D", "AnimatedSprite3D") open fun _isPlaying(): Boolean { throw NotImplementedError("_is_playing is not implemented for AnimatedSprite3D") } open fun _resChanged() { } open fun _setPlaying(playing: Boolean) { } open fun getAnimation(): String { val mb = getMethodBind("AnimatedSprite3D","get_animation") return _icall_String( mb, this.ptr) } open fun getFrame(): Long { val mb = getMethodBind("AnimatedSprite3D","get_frame") return _icall_Long( mb, this.ptr) } open fun getSpriteFrames(): SpriteFrames { val mb = getMethodBind("AnimatedSprite3D","get_sprite_frames") return _icall_SpriteFrames( mb, this.ptr) } open fun isPlaying(): Boolean { val mb = getMethodBind("AnimatedSprite3D","is_playing") return _icall_Boolean( mb, this.ptr) } open fun play(anim: String = "") { val mb = getMethodBind("AnimatedSprite3D","play") _icall_Unit_String( mb, this.ptr, anim) } open fun setAnimation(animation: String) { val mb = getMethodBind("AnimatedSprite3D","set_animation") _icall_Unit_String( mb, this.ptr, animation) } open fun setFrame(frame: Long) { val mb = getMethodBind("AnimatedSprite3D","set_frame") _icall_Unit_Long( mb, this.ptr, frame) } open fun setSpriteFrames(spriteFrames: SpriteFrames) { val mb = getMethodBind("AnimatedSprite3D","set_sprite_frames") _icall_Unit_Object( mb, this.ptr, spriteFrames) } open fun stop() { val mb = getMethodBind("AnimatedSprite3D","stop") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimatedTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Texture_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class AnimatedTexture : Texture() { open var currentFrame: Long get() { val mb = getMethodBind("AnimatedTexture","get_current_frame") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedTexture","set_current_frame") _icall_Unit_Long(mb, this.ptr, value) } open var fps: Double get() { val mb = getMethodBind("AnimatedTexture","get_fps") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedTexture","set_fps") _icall_Unit_Double(mb, this.ptr, value) } open var frame0_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var frame0_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 0, value) } open var frame1_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var frame1_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 1, value) } open var frame10_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 10, value) } open var frame10_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 10, value) } open var frame100_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 100) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 100, value) } open var frame100_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 100) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 100, value) } open var frame101_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 101) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 101, value) } open var frame101_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 101) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 101, value) } open var frame102_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 102) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 102, value) } open var frame102_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 102) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 102, value) } open var frame103_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 103) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 103, value) } open var frame103_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 103) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 103, value) } open var frame104_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 104) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 104, value) } open var frame104_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 104) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 104, value) } open var frame105_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 105) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 105, value) } open var frame105_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 105) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 105, value) } open var frame106_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 106) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 106, value) } open var frame106_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 106) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 106, value) } open var frame107_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 107) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 107, value) } open var frame107_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 107) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 107, value) } open var frame108_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 108) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 108, value) } open var frame108_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 108) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 108, value) } open var frame109_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 109) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 109, value) } open var frame109_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 109) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 109, value) } open var frame11_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 11, value) } open var frame11_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 11, value) } open var frame110_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 110) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 110, value) } open var frame110_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 110) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 110, value) } open var frame111_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 111) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 111, value) } open var frame111_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 111) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 111, value) } open var frame112_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 112) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 112, value) } open var frame112_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 112) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 112, value) } open var frame113_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 113) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 113, value) } open var frame113_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 113) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 113, value) } open var frame114_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 114) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 114, value) } open var frame114_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 114) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 114, value) } open var frame115_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 115) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 115, value) } open var frame115_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 115) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 115, value) } open var frame116_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 116) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 116, value) } open var frame116_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 116) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 116, value) } open var frame117_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 117) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 117, value) } open var frame117_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 117) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 117, value) } open var frame118_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 118) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 118, value) } open var frame118_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 118) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 118, value) } open var frame119_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 119) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 119, value) } open var frame119_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 119) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 119, value) } open var frame12_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 12) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 12, value) } open var frame12_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 12) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 12, value) } open var frame120_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 120) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 120, value) } open var frame120_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 120) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 120, value) } open var frame121_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 121) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 121, value) } open var frame121_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 121) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 121, value) } open var frame122_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 122) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 122, value) } open var frame122_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 122) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 122, value) } open var frame123_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 123) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 123, value) } open var frame123_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 123) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 123, value) } open var frame124_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 124) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 124, value) } open var frame124_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 124) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 124, value) } open var frame125_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 125) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 125, value) } open var frame125_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 125) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 125, value) } open var frame126_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 126) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 126, value) } open var frame126_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 126) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 126, value) } open var frame127_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 127) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 127, value) } open var frame127_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 127) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 127, value) } open var frame128_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 128) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 128, value) } open var frame128_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 128) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 128, value) } open var frame129_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 129) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 129, value) } open var frame129_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 129) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 129, value) } open var frame13_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 13, value) } open var frame13_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 13, value) } open var frame130_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 130) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 130, value) } open var frame130_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 130) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 130, value) } open var frame131_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 131) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 131, value) } open var frame131_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 131) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 131, value) } open var frame132_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 132) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 132, value) } open var frame132_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 132) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 132, value) } open var frame133_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 133) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 133, value) } open var frame133_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 133) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 133, value) } open var frame134_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 134) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 134, value) } open var frame134_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 134) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 134, value) } open var frame135_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 135) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 135, value) } open var frame135_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 135) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 135, value) } open var frame136_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 136) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 136, value) } open var frame136_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 136) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 136, value) } open var frame137_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 137) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 137, value) } open var frame137_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 137) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 137, value) } open var frame138_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 138) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 138, value) } open var frame138_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 138) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 138, value) } open var frame139_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 139) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 139, value) } open var frame139_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 139) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 139, value) } open var frame14_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 14) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 14, value) } open var frame14_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 14) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 14, value) } open var frame140_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 140) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 140, value) } open var frame140_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 140) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 140, value) } open var frame141_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 141) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 141, value) } open var frame141_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 141) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 141, value) } open var frame142_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 142) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 142, value) } open var frame142_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 142) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 142, value) } open var frame143_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 143) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 143, value) } open var frame143_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 143) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 143, value) } open var frame144_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 144) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 144, value) } open var frame144_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 144) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 144, value) } open var frame145_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 145) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 145, value) } open var frame145_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 145) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 145, value) } open var frame146_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 146) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 146, value) } open var frame146_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 146) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 146, value) } open var frame147_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 147) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 147, value) } open var frame147_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 147) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 147, value) } open var frame148_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 148) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 148, value) } open var frame148_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 148) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 148, value) } open var frame149_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 149) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 149, value) } open var frame149_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 149) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 149, value) } open var frame15_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 15) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 15, value) } open var frame15_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 15) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 15, value) } open var frame150_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 150) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 150, value) } open var frame150_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 150) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 150, value) } open var frame151_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 151) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 151, value) } open var frame151_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 151) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 151, value) } open var frame152_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 152) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 152, value) } open var frame152_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 152) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 152, value) } open var frame153_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 153) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 153, value) } open var frame153_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 153) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 153, value) } open var frame154_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 154) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 154, value) } open var frame154_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 154) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 154, value) } open var frame155_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 155) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 155, value) } open var frame155_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 155) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 155, value) } open var frame156_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 156) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 156, value) } open var frame156_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 156) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 156, value) } open var frame157_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 157) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 157, value) } open var frame157_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 157) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 157, value) } open var frame158_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 158) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 158, value) } open var frame158_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 158) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 158, value) } open var frame159_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 159) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 159, value) } open var frame159_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 159) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 159, value) } open var frame16_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 16, value) } open var frame16_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 16, value) } open var frame160_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 160) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 160, value) } open var frame160_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 160) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 160, value) } open var frame161_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 161) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 161, value) } open var frame161_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 161) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 161, value) } open var frame162_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 162) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 162, value) } open var frame162_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 162) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 162, value) } open var frame163_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 163) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 163, value) } open var frame163_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 163) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 163, value) } open var frame164_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 164) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 164, value) } open var frame164_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 164) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 164, value) } open var frame165_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 165) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 165, value) } open var frame165_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 165) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 165, value) } open var frame166_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 166) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 166, value) } open var frame166_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 166) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 166, value) } open var frame167_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 167) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 167, value) } open var frame167_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 167) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 167, value) } open var frame168_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 168) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 168, value) } open var frame168_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 168) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 168, value) } open var frame169_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 169) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 169, value) } open var frame169_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 169) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 169, value) } open var frame17_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 17) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 17, value) } open var frame17_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 17) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 17, value) } open var frame170_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 170) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 170, value) } open var frame170_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 170) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 170, value) } open var frame171_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 171) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 171, value) } open var frame171_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 171) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 171, value) } open var frame172_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 172) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 172, value) } open var frame172_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 172) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 172, value) } open var frame173_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 173) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 173, value) } open var frame173_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 173) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 173, value) } open var frame174_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 174) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 174, value) } open var frame174_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 174) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 174, value) } open var frame175_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 175) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 175, value) } open var frame175_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 175) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 175, value) } open var frame176_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 176) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 176, value) } open var frame176_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 176) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 176, value) } open var frame177_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 177) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 177, value) } open var frame177_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 177) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 177, value) } open var frame178_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 178) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 178, value) } open var frame178_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 178) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 178, value) } open var frame179_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 179) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 179, value) } open var frame179_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 179) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 179, value) } open var frame18_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 18) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 18, value) } open var frame18_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 18) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 18, value) } open var frame180_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 180) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 180, value) } open var frame180_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 180) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 180, value) } open var frame181_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 181) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 181, value) } open var frame181_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 181) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 181, value) } open var frame182_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 182) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 182, value) } open var frame182_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 182) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 182, value) } open var frame183_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 183) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 183, value) } open var frame183_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 183) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 183, value) } open var frame184_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 184) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 184, value) } open var frame184_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 184) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 184, value) } open var frame185_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 185) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 185, value) } open var frame185_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 185) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 185, value) } open var frame186_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 186) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 186, value) } open var frame186_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 186) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 186, value) } open var frame187_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 187) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 187, value) } open var frame187_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 187) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 187, value) } open var frame188_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 188) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 188, value) } open var frame188_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 188) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 188, value) } open var frame189_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 189) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 189, value) } open var frame189_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 189) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 189, value) } open var frame19_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 19) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 19, value) } open var frame19_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 19) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 19, value) } open var frame190_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 190) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 190, value) } open var frame190_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 190) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 190, value) } open var frame191_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 191) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 191, value) } open var frame191_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 191) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 191, value) } open var frame192_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 192) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 192, value) } open var frame192_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 192) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 192, value) } open var frame193_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 193) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 193, value) } open var frame193_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 193) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 193, value) } open var frame194_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 194) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 194, value) } open var frame194_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 194) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 194, value) } open var frame195_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 195) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 195, value) } open var frame195_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 195) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 195, value) } open var frame196_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 196) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 196, value) } open var frame196_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 196) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 196, value) } open var frame197_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 197) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 197, value) } open var frame197_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 197) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 197, value) } open var frame198_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 198) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 198, value) } open var frame198_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 198) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 198, value) } open var frame199_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 199) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 199, value) } open var frame199_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 199) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 199, value) } open var frame2_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var frame2_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 2, value) } open var frame20_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 20) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 20, value) } open var frame20_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 20) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 20, value) } open var frame200_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 200) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 200, value) } open var frame200_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 200) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 200, value) } open var frame201_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 201) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 201, value) } open var frame201_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 201) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 201, value) } open var frame202_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 202) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 202, value) } open var frame202_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 202) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 202, value) } open var frame203_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 203) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 203, value) } open var frame203_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 203) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 203, value) } open var frame204_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 204) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 204, value) } open var frame204_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 204) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 204, value) } open var frame205_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 205) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 205, value) } open var frame205_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 205) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 205, value) } open var frame206_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 206) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 206, value) } open var frame206_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 206) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 206, value) } open var frame207_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 207) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 207, value) } open var frame207_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 207) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 207, value) } open var frame208_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 208) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 208, value) } open var frame208_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 208) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 208, value) } open var frame209_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 209) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 209, value) } open var frame209_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 209) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 209, value) } open var frame21_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 21) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 21, value) } open var frame21_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 21) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 21, value) } open var frame210_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 210) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 210, value) } open var frame210_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 210) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 210, value) } open var frame211_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 211) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 211, value) } open var frame211_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 211) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 211, value) } open var frame212_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 212) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 212, value) } open var frame212_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 212) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 212, value) } open var frame213_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 213) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 213, value) } open var frame213_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 213) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 213, value) } open var frame214_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 214) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 214, value) } open var frame214_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 214) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 214, value) } open var frame215_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 215) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 215, value) } open var frame215_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 215) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 215, value) } open var frame216_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 216) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 216, value) } open var frame216_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 216) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 216, value) } open var frame217_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 217) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 217, value) } open var frame217_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 217) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 217, value) } open var frame218_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 218) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 218, value) } open var frame218_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 218) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 218, value) } open var frame219_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 219) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 219, value) } open var frame219_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 219) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 219, value) } open var frame22_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 22) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 22, value) } open var frame22_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 22) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 22, value) } open var frame220_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 220) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 220, value) } open var frame220_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 220) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 220, value) } open var frame221_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 221) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 221, value) } open var frame221_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 221) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 221, value) } open var frame222_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 222) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 222, value) } open var frame222_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 222) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 222, value) } open var frame223_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 223) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 223, value) } open var frame223_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 223) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 223, value) } open var frame224_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 224) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 224, value) } open var frame224_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 224) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 224, value) } open var frame225_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 225) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 225, value) } open var frame225_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 225) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 225, value) } open var frame226_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 226) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 226, value) } open var frame226_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 226) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 226, value) } open var frame227_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 227) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 227, value) } open var frame227_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 227) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 227, value) } open var frame228_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 228) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 228, value) } open var frame228_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 228) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 228, value) } open var frame229_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 229) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 229, value) } open var frame229_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 229) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 229, value) } open var frame23_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 23) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 23, value) } open var frame23_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 23) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 23, value) } open var frame230_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 230) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 230, value) } open var frame230_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 230) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 230, value) } open var frame231_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 231) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 231, value) } open var frame231_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 231) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 231, value) } open var frame232_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 232) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 232, value) } open var frame232_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 232) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 232, value) } open var frame233_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 233) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 233, value) } open var frame233_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 233) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 233, value) } open var frame234_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 234) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 234, value) } open var frame234_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 234) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 234, value) } open var frame235_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 235) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 235, value) } open var frame235_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 235) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 235, value) } open var frame236_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 236) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 236, value) } open var frame236_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 236) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 236, value) } open var frame237_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 237) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 237, value) } open var frame237_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 237) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 237, value) } open var frame238_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 238) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 238, value) } open var frame238_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 238) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 238, value) } open var frame239_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 239) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 239, value) } open var frame239_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 239) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 239, value) } open var frame24_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 24) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 24, value) } open var frame24_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 24) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 24, value) } open var frame240_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 240) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 240, value) } open var frame240_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 240) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 240, value) } open var frame241_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 241) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 241, value) } open var frame241_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 241) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 241, value) } open var frame242_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 242) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 242, value) } open var frame242_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 242) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 242, value) } open var frame243_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 243) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 243, value) } open var frame243_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 243) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 243, value) } open var frame244_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 244) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 244, value) } open var frame244_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 244) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 244, value) } open var frame245_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 245) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 245, value) } open var frame245_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 245) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 245, value) } open var frame246_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 246) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 246, value) } open var frame246_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 246) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 246, value) } open var frame247_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 247) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 247, value) } open var frame247_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 247) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 247, value) } open var frame248_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 248) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 248, value) } open var frame248_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 248) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 248, value) } open var frame249_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 249) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 249, value) } open var frame249_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 249) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 249, value) } open var frame25_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 25) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 25, value) } open var frame25_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 25) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 25, value) } open var frame250_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 250) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 250, value) } open var frame250_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 250) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 250, value) } open var frame251_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 251) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 251, value) } open var frame251_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 251) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 251, value) } open var frame252_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 252) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 252, value) } open var frame252_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 252) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 252, value) } open var frame253_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 253) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 253, value) } open var frame253_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 253) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 253, value) } open var frame254_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 254) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 254, value) } open var frame254_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 254) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 254, value) } open var frame255_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 255) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 255, value) } open var frame255_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 255) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 255, value) } open var frame26_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 26) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 26, value) } open var frame26_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 26) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 26, value) } open var frame27_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 27) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 27, value) } open var frame27_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 27) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 27, value) } open var frame28_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 28) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 28, value) } open var frame28_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 28) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 28, value) } open var frame29_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 29) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 29, value) } open var frame29_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 29) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 29, value) } open var frame3_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var frame3_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 3, value) } open var frame30_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 30) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 30, value) } open var frame30_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 30) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 30, value) } open var frame31_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 31) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 31, value) } open var frame31_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 31) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 31, value) } open var frame32_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 32) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 32, value) } open var frame32_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 32) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 32, value) } open var frame33_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 33) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 33, value) } open var frame33_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 33) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 33, value) } open var frame34_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 34) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 34, value) } open var frame34_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 34) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 34, value) } open var frame35_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 35) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 35, value) } open var frame35_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 35) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 35, value) } open var frame36_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 36) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 36, value) } open var frame36_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 36) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 36, value) } open var frame37_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 37) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 37, value) } open var frame37_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 37) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 37, value) } open var frame38_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 38) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 38, value) } open var frame38_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 38) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 38, value) } open var frame39_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 39) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 39, value) } open var frame39_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 39) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 39, value) } open var frame4_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var frame4_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 4, value) } open var frame40_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 40) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 40, value) } open var frame40_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 40) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 40, value) } open var frame41_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 41) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 41, value) } open var frame41_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 41) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 41, value) } open var frame42_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 42) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 42, value) } open var frame42_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 42) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 42, value) } open var frame43_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 43) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 43, value) } open var frame43_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 43) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 43, value) } open var frame44_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 44) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 44, value) } open var frame44_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 44) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 44, value) } open var frame45_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 45) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 45, value) } open var frame45_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 45) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 45, value) } open var frame46_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 46) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 46, value) } open var frame46_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 46) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 46, value) } open var frame47_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 47) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 47, value) } open var frame47_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 47) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 47, value) } open var frame48_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 48) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 48, value) } open var frame48_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 48) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 48, value) } open var frame49_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 49) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 49, value) } open var frame49_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 49) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 49, value) } open var frame5_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var frame5_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 5, value) } open var frame50_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 50) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 50, value) } open var frame50_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 50) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 50, value) } open var frame51_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 51) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 51, value) } open var frame51_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 51) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 51, value) } open var frame52_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 52) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 52, value) } open var frame52_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 52) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 52, value) } open var frame53_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 53) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 53, value) } open var frame53_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 53) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 53, value) } open var frame54_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 54) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 54, value) } open var frame54_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 54) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 54, value) } open var frame55_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 55) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 55, value) } open var frame55_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 55) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 55, value) } open var frame56_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 56) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 56, value) } open var frame56_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 56) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 56, value) } open var frame57_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 57) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 57, value) } open var frame57_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 57) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 57, value) } open var frame58_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 58) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 58, value) } open var frame58_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 58) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 58, value) } open var frame59_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 59) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 59, value) } open var frame59_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 59) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 59, value) } open var frame6_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var frame6_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 6, value) } open var frame60_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 60) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 60, value) } open var frame60_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 60) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 60, value) } open var frame61_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 61) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 61, value) } open var frame61_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 61) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 61, value) } open var frame62_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 62) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 62, value) } open var frame62_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 62) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 62, value) } open var frame63_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 63) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 63, value) } open var frame63_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 63) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 63, value) } open var frame64_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 64) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 64, value) } open var frame64_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 64) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 64, value) } open var frame65_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 65) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 65, value) } open var frame65_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 65) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 65, value) } open var frame66_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 66) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 66, value) } open var frame66_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 66) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 66, value) } open var frame67_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 67) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 67, value) } open var frame67_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 67) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 67, value) } open var frame68_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 68) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 68, value) } open var frame68_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 68) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 68, value) } open var frame69_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 69) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 69, value) } open var frame69_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 69) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 69, value) } open var frame7_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var frame7_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 7, value) } open var frame70_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 70) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 70, value) } open var frame70_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 70) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 70, value) } open var frame71_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 71) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 71, value) } open var frame71_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 71) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 71, value) } open var frame72_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 72) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 72, value) } open var frame72_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 72) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 72, value) } open var frame73_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 73) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 73, value) } open var frame73_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 73) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 73, value) } open var frame74_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 74) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 74, value) } open var frame74_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 74) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 74, value) } open var frame75_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 75) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 75, value) } open var frame75_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 75) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 75, value) } open var frame76_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 76) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 76, value) } open var frame76_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 76) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 76, value) } open var frame77_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 77) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 77, value) } open var frame77_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 77) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 77, value) } open var frame78_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 78) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 78, value) } open var frame78_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 78) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 78, value) } open var frame79_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 79) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 79, value) } open var frame79_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 79) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 79, value) } open var frame8_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var frame8_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 8, value) } open var frame80_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 80) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 80, value) } open var frame80_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 80) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 80, value) } open var frame81_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 81) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 81, value) } open var frame81_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 81) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 81, value) } open var frame82_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 82) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 82, value) } open var frame82_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 82) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 82, value) } open var frame83_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 83) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 83, value) } open var frame83_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 83) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 83, value) } open var frame84_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 84) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 84, value) } open var frame84_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 84) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 84, value) } open var frame85_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 85) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 85, value) } open var frame85_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 85) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 85, value) } open var frame86_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 86) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 86, value) } open var frame86_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 86) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 86, value) } open var frame87_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 87) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 87, value) } open var frame87_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 87) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 87, value) } open var frame88_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 88) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 88, value) } open var frame88_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 88) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 88, value) } open var frame89_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 89) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 89, value) } open var frame89_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 89) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 89, value) } open var frame9_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var frame9_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 9, value) } open var frame90_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 90) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 90, value) } open var frame90_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 90) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 90, value) } open var frame91_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 91) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 91, value) } open var frame91_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 91) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 91, value) } open var frame92_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 92) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 92, value) } open var frame92_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 92) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 92, value) } open var frame93_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 93) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 93, value) } open var frame93_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 93) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 93, value) } open var frame94_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 94) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 94, value) } open var frame94_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 94) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 94, value) } open var frame95_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 95) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 95, value) } open var frame95_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 95) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 95, value) } open var frame96_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 96) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 96, value) } open var frame96_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 96) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 96, value) } open var frame97_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 97) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 97, value) } open var frame97_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 97) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 97, value) } open var frame98_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 98) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 98, value) } open var frame98_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 98) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 98, value) } open var frame99_delaySec: Double get() { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long(mb, this.ptr, 99) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double(mb, this.ptr, 99, value) } open var frame99_texture: Texture get() { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long(mb, this.ptr, 99) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object(mb, this.ptr, 99, value) } open var frames: Long get() { val mb = getMethodBind("AnimatedTexture","get_frames") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedTexture","set_frames") _icall_Unit_Long(mb, this.ptr, value) } open var oneshot: Boolean get() { val mb = getMethodBind("AnimatedTexture","get_oneshot") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedTexture","set_oneshot") _icall_Unit_Boolean(mb, this.ptr, value) } open var pause: Boolean get() { val mb = getMethodBind("AnimatedTexture","get_pause") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimatedTexture","set_pause") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimatedTexture", "AnimatedTexture") open fun _updateProxy() { } open fun getCurrentFrame(): Long { val mb = getMethodBind("AnimatedTexture","get_current_frame") return _icall_Long( mb, this.ptr) } open fun getFps(): Double { val mb = getMethodBind("AnimatedTexture","get_fps") return _icall_Double( mb, this.ptr) } open fun getFrameDelay(frame: Long): Double { val mb = getMethodBind("AnimatedTexture","get_frame_delay") return _icall_Double_Long( mb, this.ptr, frame) } open fun getFrameTexture(frame: Long): Texture { val mb = getMethodBind("AnimatedTexture","get_frame_texture") return _icall_Texture_Long( mb, this.ptr, frame) } open fun getFrames(): Long { val mb = getMethodBind("AnimatedTexture","get_frames") return _icall_Long( mb, this.ptr) } open fun getOneshot(): Boolean { val mb = getMethodBind("AnimatedTexture","get_oneshot") return _icall_Boolean( mb, this.ptr) } open fun getPause(): Boolean { val mb = getMethodBind("AnimatedTexture","get_pause") return _icall_Boolean( mb, this.ptr) } open fun setCurrentFrame(frame: Long) { val mb = getMethodBind("AnimatedTexture","set_current_frame") _icall_Unit_Long( mb, this.ptr, frame) } open fun setFps(fps: Double) { val mb = getMethodBind("AnimatedTexture","set_fps") _icall_Unit_Double( mb, this.ptr, fps) } open fun setFrameDelay(frame: Long, delay: Double) { val mb = getMethodBind("AnimatedTexture","set_frame_delay") _icall_Unit_Long_Double( mb, this.ptr, frame, delay) } open fun setFrameTexture(frame: Long, texture: Texture) { val mb = getMethodBind("AnimatedTexture","set_frame_texture") _icall_Unit_Long_Object( mb, this.ptr, frame, texture) } open fun setFrames(frames: Long) { val mb = getMethodBind("AnimatedTexture","set_frames") _icall_Unit_Long( mb, this.ptr, frames) } open fun setOneshot(oneshot: Boolean) { val mb = getMethodBind("AnimatedTexture","set_oneshot") _icall_Unit_Boolean( mb, this.ptr, oneshot) } open fun setPause(pause: Boolean) { val mb = getMethodBind("AnimatedTexture","set_pause") _icall_Unit_Boolean( mb, this.ptr, pause) } companion object { final const val MAX_FRAMES: Long = 256 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Animation.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Animation import godot.core.NodePath import godot.core.PoolIntArray import godot.core.Quat import godot.core.Signal0 import godot.core.Variant import godot.core.VariantArray import godot.core.Vector2 import godot.core.Vector3 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double import godot.icalls._icall_Double_Long_Double import godot.icalls._icall_Double_Long_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_Long_Double_Boolean import godot.icalls._icall_Long_Long_Double_Double_Vector2_Vector2 import godot.icalls._icall_Long_Long_Double_Object_Double_Double import godot.icalls._icall_Long_Long_Double_String import godot.icalls._icall_Long_Long_Double_Vector3_Quat_Vector3 import godot.icalls._icall_Long_Long_Long import godot.icalls._icall_Long_NodePath import godot.icalls._icall_NodePath_Long import godot.icalls._icall_PoolIntArray_Long_Double_Double import godot.icalls._icall_Resource_Long_Long import godot.icalls._icall_String_Long_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Double_Variant_Double import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Long_Double import godot.icalls._icall_Unit_Long_Long_Object import godot.icalls._icall_Unit_Long_Long_String import godot.icalls._icall_Unit_Long_Long_Variant import godot.icalls._icall_Unit_Long_Long_Vector2 import godot.icalls._icall_Unit_Long_NodePath import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_VariantArray_Long_Double import godot.icalls._icall_VariantArray_Long_Long import godot.icalls._icall_Variant_Long_Long import godot.icalls._icall_Vector2_Long_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class Animation : Resource() { val tracksChanged: Signal0 by signal() open var length: Double get() { val mb = getMethodBind("Animation","get_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Animation","set_length") _icall_Unit_Double(mb, this.ptr, value) } open var loop: Boolean get() { val mb = getMethodBind("Animation","has_loop") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Animation","set_loop") _icall_Unit_Boolean(mb, this.ptr, value) } open var step: Double get() { val mb = getMethodBind("Animation","get_step") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Animation","set_step") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Animation", "Animation") open fun addTrack(type: Long, atPosition: Long = -1): Long { val mb = getMethodBind("Animation","add_track") return _icall_Long_Long_Long( mb, this.ptr, type, atPosition) } open fun animationTrackGetKeyAnimation(trackIdx: Long, keyIdx: Long): String { val mb = getMethodBind("Animation","animation_track_get_key_animation") return _icall_String_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun animationTrackInsertKey( trackIdx: Long, time: Double, animation: String ): Long { val mb = getMethodBind("Animation","animation_track_insert_key") return _icall_Long_Long_Double_String( mb, this.ptr, trackIdx, time, animation) } open fun animationTrackSetKeyAnimation( trackIdx: Long, keyIdx: Long, animation: String ) { val mb = getMethodBind("Animation","animation_track_set_key_animation") _icall_Unit_Long_Long_String( mb, this.ptr, trackIdx, keyIdx, animation) } open fun audioTrackGetKeyEndOffset(trackIdx: Long, keyIdx: Long): Double { val mb = getMethodBind("Animation","audio_track_get_key_end_offset") return _icall_Double_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun audioTrackGetKeyStartOffset(trackIdx: Long, keyIdx: Long): Double { val mb = getMethodBind("Animation","audio_track_get_key_start_offset") return _icall_Double_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun audioTrackGetKeyStream(trackIdx: Long, keyIdx: Long): Resource { val mb = getMethodBind("Animation","audio_track_get_key_stream") return _icall_Resource_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun audioTrackInsertKey( trackIdx: Long, time: Double, stream: Resource, startOffset: Double = 0.0, endOffset: Double = 0.0 ): Long { val mb = getMethodBind("Animation","audio_track_insert_key") return _icall_Long_Long_Double_Object_Double_Double( mb, this.ptr, trackIdx, time, stream, startOffset, endOffset) } open fun audioTrackSetKeyEndOffset( trackIdx: Long, keyIdx: Long, offset: Double ) { val mb = getMethodBind("Animation","audio_track_set_key_end_offset") _icall_Unit_Long_Long_Double( mb, this.ptr, trackIdx, keyIdx, offset) } open fun audioTrackSetKeyStartOffset( trackIdx: Long, keyIdx: Long, offset: Double ) { val mb = getMethodBind("Animation","audio_track_set_key_start_offset") _icall_Unit_Long_Long_Double( mb, this.ptr, trackIdx, keyIdx, offset) } open fun audioTrackSetKeyStream( trackIdx: Long, keyIdx: Long, stream: Resource ) { val mb = getMethodBind("Animation","audio_track_set_key_stream") _icall_Unit_Long_Long_Object( mb, this.ptr, trackIdx, keyIdx, stream) } open fun bezierTrackGetKeyInHandle(trackIdx: Long, keyIdx: Long): Vector2 { val mb = getMethodBind("Animation","bezier_track_get_key_in_handle") return _icall_Vector2_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun bezierTrackGetKeyOutHandle(trackIdx: Long, keyIdx: Long): Vector2 { val mb = getMethodBind("Animation","bezier_track_get_key_out_handle") return _icall_Vector2_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun bezierTrackGetKeyValue(trackIdx: Long, keyIdx: Long): Double { val mb = getMethodBind("Animation","bezier_track_get_key_value") return _icall_Double_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun bezierTrackInsertKey( trackIdx: Long, time: Double, value: Double, inHandle: Vector2 = Vector2(0.0, 0.0), outHandle: Vector2 = Vector2(0.0, 0.0) ): Long { val mb = getMethodBind("Animation","bezier_track_insert_key") return _icall_Long_Long_Double_Double_Vector2_Vector2( mb, this.ptr, trackIdx, time, value, inHandle, outHandle) } open fun bezierTrackInterpolate(trackIdx: Long, time: Double): Double { val mb = getMethodBind("Animation","bezier_track_interpolate") return _icall_Double_Long_Double( mb, this.ptr, trackIdx, time) } open fun bezierTrackSetKeyInHandle( trackIdx: Long, keyIdx: Long, inHandle: Vector2 ) { val mb = getMethodBind("Animation","bezier_track_set_key_in_handle") _icall_Unit_Long_Long_Vector2( mb, this.ptr, trackIdx, keyIdx, inHandle) } open fun bezierTrackSetKeyOutHandle( trackIdx: Long, keyIdx: Long, outHandle: Vector2 ) { val mb = getMethodBind("Animation","bezier_track_set_key_out_handle") _icall_Unit_Long_Long_Vector2( mb, this.ptr, trackIdx, keyIdx, outHandle) } open fun bezierTrackSetKeyValue( trackIdx: Long, keyIdx: Long, value: Double ) { val mb = getMethodBind("Animation","bezier_track_set_key_value") _icall_Unit_Long_Long_Double( mb, this.ptr, trackIdx, keyIdx, value) } open fun clear() { val mb = getMethodBind("Animation","clear") _icall_Unit( mb, this.ptr) } open fun copyTrack(trackIdx: Long, toAnimation: Animation) { val mb = getMethodBind("Animation","copy_track") _icall_Unit_Long_Object( mb, this.ptr, trackIdx, toAnimation) } open fun findTrack(path: NodePath): Long { val mb = getMethodBind("Animation","find_track") return _icall_Long_NodePath( mb, this.ptr, path) } open fun getLength(): Double { val mb = getMethodBind("Animation","get_length") return _icall_Double( mb, this.ptr) } open fun getStep(): Double { val mb = getMethodBind("Animation","get_step") return _icall_Double( mb, this.ptr) } open fun getTrackCount(): Long { val mb = getMethodBind("Animation","get_track_count") return _icall_Long( mb, this.ptr) } open fun hasLoop(): Boolean { val mb = getMethodBind("Animation","has_loop") return _icall_Boolean( mb, this.ptr) } open fun methodTrackGetKeyIndices( trackIdx: Long, timeSec: Double, delta: Double ): PoolIntArray { val mb = getMethodBind("Animation","method_track_get_key_indices") return _icall_PoolIntArray_Long_Double_Double( mb, this.ptr, trackIdx, timeSec, delta) } open fun methodTrackGetName(trackIdx: Long, keyIdx: Long): String { val mb = getMethodBind("Animation","method_track_get_name") return _icall_String_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun methodTrackGetParams(trackIdx: Long, keyIdx: Long): VariantArray { val mb = getMethodBind("Animation","method_track_get_params") return _icall_VariantArray_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun removeTrack(trackIdx: Long) { val mb = getMethodBind("Animation","remove_track") _icall_Unit_Long( mb, this.ptr, trackIdx) } open fun setLength(timeSec: Double) { val mb = getMethodBind("Animation","set_length") _icall_Unit_Double( mb, this.ptr, timeSec) } open fun setLoop(enabled: Boolean) { val mb = getMethodBind("Animation","set_loop") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setStep(sizeSec: Double) { val mb = getMethodBind("Animation","set_step") _icall_Unit_Double( mb, this.ptr, sizeSec) } open fun trackFindKey( trackIdx: Long, time: Double, exact: Boolean = false ): Long { val mb = getMethodBind("Animation","track_find_key") return _icall_Long_Long_Double_Boolean( mb, this.ptr, trackIdx, time, exact) } open fun trackGetInterpolationLoopWrap(trackIdx: Long): Boolean { val mb = getMethodBind("Animation","track_get_interpolation_loop_wrap") return _icall_Boolean_Long( mb, this.ptr, trackIdx) } open fun trackGetInterpolationType(trackIdx: Long): Animation.InterpolationType { val mb = getMethodBind("Animation","track_get_interpolation_type") return Animation.InterpolationType.from( _icall_Long_Long( mb, this.ptr, trackIdx)) } open fun trackGetKeyCount(trackIdx: Long): Long { val mb = getMethodBind("Animation","track_get_key_count") return _icall_Long_Long( mb, this.ptr, trackIdx) } open fun trackGetKeyTime(trackIdx: Long, keyIdx: Long): Double { val mb = getMethodBind("Animation","track_get_key_time") return _icall_Double_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun trackGetKeyTransition(trackIdx: Long, keyIdx: Long): Double { val mb = getMethodBind("Animation","track_get_key_transition") return _icall_Double_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun trackGetKeyValue(trackIdx: Long, keyIdx: Long): Variant { val mb = getMethodBind("Animation","track_get_key_value") return _icall_Variant_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun trackGetPath(trackIdx: Long): NodePath { val mb = getMethodBind("Animation","track_get_path") return _icall_NodePath_Long( mb, this.ptr, trackIdx) } open fun trackGetType(trackIdx: Long): Animation.TrackType { val mb = getMethodBind("Animation","track_get_type") return Animation.TrackType.from( _icall_Long_Long( mb, this.ptr, trackIdx)) } open fun trackInsertKey( trackIdx: Long, time: Double, key: Variant, transition: Double = 1.0 ) { val mb = getMethodBind("Animation","track_insert_key") _icall_Unit_Long_Double_Variant_Double( mb, this.ptr, trackIdx, time, key, transition) } open fun trackIsEnabled(trackIdx: Long): Boolean { val mb = getMethodBind("Animation","track_is_enabled") return _icall_Boolean_Long( mb, this.ptr, trackIdx) } open fun trackIsImported(trackIdx: Long): Boolean { val mb = getMethodBind("Animation","track_is_imported") return _icall_Boolean_Long( mb, this.ptr, trackIdx) } open fun trackMoveDown(trackIdx: Long) { val mb = getMethodBind("Animation","track_move_down") _icall_Unit_Long( mb, this.ptr, trackIdx) } open fun trackMoveTo(trackIdx: Long, toIdx: Long) { val mb = getMethodBind("Animation","track_move_to") _icall_Unit_Long_Long( mb, this.ptr, trackIdx, toIdx) } open fun trackMoveUp(trackIdx: Long) { val mb = getMethodBind("Animation","track_move_up") _icall_Unit_Long( mb, this.ptr, trackIdx) } open fun trackRemoveKey(trackIdx: Long, keyIdx: Long) { val mb = getMethodBind("Animation","track_remove_key") _icall_Unit_Long_Long( mb, this.ptr, trackIdx, keyIdx) } open fun trackRemoveKeyAtPosition(trackIdx: Long, position: Double) { val mb = getMethodBind("Animation","track_remove_key_at_position") _icall_Unit_Long_Double( mb, this.ptr, trackIdx, position) } open fun trackSetEnabled(trackIdx: Long, enabled: Boolean) { val mb = getMethodBind("Animation","track_set_enabled") _icall_Unit_Long_Boolean( mb, this.ptr, trackIdx, enabled) } open fun trackSetImported(trackIdx: Long, imported: Boolean) { val mb = getMethodBind("Animation","track_set_imported") _icall_Unit_Long_Boolean( mb, this.ptr, trackIdx, imported) } open fun trackSetInterpolationLoopWrap(trackIdx: Long, interpolation: Boolean) { val mb = getMethodBind("Animation","track_set_interpolation_loop_wrap") _icall_Unit_Long_Boolean( mb, this.ptr, trackIdx, interpolation) } open fun trackSetInterpolationType(trackIdx: Long, interpolation: Long) { val mb = getMethodBind("Animation","track_set_interpolation_type") _icall_Unit_Long_Long( mb, this.ptr, trackIdx, interpolation) } open fun trackSetKeyTime( trackIdx: Long, keyIdx: Long, time: Double ) { val mb = getMethodBind("Animation","track_set_key_time") _icall_Unit_Long_Long_Double( mb, this.ptr, trackIdx, keyIdx, time) } open fun trackSetKeyTransition( trackIdx: Long, keyIdx: Long, transition: Double ) { val mb = getMethodBind("Animation","track_set_key_transition") _icall_Unit_Long_Long_Double( mb, this.ptr, trackIdx, keyIdx, transition) } open fun trackSetKeyValue( trackIdx: Long, key: Long, value: Variant ) { val mb = getMethodBind("Animation","track_set_key_value") _icall_Unit_Long_Long_Variant( mb, this.ptr, trackIdx, key, value) } open fun trackSetPath(trackIdx: Long, path: NodePath) { val mb = getMethodBind("Animation","track_set_path") _icall_Unit_Long_NodePath( mb, this.ptr, trackIdx, path) } open fun trackSwap(trackIdx: Long, withIdx: Long) { val mb = getMethodBind("Animation","track_swap") _icall_Unit_Long_Long( mb, this.ptr, trackIdx, withIdx) } open fun transformTrackInsertKey( trackIdx: Long, time: Double, location: Vector3, rotation: Quat, scale: Vector3 ): Long { val mb = getMethodBind("Animation","transform_track_insert_key") return _icall_Long_Long_Double_Vector3_Quat_Vector3( mb, this.ptr, trackIdx, time, location, rotation, scale) } open fun transformTrackInterpolate(trackIdx: Long, timeSec: Double): VariantArray { val mb = getMethodBind("Animation","transform_track_interpolate") return _icall_VariantArray_Long_Double( mb, this.ptr, trackIdx, timeSec) } open fun valueTrackGetKeyIndices( trackIdx: Long, timeSec: Double, delta: Double ): PoolIntArray { val mb = getMethodBind("Animation","value_track_get_key_indices") return _icall_PoolIntArray_Long_Double_Double( mb, this.ptr, trackIdx, timeSec, delta) } open fun valueTrackGetUpdateMode(trackIdx: Long): Animation.UpdateMode { val mb = getMethodBind("Animation","value_track_get_update_mode") return Animation.UpdateMode.from( _icall_Long_Long( mb, this.ptr, trackIdx)) } open fun valueTrackSetUpdateMode(trackIdx: Long, mode: Long) { val mb = getMethodBind("Animation","value_track_set_update_mode") _icall_Unit_Long_Long( mb, this.ptr, trackIdx, mode) } enum class TrackType( id: Long ) { TYPE_VALUE(0), TYPE_TRANSFORM(1), TYPE_METHOD(2), TYPE_BEZIER(3), TYPE_AUDIO(4), TYPE_ANIMATION(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class UpdateMode( id: Long ) { UPDATE_CONTINUOUS(0), UPDATE_DISCRETE(1), UPDATE_TRIGGER(2), UPDATE_CAPTURE(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class InterpolationType( id: Long ) { INTERPOLATION_NEAREST(0), INTERPOLATION_LINEAR(1), INTERPOLATION_CUBIC(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNode.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.NodePath import godot.core.Signal0 import godot.core.Variant import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_NodePath import godot.icalls._icall_Double_Long_Double_Boolean_Double_Long_Boolean import godot.icalls._icall_Double_String_Object_Double_Boolean_Double_Long_Boolean import godot.icalls._icall_Long import godot.icalls._icall_String_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_NodePath_Boolean import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Double_Double_Boolean_Double import godot.icalls._icall_Unit_String_Variant import godot.icalls._icall_Variant_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationNode : Resource() { val removedFromGraph: Signal0 by signal() val treeChanged: Signal0 by signal() open var filterEnabled: Boolean get() { val mb = getMethodBind("AnimationNode","is_filter_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNode","set_filter_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNode", "AnimationNode") open fun _getFilters(): VariantArray { throw NotImplementedError("_get_filters is not implemented for AnimationNode") } open fun _setFilters(filters: VariantArray) { } open fun addInput(name: String) { val mb = getMethodBind("AnimationNode","add_input") _icall_Unit_String( mb, this.ptr, name) } open fun blendAnimation( animation: String, time: Double, delta: Double, seeked: Boolean, blend: Double ) { val mb = getMethodBind("AnimationNode","blend_animation") _icall_Unit_String_Double_Double_Boolean_Double( mb, this.ptr, animation, time, delta, seeked, blend) } open fun blendInput( inputIndex: Long, time: Double, seek: Boolean, blend: Double, filter: Long = 0, optimize: Boolean = true ): Double { val mb = getMethodBind("AnimationNode","blend_input") return _icall_Double_Long_Double_Boolean_Double_Long_Boolean( mb, this.ptr, inputIndex, time, seek, blend, filter, optimize) } open fun blendNode( name: String, node: AnimationNode, time: Double, seek: Boolean, blend: Double, filter: Long = 0, optimize: Boolean = true ): Double { val mb = getMethodBind("AnimationNode","blend_node") return _icall_Double_String_Object_Double_Boolean_Double_Long_Boolean( mb, this.ptr, name, node, time, seek, blend, filter, optimize) } open fun getCaption(): String { throw NotImplementedError("get_caption is not implemented for AnimationNode") } open fun getChildByName(name: String): Object { throw NotImplementedError("get_child_by_name is not implemented for AnimationNode") } open fun getChildNodes(): Dictionary { throw NotImplementedError("get_child_nodes is not implemented for AnimationNode") } open fun getInputCount(): Long { val mb = getMethodBind("AnimationNode","get_input_count") return _icall_Long( mb, this.ptr) } open fun getInputName(input: Long): String { val mb = getMethodBind("AnimationNode","get_input_name") return _icall_String_Long( mb, this.ptr, input) } open fun getParameter(name: String): Variant { val mb = getMethodBind("AnimationNode","get_parameter") return _icall_Variant_String( mb, this.ptr, name) } open fun getParameterDefaultValue(name: String): Variant { throw NotImplementedError("get_parameter_default_value is not implemented for AnimationNode") } open fun getParameterList(): VariantArray { throw NotImplementedError("get_parameter_list is not implemented for AnimationNode") } open fun hasFilter(): String { throw NotImplementedError("has_filter is not implemented for AnimationNode") } open fun isFilterEnabled(): Boolean { val mb = getMethodBind("AnimationNode","is_filter_enabled") return _icall_Boolean( mb, this.ptr) } open fun isPathFiltered(path: NodePath): Boolean { val mb = getMethodBind("AnimationNode","is_path_filtered") return _icall_Boolean_NodePath( mb, this.ptr, path) } open fun process(time: Double, seek: Boolean) { } open fun removeInput(index: Long) { val mb = getMethodBind("AnimationNode","remove_input") _icall_Unit_Long( mb, this.ptr, index) } open fun setFilterEnabled(enable: Boolean) { val mb = getMethodBind("AnimationNode","set_filter_enabled") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setFilterPath(path: NodePath, enable: Boolean) { val mb = getMethodBind("AnimationNode","set_filter_path") _icall_Unit_NodePath_Boolean( mb, this.ptr, path, enable) } open fun setParameter(name: String, value: Variant) { val mb = getMethodBind("AnimationNode","set_parameter") _icall_Unit_String_Variant( mb, this.ptr, name, value) } enum class FilterAction( id: Long ) { FILTER_IGNORE(0), FILTER_PASS(1), FILTER_STOP(2), FILTER_BLEND(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeAdd2.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class AnimationNodeAdd2 : AnimationNode() { open var sync: Boolean get() { val mb = getMethodBind("AnimationNodeAdd2","is_using_sync") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeAdd2","set_use_sync") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeAdd2", "AnimationNodeAdd2") open fun isUsingSync(): Boolean { val mb = getMethodBind("AnimationNodeAdd2","is_using_sync") return _icall_Boolean( mb, this.ptr) } open fun setUseSync(enable: Boolean) { val mb = getMethodBind("AnimationNodeAdd2","set_use_sync") _icall_Unit_Boolean( mb, this.ptr, enable) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeAdd3.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class AnimationNodeAdd3 : AnimationNode() { open var sync: Boolean get() { val mb = getMethodBind("AnimationNodeAdd3","is_using_sync") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeAdd3","set_use_sync") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeAdd3", "AnimationNodeAdd3") open fun isUsingSync(): Boolean { val mb = getMethodBind("AnimationNodeAdd3","is_using_sync") return _icall_Boolean( mb, this.ptr) } open fun setUseSync(enable: Boolean) { val mb = getMethodBind("AnimationNodeAdd3","set_use_sync") _icall_Unit_Boolean( mb, this.ptr, enable) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeAnimation.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_String import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationNodeAnimation : AnimationRootNode() { open var animation: String get() { val mb = getMethodBind("AnimationNodeAnimation","get_animation") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeAnimation","set_animation") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeAnimation", "AnimationNodeAnimation") open fun getAnimation(): String { val mb = getMethodBind("AnimationNodeAnimation","get_animation") return _icall_String( mb, this.ptr) } open fun setAnimation(name: String) { val mb = getMethodBind("AnimationNodeAnimation","set_animation") _icall_Unit_String( mb, this.ptr, name) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeBlend2.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class AnimationNodeBlend2 : AnimationNode() { open var sync: Boolean get() { val mb = getMethodBind("AnimationNodeBlend2","is_using_sync") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlend2","set_use_sync") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeBlend2", "AnimationNodeBlend2") open fun isUsingSync(): Boolean { val mb = getMethodBind("AnimationNodeBlend2","is_using_sync") return _icall_Boolean( mb, this.ptr) } open fun setUseSync(enable: Boolean) { val mb = getMethodBind("AnimationNodeBlend2","set_use_sync") _icall_Unit_Boolean( mb, this.ptr, enable) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeBlend3.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class AnimationNodeBlend3 : AnimationNode() { open var sync: Boolean get() { val mb = getMethodBind("AnimationNodeBlend3","is_using_sync") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlend3","set_use_sync") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeBlend3", "AnimationNodeBlend3") open fun isUsingSync(): Boolean { val mb = getMethodBind("AnimationNodeBlend3","is_using_sync") return _icall_Boolean( mb, this.ptr) } open fun setUseSync(enable: Boolean) { val mb = getMethodBind("AnimationNodeBlend3","set_use_sync") _icall_Unit_Boolean( mb, this.ptr, enable) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace1D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_AnimationRootNode_Long import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Object_Double_Long import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationNodeBlendSpace1D : AnimationRootNode() { open val blendPoint0_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 0) } open var blendPoint0_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open val blendPoint1_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 1) } open var blendPoint1_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open val blendPoint10_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 10) } open var blendPoint10_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 10, value) } open val blendPoint11_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 11) } open var blendPoint11_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 11, value) } open val blendPoint12_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 12) } open var blendPoint12_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 12) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 12, value) } open val blendPoint13_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 13) } open var blendPoint13_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 13, value) } open val blendPoint14_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 14) } open var blendPoint14_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 14) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 14, value) } open val blendPoint15_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 15) } open var blendPoint15_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 15) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 15, value) } open val blendPoint16_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 16) } open var blendPoint16_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 16, value) } open val blendPoint17_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 17) } open var blendPoint17_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 17) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 17, value) } open val blendPoint18_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 18) } open var blendPoint18_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 18) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 18, value) } open val blendPoint19_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 19) } open var blendPoint19_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 19) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 19, value) } open val blendPoint2_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 2) } open var blendPoint2_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open val blendPoint20_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 20) } open var blendPoint20_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 20) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 20, value) } open val blendPoint21_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 21) } open var blendPoint21_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 21) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 21, value) } open val blendPoint22_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 22) } open var blendPoint22_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 22) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 22, value) } open val blendPoint23_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 23) } open var blendPoint23_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 23) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 23, value) } open val blendPoint24_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 24) } open var blendPoint24_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 24) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 24, value) } open val blendPoint25_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 25) } open var blendPoint25_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 25) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 25, value) } open val blendPoint26_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 26) } open var blendPoint26_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 26) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 26, value) } open val blendPoint27_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 27) } open var blendPoint27_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 27) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 27, value) } open val blendPoint28_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 28) } open var blendPoint28_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 28) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 28, value) } open val blendPoint29_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 29) } open var blendPoint29_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 29) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 29, value) } open val blendPoint3_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 3) } open var blendPoint3_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open val blendPoint30_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 30) } open var blendPoint30_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 30) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 30, value) } open val blendPoint31_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 31) } open var blendPoint31_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 31) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 31, value) } open val blendPoint32_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 32) } open var blendPoint32_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 32) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 32, value) } open val blendPoint33_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 33) } open var blendPoint33_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 33) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 33, value) } open val blendPoint34_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 34) } open var blendPoint34_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 34) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 34, value) } open val blendPoint35_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 35) } open var blendPoint35_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 35) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 35, value) } open val blendPoint36_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 36) } open var blendPoint36_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 36) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 36, value) } open val blendPoint37_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 37) } open var blendPoint37_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 37) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 37, value) } open val blendPoint38_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 38) } open var blendPoint38_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 38) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 38, value) } open val blendPoint39_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 39) } open var blendPoint39_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 39) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 39, value) } open val blendPoint4_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 4) } open var blendPoint4_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open val blendPoint40_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 40) } open var blendPoint40_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 40) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 40, value) } open val blendPoint41_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 41) } open var blendPoint41_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 41) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 41, value) } open val blendPoint42_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 42) } open var blendPoint42_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 42) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 42, value) } open val blendPoint43_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 43) } open var blendPoint43_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 43) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 43, value) } open val blendPoint44_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 44) } open var blendPoint44_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 44) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 44, value) } open val blendPoint45_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 45) } open var blendPoint45_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 45) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 45, value) } open val blendPoint46_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 46) } open var blendPoint46_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 46) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 46, value) } open val blendPoint47_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 47) } open var blendPoint47_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 47) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 47, value) } open val blendPoint48_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 48) } open var blendPoint48_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 48) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 48, value) } open val blendPoint49_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 49) } open var blendPoint49_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 49) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 49, value) } open val blendPoint5_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 5) } open var blendPoint5_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open val blendPoint50_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 50) } open var blendPoint50_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 50) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 50, value) } open val blendPoint51_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 51) } open var blendPoint51_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 51) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 51, value) } open val blendPoint52_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 52) } open var blendPoint52_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 52) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 52, value) } open val blendPoint53_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 53) } open var blendPoint53_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 53) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 53, value) } open val blendPoint54_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 54) } open var blendPoint54_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 54) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 54, value) } open val blendPoint55_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 55) } open var blendPoint55_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 55) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 55, value) } open val blendPoint56_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 56) } open var blendPoint56_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 56) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 56, value) } open val blendPoint57_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 57) } open var blendPoint57_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 57) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 57, value) } open val blendPoint58_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 58) } open var blendPoint58_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 58) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 58, value) } open val blendPoint59_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 59) } open var blendPoint59_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 59) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 59, value) } open val blendPoint6_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 6) } open var blendPoint6_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open val blendPoint60_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 60) } open var blendPoint60_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 60) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 60, value) } open val blendPoint61_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 61) } open var blendPoint61_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 61) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 61, value) } open val blendPoint62_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 62) } open var blendPoint62_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 62) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 62, value) } open val blendPoint63_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 63) } open var blendPoint63_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 63) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 63, value) } open val blendPoint7_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 7) } open var blendPoint7_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open val blendPoint8_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 8) } open var blendPoint8_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open val blendPoint9_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 9) } open var blendPoint9_pos: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var maxSpace: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_max_space") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_max_space") _icall_Unit_Double(mb, this.ptr, value) } open var minSpace: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_min_space") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_min_space") _icall_Unit_Double(mb, this.ptr, value) } open var snap: Double get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_snap") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_snap") _icall_Unit_Double(mb, this.ptr, value) } open var valueLabel: String get() { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_value_label") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_value_label") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeBlendSpace1D", "AnimationNodeBlendSpace1D") open fun _addBlendPoint(index: Long, node: AnimationRootNode) { } open fun _treeChanged() { } open fun addBlendPoint( node: AnimationRootNode, pos: Double, atIndex: Long = -1 ) { val mb = getMethodBind("AnimationNodeBlendSpace1D","add_blend_point") _icall_Unit_Object_Double_Long( mb, this.ptr, node, pos, atIndex) } open fun getBlendPointCount(): Long { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_count") return _icall_Long( mb, this.ptr) } open fun getBlendPointNode(point: Long): AnimationRootNode { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_node") return _icall_AnimationRootNode_Long( mb, this.ptr, point) } open fun getBlendPointPosition(point: Long): Double { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_blend_point_position") return _icall_Double_Long( mb, this.ptr, point) } open fun getMaxSpace(): Double { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_max_space") return _icall_Double( mb, this.ptr) } open fun getMinSpace(): Double { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_min_space") return _icall_Double( mb, this.ptr) } open fun getSnap(): Double { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_snap") return _icall_Double( mb, this.ptr) } open fun getValueLabel(): String { val mb = getMethodBind("AnimationNodeBlendSpace1D","get_value_label") return _icall_String( mb, this.ptr) } open fun removeBlendPoint(point: Long) { val mb = getMethodBind("AnimationNodeBlendSpace1D","remove_blend_point") _icall_Unit_Long( mb, this.ptr, point) } open fun setBlendPointNode(point: Long, node: AnimationRootNode) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_node") _icall_Unit_Long_Object( mb, this.ptr, point, node) } open fun setBlendPointPosition(point: Long, pos: Double) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_blend_point_position") _icall_Unit_Long_Double( mb, this.ptr, point, pos) } open fun setMaxSpace(maxSpace: Double) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_max_space") _icall_Unit_Double( mb, this.ptr, maxSpace) } open fun setMinSpace(minSpace: Double) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_min_space") _icall_Unit_Double( mb, this.ptr, minSpace) } open fun setSnap(snap: Double) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_snap") _icall_Unit_Double( mb, this.ptr, snap) } open fun setValueLabel(text: String) { val mb = getMethodBind("AnimationNodeBlendSpace1D","set_value_label") _icall_Unit_String( mb, this.ptr, text) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeBlendSpace2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AnimationNodeBlendSpace2D import godot.core.PoolIntArray import godot.core.Signal0 import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_AnimationRootNode_Long import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_Long_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Long_Long_Long import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Long_Vector2 import godot.icalls._icall_Unit_Object_Vector2_Long import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class AnimationNodeBlendSpace2D : AnimationRootNode() { val trianglesUpdated: Signal0 by signal() open var autoTriangles: Boolean get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_auto_triangles") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_auto_triangles") _icall_Unit_Boolean(mb, this.ptr, value) } open var blendMode: Long get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_mode") _icall_Unit_Long(mb, this.ptr, value) } open val blendPoint0_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 0) } open var blendPoint0_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 0, value) } open val blendPoint1_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 1) } open var blendPoint1_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 1, value) } open val blendPoint10_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 10) } open var blendPoint10_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 10, value) } open val blendPoint11_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 11) } open var blendPoint11_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 11, value) } open val blendPoint12_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 12) } open var blendPoint12_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 12) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 12, value) } open val blendPoint13_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 13) } open var blendPoint13_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 13, value) } open val blendPoint14_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 14) } open var blendPoint14_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 14) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 14, value) } open val blendPoint15_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 15) } open var blendPoint15_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 15) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 15, value) } open val blendPoint16_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 16) } open var blendPoint16_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 16, value) } open val blendPoint17_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 17) } open var blendPoint17_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 17) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 17, value) } open val blendPoint18_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 18) } open var blendPoint18_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 18) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 18, value) } open val blendPoint19_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 19) } open var blendPoint19_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 19) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 19, value) } open val blendPoint2_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 2) } open var blendPoint2_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 2, value) } open val blendPoint20_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 20) } open var blendPoint20_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 20) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 20, value) } open val blendPoint21_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 21) } open var blendPoint21_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 21) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 21, value) } open val blendPoint22_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 22) } open var blendPoint22_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 22) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 22, value) } open val blendPoint23_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 23) } open var blendPoint23_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 23) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 23, value) } open val blendPoint24_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 24) } open var blendPoint24_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 24) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 24, value) } open val blendPoint25_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 25) } open var blendPoint25_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 25) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 25, value) } open val blendPoint26_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 26) } open var blendPoint26_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 26) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 26, value) } open val blendPoint27_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 27) } open var blendPoint27_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 27) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 27, value) } open val blendPoint28_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 28) } open var blendPoint28_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 28) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 28, value) } open val blendPoint29_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 29) } open var blendPoint29_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 29) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 29, value) } open val blendPoint3_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 3) } open var blendPoint3_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 3, value) } open val blendPoint30_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 30) } open var blendPoint30_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 30) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 30, value) } open val blendPoint31_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 31) } open var blendPoint31_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 31) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 31, value) } open val blendPoint32_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 32) } open var blendPoint32_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 32) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 32, value) } open val blendPoint33_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 33) } open var blendPoint33_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 33) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 33, value) } open val blendPoint34_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 34) } open var blendPoint34_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 34) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 34, value) } open val blendPoint35_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 35) } open var blendPoint35_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 35) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 35, value) } open val blendPoint36_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 36) } open var blendPoint36_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 36) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 36, value) } open val blendPoint37_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 37) } open var blendPoint37_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 37) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 37, value) } open val blendPoint38_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 38) } open var blendPoint38_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 38) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 38, value) } open val blendPoint39_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 39) } open var blendPoint39_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 39) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 39, value) } open val blendPoint4_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 4) } open var blendPoint4_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 4, value) } open val blendPoint40_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 40) } open var blendPoint40_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 40) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 40, value) } open val blendPoint41_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 41) } open var blendPoint41_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 41) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 41, value) } open val blendPoint42_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 42) } open var blendPoint42_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 42) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 42, value) } open val blendPoint43_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 43) } open var blendPoint43_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 43) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 43, value) } open val blendPoint44_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 44) } open var blendPoint44_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 44) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 44, value) } open val blendPoint45_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 45) } open var blendPoint45_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 45) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 45, value) } open val blendPoint46_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 46) } open var blendPoint46_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 46) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 46, value) } open val blendPoint47_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 47) } open var blendPoint47_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 47) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 47, value) } open val blendPoint48_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 48) } open var blendPoint48_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 48) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 48, value) } open val blendPoint49_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 49) } open var blendPoint49_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 49) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 49, value) } open val blendPoint5_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 5) } open var blendPoint5_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 5, value) } open val blendPoint50_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 50) } open var blendPoint50_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 50) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 50, value) } open val blendPoint51_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 51) } open var blendPoint51_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 51) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 51, value) } open val blendPoint52_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 52) } open var blendPoint52_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 52) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 52, value) } open val blendPoint53_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 53) } open var blendPoint53_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 53) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 53, value) } open val blendPoint54_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 54) } open var blendPoint54_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 54) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 54, value) } open val blendPoint55_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 55) } open var blendPoint55_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 55) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 55, value) } open val blendPoint56_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 56) } open var blendPoint56_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 56) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 56, value) } open val blendPoint57_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 57) } open var blendPoint57_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 57) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 57, value) } open val blendPoint58_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 58) } open var blendPoint58_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 58) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 58, value) } open val blendPoint59_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 59) } open var blendPoint59_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 59) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 59, value) } open val blendPoint6_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 6) } open var blendPoint6_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 6, value) } open val blendPoint60_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 60) } open var blendPoint60_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 60) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 60, value) } open val blendPoint61_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 61) } open var blendPoint61_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 61) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 61, value) } open val blendPoint62_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 62) } open var blendPoint62_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 62) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 62, value) } open val blendPoint63_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 63) } open var blendPoint63_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 63) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 63, value) } open val blendPoint7_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 7) } open var blendPoint7_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 7, value) } open val blendPoint8_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 8) } open var blendPoint8_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 8, value) } open val blendPoint9_node: AnimationRootNode get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long(mb, this.ptr, 9) } open var blendPoint9_pos: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2(mb, this.ptr, 9, value) } open var maxSpace: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_max_space") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_max_space") _icall_Unit_Vector2(mb, this.ptr, value) } open var minSpace: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_min_space") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_min_space") _icall_Unit_Vector2(mb, this.ptr, value) } open var snap: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_snap") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_snap") _icall_Unit_Vector2(mb, this.ptr, value) } open var xLabel: String get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_x_label") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_x_label") _icall_Unit_String(mb, this.ptr, value) } open var yLabel: String get() { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_y_label") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_y_label") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeBlendSpace2D", "AnimationNodeBlendSpace2D") open fun blendPoint0_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint0_pos.apply{ schedule(this) blendPoint0_pos = this } open fun blendPoint1_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint1_pos.apply{ schedule(this) blendPoint1_pos = this } open fun blendPoint10_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint10_pos.apply{ schedule(this) blendPoint10_pos = this } open fun blendPoint11_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint11_pos.apply{ schedule(this) blendPoint11_pos = this } open fun blendPoint12_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint12_pos.apply{ schedule(this) blendPoint12_pos = this } open fun blendPoint13_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint13_pos.apply{ schedule(this) blendPoint13_pos = this } open fun blendPoint14_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint14_pos.apply{ schedule(this) blendPoint14_pos = this } open fun blendPoint15_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint15_pos.apply{ schedule(this) blendPoint15_pos = this } open fun blendPoint16_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint16_pos.apply{ schedule(this) blendPoint16_pos = this } open fun blendPoint17_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint17_pos.apply{ schedule(this) blendPoint17_pos = this } open fun blendPoint18_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint18_pos.apply{ schedule(this) blendPoint18_pos = this } open fun blendPoint19_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint19_pos.apply{ schedule(this) blendPoint19_pos = this } open fun blendPoint2_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint2_pos.apply{ schedule(this) blendPoint2_pos = this } open fun blendPoint20_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint20_pos.apply{ schedule(this) blendPoint20_pos = this } open fun blendPoint21_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint21_pos.apply{ schedule(this) blendPoint21_pos = this } open fun blendPoint22_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint22_pos.apply{ schedule(this) blendPoint22_pos = this } open fun blendPoint23_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint23_pos.apply{ schedule(this) blendPoint23_pos = this } open fun blendPoint24_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint24_pos.apply{ schedule(this) blendPoint24_pos = this } open fun blendPoint25_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint25_pos.apply{ schedule(this) blendPoint25_pos = this } open fun blendPoint26_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint26_pos.apply{ schedule(this) blendPoint26_pos = this } open fun blendPoint27_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint27_pos.apply{ schedule(this) blendPoint27_pos = this } open fun blendPoint28_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint28_pos.apply{ schedule(this) blendPoint28_pos = this } open fun blendPoint29_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint29_pos.apply{ schedule(this) blendPoint29_pos = this } open fun blendPoint3_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint3_pos.apply{ schedule(this) blendPoint3_pos = this } open fun blendPoint30_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint30_pos.apply{ schedule(this) blendPoint30_pos = this } open fun blendPoint31_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint31_pos.apply{ schedule(this) blendPoint31_pos = this } open fun blendPoint32_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint32_pos.apply{ schedule(this) blendPoint32_pos = this } open fun blendPoint33_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint33_pos.apply{ schedule(this) blendPoint33_pos = this } open fun blendPoint34_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint34_pos.apply{ schedule(this) blendPoint34_pos = this } open fun blendPoint35_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint35_pos.apply{ schedule(this) blendPoint35_pos = this } open fun blendPoint36_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint36_pos.apply{ schedule(this) blendPoint36_pos = this } open fun blendPoint37_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint37_pos.apply{ schedule(this) blendPoint37_pos = this } open fun blendPoint38_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint38_pos.apply{ schedule(this) blendPoint38_pos = this } open fun blendPoint39_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint39_pos.apply{ schedule(this) blendPoint39_pos = this } open fun blendPoint4_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint4_pos.apply{ schedule(this) blendPoint4_pos = this } open fun blendPoint40_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint40_pos.apply{ schedule(this) blendPoint40_pos = this } open fun blendPoint41_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint41_pos.apply{ schedule(this) blendPoint41_pos = this } open fun blendPoint42_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint42_pos.apply{ schedule(this) blendPoint42_pos = this } open fun blendPoint43_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint43_pos.apply{ schedule(this) blendPoint43_pos = this } open fun blendPoint44_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint44_pos.apply{ schedule(this) blendPoint44_pos = this } open fun blendPoint45_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint45_pos.apply{ schedule(this) blendPoint45_pos = this } open fun blendPoint46_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint46_pos.apply{ schedule(this) blendPoint46_pos = this } open fun blendPoint47_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint47_pos.apply{ schedule(this) blendPoint47_pos = this } open fun blendPoint48_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint48_pos.apply{ schedule(this) blendPoint48_pos = this } open fun blendPoint49_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint49_pos.apply{ schedule(this) blendPoint49_pos = this } open fun blendPoint5_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint5_pos.apply{ schedule(this) blendPoint5_pos = this } open fun blendPoint50_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint50_pos.apply{ schedule(this) blendPoint50_pos = this } open fun blendPoint51_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint51_pos.apply{ schedule(this) blendPoint51_pos = this } open fun blendPoint52_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint52_pos.apply{ schedule(this) blendPoint52_pos = this } open fun blendPoint53_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint53_pos.apply{ schedule(this) blendPoint53_pos = this } open fun blendPoint54_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint54_pos.apply{ schedule(this) blendPoint54_pos = this } open fun blendPoint55_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint55_pos.apply{ schedule(this) blendPoint55_pos = this } open fun blendPoint56_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint56_pos.apply{ schedule(this) blendPoint56_pos = this } open fun blendPoint57_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint57_pos.apply{ schedule(this) blendPoint57_pos = this } open fun blendPoint58_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint58_pos.apply{ schedule(this) blendPoint58_pos = this } open fun blendPoint59_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint59_pos.apply{ schedule(this) blendPoint59_pos = this } open fun blendPoint6_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint6_pos.apply{ schedule(this) blendPoint6_pos = this } open fun blendPoint60_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint60_pos.apply{ schedule(this) blendPoint60_pos = this } open fun blendPoint61_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint61_pos.apply{ schedule(this) blendPoint61_pos = this } open fun blendPoint62_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint62_pos.apply{ schedule(this) blendPoint62_pos = this } open fun blendPoint63_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint63_pos.apply{ schedule(this) blendPoint63_pos = this } open fun blendPoint7_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint7_pos.apply{ schedule(this) blendPoint7_pos = this } open fun blendPoint8_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint8_pos.apply{ schedule(this) blendPoint8_pos = this } open fun blendPoint9_pos(schedule: Vector2.() -> Unit): Vector2 = blendPoint9_pos.apply{ schedule(this) blendPoint9_pos = this } open fun maxSpace(schedule: Vector2.() -> Unit): Vector2 = maxSpace.apply{ schedule(this) maxSpace = this } open fun minSpace(schedule: Vector2.() -> Unit): Vector2 = minSpace.apply{ schedule(this) minSpace = this } open fun snap(schedule: Vector2.() -> Unit): Vector2 = snap.apply{ schedule(this) snap = this } open fun _addBlendPoint(index: Long, node: AnimationRootNode) { } open fun _getTriangles(): PoolIntArray { throw NotImplementedError("_get_triangles is not implemented for AnimationNodeBlendSpace2D") } open fun _setTriangles(triangles: PoolIntArray) { } open fun _treeChanged() { } open fun _updateTriangles() { } open fun addBlendPoint( node: AnimationRootNode, pos: Vector2, atIndex: Long = -1 ) { val mb = getMethodBind("AnimationNodeBlendSpace2D","add_blend_point") _icall_Unit_Object_Vector2_Long( mb, this.ptr, node, pos, atIndex) } open fun addTriangle( x: Long, y: Long, z: Long, atIndex: Long = -1 ) { val mb = getMethodBind("AnimationNodeBlendSpace2D","add_triangle") _icall_Unit_Long_Long_Long_Long( mb, this.ptr, x, y, z, atIndex) } open fun getAutoTriangles(): Boolean { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_auto_triangles") return _icall_Boolean( mb, this.ptr) } open fun getBlendMode(): AnimationNodeBlendSpace2D.BlendMode { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_mode") return AnimationNodeBlendSpace2D.BlendMode.from( _icall_Long( mb, this.ptr)) } open fun getBlendPointCount(): Long { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_count") return _icall_Long( mb, this.ptr) } open fun getBlendPointNode(point: Long): AnimationRootNode { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_node") return _icall_AnimationRootNode_Long( mb, this.ptr, point) } open fun getBlendPointPosition(point: Long): Vector2 { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_blend_point_position") return _icall_Vector2_Long( mb, this.ptr, point) } open fun getMaxSpace(): Vector2 { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_max_space") return _icall_Vector2( mb, this.ptr) } open fun getMinSpace(): Vector2 { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_min_space") return _icall_Vector2( mb, this.ptr) } open fun getSnap(): Vector2 { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_snap") return _icall_Vector2( mb, this.ptr) } open fun getTriangleCount(): Long { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_triangle_count") return _icall_Long( mb, this.ptr) } open fun getTrianglePoint(triangle: Long, point: Long): Long { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_triangle_point") return _icall_Long_Long_Long( mb, this.ptr, triangle, point) } open fun getXLabel(): String { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_x_label") return _icall_String( mb, this.ptr) } open fun getYLabel(): String { val mb = getMethodBind("AnimationNodeBlendSpace2D","get_y_label") return _icall_String( mb, this.ptr) } open fun removeBlendPoint(point: Long) { val mb = getMethodBind("AnimationNodeBlendSpace2D","remove_blend_point") _icall_Unit_Long( mb, this.ptr, point) } open fun removeTriangle(triangle: Long) { val mb = getMethodBind("AnimationNodeBlendSpace2D","remove_triangle") _icall_Unit_Long( mb, this.ptr, triangle) } open fun setAutoTriangles(enable: Boolean) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_auto_triangles") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setBlendMode(mode: Long) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setBlendPointNode(point: Long, node: AnimationRootNode) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_node") _icall_Unit_Long_Object( mb, this.ptr, point, node) } open fun setBlendPointPosition(point: Long, pos: Vector2) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_blend_point_position") _icall_Unit_Long_Vector2( mb, this.ptr, point, pos) } open fun setMaxSpace(maxSpace: Vector2) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_max_space") _icall_Unit_Vector2( mb, this.ptr, maxSpace) } open fun setMinSpace(minSpace: Vector2) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_min_space") _icall_Unit_Vector2( mb, this.ptr, minSpace) } open fun setSnap(snap: Vector2) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_snap") _icall_Unit_Vector2( mb, this.ptr, snap) } open fun setXLabel(text: String) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_x_label") _icall_Unit_String( mb, this.ptr, text) } open fun setYLabel(text: String) { val mb = getMethodBind("AnimationNodeBlendSpace2D","set_y_label") _icall_Unit_String( mb, this.ptr, text) } enum class BlendMode( id: Long ) { BLEND_MODE_INTERPOLATED(0), BLEND_MODE_DISCRETE(1), BLEND_MODE_DISCRETE_CARRY(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeBlendTree.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_AnimationNode_String import godot.icalls._icall_Boolean_String import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Long import godot.icalls._icall_Unit_String_Long_String import godot.icalls._icall_Unit_String_Object_Vector2 import godot.icalls._icall_Unit_String_String import godot.icalls._icall_Unit_String_Vector2 import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class AnimationNodeBlendTree : AnimationRootNode() { open var graphOffset: Vector2 get() { val mb = getMethodBind("AnimationNodeBlendTree","get_graph_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeBlendTree","set_graph_offset") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeBlendTree", "AnimationNodeBlendTree") open fun graphOffset(schedule: Vector2.() -> Unit): Vector2 = graphOffset.apply{ schedule(this) graphOffset = this } open fun _nodeChanged(node: String) { } open fun _treeChanged() { } open fun addNode( name: String, node: AnimationNode, position: Vector2 = Vector2(0.0, 0.0) ) { val mb = getMethodBind("AnimationNodeBlendTree","add_node") _icall_Unit_String_Object_Vector2( mb, this.ptr, name, node, position) } open fun connectNode( inputNode: String, inputIndex: Long, outputNode: String ) { val mb = getMethodBind("AnimationNodeBlendTree","connect_node") _icall_Unit_String_Long_String( mb, this.ptr, inputNode, inputIndex, outputNode) } open fun disconnectNode(inputNode: String, inputIndex: Long) { val mb = getMethodBind("AnimationNodeBlendTree","disconnect_node") _icall_Unit_String_Long( mb, this.ptr, inputNode, inputIndex) } open fun getGraphOffset(): Vector2 { val mb = getMethodBind("AnimationNodeBlendTree","get_graph_offset") return _icall_Vector2( mb, this.ptr) } open fun getNode(name: String): AnimationNode { val mb = getMethodBind("AnimationNodeBlendTree","get_node") return _icall_AnimationNode_String( mb, this.ptr, name) } open fun getNodePosition(name: String): Vector2 { val mb = getMethodBind("AnimationNodeBlendTree","get_node_position") return _icall_Vector2_String( mb, this.ptr, name) } open fun hasNode(name: String): Boolean { val mb = getMethodBind("AnimationNodeBlendTree","has_node") return _icall_Boolean_String( mb, this.ptr, name) } open fun removeNode(name: String) { val mb = getMethodBind("AnimationNodeBlendTree","remove_node") _icall_Unit_String( mb, this.ptr, name) } open fun renameNode(name: String, newName: String) { val mb = getMethodBind("AnimationNodeBlendTree","rename_node") _icall_Unit_String_String( mb, this.ptr, name, newName) } open fun setGraphOffset(offset: Vector2) { val mb = getMethodBind("AnimationNodeBlendTree","set_graph_offset") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun setNodePosition(name: String, position: Vector2) { val mb = getMethodBind("AnimationNodeBlendTree","set_node_position") _icall_Unit_String_Vector2( mb, this.ptr, name, position) } companion object { final const val CONNECTION_ERROR_CONNECTION_EXISTS: Long = 5 final const val CONNECTION_ERROR_NO_INPUT: Long = 1 final const val CONNECTION_ERROR_NO_INPUT_INDEX: Long = 2 final const val CONNECTION_ERROR_NO_OUTPUT: Long = 3 final const val CONNECTION_ERROR_SAME_NODE: Long = 4 final const val CONNECTION_OK: Long = 0 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeOneShot.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AnimationNodeOneShot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class AnimationNodeOneShot : AnimationNode() { open var autorestart: Boolean get() { val mb = getMethodBind("AnimationNodeOneShot","has_autorestart") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeOneShot","set_autorestart") _icall_Unit_Boolean(mb, this.ptr, value) } open var autorestartDelay: Double get() { val mb = getMethodBind("AnimationNodeOneShot","get_autorestart_delay") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeOneShot","set_autorestart_delay") _icall_Unit_Double(mb, this.ptr, value) } open var autorestartRandomDelay: Double get() { val mb = getMethodBind("AnimationNodeOneShot","get_autorestart_random_delay") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeOneShot","set_autorestart_random_delay") _icall_Unit_Double(mb, this.ptr, value) } open var fadeinTime: Double get() { val mb = getMethodBind("AnimationNodeOneShot","get_fadein_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeOneShot","set_fadein_time") _icall_Unit_Double(mb, this.ptr, value) } open var fadeoutTime: Double get() { val mb = getMethodBind("AnimationNodeOneShot","get_fadeout_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeOneShot","set_fadeout_time") _icall_Unit_Double(mb, this.ptr, value) } open var sync: Boolean get() { val mb = getMethodBind("AnimationNodeOneShot","is_using_sync") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeOneShot","set_use_sync") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeOneShot", "AnimationNodeOneShot") open fun getAutorestartDelay(): Double { val mb = getMethodBind("AnimationNodeOneShot","get_autorestart_delay") return _icall_Double( mb, this.ptr) } open fun getAutorestartRandomDelay(): Double { val mb = getMethodBind("AnimationNodeOneShot","get_autorestart_random_delay") return _icall_Double( mb, this.ptr) } open fun getFadeinTime(): Double { val mb = getMethodBind("AnimationNodeOneShot","get_fadein_time") return _icall_Double( mb, this.ptr) } open fun getFadeoutTime(): Double { val mb = getMethodBind("AnimationNodeOneShot","get_fadeout_time") return _icall_Double( mb, this.ptr) } open fun getMixMode(): AnimationNodeOneShot.MixMode { val mb = getMethodBind("AnimationNodeOneShot","get_mix_mode") return AnimationNodeOneShot.MixMode.from( _icall_Long( mb, this.ptr)) } open fun hasAutorestart(): Boolean { val mb = getMethodBind("AnimationNodeOneShot","has_autorestart") return _icall_Boolean( mb, this.ptr) } open fun isUsingSync(): Boolean { val mb = getMethodBind("AnimationNodeOneShot","is_using_sync") return _icall_Boolean( mb, this.ptr) } open fun setAutorestart(enable: Boolean) { val mb = getMethodBind("AnimationNodeOneShot","set_autorestart") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setAutorestartDelay(enable: Double) { val mb = getMethodBind("AnimationNodeOneShot","set_autorestart_delay") _icall_Unit_Double( mb, this.ptr, enable) } open fun setAutorestartRandomDelay(enable: Double) { val mb = getMethodBind("AnimationNodeOneShot","set_autorestart_random_delay") _icall_Unit_Double( mb, this.ptr, enable) } open fun setFadeinTime(time: Double) { val mb = getMethodBind("AnimationNodeOneShot","set_fadein_time") _icall_Unit_Double( mb, this.ptr, time) } open fun setFadeoutTime(time: Double) { val mb = getMethodBind("AnimationNodeOneShot","set_fadeout_time") _icall_Unit_Double( mb, this.ptr, time) } open fun setMixMode(mode: Long) { val mb = getMethodBind("AnimationNodeOneShot","set_mix_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setUseSync(enable: Boolean) { val mb = getMethodBind("AnimationNodeOneShot","set_use_sync") _icall_Unit_Boolean( mb, this.ptr, enable) } enum class MixMode( id: Long ) { MIX_MODE_BLEND(0), MIX_MODE_ADD(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeOutput.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AnimationNodeOutput : AnimationNode() { override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeOutput", "AnimationNodeOutput") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeStateMachine.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_AnimationNodeStateMachineTransition_Long import godot.icalls._icall_AnimationNode_String import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_String import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_String_Long import godot.icalls._icall_String_Object import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Object import godot.icalls._icall_Unit_String_Object_Vector2 import godot.icalls._icall_Unit_String_String import godot.icalls._icall_Unit_String_String_Object import godot.icalls._icall_Unit_String_Vector2 import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationNodeStateMachine : AnimationRootNode() { override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeStateMachine", "AnimationNodeStateMachine") open fun _treeChanged() { } open fun addNode( name: String, node: AnimationNode, position: Vector2 = Vector2(0.0, 0.0) ) { val mb = getMethodBind("AnimationNodeStateMachine","add_node") _icall_Unit_String_Object_Vector2( mb, this.ptr, name, node, position) } open fun addTransition( from: String, to: String, transition: AnimationNodeStateMachineTransition ) { val mb = getMethodBind("AnimationNodeStateMachine","add_transition") _icall_Unit_String_String_Object( mb, this.ptr, from, to, transition) } open fun getEndNode(): String { val mb = getMethodBind("AnimationNodeStateMachine","get_end_node") return _icall_String( mb, this.ptr) } open fun getGraphOffset(): Vector2 { val mb = getMethodBind("AnimationNodeStateMachine","get_graph_offset") return _icall_Vector2( mb, this.ptr) } open fun getNode(name: String): AnimationNode { val mb = getMethodBind("AnimationNodeStateMachine","get_node") return _icall_AnimationNode_String( mb, this.ptr, name) } open fun getNodeName(node: AnimationNode): String { val mb = getMethodBind("AnimationNodeStateMachine","get_node_name") return _icall_String_Object( mb, this.ptr, node) } open fun getNodePosition(name: String): Vector2 { val mb = getMethodBind("AnimationNodeStateMachine","get_node_position") return _icall_Vector2_String( mb, this.ptr, name) } open fun getStartNode(): String { val mb = getMethodBind("AnimationNodeStateMachine","get_start_node") return _icall_String( mb, this.ptr) } open fun getTransition(idx: Long): AnimationNodeStateMachineTransition { val mb = getMethodBind("AnimationNodeStateMachine","get_transition") return _icall_AnimationNodeStateMachineTransition_Long( mb, this.ptr, idx) } open fun getTransitionCount(): Long { val mb = getMethodBind("AnimationNodeStateMachine","get_transition_count") return _icall_Long( mb, this.ptr) } open fun getTransitionFrom(idx: Long): String { val mb = getMethodBind("AnimationNodeStateMachine","get_transition_from") return _icall_String_Long( mb, this.ptr, idx) } open fun getTransitionTo(idx: Long): String { val mb = getMethodBind("AnimationNodeStateMachine","get_transition_to") return _icall_String_Long( mb, this.ptr, idx) } open fun hasNode(name: String): Boolean { val mb = getMethodBind("AnimationNodeStateMachine","has_node") return _icall_Boolean_String( mb, this.ptr, name) } open fun hasTransition(from: String, to: String): Boolean { val mb = getMethodBind("AnimationNodeStateMachine","has_transition") return _icall_Boolean_String_String( mb, this.ptr, from, to) } open fun removeNode(name: String) { val mb = getMethodBind("AnimationNodeStateMachine","remove_node") _icall_Unit_String( mb, this.ptr, name) } open fun removeTransition(from: String, to: String) { val mb = getMethodBind("AnimationNodeStateMachine","remove_transition") _icall_Unit_String_String( mb, this.ptr, from, to) } open fun removeTransitionByIndex(idx: Long) { val mb = getMethodBind("AnimationNodeStateMachine","remove_transition_by_index") _icall_Unit_Long( mb, this.ptr, idx) } open fun renameNode(name: String, newName: String) { val mb = getMethodBind("AnimationNodeStateMachine","rename_node") _icall_Unit_String_String( mb, this.ptr, name, newName) } open fun replaceNode(name: String, node: AnimationNode) { val mb = getMethodBind("AnimationNodeStateMachine","replace_node") _icall_Unit_String_Object( mb, this.ptr, name, node) } open fun setEndNode(name: String) { val mb = getMethodBind("AnimationNodeStateMachine","set_end_node") _icall_Unit_String( mb, this.ptr, name) } open fun setGraphOffset(offset: Vector2) { val mb = getMethodBind("AnimationNodeStateMachine","set_graph_offset") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun setNodePosition(name: String, position: Vector2) { val mb = getMethodBind("AnimationNodeStateMachine","set_node_position") _icall_Unit_String_Vector2( mb, this.ptr, name, position) } open fun setStartNode(name: String) { val mb = getMethodBind("AnimationNodeStateMachine","set_start_node") _icall_Unit_String( mb, this.ptr, name) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeStateMachinePlayback.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.icalls._icall_Boolean import godot.icalls._icall_PoolStringArray import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationNodeStateMachinePlayback : Resource() { override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeStateMachinePlayback", "AnimationNodeStateMachinePlayback") open fun getCurrentNode(): String { val mb = getMethodBind("AnimationNodeStateMachinePlayback","get_current_node") return _icall_String( mb, this.ptr) } open fun getTravelPath(): PoolStringArray { val mb = getMethodBind("AnimationNodeStateMachinePlayback","get_travel_path") return _icall_PoolStringArray( mb, this.ptr) } open fun isPlaying(): Boolean { val mb = getMethodBind("AnimationNodeStateMachinePlayback","is_playing") return _icall_Boolean( mb, this.ptr) } open fun start(node: String) { val mb = getMethodBind("AnimationNodeStateMachinePlayback","start") _icall_Unit_String( mb, this.ptr, node) } open fun stop() { val mb = getMethodBind("AnimationNodeStateMachinePlayback","stop") _icall_Unit( mb, this.ptr) } open fun travel(toNode: String) { val mb = getMethodBind("AnimationNodeStateMachinePlayback","travel") _icall_Unit_String( mb, this.ptr, toNode) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeStateMachineTransition.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AnimationNodeStateMachineTransition import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationNodeStateMachineTransition : Resource() { val advanceConditionChanged: Signal0 by signal() open var advanceCondition: String get() { val mb = getMethodBind("AnimationNodeStateMachineTransition","get_advance_condition") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_advance_condition") _icall_Unit_String(mb, this.ptr, value) } open var autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeStateMachineTransition","has_auto_advance") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_auto_advance") _icall_Unit_Boolean(mb, this.ptr, value) } open var disabled: Boolean get() { val mb = getMethodBind("AnimationNodeStateMachineTransition","is_disabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_disabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var priority: Long get() { val mb = getMethodBind("AnimationNodeStateMachineTransition","get_priority") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_priority") _icall_Unit_Long(mb, this.ptr, value) } open var switchMode: Long get() { val mb = getMethodBind("AnimationNodeStateMachineTransition","get_switch_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_switch_mode") _icall_Unit_Long(mb, this.ptr, value) } open var xfadeTime: Double get() { val mb = getMethodBind("AnimationNodeStateMachineTransition","get_xfade_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_xfade_time") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeStateMachineTransition", "AnimationNodeStateMachineTransition") open fun getAdvanceCondition(): String { val mb = getMethodBind("AnimationNodeStateMachineTransition","get_advance_condition") return _icall_String( mb, this.ptr) } open fun getPriority(): Long { val mb = getMethodBind("AnimationNodeStateMachineTransition","get_priority") return _icall_Long( mb, this.ptr) } open fun getSwitchMode(): AnimationNodeStateMachineTransition.SwitchMode { val mb = getMethodBind("AnimationNodeStateMachineTransition","get_switch_mode") return AnimationNodeStateMachineTransition.SwitchMode.from( _icall_Long( mb, this.ptr)) } open fun getXfadeTime(): Double { val mb = getMethodBind("AnimationNodeStateMachineTransition","get_xfade_time") return _icall_Double( mb, this.ptr) } open fun hasAutoAdvance(): Boolean { val mb = getMethodBind("AnimationNodeStateMachineTransition","has_auto_advance") return _icall_Boolean( mb, this.ptr) } open fun isDisabled(): Boolean { val mb = getMethodBind("AnimationNodeStateMachineTransition","is_disabled") return _icall_Boolean( mb, this.ptr) } open fun setAdvanceCondition(name: String) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_advance_condition") _icall_Unit_String( mb, this.ptr, name) } open fun setAutoAdvance(autoAdvance: Boolean) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_auto_advance") _icall_Unit_Boolean( mb, this.ptr, autoAdvance) } open fun setDisabled(disabled: Boolean) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_disabled") _icall_Unit_Boolean( mb, this.ptr, disabled) } open fun setPriority(priority: Long) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_priority") _icall_Unit_Long( mb, this.ptr, priority) } open fun setSwitchMode(mode: Long) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_switch_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setXfadeTime(secs: Double) { val mb = getMethodBind("AnimationNodeStateMachineTransition","set_xfade_time") _icall_Unit_Double( mb, this.ptr, secs) } enum class SwitchMode( id: Long ) { SWITCH_MODE_IMMEDIATE(0), SWITCH_MODE_SYNC(1), SWITCH_MODE_AT_END(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeTimeScale.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AnimationNodeTimeScale : AnimationNode() { override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeTimeScale", "AnimationNodeTimeScale") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeTimeSeek.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AnimationNodeTimeSeek : AnimationNode() { override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeTimeSeek", "AnimationNodeTimeSeek") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationNodeTransition.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_String_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationNodeTransition : AnimationNode() { open var input0_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open var input0_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 0, value) } open var input1_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var input1_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 1, value) } open var input10_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 10, value) } open var input10_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 10, value) } open var input11_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 11, value) } open var input11_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 11, value) } open var input12_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 12) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 12, value) } open var input12_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 12) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 12, value) } open var input13_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 13, value) } open var input13_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 13, value) } open var input14_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 14) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 14, value) } open var input14_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 14) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 14, value) } open var input15_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 15) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 15, value) } open var input15_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 15) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 15, value) } open var input16_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 16, value) } open var input16_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 16, value) } open var input17_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 17) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 17, value) } open var input17_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 17) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 17, value) } open var input18_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 18) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 18, value) } open var input18_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 18) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 18, value) } open var input19_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 19) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 19, value) } open var input19_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 19) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 19, value) } open var input2_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 2, value) } open var input2_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 2, value) } open var input20_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 20) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 20, value) } open var input20_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 20) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 20, value) } open var input21_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 21) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 21, value) } open var input21_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 21) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 21, value) } open var input22_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 22) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 22, value) } open var input22_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 22) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 22, value) } open var input23_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 23) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 23, value) } open var input23_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 23) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 23, value) } open var input24_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 24) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 24, value) } open var input24_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 24) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 24, value) } open var input25_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 25) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 25, value) } open var input25_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 25) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 25, value) } open var input26_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 26) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 26, value) } open var input26_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 26) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 26, value) } open var input27_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 27) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 27, value) } open var input27_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 27) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 27, value) } open var input28_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 28) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 28, value) } open var input28_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 28) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 28, value) } open var input29_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 29) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 29, value) } open var input29_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 29) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 29, value) } open var input3_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 3, value) } open var input3_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 3, value) } open var input30_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 30) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 30, value) } open var input30_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 30) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 30, value) } open var input31_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 31) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 31, value) } open var input31_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 31) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 31, value) } open var input4_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 4, value) } open var input4_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 4, value) } open var input5_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 5, value) } open var input5_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 5, value) } open var input6_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 6, value) } open var input6_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 6, value) } open var input7_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 7, value) } open var input7_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 7, value) } open var input8_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 8, value) } open var input8_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 8, value) } open var input9_autoAdvance: Boolean get() { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean(mb, this.ptr, 9, value) } open var input9_name: String get() { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String(mb, this.ptr, 9, value) } open var inputCount: Long get() { val mb = getMethodBind("AnimationNodeTransition","get_enabled_inputs") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_enabled_inputs") _icall_Unit_Long(mb, this.ptr, value) } open var xfadeTime: Double get() { val mb = getMethodBind("AnimationNodeTransition","get_cross_fade_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationNodeTransition","set_cross_fade_time") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationNodeTransition", "AnimationNodeTransition") open fun getCrossFadeTime(): Double { val mb = getMethodBind("AnimationNodeTransition","get_cross_fade_time") return _icall_Double( mb, this.ptr) } open fun getEnabledInputs(): Long { val mb = getMethodBind("AnimationNodeTransition","get_enabled_inputs") return _icall_Long( mb, this.ptr) } open fun getInputCaption(input: Long): String { val mb = getMethodBind("AnimationNodeTransition","get_input_caption") return _icall_String_Long( mb, this.ptr, input) } open fun isInputSetAsAutoAdvance(input: Long): Boolean { val mb = getMethodBind("AnimationNodeTransition","is_input_set_as_auto_advance") return _icall_Boolean_Long( mb, this.ptr, input) } open fun setCrossFadeTime(time: Double) { val mb = getMethodBind("AnimationNodeTransition","set_cross_fade_time") _icall_Unit_Double( mb, this.ptr, time) } open fun setEnabledInputs(amount: Long) { val mb = getMethodBind("AnimationNodeTransition","set_enabled_inputs") _icall_Unit_Long( mb, this.ptr, amount) } open fun setInputAsAutoAdvance(input: Long, enable: Boolean) { val mb = getMethodBind("AnimationNodeTransition","set_input_as_auto_advance") _icall_Unit_Long_Boolean( mb, this.ptr, input, enable) } open fun setInputCaption(input: Long, caption: String) { val mb = getMethodBind("AnimationNodeTransition","set_input_caption") _icall_Unit_Long_String( mb, this.ptr, input, caption) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationPlayer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AnimationPlayer import godot.core.GodotError import godot.core.NodePath import godot.core.PoolStringArray import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal2 import godot.core.signal import godot.icalls._icall_Animation_String import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_String import godot.icalls._icall_Double import godot.icalls._icall_Double_String_String import godot.icalls._icall_Long import godot.icalls._icall_Long_String_Object import godot.icalls._icall_NodePath import godot.icalls._icall_PoolStringArray import godot.icalls._icall_String import godot.icalls._icall_String_Object import godot.icalls._icall_String_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Double_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_NodePath import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Double import godot.icalls._icall_Unit_String_Double_Double_Boolean import godot.icalls._icall_Unit_String_String import godot.icalls._icall_Unit_String_String_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationPlayer : Node() { val animationChanged: Signal2 by signal("old_name", "new_name") val animationFinished: Signal1 by signal("anim_name") val animationStarted: Signal1 by signal("anim_name") val cachesCleared: Signal0 by signal() open var assignedAnimation: String get() { val mb = getMethodBind("AnimationPlayer","get_assigned_animation") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationPlayer","set_assigned_animation") _icall_Unit_String(mb, this.ptr, value) } open var autoplay: String get() { val mb = getMethodBind("AnimationPlayer","get_autoplay") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationPlayer","set_autoplay") _icall_Unit_String(mb, this.ptr, value) } open var currentAnimation: String get() { val mb = getMethodBind("AnimationPlayer","get_current_animation") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationPlayer","set_current_animation") _icall_Unit_String(mb, this.ptr, value) } open val currentAnimationLength: Double get() { val mb = getMethodBind("AnimationPlayer","get_current_animation_length") return _icall_Double(mb, this.ptr) } open val currentAnimationPosition: Double get() { val mb = getMethodBind("AnimationPlayer","get_current_animation_position") return _icall_Double(mb, this.ptr) } open var methodCallMode: Long get() { val mb = getMethodBind("AnimationPlayer","get_method_call_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationPlayer","set_method_call_mode") _icall_Unit_Long(mb, this.ptr, value) } open var playbackActive: Boolean get() { val mb = getMethodBind("AnimationPlayer","is_active") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationPlayer","set_active") _icall_Unit_Boolean(mb, this.ptr, value) } open var playbackDefaultBlendTime: Double get() { val mb = getMethodBind("AnimationPlayer","get_default_blend_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationPlayer","set_default_blend_time") _icall_Unit_Double(mb, this.ptr, value) } open var playbackProcessMode: Long get() { val mb = getMethodBind("AnimationPlayer","get_animation_process_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationPlayer","set_animation_process_mode") _icall_Unit_Long(mb, this.ptr, value) } open var playbackSpeed: Double get() { val mb = getMethodBind("AnimationPlayer","get_speed_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationPlayer","set_speed_scale") _icall_Unit_Double(mb, this.ptr, value) } open var rootNode: NodePath get() { val mb = getMethodBind("AnimationPlayer","get_root") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationPlayer","set_root") _icall_Unit_NodePath(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationPlayer", "AnimationPlayer") open fun _animationChanged() { } open fun _nodeRemoved(arg0: Node) { } open fun addAnimation(name: String, animation: Animation): GodotError { val mb = getMethodBind("AnimationPlayer","add_animation") return GodotError.byValue( _icall_Long_String_Object( mb, this.ptr, name, animation).toUInt()) } open fun advance(delta: Double) { val mb = getMethodBind("AnimationPlayer","advance") _icall_Unit_Double( mb, this.ptr, delta) } open fun animationGetNext(animFrom: String): String { val mb = getMethodBind("AnimationPlayer","animation_get_next") return _icall_String_String( mb, this.ptr, animFrom) } open fun animationSetNext(animFrom: String, animTo: String) { val mb = getMethodBind("AnimationPlayer","animation_set_next") _icall_Unit_String_String( mb, this.ptr, animFrom, animTo) } open fun clearCaches() { val mb = getMethodBind("AnimationPlayer","clear_caches") _icall_Unit( mb, this.ptr) } open fun clearQueue() { val mb = getMethodBind("AnimationPlayer","clear_queue") _icall_Unit( mb, this.ptr) } open fun findAnimation(animation: Animation): String { val mb = getMethodBind("AnimationPlayer","find_animation") return _icall_String_Object( mb, this.ptr, animation) } open fun getAnimation(name: String): Animation { val mb = getMethodBind("AnimationPlayer","get_animation") return _icall_Animation_String( mb, this.ptr, name) } open fun getAnimationList(): PoolStringArray { val mb = getMethodBind("AnimationPlayer","get_animation_list") return _icall_PoolStringArray( mb, this.ptr) } open fun getAnimationProcessMode(): AnimationPlayer.AnimationProcessMode { val mb = getMethodBind("AnimationPlayer","get_animation_process_mode") return AnimationPlayer.AnimationProcessMode.from( _icall_Long( mb, this.ptr)) } open fun getAssignedAnimation(): String { val mb = getMethodBind("AnimationPlayer","get_assigned_animation") return _icall_String( mb, this.ptr) } open fun getAutoplay(): String { val mb = getMethodBind("AnimationPlayer","get_autoplay") return _icall_String( mb, this.ptr) } open fun getBlendTime(animFrom: String, animTo: String): Double { val mb = getMethodBind("AnimationPlayer","get_blend_time") return _icall_Double_String_String( mb, this.ptr, animFrom, animTo) } open fun getCurrentAnimation(): String { val mb = getMethodBind("AnimationPlayer","get_current_animation") return _icall_String( mb, this.ptr) } open fun getCurrentAnimationLength(): Double { val mb = getMethodBind("AnimationPlayer","get_current_animation_length") return _icall_Double( mb, this.ptr) } open fun getCurrentAnimationPosition(): Double { val mb = getMethodBind("AnimationPlayer","get_current_animation_position") return _icall_Double( mb, this.ptr) } open fun getDefaultBlendTime(): Double { val mb = getMethodBind("AnimationPlayer","get_default_blend_time") return _icall_Double( mb, this.ptr) } open fun getMethodCallMode(): AnimationPlayer.AnimationMethodCallMode { val mb = getMethodBind("AnimationPlayer","get_method_call_mode") return AnimationPlayer.AnimationMethodCallMode.from( _icall_Long( mb, this.ptr)) } open fun getPlayingSpeed(): Double { val mb = getMethodBind("AnimationPlayer","get_playing_speed") return _icall_Double( mb, this.ptr) } open fun getQueue(): PoolStringArray { val mb = getMethodBind("AnimationPlayer","get_queue") return _icall_PoolStringArray( mb, this.ptr) } open fun getRoot(): NodePath { val mb = getMethodBind("AnimationPlayer","get_root") return _icall_NodePath( mb, this.ptr) } open fun getSpeedScale(): Double { val mb = getMethodBind("AnimationPlayer","get_speed_scale") return _icall_Double( mb, this.ptr) } open fun hasAnimation(name: String): Boolean { val mb = getMethodBind("AnimationPlayer","has_animation") return _icall_Boolean_String( mb, this.ptr, name) } open fun isActive(): Boolean { val mb = getMethodBind("AnimationPlayer","is_active") return _icall_Boolean( mb, this.ptr) } open fun isPlaying(): Boolean { val mb = getMethodBind("AnimationPlayer","is_playing") return _icall_Boolean( mb, this.ptr) } open fun play( name: String = "", customBlend: Double = -1.0, customSpeed: Double = 1.0, fromEnd: Boolean = false ) { val mb = getMethodBind("AnimationPlayer","play") _icall_Unit_String_Double_Double_Boolean( mb, this.ptr, name, customBlend, customSpeed, fromEnd) } open fun playBackwards(name: String = "", customBlend: Double = -1.0) { val mb = getMethodBind("AnimationPlayer","play_backwards") _icall_Unit_String_Double( mb, this.ptr, name, customBlend) } open fun queue(name: String) { val mb = getMethodBind("AnimationPlayer","queue") _icall_Unit_String( mb, this.ptr, name) } open fun removeAnimation(name: String) { val mb = getMethodBind("AnimationPlayer","remove_animation") _icall_Unit_String( mb, this.ptr, name) } open fun renameAnimation(name: String, newname: String) { val mb = getMethodBind("AnimationPlayer","rename_animation") _icall_Unit_String_String( mb, this.ptr, name, newname) } open fun seek(seconds: Double, update: Boolean = false) { val mb = getMethodBind("AnimationPlayer","seek") _icall_Unit_Double_Boolean( mb, this.ptr, seconds, update) } open fun setActive(active: Boolean) { val mb = getMethodBind("AnimationPlayer","set_active") _icall_Unit_Boolean( mb, this.ptr, active) } open fun setAnimationProcessMode(mode: Long) { val mb = getMethodBind("AnimationPlayer","set_animation_process_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setAssignedAnimation(anim: String) { val mb = getMethodBind("AnimationPlayer","set_assigned_animation") _icall_Unit_String( mb, this.ptr, anim) } open fun setAutoplay(name: String) { val mb = getMethodBind("AnimationPlayer","set_autoplay") _icall_Unit_String( mb, this.ptr, name) } open fun setBlendTime( animFrom: String, animTo: String, sec: Double ) { val mb = getMethodBind("AnimationPlayer","set_blend_time") _icall_Unit_String_String_Double( mb, this.ptr, animFrom, animTo, sec) } open fun setCurrentAnimation(anim: String) { val mb = getMethodBind("AnimationPlayer","set_current_animation") _icall_Unit_String( mb, this.ptr, anim) } open fun setDefaultBlendTime(sec: Double) { val mb = getMethodBind("AnimationPlayer","set_default_blend_time") _icall_Unit_Double( mb, this.ptr, sec) } open fun setMethodCallMode(mode: Long) { val mb = getMethodBind("AnimationPlayer","set_method_call_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setRoot(path: NodePath) { val mb = getMethodBind("AnimationPlayer","set_root") _icall_Unit_NodePath( mb, this.ptr, path) } open fun setSpeedScale(speed: Double) { val mb = getMethodBind("AnimationPlayer","set_speed_scale") _icall_Unit_Double( mb, this.ptr, speed) } open fun stop(reset: Boolean = true) { val mb = getMethodBind("AnimationPlayer","stop") _icall_Unit_Boolean( mb, this.ptr, reset) } enum class AnimationProcessMode( id: Long ) { ANIMATION_PROCESS_PHYSICS(0), ANIMATION_PROCESS_IDLE(1), ANIMATION_PROCESS_MANUAL(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class AnimationMethodCallMode( id: Long ) { ANIMATION_METHOD_CALL_DEFERRED(0), ANIMATION_METHOD_CALL_IMMEDIATE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationRootNode.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AnimationRootNode : AnimationNode() { override fun __new(): COpaquePointer = invokeConstructor("AnimationRootNode", "AnimationRootNode") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationTrackEditPlugin.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class AnimationTrackEditPlugin internal constructor() : Reference() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationTree.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AnimationTree import godot.core.NodePath import godot.core.Transform import godot.icalls._icall_AnimationNode import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_NodePath import godot.icalls._icall_Transform import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_NodePath import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationTree : Node() { open var active: Boolean get() { val mb = getMethodBind("AnimationTree","is_active") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationTree","set_active") _icall_Unit_Boolean(mb, this.ptr, value) } open var animPlayer: NodePath get() { val mb = getMethodBind("AnimationTree","get_animation_player") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationTree","set_animation_player") _icall_Unit_NodePath(mb, this.ptr, value) } open var processMode: Long get() { val mb = getMethodBind("AnimationTree","get_process_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationTree","set_process_mode") _icall_Unit_Long(mb, this.ptr, value) } open var rootMotionTrack: NodePath get() { val mb = getMethodBind("AnimationTree","get_root_motion_track") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationTree","set_root_motion_track") _icall_Unit_NodePath(mb, this.ptr, value) } open var treeRoot: AnimationNode get() { val mb = getMethodBind("AnimationTree","get_tree_root") return _icall_AnimationNode(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationTree","set_tree_root") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationTree", "AnimationTree") open fun _clearCaches() { } open fun _nodeRemoved(arg0: Node) { } open fun _treeChanged() { } open fun _updateProperties() { } open fun advance(delta: Double) { val mb = getMethodBind("AnimationTree","advance") _icall_Unit_Double( mb, this.ptr, delta) } open fun getAnimationPlayer(): NodePath { val mb = getMethodBind("AnimationTree","get_animation_player") return _icall_NodePath( mb, this.ptr) } open fun getProcessMode(): AnimationTree.AnimationProcessMode { val mb = getMethodBind("AnimationTree","get_process_mode") return AnimationTree.AnimationProcessMode.from( _icall_Long( mb, this.ptr)) } open fun getRootMotionTrack(): NodePath { val mb = getMethodBind("AnimationTree","get_root_motion_track") return _icall_NodePath( mb, this.ptr) } open fun getRootMotionTransform(): Transform { val mb = getMethodBind("AnimationTree","get_root_motion_transform") return _icall_Transform( mb, this.ptr) } open fun getTreeRoot(): AnimationNode { val mb = getMethodBind("AnimationTree","get_tree_root") return _icall_AnimationNode( mb, this.ptr) } open fun isActive(): Boolean { val mb = getMethodBind("AnimationTree","is_active") return _icall_Boolean( mb, this.ptr) } open fun renameParameter(oldName: String, newName: String) { val mb = getMethodBind("AnimationTree","rename_parameter") _icall_Unit_String_String( mb, this.ptr, oldName, newName) } open fun setActive(active: Boolean) { val mb = getMethodBind("AnimationTree","set_active") _icall_Unit_Boolean( mb, this.ptr, active) } open fun setAnimationPlayer(root: NodePath) { val mb = getMethodBind("AnimationTree","set_animation_player") _icall_Unit_NodePath( mb, this.ptr, root) } open fun setProcessMode(mode: Long) { val mb = getMethodBind("AnimationTree","set_process_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setRootMotionTrack(path: NodePath) { val mb = getMethodBind("AnimationTree","set_root_motion_track") _icall_Unit_NodePath( mb, this.ptr, path) } open fun setTreeRoot(root: AnimationNode) { val mb = getMethodBind("AnimationTree","set_tree_root") _icall_Unit_Object( mb, this.ptr, root) } enum class AnimationProcessMode( id: Long ) { ANIMATION_PROCESS_PHYSICS(0), ANIMATION_PROCESS_IDLE(1), ANIMATION_PROCESS_MANUAL(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AnimationTreePlayer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AnimationTreePlayer import godot.core.GodotError import godot.core.NodePath import godot.core.PoolStringArray import godot.core.Vector2 import godot.icalls._icall_Animation_String import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_Long import godot.icalls._icall_Boolean_String_String_Long import godot.icalls._icall_Double_String import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_Long_String_String import godot.icalls._icall_Long_String_String_Long import godot.icalls._icall_NodePath import godot.icalls._icall_PoolStringArray import godot.icalls._icall_String_String import godot.icalls._icall_String_String_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_String import godot.icalls._icall_Unit_NodePath import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Boolean import godot.icalls._icall_Unit_String_Double import godot.icalls._icall_Unit_String_Long import godot.icalls._icall_Unit_String_Long_Boolean import godot.icalls._icall_Unit_String_NodePath_Boolean import godot.icalls._icall_Unit_String_Object import godot.icalls._icall_Unit_String_String import godot.icalls._icall_Unit_String_Vector2 import godot.icalls._icall_Vector2_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class AnimationTreePlayer : Node() { open var active: Boolean get() { val mb = getMethodBind("AnimationTreePlayer","is_active") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationTreePlayer","set_active") _icall_Unit_Boolean(mb, this.ptr, value) } open var basePath: NodePath get() { val mb = getMethodBind("AnimationTreePlayer","get_base_path") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationTreePlayer","set_base_path") _icall_Unit_NodePath(mb, this.ptr, value) } open var masterPlayer: NodePath get() { val mb = getMethodBind("AnimationTreePlayer","get_master_player") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationTreePlayer","set_master_player") _icall_Unit_NodePath(mb, this.ptr, value) } open var playbackProcessMode: Long get() { val mb = getMethodBind("AnimationTreePlayer","get_animation_process_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AnimationTreePlayer","set_animation_process_mode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AnimationTreePlayer", "AnimationTreePlayer") open fun addNode(type: Long, id: String) { val mb = getMethodBind("AnimationTreePlayer","add_node") _icall_Unit_Long_String( mb, this.ptr, type, id) } open fun advance(delta: Double) { val mb = getMethodBind("AnimationTreePlayer","advance") _icall_Unit_Double( mb, this.ptr, delta) } open fun animationNodeGetAnimation(id: String): Animation { val mb = getMethodBind("AnimationTreePlayer","animation_node_get_animation") return _icall_Animation_String( mb, this.ptr, id) } open fun animationNodeGetMasterAnimation(id: String): String { val mb = getMethodBind("AnimationTreePlayer","animation_node_get_master_animation") return _icall_String_String( mb, this.ptr, id) } open fun animationNodeGetPosition(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","animation_node_get_position") return _icall_Double_String( mb, this.ptr, id) } open fun animationNodeSetAnimation(id: String, animation: Animation) { val mb = getMethodBind("AnimationTreePlayer","animation_node_set_animation") _icall_Unit_String_Object( mb, this.ptr, id, animation) } open fun animationNodeSetFilterPath( id: String, path: NodePath, enable: Boolean ) { val mb = getMethodBind("AnimationTreePlayer","animation_node_set_filter_path") _icall_Unit_String_NodePath_Boolean( mb, this.ptr, id, path, enable) } open fun animationNodeSetMasterAnimation(id: String, source: String) { val mb = getMethodBind("AnimationTreePlayer","animation_node_set_master_animation") _icall_Unit_String_String( mb, this.ptr, id, source) } open fun areNodesConnected( id: String, dstId: String, dstInputIdx: Long ): Boolean { val mb = getMethodBind("AnimationTreePlayer","are_nodes_connected") return _icall_Boolean_String_String_Long( mb, this.ptr, id, dstId, dstInputIdx) } open fun blend2NodeGetAmount(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","blend2_node_get_amount") return _icall_Double_String( mb, this.ptr, id) } open fun blend2NodeSetAmount(id: String, blend: Double) { val mb = getMethodBind("AnimationTreePlayer","blend2_node_set_amount") _icall_Unit_String_Double( mb, this.ptr, id, blend) } open fun blend2NodeSetFilterPath( id: String, path: NodePath, enable: Boolean ) { val mb = getMethodBind("AnimationTreePlayer","blend2_node_set_filter_path") _icall_Unit_String_NodePath_Boolean( mb, this.ptr, id, path, enable) } open fun blend3NodeGetAmount(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","blend3_node_get_amount") return _icall_Double_String( mb, this.ptr, id) } open fun blend3NodeSetAmount(id: String, blend: Double) { val mb = getMethodBind("AnimationTreePlayer","blend3_node_set_amount") _icall_Unit_String_Double( mb, this.ptr, id, blend) } open fun blend4NodeGetAmount(id: String): Vector2 { val mb = getMethodBind("AnimationTreePlayer","blend4_node_get_amount") return _icall_Vector2_String( mb, this.ptr, id) } open fun blend4NodeSetAmount(id: String, blend: Vector2) { val mb = getMethodBind("AnimationTreePlayer","blend4_node_set_amount") _icall_Unit_String_Vector2( mb, this.ptr, id, blend) } open fun connectNodes( id: String, dstId: String, dstInputIdx: Long ): GodotError { val mb = getMethodBind("AnimationTreePlayer","connect_nodes") return GodotError.byValue( _icall_Long_String_String_Long( mb, this.ptr, id, dstId, dstInputIdx).toUInt()) } open fun disconnectNodes(id: String, dstInputIdx: Long) { val mb = getMethodBind("AnimationTreePlayer","disconnect_nodes") _icall_Unit_String_Long( mb, this.ptr, id, dstInputIdx) } open fun getAnimationProcessMode(): AnimationTreePlayer.AnimationProcessMode { val mb = getMethodBind("AnimationTreePlayer","get_animation_process_mode") return AnimationTreePlayer.AnimationProcessMode.from( _icall_Long( mb, this.ptr)) } open fun getBasePath(): NodePath { val mb = getMethodBind("AnimationTreePlayer","get_base_path") return _icall_NodePath( mb, this.ptr) } open fun getMasterPlayer(): NodePath { val mb = getMethodBind("AnimationTreePlayer","get_master_player") return _icall_NodePath( mb, this.ptr) } open fun getNodeList(): PoolStringArray { val mb = getMethodBind("AnimationTreePlayer","get_node_list") return _icall_PoolStringArray( mb, this.ptr) } open fun isActive(): Boolean { val mb = getMethodBind("AnimationTreePlayer","is_active") return _icall_Boolean( mb, this.ptr) } open fun mixNodeGetAmount(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","mix_node_get_amount") return _icall_Double_String( mb, this.ptr, id) } open fun mixNodeSetAmount(id: String, ratio: Double) { val mb = getMethodBind("AnimationTreePlayer","mix_node_set_amount") _icall_Unit_String_Double( mb, this.ptr, id, ratio) } open fun nodeExists(node: String): Boolean { val mb = getMethodBind("AnimationTreePlayer","node_exists") return _icall_Boolean_String( mb, this.ptr, node) } open fun nodeGetInputCount(id: String): Long { val mb = getMethodBind("AnimationTreePlayer","node_get_input_count") return _icall_Long_String( mb, this.ptr, id) } open fun nodeGetInputSource(id: String, idx: Long): String { val mb = getMethodBind("AnimationTreePlayer","node_get_input_source") return _icall_String_String_Long( mb, this.ptr, id, idx) } open fun nodeGetPosition(id: String): Vector2 { val mb = getMethodBind("AnimationTreePlayer","node_get_position") return _icall_Vector2_String( mb, this.ptr, id) } open fun nodeGetType(id: String): AnimationTreePlayer.NodeType { val mb = getMethodBind("AnimationTreePlayer","node_get_type") return AnimationTreePlayer.NodeType.from( _icall_Long_String( mb, this.ptr, id)) } open fun nodeRename(node: String, newName: String): GodotError { val mb = getMethodBind("AnimationTreePlayer","node_rename") return GodotError.byValue( _icall_Long_String_String( mb, this.ptr, node, newName).toUInt()) } open fun nodeSetPosition(id: String, screenPosition: Vector2) { val mb = getMethodBind("AnimationTreePlayer","node_set_position") _icall_Unit_String_Vector2( mb, this.ptr, id, screenPosition) } open fun oneshotNodeGetAutorestartDelay(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_get_autorestart_delay") return _icall_Double_String( mb, this.ptr, id) } open fun oneshotNodeGetAutorestartRandomDelay(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_get_autorestart_random_delay") return _icall_Double_String( mb, this.ptr, id) } open fun oneshotNodeGetFadeinTime(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_get_fadein_time") return _icall_Double_String( mb, this.ptr, id) } open fun oneshotNodeGetFadeoutTime(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_get_fadeout_time") return _icall_Double_String( mb, this.ptr, id) } open fun oneshotNodeHasAutorestart(id: String): Boolean { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_has_autorestart") return _icall_Boolean_String( mb, this.ptr, id) } open fun oneshotNodeIsActive(id: String): Boolean { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_is_active") return _icall_Boolean_String( mb, this.ptr, id) } open fun oneshotNodeSetAutorestart(id: String, enable: Boolean) { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_set_autorestart") _icall_Unit_String_Boolean( mb, this.ptr, id, enable) } open fun oneshotNodeSetAutorestartDelay(id: String, delaySec: Double) { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_set_autorestart_delay") _icall_Unit_String_Double( mb, this.ptr, id, delaySec) } open fun oneshotNodeSetAutorestartRandomDelay(id: String, randSec: Double) { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_set_autorestart_random_delay") _icall_Unit_String_Double( mb, this.ptr, id, randSec) } open fun oneshotNodeSetFadeinTime(id: String, timeSec: Double) { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_set_fadein_time") _icall_Unit_String_Double( mb, this.ptr, id, timeSec) } open fun oneshotNodeSetFadeoutTime(id: String, timeSec: Double) { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_set_fadeout_time") _icall_Unit_String_Double( mb, this.ptr, id, timeSec) } open fun oneshotNodeSetFilterPath( id: String, path: NodePath, enable: Boolean ) { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_set_filter_path") _icall_Unit_String_NodePath_Boolean( mb, this.ptr, id, path, enable) } open fun oneshotNodeStart(id: String) { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_start") _icall_Unit_String( mb, this.ptr, id) } open fun oneshotNodeStop(id: String) { val mb = getMethodBind("AnimationTreePlayer","oneshot_node_stop") _icall_Unit_String( mb, this.ptr, id) } open fun recomputeCaches() { val mb = getMethodBind("AnimationTreePlayer","recompute_caches") _icall_Unit( mb, this.ptr) } open fun removeNode(id: String) { val mb = getMethodBind("AnimationTreePlayer","remove_node") _icall_Unit_String( mb, this.ptr, id) } open fun reset() { val mb = getMethodBind("AnimationTreePlayer","reset") _icall_Unit( mb, this.ptr) } open fun setActive(enabled: Boolean) { val mb = getMethodBind("AnimationTreePlayer","set_active") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setAnimationProcessMode(mode: Long) { val mb = getMethodBind("AnimationTreePlayer","set_animation_process_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setBasePath(path: NodePath) { val mb = getMethodBind("AnimationTreePlayer","set_base_path") _icall_Unit_NodePath( mb, this.ptr, path) } open fun setMasterPlayer(nodepath: NodePath) { val mb = getMethodBind("AnimationTreePlayer","set_master_player") _icall_Unit_NodePath( mb, this.ptr, nodepath) } open fun timescaleNodeGetScale(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","timescale_node_get_scale") return _icall_Double_String( mb, this.ptr, id) } open fun timescaleNodeSetScale(id: String, scale: Double) { val mb = getMethodBind("AnimationTreePlayer","timescale_node_set_scale") _icall_Unit_String_Double( mb, this.ptr, id, scale) } open fun timeseekNodeSeek(id: String, seconds: Double) { val mb = getMethodBind("AnimationTreePlayer","timeseek_node_seek") _icall_Unit_String_Double( mb, this.ptr, id, seconds) } open fun transitionNodeDeleteInput(id: String, inputIdx: Long) { val mb = getMethodBind("AnimationTreePlayer","transition_node_delete_input") _icall_Unit_String_Long( mb, this.ptr, id, inputIdx) } open fun transitionNodeGetCurrent(id: String): Long { val mb = getMethodBind("AnimationTreePlayer","transition_node_get_current") return _icall_Long_String( mb, this.ptr, id) } open fun transitionNodeGetInputCount(id: String): Long { val mb = getMethodBind("AnimationTreePlayer","transition_node_get_input_count") return _icall_Long_String( mb, this.ptr, id) } open fun transitionNodeGetXfadeTime(id: String): Double { val mb = getMethodBind("AnimationTreePlayer","transition_node_get_xfade_time") return _icall_Double_String( mb, this.ptr, id) } open fun transitionNodeHasInputAutoAdvance(id: String, inputIdx: Long): Boolean { val mb = getMethodBind("AnimationTreePlayer","transition_node_has_input_auto_advance") return _icall_Boolean_String_Long( mb, this.ptr, id, inputIdx) } open fun transitionNodeSetCurrent(id: String, inputIdx: Long) { val mb = getMethodBind("AnimationTreePlayer","transition_node_set_current") _icall_Unit_String_Long( mb, this.ptr, id, inputIdx) } open fun transitionNodeSetInputAutoAdvance( id: String, inputIdx: Long, enable: Boolean ) { val mb = getMethodBind("AnimationTreePlayer","transition_node_set_input_auto_advance") _icall_Unit_String_Long_Boolean( mb, this.ptr, id, inputIdx, enable) } open fun transitionNodeSetInputCount(id: String, count: Long) { val mb = getMethodBind("AnimationTreePlayer","transition_node_set_input_count") _icall_Unit_String_Long( mb, this.ptr, id, count) } open fun transitionNodeSetXfadeTime(id: String, timeSec: Double) { val mb = getMethodBind("AnimationTreePlayer","transition_node_set_xfade_time") _icall_Unit_String_Double( mb, this.ptr, id, timeSec) } enum class AnimationProcessMode( id: Long ) { ANIMATION_PROCESS_PHYSICS(0), ANIMATION_PROCESS_IDLE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class NodeType( id: Long ) { NODE_OUTPUT(0), NODE_ANIMATION(1), NODE_ONESHOT(2), NODE_MIX(3), NODE_BLEND2(4), NODE_BLEND3(5), NODE_BLEND4(6), NODE_TIMESCALE(7), NODE_TIMESEEK(8), NODE_TRANSITION(9); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Area.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Area import godot.core.RID import godot.core.Signal1 import godot.core.Signal4 import godot.core.VariantArray import godot.core.Vector3 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_Object import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Area : CollisionObject() { val areaEntered: Signal1 by signal("area") val areaExited: Signal1 by signal("area") val areaShapeEntered: Signal4 by signal("area_id", "area", "area_shape", "self_shape") val areaShapeExited: Signal4 by signal("area_id", "area", "area_shape", "self_shape") val bodyEntered: Signal1 by signal("body") val bodyExited: Signal1 by signal("body") val bodyShapeEntered: Signal4 by signal("body_id", "body", "body_shape", "area_shape") val bodyShapeExited: Signal4 by signal("body_id", "body", "body_shape", "area_shape") open var angularDamp: Double get() { val mb = getMethodBind("Area","get_angular_damp") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_angular_damp") _icall_Unit_Double(mb, this.ptr, value) } open var audioBusName: String get() { val mb = getMethodBind("Area","get_audio_bus") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_audio_bus") _icall_Unit_String(mb, this.ptr, value) } open var audioBusOverride: Boolean get() { val mb = getMethodBind("Area","is_overriding_audio_bus") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_audio_bus_override") _icall_Unit_Boolean(mb, this.ptr, value) } open var collisionLayer: Long get() { val mb = getMethodBind("Area","get_collision_layer") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_collision_layer") _icall_Unit_Long(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("Area","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open var gravity: Double get() { val mb = getMethodBind("Area","get_gravity") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_gravity") _icall_Unit_Double(mb, this.ptr, value) } open var gravityDistanceScale: Double get() { val mb = getMethodBind("Area","get_gravity_distance_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_gravity_distance_scale") _icall_Unit_Double(mb, this.ptr, value) } open var gravityPoint: Boolean get() { val mb = getMethodBind("Area","is_gravity_a_point") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_gravity_is_point") _icall_Unit_Boolean(mb, this.ptr, value) } open var gravityVec: Vector3 get() { val mb = getMethodBind("Area","get_gravity_vector") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_gravity_vector") _icall_Unit_Vector3(mb, this.ptr, value) } open var linearDamp: Double get() { val mb = getMethodBind("Area","get_linear_damp") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_linear_damp") _icall_Unit_Double(mb, this.ptr, value) } open var monitorable: Boolean get() { val mb = getMethodBind("Area","is_monitorable") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_monitorable") _icall_Unit_Boolean(mb, this.ptr, value) } open var monitoring: Boolean get() { val mb = getMethodBind("Area","is_monitoring") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_monitoring") _icall_Unit_Boolean(mb, this.ptr, value) } open var priority: Double get() { val mb = getMethodBind("Area","get_priority") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_priority") _icall_Unit_Double(mb, this.ptr, value) } open var reverbBusAmount: Double get() { val mb = getMethodBind("Area","get_reverb_amount") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_reverb_amount") _icall_Unit_Double(mb, this.ptr, value) } open var reverbBusEnable: Boolean get() { val mb = getMethodBind("Area","is_using_reverb_bus") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_use_reverb_bus") _icall_Unit_Boolean(mb, this.ptr, value) } open var reverbBusName: String get() { val mb = getMethodBind("Area","get_reverb_bus") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_reverb_bus") _icall_Unit_String(mb, this.ptr, value) } open var reverbBusUniformity: Double get() { val mb = getMethodBind("Area","get_reverb_uniformity") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_reverb_uniformity") _icall_Unit_Double(mb, this.ptr, value) } open var spaceOverride: Long get() { val mb = getMethodBind("Area","get_space_override_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Area","set_space_override_mode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Area", "Area") open fun gravityVec(schedule: Vector3.() -> Unit): Vector3 = gravityVec.apply{ schedule(this) gravityVec = this } open fun _areaEnterTree(id: Long) { } open fun _areaExitTree(id: Long) { } open fun _areaInout( arg0: Long, arg1: RID, arg2: Long, arg3: Long, arg4: Long ) { } open fun _bodyEnterTree(id: Long) { } open fun _bodyExitTree(id: Long) { } open fun _bodyInout( arg0: Long, arg1: RID, arg2: Long, arg3: Long, arg4: Long ) { } open fun getAngularDamp(): Double { val mb = getMethodBind("Area","get_angular_damp") return _icall_Double( mb, this.ptr) } open fun getAudioBus(): String { val mb = getMethodBind("Area","get_audio_bus") return _icall_String( mb, this.ptr) } open fun getCollisionLayer(): Long { val mb = getMethodBind("Area","get_collision_layer") return _icall_Long( mb, this.ptr) } open fun getCollisionLayerBit(bit: Long): Boolean { val mb = getMethodBind("Area","get_collision_layer_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getCollisionMask(): Long { val mb = getMethodBind("Area","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("Area","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getGravity(): Double { val mb = getMethodBind("Area","get_gravity") return _icall_Double( mb, this.ptr) } open fun getGravityDistanceScale(): Double { val mb = getMethodBind("Area","get_gravity_distance_scale") return _icall_Double( mb, this.ptr) } open fun getGravityVector(): Vector3 { val mb = getMethodBind("Area","get_gravity_vector") return _icall_Vector3( mb, this.ptr) } open fun getLinearDamp(): Double { val mb = getMethodBind("Area","get_linear_damp") return _icall_Double( mb, this.ptr) } open fun getOverlappingAreas(): VariantArray { val mb = getMethodBind("Area","get_overlapping_areas") return _icall_VariantArray( mb, this.ptr) } open fun getOverlappingBodies(): VariantArray { val mb = getMethodBind("Area","get_overlapping_bodies") return _icall_VariantArray( mb, this.ptr) } open fun getPriority(): Double { val mb = getMethodBind("Area","get_priority") return _icall_Double( mb, this.ptr) } open fun getReverbAmount(): Double { val mb = getMethodBind("Area","get_reverb_amount") return _icall_Double( mb, this.ptr) } open fun getReverbBus(): String { val mb = getMethodBind("Area","get_reverb_bus") return _icall_String( mb, this.ptr) } open fun getReverbUniformity(): Double { val mb = getMethodBind("Area","get_reverb_uniformity") return _icall_Double( mb, this.ptr) } open fun getSpaceOverrideMode(): Area.SpaceOverride { val mb = getMethodBind("Area","get_space_override_mode") return Area.SpaceOverride.from( _icall_Long( mb, this.ptr)) } open fun isGravityAPoint(): Boolean { val mb = getMethodBind("Area","is_gravity_a_point") return _icall_Boolean( mb, this.ptr) } open fun isMonitorable(): Boolean { val mb = getMethodBind("Area","is_monitorable") return _icall_Boolean( mb, this.ptr) } open fun isMonitoring(): Boolean { val mb = getMethodBind("Area","is_monitoring") return _icall_Boolean( mb, this.ptr) } open fun isOverridingAudioBus(): Boolean { val mb = getMethodBind("Area","is_overriding_audio_bus") return _icall_Boolean( mb, this.ptr) } open fun isUsingReverbBus(): Boolean { val mb = getMethodBind("Area","is_using_reverb_bus") return _icall_Boolean( mb, this.ptr) } open fun overlapsArea(area: Node): Boolean { val mb = getMethodBind("Area","overlaps_area") return _icall_Boolean_Object( mb, this.ptr, area) } open fun overlapsBody(body: Node): Boolean { val mb = getMethodBind("Area","overlaps_body") return _icall_Boolean_Object( mb, this.ptr, body) } open fun setAngularDamp(angularDamp: Double) { val mb = getMethodBind("Area","set_angular_damp") _icall_Unit_Double( mb, this.ptr, angularDamp) } open fun setAudioBus(name: String) { val mb = getMethodBind("Area","set_audio_bus") _icall_Unit_String( mb, this.ptr, name) } open fun setAudioBusOverride(enable: Boolean) { val mb = getMethodBind("Area","set_audio_bus_override") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollisionLayer(collisionLayer: Long) { val mb = getMethodBind("Area","set_collision_layer") _icall_Unit_Long( mb, this.ptr, collisionLayer) } open fun setCollisionLayerBit(bit: Long, value: Boolean) { val mb = getMethodBind("Area","set_collision_layer_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setCollisionMask(collisionMask: Long) { val mb = getMethodBind("Area","set_collision_mask") _icall_Unit_Long( mb, this.ptr, collisionMask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("Area","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setGravity(gravity: Double) { val mb = getMethodBind("Area","set_gravity") _icall_Unit_Double( mb, this.ptr, gravity) } open fun setGravityDistanceScale(distanceScale: Double) { val mb = getMethodBind("Area","set_gravity_distance_scale") _icall_Unit_Double( mb, this.ptr, distanceScale) } open fun setGravityIsPoint(enable: Boolean) { val mb = getMethodBind("Area","set_gravity_is_point") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setGravityVector(vector: Vector3) { val mb = getMethodBind("Area","set_gravity_vector") _icall_Unit_Vector3( mb, this.ptr, vector) } open fun setLinearDamp(linearDamp: Double) { val mb = getMethodBind("Area","set_linear_damp") _icall_Unit_Double( mb, this.ptr, linearDamp) } open fun setMonitorable(enable: Boolean) { val mb = getMethodBind("Area","set_monitorable") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setMonitoring(enable: Boolean) { val mb = getMethodBind("Area","set_monitoring") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setPriority(priority: Double) { val mb = getMethodBind("Area","set_priority") _icall_Unit_Double( mb, this.ptr, priority) } open fun setReverbAmount(amount: Double) { val mb = getMethodBind("Area","set_reverb_amount") _icall_Unit_Double( mb, this.ptr, amount) } open fun setReverbBus(name: String) { val mb = getMethodBind("Area","set_reverb_bus") _icall_Unit_String( mb, this.ptr, name) } open fun setReverbUniformity(amount: Double) { val mb = getMethodBind("Area","set_reverb_uniformity") _icall_Unit_Double( mb, this.ptr, amount) } open fun setSpaceOverrideMode(enable: Long) { val mb = getMethodBind("Area","set_space_override_mode") _icall_Unit_Long( mb, this.ptr, enable) } open fun setUseReverbBus(enable: Boolean) { val mb = getMethodBind("Area","set_use_reverb_bus") _icall_Unit_Boolean( mb, this.ptr, enable) } enum class SpaceOverride( id: Long ) { SPACE_OVERRIDE_DISABLED(0), SPACE_OVERRIDE_COMBINE(1), SPACE_OVERRIDE_COMBINE_REPLACE(2), SPACE_OVERRIDE_REPLACE(3), SPACE_OVERRIDE_REPLACE_COMBINE(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Area2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Area2D import godot.core.RID import godot.core.Signal1 import godot.core.Signal4 import godot.core.VariantArray import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_Object import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Area2D : CollisionObject2D() { val areaEntered: Signal1 by signal("area") val areaExited: Signal1 by signal("area") val areaShapeEntered: Signal4 by signal("area_id", "area", "area_shape", "self_shape") val areaShapeExited: Signal4 by signal("area_id", "area", "area_shape", "self_shape") val bodyEntered: Signal1 by signal("body") val bodyExited: Signal1 by signal("body") val bodyShapeEntered: Signal4 by signal("body_id", "body", "body_shape", "area_shape") val bodyShapeExited: Signal4 by signal("body_id", "body", "body_shape", "area_shape") open var angularDamp: Double get() { val mb = getMethodBind("Area2D","get_angular_damp") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_angular_damp") _icall_Unit_Double(mb, this.ptr, value) } open var audioBusName: String get() { val mb = getMethodBind("Area2D","get_audio_bus_name") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_audio_bus_name") _icall_Unit_String(mb, this.ptr, value) } open var audioBusOverride: Boolean get() { val mb = getMethodBind("Area2D","is_overriding_audio_bus") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_audio_bus_override") _icall_Unit_Boolean(mb, this.ptr, value) } open var collisionLayer: Long get() { val mb = getMethodBind("Area2D","get_collision_layer") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_collision_layer") _icall_Unit_Long(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("Area2D","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open var gravity: Double get() { val mb = getMethodBind("Area2D","get_gravity") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_gravity") _icall_Unit_Double(mb, this.ptr, value) } open var gravityDistanceScale: Double get() { val mb = getMethodBind("Area2D","get_gravity_distance_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_gravity_distance_scale") _icall_Unit_Double(mb, this.ptr, value) } open var gravityPoint: Boolean get() { val mb = getMethodBind("Area2D","is_gravity_a_point") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_gravity_is_point") _icall_Unit_Boolean(mb, this.ptr, value) } open var gravityVec: Vector2 get() { val mb = getMethodBind("Area2D","get_gravity_vector") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_gravity_vector") _icall_Unit_Vector2(mb, this.ptr, value) } open var linearDamp: Double get() { val mb = getMethodBind("Area2D","get_linear_damp") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_linear_damp") _icall_Unit_Double(mb, this.ptr, value) } open var monitorable: Boolean get() { val mb = getMethodBind("Area2D","is_monitorable") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_monitorable") _icall_Unit_Boolean(mb, this.ptr, value) } open var monitoring: Boolean get() { val mb = getMethodBind("Area2D","is_monitoring") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_monitoring") _icall_Unit_Boolean(mb, this.ptr, value) } open var priority: Double get() { val mb = getMethodBind("Area2D","get_priority") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_priority") _icall_Unit_Double(mb, this.ptr, value) } open var spaceOverride: Long get() { val mb = getMethodBind("Area2D","get_space_override_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Area2D","set_space_override_mode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Area2D", "Area2D") open fun gravityVec(schedule: Vector2.() -> Unit): Vector2 = gravityVec.apply{ schedule(this) gravityVec = this } open fun _areaEnterTree(id: Long) { } open fun _areaExitTree(id: Long) { } open fun _areaInout( arg0: Long, arg1: RID, arg2: Long, arg3: Long, arg4: Long ) { } open fun _bodyEnterTree(id: Long) { } open fun _bodyExitTree(id: Long) { } open fun _bodyInout( arg0: Long, arg1: RID, arg2: Long, arg3: Long, arg4: Long ) { } open fun getAngularDamp(): Double { val mb = getMethodBind("Area2D","get_angular_damp") return _icall_Double( mb, this.ptr) } open fun getAudioBusName(): String { val mb = getMethodBind("Area2D","get_audio_bus_name") return _icall_String( mb, this.ptr) } open fun getCollisionLayer(): Long { val mb = getMethodBind("Area2D","get_collision_layer") return _icall_Long( mb, this.ptr) } open fun getCollisionLayerBit(bit: Long): Boolean { val mb = getMethodBind("Area2D","get_collision_layer_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getCollisionMask(): Long { val mb = getMethodBind("Area2D","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("Area2D","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getGravity(): Double { val mb = getMethodBind("Area2D","get_gravity") return _icall_Double( mb, this.ptr) } open fun getGravityDistanceScale(): Double { val mb = getMethodBind("Area2D","get_gravity_distance_scale") return _icall_Double( mb, this.ptr) } open fun getGravityVector(): Vector2 { val mb = getMethodBind("Area2D","get_gravity_vector") return _icall_Vector2( mb, this.ptr) } open fun getLinearDamp(): Double { val mb = getMethodBind("Area2D","get_linear_damp") return _icall_Double( mb, this.ptr) } open fun getOverlappingAreas(): VariantArray { val mb = getMethodBind("Area2D","get_overlapping_areas") return _icall_VariantArray( mb, this.ptr) } open fun getOverlappingBodies(): VariantArray { val mb = getMethodBind("Area2D","get_overlapping_bodies") return _icall_VariantArray( mb, this.ptr) } open fun getPriority(): Double { val mb = getMethodBind("Area2D","get_priority") return _icall_Double( mb, this.ptr) } open fun getSpaceOverrideMode(): Area2D.SpaceOverride { val mb = getMethodBind("Area2D","get_space_override_mode") return Area2D.SpaceOverride.from( _icall_Long( mb, this.ptr)) } open fun isGravityAPoint(): Boolean { val mb = getMethodBind("Area2D","is_gravity_a_point") return _icall_Boolean( mb, this.ptr) } open fun isMonitorable(): Boolean { val mb = getMethodBind("Area2D","is_monitorable") return _icall_Boolean( mb, this.ptr) } open fun isMonitoring(): Boolean { val mb = getMethodBind("Area2D","is_monitoring") return _icall_Boolean( mb, this.ptr) } open fun isOverridingAudioBus(): Boolean { val mb = getMethodBind("Area2D","is_overriding_audio_bus") return _icall_Boolean( mb, this.ptr) } open fun overlapsArea(area: Node): Boolean { val mb = getMethodBind("Area2D","overlaps_area") return _icall_Boolean_Object( mb, this.ptr, area) } open fun overlapsBody(body: Node): Boolean { val mb = getMethodBind("Area2D","overlaps_body") return _icall_Boolean_Object( mb, this.ptr, body) } open fun setAngularDamp(angularDamp: Double) { val mb = getMethodBind("Area2D","set_angular_damp") _icall_Unit_Double( mb, this.ptr, angularDamp) } open fun setAudioBusName(name: String) { val mb = getMethodBind("Area2D","set_audio_bus_name") _icall_Unit_String( mb, this.ptr, name) } open fun setAudioBusOverride(enable: Boolean) { val mb = getMethodBind("Area2D","set_audio_bus_override") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollisionLayer(collisionLayer: Long) { val mb = getMethodBind("Area2D","set_collision_layer") _icall_Unit_Long( mb, this.ptr, collisionLayer) } open fun setCollisionLayerBit(bit: Long, value: Boolean) { val mb = getMethodBind("Area2D","set_collision_layer_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setCollisionMask(collisionMask: Long) { val mb = getMethodBind("Area2D","set_collision_mask") _icall_Unit_Long( mb, this.ptr, collisionMask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("Area2D","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setGravity(gravity: Double) { val mb = getMethodBind("Area2D","set_gravity") _icall_Unit_Double( mb, this.ptr, gravity) } open fun setGravityDistanceScale(distanceScale: Double) { val mb = getMethodBind("Area2D","set_gravity_distance_scale") _icall_Unit_Double( mb, this.ptr, distanceScale) } open fun setGravityIsPoint(enable: Boolean) { val mb = getMethodBind("Area2D","set_gravity_is_point") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setGravityVector(vector: Vector2) { val mb = getMethodBind("Area2D","set_gravity_vector") _icall_Unit_Vector2( mb, this.ptr, vector) } open fun setLinearDamp(linearDamp: Double) { val mb = getMethodBind("Area2D","set_linear_damp") _icall_Unit_Double( mb, this.ptr, linearDamp) } open fun setMonitorable(enable: Boolean) { val mb = getMethodBind("Area2D","set_monitorable") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setMonitoring(enable: Boolean) { val mb = getMethodBind("Area2D","set_monitoring") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setPriority(priority: Double) { val mb = getMethodBind("Area2D","set_priority") _icall_Unit_Double( mb, this.ptr, priority) } open fun setSpaceOverrideMode(spaceOverrideMode: Long) { val mb = getMethodBind("Area2D","set_space_override_mode") _icall_Unit_Long( mb, this.ptr, spaceOverrideMode) } enum class SpaceOverride( id: Long ) { SPACE_OVERRIDE_DISABLED(0), SPACE_OVERRIDE_COMBINE(1), SPACE_OVERRIDE_COMBINE_REPLACE(2), SPACE_OVERRIDE_REPLACE(3), SPACE_OVERRIDE_REPLACE_COMBINE(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ArrayMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Mesh import godot.core.AABB import godot.core.GodotError import godot.core.PoolByteArray import godot.core.Transform import godot.core.VariantArray import godot.icalls._icall_AABB import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_String import godot.icalls._icall_Long_Transform_Double import godot.icalls._icall_String_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_AABB import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Long_PoolByteArray import godot.icalls._icall_Unit_Long_String import godot.icalls._icall_Unit_Long_VariantArray_VariantArray_Long import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ArrayMesh : Mesh() { open var blendShapeMode: Long get() { val mb = getMethodBind("ArrayMesh","get_blend_shape_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ArrayMesh","set_blend_shape_mode") _icall_Unit_Long(mb, this.ptr, value) } open var customAabb: AABB get() { val mb = getMethodBind("ArrayMesh","get_custom_aabb") return _icall_AABB(mb, this.ptr) } set(value) { val mb = getMethodBind("ArrayMesh","set_custom_aabb") _icall_Unit_AABB(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ArrayMesh", "ArrayMesh") open fun customAabb(schedule: AABB.() -> Unit): AABB = customAabb.apply{ schedule(this) customAabb = this } open fun addBlendShape(name: String) { val mb = getMethodBind("ArrayMesh","add_blend_shape") _icall_Unit_String( mb, this.ptr, name) } open fun addSurfaceFromArrays( primitive: Long, arrays: VariantArray, blendShapes: VariantArray = VariantArray(), compressFlags: Long = 97280 ) { val mb = getMethodBind("ArrayMesh","add_surface_from_arrays") _icall_Unit_Long_VariantArray_VariantArray_Long( mb, this.ptr, primitive, arrays, blendShapes, compressFlags) } open fun clearBlendShapes() { val mb = getMethodBind("ArrayMesh","clear_blend_shapes") _icall_Unit( mb, this.ptr) } open fun getBlendShapeCount(): Long { val mb = getMethodBind("ArrayMesh","get_blend_shape_count") return _icall_Long( mb, this.ptr) } open fun getBlendShapeMode(): Mesh.BlendShapeMode { val mb = getMethodBind("ArrayMesh","get_blend_shape_mode") return Mesh.BlendShapeMode.from( _icall_Long( mb, this.ptr)) } open fun getBlendShapeName(index: Long): String { val mb = getMethodBind("ArrayMesh","get_blend_shape_name") return _icall_String_Long( mb, this.ptr, index) } open fun getCustomAabb(): AABB { val mb = getMethodBind("ArrayMesh","get_custom_aabb") return _icall_AABB( mb, this.ptr) } open fun lightmapUnwrap(transform: Transform, texelSize: Double): GodotError { val mb = getMethodBind("ArrayMesh","lightmap_unwrap") return GodotError.byValue( _icall_Long_Transform_Double( mb, this.ptr, transform, texelSize).toUInt()) } open fun regenNormalmaps() { val mb = getMethodBind("ArrayMesh","regen_normalmaps") _icall_Unit( mb, this.ptr) } open fun setBlendShapeMode(mode: Long) { val mb = getMethodBind("ArrayMesh","set_blend_shape_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setCustomAabb(aabb: AABB) { val mb = getMethodBind("ArrayMesh","set_custom_aabb") _icall_Unit_AABB( mb, this.ptr, aabb) } open fun surfaceFindByName(name: String): Long { val mb = getMethodBind("ArrayMesh","surface_find_by_name") return _icall_Long_String( mb, this.ptr, name) } open fun surfaceGetArrayIndexLen(surfIdx: Long): Long { val mb = getMethodBind("ArrayMesh","surface_get_array_index_len") return _icall_Long_Long( mb, this.ptr, surfIdx) } open fun surfaceGetArrayLen(surfIdx: Long): Long { val mb = getMethodBind("ArrayMesh","surface_get_array_len") return _icall_Long_Long( mb, this.ptr, surfIdx) } open fun surfaceGetFormat(surfIdx: Long): Long { val mb = getMethodBind("ArrayMesh","surface_get_format") return _icall_Long_Long( mb, this.ptr, surfIdx) } open fun surfaceGetName(surfIdx: Long): String { val mb = getMethodBind("ArrayMesh","surface_get_name") return _icall_String_Long( mb, this.ptr, surfIdx) } open fun surfaceGetPrimitiveType(surfIdx: Long): Mesh.PrimitiveType { val mb = getMethodBind("ArrayMesh","surface_get_primitive_type") return Mesh.PrimitiveType.from( _icall_Long_Long( mb, this.ptr, surfIdx)) } open fun surfaceRemove(surfIdx: Long) { val mb = getMethodBind("ArrayMesh","surface_remove") _icall_Unit_Long( mb, this.ptr, surfIdx) } open fun surfaceSetName(surfIdx: Long, name: String) { val mb = getMethodBind("ArrayMesh","surface_set_name") _icall_Unit_Long_String( mb, this.ptr, surfIdx, name) } open fun surfaceUpdateRegion( surfIdx: Long, offset: Long, data: PoolByteArray ) { val mb = getMethodBind("ArrayMesh","surface_update_region") _icall_Unit_Long_Long_PoolByteArray( mb, this.ptr, surfIdx, offset, data) } enum class ArrayFormat( id: Long ) { ARRAY_FORMAT_VERTEX(1), ARRAY_FORMAT_NORMAL(2), ARRAY_FORMAT_TANGENT(4), ARRAY_FORMAT_COLOR(8), ARRAY_FORMAT_TEX_UV(16), ARRAY_FORMAT_TEX_UV2(32), ARRAY_FORMAT_BONES(64), ARRAY_FORMAT_WEIGHTS(128), ARRAY_FORMAT_INDEX(256); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ArrayType( id: Long ) { ARRAY_VERTEX(0), ARRAY_NORMAL(1), ARRAY_TANGENT(2), ARRAY_COLOR(3), ARRAY_TEX_UV(4), ARRAY_TEX_UV2(5), ARRAY_BONES(6), ARRAY_WEIGHTS(7), ARRAY_INDEX(8), ARRAY_MAX(9); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object { final const val ARRAY_WEIGHTS_SIZE: Long = 4 final const val NO_INDEX_ARRAY: Long = -1 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AtlasTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Rect2 import godot.icalls._icall_Boolean import godot.icalls._icall_Rect2 import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Rect2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class AtlasTexture : Texture() { open var atlas: Texture get() { val mb = getMethodBind("AtlasTexture","get_atlas") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("AtlasTexture","set_atlas") _icall_Unit_Object(mb, this.ptr, value) } open var filterClip: Boolean get() { val mb = getMethodBind("AtlasTexture","has_filter_clip") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AtlasTexture","set_filter_clip") _icall_Unit_Boolean(mb, this.ptr, value) } open var margin: Rect2 get() { val mb = getMethodBind("AtlasTexture","get_margin") return _icall_Rect2(mb, this.ptr) } set(value) { val mb = getMethodBind("AtlasTexture","set_margin") _icall_Unit_Rect2(mb, this.ptr, value) } open var region: Rect2 get() { val mb = getMethodBind("AtlasTexture","get_region") return _icall_Rect2(mb, this.ptr) } set(value) { val mb = getMethodBind("AtlasTexture","set_region") _icall_Unit_Rect2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AtlasTexture", "AtlasTexture") open fun margin(schedule: Rect2.() -> Unit): Rect2 = margin.apply{ schedule(this) margin = this } open fun region(schedule: Rect2.() -> Unit): Rect2 = region.apply{ schedule(this) region = this } open fun getAtlas(): Texture { val mb = getMethodBind("AtlasTexture","get_atlas") return _icall_Texture( mb, this.ptr) } open fun getMargin(): Rect2 { val mb = getMethodBind("AtlasTexture","get_margin") return _icall_Rect2( mb, this.ptr) } open fun getRegion(): Rect2 { val mb = getMethodBind("AtlasTexture","get_region") return _icall_Rect2( mb, this.ptr) } open fun hasFilterClip(): Boolean { val mb = getMethodBind("AtlasTexture","has_filter_clip") return _icall_Boolean( mb, this.ptr) } open fun setAtlas(atlas: Texture) { val mb = getMethodBind("AtlasTexture","set_atlas") _icall_Unit_Object( mb, this.ptr, atlas) } open fun setFilterClip(enable: Boolean) { val mb = getMethodBind("AtlasTexture","set_filter_clip") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setMargin(margin: Rect2) { val mb = getMethodBind("AtlasTexture","set_margin") _icall_Unit_Rect2( mb, this.ptr, margin) } open fun setRegion(region: Rect2) { val mb = getMethodBind("AtlasTexture","set_region") _icall_Unit_Rect2( mb, this.ptr, region) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioBusLayout.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioBusLayout : Resource() { override fun __new(): COpaquePointer = invokeConstructor("AudioBusLayout", "AudioBusLayout") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffect.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class AudioEffect internal constructor() : Resource() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectAmplify.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioEffectAmplify : AudioEffect() { open var volumeDb: Double get() { val mb = getMethodBind("AudioEffectAmplify","get_volume_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectAmplify","set_volume_db") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectAmplify", "AudioEffectAmplify") open fun getVolumeDb(): Double { val mb = getMethodBind("AudioEffectAmplify","get_volume_db") return _icall_Double( mb, this.ptr) } open fun setVolumeDb(volume: Double) { val mb = getMethodBind("AudioEffectAmplify","set_volume_db") _icall_Unit_Double( mb, this.ptr, volume) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectBandLimitFilter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectBandLimitFilter : AudioEffectFilter() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectBandLimitFilter", "AudioEffectBandLimitFilter") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectBandPassFilter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectBandPassFilter : AudioEffectFilter() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectBandPassFilter", "AudioEffectBandPassFilter") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectChorus.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class AudioEffectChorus : AudioEffect() { open var dry: Double get() { val mb = getMethodBind("AudioEffectChorus","get_dry") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_dry") _icall_Unit_Double(mb, this.ptr, value) } open var voice_1_cutoffHz: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_cutoff_hz") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_cutoff_hz") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var voice_1_delayMs: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_delay_ms") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_delay_ms") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var voice_1_depthMs: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_depth_ms") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_depth_ms") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var voice_1_levelDb: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_level_db") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_level_db") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var voice_1_pan: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_pan") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_pan") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var voice_1_rateHz: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_rate_hz") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_rate_hz") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var voice_2_cutoffHz: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_cutoff_hz") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_cutoff_hz") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var voice_2_delayMs: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_delay_ms") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_delay_ms") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var voice_2_depthMs: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_depth_ms") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_depth_ms") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var voice_2_levelDb: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_level_db") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_level_db") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var voice_2_pan: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_pan") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_pan") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var voice_2_rateHz: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_rate_hz") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_rate_hz") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var voice_3_cutoffHz: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_cutoff_hz") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_cutoff_hz") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var voice_3_delayMs: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_delay_ms") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_delay_ms") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var voice_3_depthMs: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_depth_ms") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_depth_ms") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var voice_3_levelDb: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_level_db") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_level_db") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var voice_3_pan: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_pan") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_pan") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var voice_3_rateHz: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_rate_hz") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_rate_hz") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var voice_4_cutoffHz: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_cutoff_hz") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_cutoff_hz") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var voice_4_delayMs: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_delay_ms") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_delay_ms") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var voice_4_depthMs: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_depth_ms") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_depth_ms") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var voice_4_levelDb: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_level_db") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_level_db") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var voice_4_pan: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_pan") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_pan") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var voice_4_rateHz: Double get() { val mb = getMethodBind("AudioEffectChorus","get_voice_rate_hz") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_rate_hz") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var voiceCount: Long get() { val mb = getMethodBind("AudioEffectChorus","get_voice_count") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_voice_count") _icall_Unit_Long(mb, this.ptr, value) } open var wet: Double get() { val mb = getMethodBind("AudioEffectChorus","get_wet") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectChorus","set_wet") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectChorus", "AudioEffectChorus") open fun getDry(): Double { val mb = getMethodBind("AudioEffectChorus","get_dry") return _icall_Double( mb, this.ptr) } open fun getVoiceCount(): Long { val mb = getMethodBind("AudioEffectChorus","get_voice_count") return _icall_Long( mb, this.ptr) } open fun getVoiceCutoffHz(voiceIdx: Long): Double { val mb = getMethodBind("AudioEffectChorus","get_voice_cutoff_hz") return _icall_Double_Long( mb, this.ptr, voiceIdx) } open fun getVoiceDelayMs(voiceIdx: Long): Double { val mb = getMethodBind("AudioEffectChorus","get_voice_delay_ms") return _icall_Double_Long( mb, this.ptr, voiceIdx) } open fun getVoiceDepthMs(voiceIdx: Long): Double { val mb = getMethodBind("AudioEffectChorus","get_voice_depth_ms") return _icall_Double_Long( mb, this.ptr, voiceIdx) } open fun getVoiceLevelDb(voiceIdx: Long): Double { val mb = getMethodBind("AudioEffectChorus","get_voice_level_db") return _icall_Double_Long( mb, this.ptr, voiceIdx) } open fun getVoicePan(voiceIdx: Long): Double { val mb = getMethodBind("AudioEffectChorus","get_voice_pan") return _icall_Double_Long( mb, this.ptr, voiceIdx) } open fun getVoiceRateHz(voiceIdx: Long): Double { val mb = getMethodBind("AudioEffectChorus","get_voice_rate_hz") return _icall_Double_Long( mb, this.ptr, voiceIdx) } open fun getWet(): Double { val mb = getMethodBind("AudioEffectChorus","get_wet") return _icall_Double( mb, this.ptr) } open fun setDry(amount: Double) { val mb = getMethodBind("AudioEffectChorus","set_dry") _icall_Unit_Double( mb, this.ptr, amount) } open fun setVoiceCount(voices: Long) { val mb = getMethodBind("AudioEffectChorus","set_voice_count") _icall_Unit_Long( mb, this.ptr, voices) } open fun setVoiceCutoffHz(voiceIdx: Long, cutoffHz: Double) { val mb = getMethodBind("AudioEffectChorus","set_voice_cutoff_hz") _icall_Unit_Long_Double( mb, this.ptr, voiceIdx, cutoffHz) } open fun setVoiceDelayMs(voiceIdx: Long, delayMs: Double) { val mb = getMethodBind("AudioEffectChorus","set_voice_delay_ms") _icall_Unit_Long_Double( mb, this.ptr, voiceIdx, delayMs) } open fun setVoiceDepthMs(voiceIdx: Long, depthMs: Double) { val mb = getMethodBind("AudioEffectChorus","set_voice_depth_ms") _icall_Unit_Long_Double( mb, this.ptr, voiceIdx, depthMs) } open fun setVoiceLevelDb(voiceIdx: Long, levelDb: Double) { val mb = getMethodBind("AudioEffectChorus","set_voice_level_db") _icall_Unit_Long_Double( mb, this.ptr, voiceIdx, levelDb) } open fun setVoicePan(voiceIdx: Long, pan: Double) { val mb = getMethodBind("AudioEffectChorus","set_voice_pan") _icall_Unit_Long_Double( mb, this.ptr, voiceIdx, pan) } open fun setVoiceRateHz(voiceIdx: Long, rateHz: Double) { val mb = getMethodBind("AudioEffectChorus","set_voice_rate_hz") _icall_Unit_Long_Double( mb, this.ptr, voiceIdx, rateHz) } open fun setWet(amount: Double) { val mb = getMethodBind("AudioEffectChorus","set_wet") _icall_Unit_Double( mb, this.ptr, amount) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectCompressor.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_String import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.String import kotlinx.cinterop.COpaquePointer open class AudioEffectCompressor : AudioEffect() { open var attackUs: Double get() { val mb = getMethodBind("AudioEffectCompressor","get_attack_us") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectCompressor","set_attack_us") _icall_Unit_Double(mb, this.ptr, value) } open var gain: Double get() { val mb = getMethodBind("AudioEffectCompressor","get_gain") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectCompressor","set_gain") _icall_Unit_Double(mb, this.ptr, value) } open var mix: Double get() { val mb = getMethodBind("AudioEffectCompressor","get_mix") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectCompressor","set_mix") _icall_Unit_Double(mb, this.ptr, value) } open var ratio: Double get() { val mb = getMethodBind("AudioEffectCompressor","get_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectCompressor","set_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var releaseMs: Double get() { val mb = getMethodBind("AudioEffectCompressor","get_release_ms") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectCompressor","set_release_ms") _icall_Unit_Double(mb, this.ptr, value) } open var sidechain: String get() { val mb = getMethodBind("AudioEffectCompressor","get_sidechain") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectCompressor","set_sidechain") _icall_Unit_String(mb, this.ptr, value) } open var threshold: Double get() { val mb = getMethodBind("AudioEffectCompressor","get_threshold") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectCompressor","set_threshold") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectCompressor", "AudioEffectCompressor") open fun getAttackUs(): Double { val mb = getMethodBind("AudioEffectCompressor","get_attack_us") return _icall_Double( mb, this.ptr) } open fun getGain(): Double { val mb = getMethodBind("AudioEffectCompressor","get_gain") return _icall_Double( mb, this.ptr) } open fun getMix(): Double { val mb = getMethodBind("AudioEffectCompressor","get_mix") return _icall_Double( mb, this.ptr) } open fun getRatio(): Double { val mb = getMethodBind("AudioEffectCompressor","get_ratio") return _icall_Double( mb, this.ptr) } open fun getReleaseMs(): Double { val mb = getMethodBind("AudioEffectCompressor","get_release_ms") return _icall_Double( mb, this.ptr) } open fun getSidechain(): String { val mb = getMethodBind("AudioEffectCompressor","get_sidechain") return _icall_String( mb, this.ptr) } open fun getThreshold(): Double { val mb = getMethodBind("AudioEffectCompressor","get_threshold") return _icall_Double( mb, this.ptr) } open fun setAttackUs(attackUs: Double) { val mb = getMethodBind("AudioEffectCompressor","set_attack_us") _icall_Unit_Double( mb, this.ptr, attackUs) } open fun setGain(gain: Double) { val mb = getMethodBind("AudioEffectCompressor","set_gain") _icall_Unit_Double( mb, this.ptr, gain) } open fun setMix(mix: Double) { val mb = getMethodBind("AudioEffectCompressor","set_mix") _icall_Unit_Double( mb, this.ptr, mix) } open fun setRatio(ratio: Double) { val mb = getMethodBind("AudioEffectCompressor","set_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setReleaseMs(releaseMs: Double) { val mb = getMethodBind("AudioEffectCompressor","set_release_ms") _icall_Unit_Double( mb, this.ptr, releaseMs) } open fun setSidechain(sidechain: String) { val mb = getMethodBind("AudioEffectCompressor","set_sidechain") _icall_Unit_String( mb, this.ptr, sidechain) } open fun setThreshold(threshold: Double) { val mb = getMethodBind("AudioEffectCompressor","set_threshold") _icall_Unit_Double( mb, this.ptr, threshold) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectDelay.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioEffectDelay : AudioEffect() { open var dry: Double get() { val mb = getMethodBind("AudioEffectDelay","get_dry") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_dry") _icall_Unit_Double(mb, this.ptr, value) } open var feedback_active: Boolean get() { val mb = getMethodBind("AudioEffectDelay","is_feedback_active") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_feedback_active") _icall_Unit_Boolean(mb, this.ptr, value) } open var feedback_delayMs: Double get() { val mb = getMethodBind("AudioEffectDelay","get_feedback_delay_ms") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_feedback_delay_ms") _icall_Unit_Double(mb, this.ptr, value) } open var feedback_levelDb: Double get() { val mb = getMethodBind("AudioEffectDelay","get_feedback_level_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_feedback_level_db") _icall_Unit_Double(mb, this.ptr, value) } open var feedback_lowpass: Double get() { val mb = getMethodBind("AudioEffectDelay","get_feedback_lowpass") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_feedback_lowpass") _icall_Unit_Double(mb, this.ptr, value) } open var tap1_active: Boolean get() { val mb = getMethodBind("AudioEffectDelay","is_tap1_active") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_tap1_active") _icall_Unit_Boolean(mb, this.ptr, value) } open var tap1_delayMs: Double get() { val mb = getMethodBind("AudioEffectDelay","get_tap1_delay_ms") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_tap1_delay_ms") _icall_Unit_Double(mb, this.ptr, value) } open var tap1_levelDb: Double get() { val mb = getMethodBind("AudioEffectDelay","get_tap1_level_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_tap1_level_db") _icall_Unit_Double(mb, this.ptr, value) } open var tap1_pan: Double get() { val mb = getMethodBind("AudioEffectDelay","get_tap1_pan") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_tap1_pan") _icall_Unit_Double(mb, this.ptr, value) } open var tap2_active: Boolean get() { val mb = getMethodBind("AudioEffectDelay","is_tap2_active") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_tap2_active") _icall_Unit_Boolean(mb, this.ptr, value) } open var tap2_delayMs: Double get() { val mb = getMethodBind("AudioEffectDelay","get_tap2_delay_ms") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_tap2_delay_ms") _icall_Unit_Double(mb, this.ptr, value) } open var tap2_levelDb: Double get() { val mb = getMethodBind("AudioEffectDelay","get_tap2_level_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_tap2_level_db") _icall_Unit_Double(mb, this.ptr, value) } open var tap2_pan: Double get() { val mb = getMethodBind("AudioEffectDelay","get_tap2_pan") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDelay","set_tap2_pan") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectDelay", "AudioEffectDelay") open fun getDry(): Double { val mb = getMethodBind("AudioEffectDelay","get_dry") return _icall_Double( mb, this.ptr) } open fun getFeedbackDelayMs(): Double { val mb = getMethodBind("AudioEffectDelay","get_feedback_delay_ms") return _icall_Double( mb, this.ptr) } open fun getFeedbackLevelDb(): Double { val mb = getMethodBind("AudioEffectDelay","get_feedback_level_db") return _icall_Double( mb, this.ptr) } open fun getFeedbackLowpass(): Double { val mb = getMethodBind("AudioEffectDelay","get_feedback_lowpass") return _icall_Double( mb, this.ptr) } open fun getTap1DelayMs(): Double { val mb = getMethodBind("AudioEffectDelay","get_tap1_delay_ms") return _icall_Double( mb, this.ptr) } open fun getTap1LevelDb(): Double { val mb = getMethodBind("AudioEffectDelay","get_tap1_level_db") return _icall_Double( mb, this.ptr) } open fun getTap1Pan(): Double { val mb = getMethodBind("AudioEffectDelay","get_tap1_pan") return _icall_Double( mb, this.ptr) } open fun getTap2DelayMs(): Double { val mb = getMethodBind("AudioEffectDelay","get_tap2_delay_ms") return _icall_Double( mb, this.ptr) } open fun getTap2LevelDb(): Double { val mb = getMethodBind("AudioEffectDelay","get_tap2_level_db") return _icall_Double( mb, this.ptr) } open fun getTap2Pan(): Double { val mb = getMethodBind("AudioEffectDelay","get_tap2_pan") return _icall_Double( mb, this.ptr) } open fun isFeedbackActive(): Boolean { val mb = getMethodBind("AudioEffectDelay","is_feedback_active") return _icall_Boolean( mb, this.ptr) } open fun isTap1Active(): Boolean { val mb = getMethodBind("AudioEffectDelay","is_tap1_active") return _icall_Boolean( mb, this.ptr) } open fun isTap2Active(): Boolean { val mb = getMethodBind("AudioEffectDelay","is_tap2_active") return _icall_Boolean( mb, this.ptr) } open fun setDry(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_dry") _icall_Unit_Double( mb, this.ptr, amount) } open fun setFeedbackActive(amount: Boolean) { val mb = getMethodBind("AudioEffectDelay","set_feedback_active") _icall_Unit_Boolean( mb, this.ptr, amount) } open fun setFeedbackDelayMs(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_feedback_delay_ms") _icall_Unit_Double( mb, this.ptr, amount) } open fun setFeedbackLevelDb(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_feedback_level_db") _icall_Unit_Double( mb, this.ptr, amount) } open fun setFeedbackLowpass(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_feedback_lowpass") _icall_Unit_Double( mb, this.ptr, amount) } open fun setTap1Active(amount: Boolean) { val mb = getMethodBind("AudioEffectDelay","set_tap1_active") _icall_Unit_Boolean( mb, this.ptr, amount) } open fun setTap1DelayMs(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_tap1_delay_ms") _icall_Unit_Double( mb, this.ptr, amount) } open fun setTap1LevelDb(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_tap1_level_db") _icall_Unit_Double( mb, this.ptr, amount) } open fun setTap1Pan(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_tap1_pan") _icall_Unit_Double( mb, this.ptr, amount) } open fun setTap2Active(amount: Boolean) { val mb = getMethodBind("AudioEffectDelay","set_tap2_active") _icall_Unit_Boolean( mb, this.ptr, amount) } open fun setTap2DelayMs(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_tap2_delay_ms") _icall_Unit_Double( mb, this.ptr, amount) } open fun setTap2LevelDb(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_tap2_level_db") _icall_Unit_Double( mb, this.ptr, amount) } open fun setTap2Pan(amount: Double) { val mb = getMethodBind("AudioEffectDelay","set_tap2_pan") _icall_Unit_Double( mb, this.ptr, amount) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectDistortion.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AudioEffectDistortion import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class AudioEffectDistortion : AudioEffect() { open var drive: Double get() { val mb = getMethodBind("AudioEffectDistortion","get_drive") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDistortion","set_drive") _icall_Unit_Double(mb, this.ptr, value) } open var keepHfHz: Double get() { val mb = getMethodBind("AudioEffectDistortion","get_keep_hf_hz") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDistortion","set_keep_hf_hz") _icall_Unit_Double(mb, this.ptr, value) } open var mode: Long get() { val mb = getMethodBind("AudioEffectDistortion","get_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDistortion","set_mode") _icall_Unit_Long(mb, this.ptr, value) } open var postGain: Double get() { val mb = getMethodBind("AudioEffectDistortion","get_post_gain") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDistortion","set_post_gain") _icall_Unit_Double(mb, this.ptr, value) } open var preGain: Double get() { val mb = getMethodBind("AudioEffectDistortion","get_pre_gain") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectDistortion","set_pre_gain") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectDistortion", "AudioEffectDistortion") open fun getDrive(): Double { val mb = getMethodBind("AudioEffectDistortion","get_drive") return _icall_Double( mb, this.ptr) } open fun getKeepHfHz(): Double { val mb = getMethodBind("AudioEffectDistortion","get_keep_hf_hz") return _icall_Double( mb, this.ptr) } open fun getMode(): AudioEffectDistortion.Mode { val mb = getMethodBind("AudioEffectDistortion","get_mode") return AudioEffectDistortion.Mode.from( _icall_Long( mb, this.ptr)) } open fun getPostGain(): Double { val mb = getMethodBind("AudioEffectDistortion","get_post_gain") return _icall_Double( mb, this.ptr) } open fun getPreGain(): Double { val mb = getMethodBind("AudioEffectDistortion","get_pre_gain") return _icall_Double( mb, this.ptr) } open fun setDrive(drive: Double) { val mb = getMethodBind("AudioEffectDistortion","set_drive") _icall_Unit_Double( mb, this.ptr, drive) } open fun setKeepHfHz(keepHfHz: Double) { val mb = getMethodBind("AudioEffectDistortion","set_keep_hf_hz") _icall_Unit_Double( mb, this.ptr, keepHfHz) } open fun setMode(mode: Long) { val mb = getMethodBind("AudioEffectDistortion","set_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setPostGain(postGain: Double) { val mb = getMethodBind("AudioEffectDistortion","set_post_gain") _icall_Unit_Double( mb, this.ptr, postGain) } open fun setPreGain(preGain: Double) { val mb = getMethodBind("AudioEffectDistortion","set_pre_gain") _icall_Unit_Double( mb, this.ptr, preGain) } enum class Mode( id: Long ) { MODE_CLIP(0), MODE_ATAN(1), MODE_LOFI(2), MODE_OVERDRIVE(3), MODE_WAVESHAPE(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectEQ.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class AudioEffectEQ : AudioEffect() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectEQ", "AudioEffectEQ") open fun getBandCount(): Long { val mb = getMethodBind("AudioEffectEQ","get_band_count") return _icall_Long( mb, this.ptr) } open fun getBandGainDb(bandIdx: Long): Double { val mb = getMethodBind("AudioEffectEQ","get_band_gain_db") return _icall_Double_Long( mb, this.ptr, bandIdx) } open fun setBandGainDb(bandIdx: Long, volumeDb: Double) { val mb = getMethodBind("AudioEffectEQ","set_band_gain_db") _icall_Unit_Long_Double( mb, this.ptr, bandIdx, volumeDb) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectEQ10.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectEQ10 : AudioEffectEQ() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectEQ10", "AudioEffectEQ10") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectEQ21.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectEQ21 : AudioEffectEQ() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectEQ21", "AudioEffectEQ21") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectEQ6.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectEQ6 : AudioEffectEQ() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectEQ6", "AudioEffectEQ6") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectFilter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AudioEffectFilter import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class AudioEffectFilter : AudioEffect() { open var cutoffHz: Double get() { val mb = getMethodBind("AudioEffectFilter","get_cutoff") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectFilter","set_cutoff") _icall_Unit_Double(mb, this.ptr, value) } open var db: Long get() { val mb = getMethodBind("AudioEffectFilter","get_db") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectFilter","set_db") _icall_Unit_Long(mb, this.ptr, value) } open var gain: Double get() { val mb = getMethodBind("AudioEffectFilter","get_gain") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectFilter","set_gain") _icall_Unit_Double(mb, this.ptr, value) } open var resonance: Double get() { val mb = getMethodBind("AudioEffectFilter","get_resonance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectFilter","set_resonance") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectFilter", "AudioEffectFilter") open fun getCutoff(): Double { val mb = getMethodBind("AudioEffectFilter","get_cutoff") return _icall_Double( mb, this.ptr) } open fun getDb(): AudioEffectFilter.FilterDB { val mb = getMethodBind("AudioEffectFilter","get_db") return AudioEffectFilter.FilterDB.from( _icall_Long( mb, this.ptr)) } open fun getGain(): Double { val mb = getMethodBind("AudioEffectFilter","get_gain") return _icall_Double( mb, this.ptr) } open fun getResonance(): Double { val mb = getMethodBind("AudioEffectFilter","get_resonance") return _icall_Double( mb, this.ptr) } open fun setCutoff(freq: Double) { val mb = getMethodBind("AudioEffectFilter","set_cutoff") _icall_Unit_Double( mb, this.ptr, freq) } open fun setDb(amount: Long) { val mb = getMethodBind("AudioEffectFilter","set_db") _icall_Unit_Long( mb, this.ptr, amount) } open fun setGain(amount: Double) { val mb = getMethodBind("AudioEffectFilter","set_gain") _icall_Unit_Double( mb, this.ptr, amount) } open fun setResonance(amount: Double) { val mb = getMethodBind("AudioEffectFilter","set_resonance") _icall_Unit_Double( mb, this.ptr, amount) } enum class FilterDB( id: Long ) { FILTER_6DB(0), FILTER_12DB(1), FILTER_18DB(2), FILTER_24DB(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectHighPassFilter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectHighPassFilter : AudioEffectFilter() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectHighPassFilter", "AudioEffectHighPassFilter") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectHighShelfFilter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectHighShelfFilter : AudioEffectFilter() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectHighShelfFilter", "AudioEffectHighShelfFilter") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectInstance.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class AudioEffectInstance internal constructor() : Reference() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectLimiter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioEffectLimiter : AudioEffect() { open var ceilingDb: Double get() { val mb = getMethodBind("AudioEffectLimiter","get_ceiling_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectLimiter","set_ceiling_db") _icall_Unit_Double(mb, this.ptr, value) } open var softClipDb: Double get() { val mb = getMethodBind("AudioEffectLimiter","get_soft_clip_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectLimiter","set_soft_clip_db") _icall_Unit_Double(mb, this.ptr, value) } open var softClipRatio: Double get() { val mb = getMethodBind("AudioEffectLimiter","get_soft_clip_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectLimiter","set_soft_clip_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var thresholdDb: Double get() { val mb = getMethodBind("AudioEffectLimiter","get_threshold_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectLimiter","set_threshold_db") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectLimiter", "AudioEffectLimiter") open fun getCeilingDb(): Double { val mb = getMethodBind("AudioEffectLimiter","get_ceiling_db") return _icall_Double( mb, this.ptr) } open fun getSoftClipDb(): Double { val mb = getMethodBind("AudioEffectLimiter","get_soft_clip_db") return _icall_Double( mb, this.ptr) } open fun getSoftClipRatio(): Double { val mb = getMethodBind("AudioEffectLimiter","get_soft_clip_ratio") return _icall_Double( mb, this.ptr) } open fun getThresholdDb(): Double { val mb = getMethodBind("AudioEffectLimiter","get_threshold_db") return _icall_Double( mb, this.ptr) } open fun setCeilingDb(ceiling: Double) { val mb = getMethodBind("AudioEffectLimiter","set_ceiling_db") _icall_Unit_Double( mb, this.ptr, ceiling) } open fun setSoftClipDb(softClip: Double) { val mb = getMethodBind("AudioEffectLimiter","set_soft_clip_db") _icall_Unit_Double( mb, this.ptr, softClip) } open fun setSoftClipRatio(softClip: Double) { val mb = getMethodBind("AudioEffectLimiter","set_soft_clip_ratio") _icall_Unit_Double( mb, this.ptr, softClip) } open fun setThresholdDb(threshold: Double) { val mb = getMethodBind("AudioEffectLimiter","set_threshold_db") _icall_Unit_Double( mb, this.ptr, threshold) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectLowPassFilter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectLowPassFilter : AudioEffectFilter() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectLowPassFilter", "AudioEffectLowPassFilter") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectLowShelfFilter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectLowShelfFilter : AudioEffectFilter() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectLowShelfFilter", "AudioEffectLowShelfFilter") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectNotchFilter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioEffectNotchFilter : AudioEffectFilter() { override fun __new(): COpaquePointer = invokeConstructor("AudioEffectNotchFilter", "AudioEffectNotchFilter") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectPanner.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioEffectPanner : AudioEffect() { open var pan: Double get() { val mb = getMethodBind("AudioEffectPanner","get_pan") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectPanner","set_pan") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectPanner", "AudioEffectPanner") open fun getPan(): Double { val mb = getMethodBind("AudioEffectPanner","get_pan") return _icall_Double( mb, this.ptr) } open fun setPan(cpanume: Double) { val mb = getMethodBind("AudioEffectPanner","set_pan") _icall_Unit_Double( mb, this.ptr, cpanume) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectPhaser.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioEffectPhaser : AudioEffect() { open var depth: Double get() { val mb = getMethodBind("AudioEffectPhaser","get_depth") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectPhaser","set_depth") _icall_Unit_Double(mb, this.ptr, value) } open var feedback: Double get() { val mb = getMethodBind("AudioEffectPhaser","get_feedback") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectPhaser","set_feedback") _icall_Unit_Double(mb, this.ptr, value) } open var rangeMaxHz: Double get() { val mb = getMethodBind("AudioEffectPhaser","get_range_max_hz") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectPhaser","set_range_max_hz") _icall_Unit_Double(mb, this.ptr, value) } open var rangeMinHz: Double get() { val mb = getMethodBind("AudioEffectPhaser","get_range_min_hz") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectPhaser","set_range_min_hz") _icall_Unit_Double(mb, this.ptr, value) } open var rateHz: Double get() { val mb = getMethodBind("AudioEffectPhaser","get_rate_hz") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectPhaser","set_rate_hz") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectPhaser", "AudioEffectPhaser") open fun getDepth(): Double { val mb = getMethodBind("AudioEffectPhaser","get_depth") return _icall_Double( mb, this.ptr) } open fun getFeedback(): Double { val mb = getMethodBind("AudioEffectPhaser","get_feedback") return _icall_Double( mb, this.ptr) } open fun getRangeMaxHz(): Double { val mb = getMethodBind("AudioEffectPhaser","get_range_max_hz") return _icall_Double( mb, this.ptr) } open fun getRangeMinHz(): Double { val mb = getMethodBind("AudioEffectPhaser","get_range_min_hz") return _icall_Double( mb, this.ptr) } open fun getRateHz(): Double { val mb = getMethodBind("AudioEffectPhaser","get_rate_hz") return _icall_Double( mb, this.ptr) } open fun setDepth(depth: Double) { val mb = getMethodBind("AudioEffectPhaser","set_depth") _icall_Unit_Double( mb, this.ptr, depth) } open fun setFeedback(fbk: Double) { val mb = getMethodBind("AudioEffectPhaser","set_feedback") _icall_Unit_Double( mb, this.ptr, fbk) } open fun setRangeMaxHz(hz: Double) { val mb = getMethodBind("AudioEffectPhaser","set_range_max_hz") _icall_Unit_Double( mb, this.ptr, hz) } open fun setRangeMinHz(hz: Double) { val mb = getMethodBind("AudioEffectPhaser","set_range_min_hz") _icall_Unit_Double( mb, this.ptr, hz) } open fun setRateHz(hz: Double) { val mb = getMethodBind("AudioEffectPhaser","set_rate_hz") _icall_Unit_Double( mb, this.ptr, hz) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectPitchShift.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AudioEffectPitchShift import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class AudioEffectPitchShift : AudioEffect() { open var fftSize: Long get() { val mb = getMethodBind("AudioEffectPitchShift","get_fft_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectPitchShift","set_fft_size") _icall_Unit_Long(mb, this.ptr, value) } open var oversampling: Long get() { val mb = getMethodBind("AudioEffectPitchShift","get_oversampling") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectPitchShift","set_oversampling") _icall_Unit_Long(mb, this.ptr, value) } open var pitchScale: Double get() { val mb = getMethodBind("AudioEffectPitchShift","get_pitch_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectPitchShift","set_pitch_scale") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectPitchShift", "AudioEffectPitchShift") open fun getFftSize(): AudioEffectPitchShift.FFT_Size { val mb = getMethodBind("AudioEffectPitchShift","get_fft_size") return AudioEffectPitchShift.FFT_Size.from( _icall_Long( mb, this.ptr)) } open fun getOversampling(): Long { val mb = getMethodBind("AudioEffectPitchShift","get_oversampling") return _icall_Long( mb, this.ptr) } open fun getPitchScale(): Double { val mb = getMethodBind("AudioEffectPitchShift","get_pitch_scale") return _icall_Double( mb, this.ptr) } open fun setFftSize(size: Long) { val mb = getMethodBind("AudioEffectPitchShift","set_fft_size") _icall_Unit_Long( mb, this.ptr, size) } open fun setOversampling(amount: Long) { val mb = getMethodBind("AudioEffectPitchShift","set_oversampling") _icall_Unit_Long( mb, this.ptr, amount) } open fun setPitchScale(rate: Double) { val mb = getMethodBind("AudioEffectPitchShift","set_pitch_scale") _icall_Unit_Double( mb, this.ptr, rate) } enum class FFT_Size( id: Long ) { FFT_SIZE_256(0), FFT_SIZE_512(1), FFT_SIZE_1024(2), FFT_SIZE_2048(3), FFT_SIZE_4096(4), FFT_SIZE_MAX(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectRecord.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AudioStreamSample import godot.icalls._icall_AudioStreamSample import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlinx.cinterop.COpaquePointer open class AudioEffectRecord : AudioEffect() { open var format: Long get() { val mb = getMethodBind("AudioEffectRecord","get_format") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectRecord","set_format") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectRecord", "AudioEffectRecord") open fun getFormat(): AudioStreamSample.Format { val mb = getMethodBind("AudioEffectRecord","get_format") return AudioStreamSample.Format.from( _icall_Long( mb, this.ptr)) } open fun getRecording(): AudioStreamSample { val mb = getMethodBind("AudioEffectRecord","get_recording") return _icall_AudioStreamSample( mb, this.ptr) } open fun isRecordingActive(): Boolean { val mb = getMethodBind("AudioEffectRecord","is_recording_active") return _icall_Boolean( mb, this.ptr) } open fun setFormat(format: Long) { val mb = getMethodBind("AudioEffectRecord","set_format") _icall_Unit_Long( mb, this.ptr, format) } open fun setRecordingActive(record: Boolean) { val mb = getMethodBind("AudioEffectRecord","set_recording_active") _icall_Unit_Boolean( mb, this.ptr, record) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectReverb.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioEffectReverb : AudioEffect() { open var damping: Double get() { val mb = getMethodBind("AudioEffectReverb","get_damping") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectReverb","set_damping") _icall_Unit_Double(mb, this.ptr, value) } open var dry: Double get() { val mb = getMethodBind("AudioEffectReverb","get_dry") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectReverb","set_dry") _icall_Unit_Double(mb, this.ptr, value) } open var hipass: Double get() { val mb = getMethodBind("AudioEffectReverb","get_hpf") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectReverb","set_hpf") _icall_Unit_Double(mb, this.ptr, value) } open var predelayFeedback: Double get() { val mb = getMethodBind("AudioEffectReverb","get_predelay_feedback") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectReverb","set_predelay_feedback") _icall_Unit_Double(mb, this.ptr, value) } open var predelayMsec: Double get() { val mb = getMethodBind("AudioEffectReverb","get_predelay_msec") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectReverb","set_predelay_msec") _icall_Unit_Double(mb, this.ptr, value) } open var roomSize: Double get() { val mb = getMethodBind("AudioEffectReverb","get_room_size") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectReverb","set_room_size") _icall_Unit_Double(mb, this.ptr, value) } open var spread: Double get() { val mb = getMethodBind("AudioEffectReverb","get_spread") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectReverb","set_spread") _icall_Unit_Double(mb, this.ptr, value) } open var wet: Double get() { val mb = getMethodBind("AudioEffectReverb","get_wet") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectReverb","set_wet") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectReverb", "AudioEffectReverb") open fun getDamping(): Double { val mb = getMethodBind("AudioEffectReverb","get_damping") return _icall_Double( mb, this.ptr) } open fun getDry(): Double { val mb = getMethodBind("AudioEffectReverb","get_dry") return _icall_Double( mb, this.ptr) } open fun getHpf(): Double { val mb = getMethodBind("AudioEffectReverb","get_hpf") return _icall_Double( mb, this.ptr) } open fun getPredelayFeedback(): Double { val mb = getMethodBind("AudioEffectReverb","get_predelay_feedback") return _icall_Double( mb, this.ptr) } open fun getPredelayMsec(): Double { val mb = getMethodBind("AudioEffectReverb","get_predelay_msec") return _icall_Double( mb, this.ptr) } open fun getRoomSize(): Double { val mb = getMethodBind("AudioEffectReverb","get_room_size") return _icall_Double( mb, this.ptr) } open fun getSpread(): Double { val mb = getMethodBind("AudioEffectReverb","get_spread") return _icall_Double( mb, this.ptr) } open fun getWet(): Double { val mb = getMethodBind("AudioEffectReverb","get_wet") return _icall_Double( mb, this.ptr) } open fun setDamping(amount: Double) { val mb = getMethodBind("AudioEffectReverb","set_damping") _icall_Unit_Double( mb, this.ptr, amount) } open fun setDry(amount: Double) { val mb = getMethodBind("AudioEffectReverb","set_dry") _icall_Unit_Double( mb, this.ptr, amount) } open fun setHpf(amount: Double) { val mb = getMethodBind("AudioEffectReverb","set_hpf") _icall_Unit_Double( mb, this.ptr, amount) } open fun setPredelayFeedback(feedback: Double) { val mb = getMethodBind("AudioEffectReverb","set_predelay_feedback") _icall_Unit_Double( mb, this.ptr, feedback) } open fun setPredelayMsec(msec: Double) { val mb = getMethodBind("AudioEffectReverb","set_predelay_msec") _icall_Unit_Double( mb, this.ptr, msec) } open fun setRoomSize(size: Double) { val mb = getMethodBind("AudioEffectReverb","set_room_size") _icall_Unit_Double( mb, this.ptr, size) } open fun setSpread(amount: Double) { val mb = getMethodBind("AudioEffectReverb","set_spread") _icall_Unit_Double( mb, this.ptr, amount) } open fun setWet(amount: Double) { val mb = getMethodBind("AudioEffectReverb","set_wet") _icall_Unit_Double( mb, this.ptr, amount) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AudioEffectSpectrumAnalyzer import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class AudioEffectSpectrumAnalyzer : AudioEffect() { open var bufferLength: Double get() { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","get_buffer_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","set_buffer_length") _icall_Unit_Double(mb, this.ptr, value) } open var fftSize: Long get() { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","get_fft_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","set_fft_size") _icall_Unit_Long(mb, this.ptr, value) } open var tapBackPos: Double get() { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","get_tap_back_pos") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","set_tap_back_pos") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectSpectrumAnalyzer", "AudioEffectSpectrumAnalyzer") open fun getBufferLength(): Double { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","get_buffer_length") return _icall_Double( mb, this.ptr) } open fun getFftSize(): AudioEffectSpectrumAnalyzer.FFT_Size { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","get_fft_size") return AudioEffectSpectrumAnalyzer.FFT_Size.from( _icall_Long( mb, this.ptr)) } open fun getTapBackPos(): Double { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","get_tap_back_pos") return _icall_Double( mb, this.ptr) } open fun setBufferLength(seconds: Double) { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","set_buffer_length") _icall_Unit_Double( mb, this.ptr, seconds) } open fun setFftSize(size: Long) { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","set_fft_size") _icall_Unit_Long( mb, this.ptr, size) } open fun setTapBackPos(seconds: Double) { val mb = getMethodBind("AudioEffectSpectrumAnalyzer","set_tap_back_pos") _icall_Unit_Double( mb, this.ptr, seconds) } enum class FFT_Size( id: Long ) { FFT_SIZE_256(0), FFT_SIZE_512(1), FFT_SIZE_1024(2), FFT_SIZE_2048(3), FFT_SIZE_4096(4), FFT_SIZE_MAX(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectSpectrumAnalyzerInstance.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Vector2_Double_Double_Long import godot.internal.utils.getMethodBind import kotlin.Double import kotlin.Long open class AudioEffectSpectrumAnalyzerInstance internal constructor() : AudioEffectInstance() { open fun getMagnitudeForFrequencyRange( fromHz: Double, toHz: Double, mode: Long = 1 ): Vector2 { val mb = getMethodBind("AudioEffectSpectrumAnalyzerInstance","get_magnitude_for_frequency_range") return _icall_Vector2_Double_Double_Long( mb, this.ptr, fromHz, toHz, mode) } enum class MagnitudeMode( id: Long ) { MAGNITUDE_AVERAGE(0), MAGNITUDE_MAX(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioEffectStereoEnhance.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioEffectStereoEnhance : AudioEffect() { open var panPullout: Double get() { val mb = getMethodBind("AudioEffectStereoEnhance","get_pan_pullout") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectStereoEnhance","set_pan_pullout") _icall_Unit_Double(mb, this.ptr, value) } open var surround: Double get() { val mb = getMethodBind("AudioEffectStereoEnhance","get_surround") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectStereoEnhance","set_surround") _icall_Unit_Double(mb, this.ptr, value) } open var timePulloutMs: Double get() { val mb = getMethodBind("AudioEffectStereoEnhance","get_time_pullout") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioEffectStereoEnhance","set_time_pullout") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioEffectStereoEnhance", "AudioEffectStereoEnhance") open fun getPanPullout(): Double { val mb = getMethodBind("AudioEffectStereoEnhance","get_pan_pullout") return _icall_Double( mb, this.ptr) } open fun getSurround(): Double { val mb = getMethodBind("AudioEffectStereoEnhance","get_surround") return _icall_Double( mb, this.ptr) } open fun getTimePullout(): Double { val mb = getMethodBind("AudioEffectStereoEnhance","get_time_pullout") return _icall_Double( mb, this.ptr) } open fun setPanPullout(amount: Double) { val mb = getMethodBind("AudioEffectStereoEnhance","set_pan_pullout") _icall_Unit_Double( mb, this.ptr, amount) } open fun setSurround(amount: Double) { val mb = getMethodBind("AudioEffectStereoEnhance","set_surround") _icall_Unit_Double( mb, this.ptr, amount) } open fun setTimePullout(amount: Double) { val mb = getMethodBind("AudioEffectStereoEnhance","set_time_pullout") _icall_Unit_Double( mb, this.ptr, amount) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioServer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AudioServer import godot.core.Godot import godot.core.Signal0 import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_AudioBusLayout import godot.icalls._icall_AudioEffectInstance_Long_Long_Long import godot.icalls._icall_AudioEffect_Long_Long import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_Long_Long import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Double_Long_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_String import godot.icalls._icall_String import godot.icalls._icall_String_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Long_Boolean import godot.icalls._icall_Unit_Long_Long_Long import godot.icalls._icall_Unit_Long_Object_Long import godot.icalls._icall_Unit_Long_String import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_VariantArray import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object AudioServer : Object() { val busLayoutChanged: Signal0 by signal() var busCount: Long get() { val mb = getMethodBind("AudioServer","get_bus_count") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioServer","set_bus_count") _icall_Unit_Long(mb, this.ptr, value) } var device: String get() { val mb = getMethodBind("AudioServer","get_device") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioServer","set_device") _icall_Unit_String(mb, this.ptr, value) } var globalRateScale: Double get() { val mb = getMethodBind("AudioServer","get_global_rate_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioServer","set_global_rate_scale") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("AudioServer".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton AudioServer" } ptr } fun addBus(atPosition: Long = -1) { val mb = getMethodBind("AudioServer","add_bus") _icall_Unit_Long( mb, this.ptr, atPosition) } fun addBusEffect( busIdx: Long, effect: AudioEffect, atPosition: Long = -1 ) { val mb = getMethodBind("AudioServer","add_bus_effect") _icall_Unit_Long_Object_Long( mb, this.ptr, busIdx, effect, atPosition) } fun captureGetDevice(): String { val mb = getMethodBind("AudioServer","capture_get_device") return _icall_String( mb, this.ptr) } fun captureGetDeviceList(): VariantArray { val mb = getMethodBind("AudioServer","capture_get_device_list") return _icall_VariantArray( mb, this.ptr) } fun captureSetDevice(name: String) { val mb = getMethodBind("AudioServer","capture_set_device") _icall_Unit_String( mb, this.ptr, name) } fun generateBusLayout(): AudioBusLayout { val mb = getMethodBind("AudioServer","generate_bus_layout") return _icall_AudioBusLayout( mb, this.ptr) } fun getBusChannels(busIdx: Long): Long { val mb = getMethodBind("AudioServer","get_bus_channels") return _icall_Long_Long( mb, this.ptr, busIdx) } fun getBusCount(): Long { val mb = getMethodBind("AudioServer","get_bus_count") return _icall_Long( mb, this.ptr) } fun getBusEffect(busIdx: Long, effectIdx: Long): AudioEffect { val mb = getMethodBind("AudioServer","get_bus_effect") return _icall_AudioEffect_Long_Long( mb, this.ptr, busIdx, effectIdx) } fun getBusEffectCount(busIdx: Long): Long { val mb = getMethodBind("AudioServer","get_bus_effect_count") return _icall_Long_Long( mb, this.ptr, busIdx) } fun getBusEffectInstance( busIdx: Long, effectIdx: Long, channel: Long = 0 ): AudioEffectInstance { val mb = getMethodBind("AudioServer","get_bus_effect_instance") return _icall_AudioEffectInstance_Long_Long_Long( mb, this.ptr, busIdx, effectIdx, channel) } fun getBusIndex(busName: String): Long { val mb = getMethodBind("AudioServer","get_bus_index") return _icall_Long_String( mb, this.ptr, busName) } fun getBusName(busIdx: Long): String { val mb = getMethodBind("AudioServer","get_bus_name") return _icall_String_Long( mb, this.ptr, busIdx) } fun getBusPeakVolumeLeftDb(busIdx: Long, channel: Long): Double { val mb = getMethodBind("AudioServer","get_bus_peak_volume_left_db") return _icall_Double_Long_Long( mb, this.ptr, busIdx, channel) } fun getBusPeakVolumeRightDb(busIdx: Long, channel: Long): Double { val mb = getMethodBind("AudioServer","get_bus_peak_volume_right_db") return _icall_Double_Long_Long( mb, this.ptr, busIdx, channel) } fun getBusSend(busIdx: Long): String { val mb = getMethodBind("AudioServer","get_bus_send") return _icall_String_Long( mb, this.ptr, busIdx) } fun getBusVolumeDb(busIdx: Long): Double { val mb = getMethodBind("AudioServer","get_bus_volume_db") return _icall_Double_Long( mb, this.ptr, busIdx) } fun getDevice(): String { val mb = getMethodBind("AudioServer","get_device") return _icall_String( mb, this.ptr) } fun getDeviceList(): VariantArray { val mb = getMethodBind("AudioServer","get_device_list") return _icall_VariantArray( mb, this.ptr) } fun getGlobalRateScale(): Double { val mb = getMethodBind("AudioServer","get_global_rate_scale") return _icall_Double( mb, this.ptr) } fun getMixRate(): Double { val mb = getMethodBind("AudioServer","get_mix_rate") return _icall_Double( mb, this.ptr) } fun getOutputLatency(): Double { val mb = getMethodBind("AudioServer","get_output_latency") return _icall_Double( mb, this.ptr) } fun getSpeakerMode(): AudioServer.SpeakerMode { val mb = getMethodBind("AudioServer","get_speaker_mode") return AudioServer.SpeakerMode.from( _icall_Long( mb, this.ptr)) } fun getTimeSinceLastMix(): Double { val mb = getMethodBind("AudioServer","get_time_since_last_mix") return _icall_Double( mb, this.ptr) } fun getTimeToNextMix(): Double { val mb = getMethodBind("AudioServer","get_time_to_next_mix") return _icall_Double( mb, this.ptr) } fun isBusBypassingEffects(busIdx: Long): Boolean { val mb = getMethodBind("AudioServer","is_bus_bypassing_effects") return _icall_Boolean_Long( mb, this.ptr, busIdx) } fun isBusEffectEnabled(busIdx: Long, effectIdx: Long): Boolean { val mb = getMethodBind("AudioServer","is_bus_effect_enabled") return _icall_Boolean_Long_Long( mb, this.ptr, busIdx, effectIdx) } fun isBusMute(busIdx: Long): Boolean { val mb = getMethodBind("AudioServer","is_bus_mute") return _icall_Boolean_Long( mb, this.ptr, busIdx) } fun isBusSolo(busIdx: Long): Boolean { val mb = getMethodBind("AudioServer","is_bus_solo") return _icall_Boolean_Long( mb, this.ptr, busIdx) } fun lock() { val mb = getMethodBind("AudioServer","lock") _icall_Unit( mb, this.ptr) } fun moveBus(index: Long, toIndex: Long) { val mb = getMethodBind("AudioServer","move_bus") _icall_Unit_Long_Long( mb, this.ptr, index, toIndex) } fun removeBus(index: Long) { val mb = getMethodBind("AudioServer","remove_bus") _icall_Unit_Long( mb, this.ptr, index) } fun removeBusEffect(busIdx: Long, effectIdx: Long) { val mb = getMethodBind("AudioServer","remove_bus_effect") _icall_Unit_Long_Long( mb, this.ptr, busIdx, effectIdx) } fun setBusBypassEffects(busIdx: Long, enable: Boolean) { val mb = getMethodBind("AudioServer","set_bus_bypass_effects") _icall_Unit_Long_Boolean( mb, this.ptr, busIdx, enable) } fun setBusCount(amount: Long) { val mb = getMethodBind("AudioServer","set_bus_count") _icall_Unit_Long( mb, this.ptr, amount) } fun setBusEffectEnabled( busIdx: Long, effectIdx: Long, enabled: Boolean ) { val mb = getMethodBind("AudioServer","set_bus_effect_enabled") _icall_Unit_Long_Long_Boolean( mb, this.ptr, busIdx, effectIdx, enabled) } fun setBusLayout(busLayout: AudioBusLayout) { val mb = getMethodBind("AudioServer","set_bus_layout") _icall_Unit_Object( mb, this.ptr, busLayout) } fun setBusMute(busIdx: Long, enable: Boolean) { val mb = getMethodBind("AudioServer","set_bus_mute") _icall_Unit_Long_Boolean( mb, this.ptr, busIdx, enable) } fun setBusName(busIdx: Long, name: String) { val mb = getMethodBind("AudioServer","set_bus_name") _icall_Unit_Long_String( mb, this.ptr, busIdx, name) } fun setBusSend(busIdx: Long, send: String) { val mb = getMethodBind("AudioServer","set_bus_send") _icall_Unit_Long_String( mb, this.ptr, busIdx, send) } fun setBusSolo(busIdx: Long, enable: Boolean) { val mb = getMethodBind("AudioServer","set_bus_solo") _icall_Unit_Long_Boolean( mb, this.ptr, busIdx, enable) } fun setBusVolumeDb(busIdx: Long, volumeDb: Double) { val mb = getMethodBind("AudioServer","set_bus_volume_db") _icall_Unit_Long_Double( mb, this.ptr, busIdx, volumeDb) } fun setDevice(device: String) { val mb = getMethodBind("AudioServer","set_device") _icall_Unit_String( mb, this.ptr, device) } fun setGlobalRateScale(scale: Double) { val mb = getMethodBind("AudioServer","set_global_rate_scale") _icall_Unit_Double( mb, this.ptr, scale) } fun swapBusEffects( busIdx: Long, effectIdx: Long, byEffectIdx: Long ) { val mb = getMethodBind("AudioServer","swap_bus_effects") _icall_Unit_Long_Long_Long( mb, this.ptr, busIdx, effectIdx, byEffectIdx) } fun unlock() { val mb = getMethodBind("AudioServer","unlock") _icall_Unit( mb, this.ptr) } enum class SpeakerMode( id: Long ) { SPEAKER_MODE_STEREO(0), SPEAKER_SURROUND_31(1), SPEAKER_SURROUND_51(2), SPEAKER_SURROUND_71(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStream.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.internal.utils.getMethodBind import kotlin.Double open class AudioStream internal constructor() : Resource() { open fun getLength(): Double { val mb = getMethodBind("AudioStream","get_length") return _icall_Double( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamGenerator.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioStreamGenerator : AudioStream() { open var bufferLength: Double get() { val mb = getMethodBind("AudioStreamGenerator","get_buffer_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamGenerator","set_buffer_length") _icall_Unit_Double(mb, this.ptr, value) } open var mixRate: Double get() { val mb = getMethodBind("AudioStreamGenerator","get_mix_rate") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamGenerator","set_mix_rate") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioStreamGenerator", "AudioStreamGenerator") open fun getBufferLength(): Double { val mb = getMethodBind("AudioStreamGenerator","get_buffer_length") return _icall_Double( mb, this.ptr) } open fun getMixRate(): Double { val mb = getMethodBind("AudioStreamGenerator","get_mix_rate") return _icall_Double( mb, this.ptr) } open fun setBufferLength(seconds: Double) { val mb = getMethodBind("AudioStreamGenerator","set_buffer_length") _icall_Unit_Double( mb, this.ptr, seconds) } open fun setMixRate(hz: Double) { val mb = getMethodBind("AudioStreamGenerator","set_mix_rate") _icall_Unit_Double( mb, this.ptr, hz) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamGeneratorPlayback.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolVector2Array import godot.core.Vector2 import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_PoolVector2Array import godot.icalls._icall_Boolean_Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Unit import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long open class AudioStreamGeneratorPlayback internal constructor() : AudioStreamPlaybackResampled() { open fun canPushBuffer(amount: Long): Boolean { val mb = getMethodBind("AudioStreamGeneratorPlayback","can_push_buffer") return _icall_Boolean_Long( mb, this.ptr, amount) } open fun clearBuffer() { val mb = getMethodBind("AudioStreamGeneratorPlayback","clear_buffer") _icall_Unit( mb, this.ptr) } open fun getFramesAvailable(): Long { val mb = getMethodBind("AudioStreamGeneratorPlayback","get_frames_available") return _icall_Long( mb, this.ptr) } open fun getSkips(): Long { val mb = getMethodBind("AudioStreamGeneratorPlayback","get_skips") return _icall_Long( mb, this.ptr) } open fun pushBuffer(frames: PoolVector2Array): Boolean { val mb = getMethodBind("AudioStreamGeneratorPlayback","push_buffer") return _icall_Boolean_PoolVector2Array( mb, this.ptr, frames) } open fun pushFrame(frame: Vector2): Boolean { val mb = getMethodBind("AudioStreamGeneratorPlayback","push_frame") return _icall_Boolean_Vector2( mb, this.ptr, frame) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamMicrophone.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class AudioStreamMicrophone : AudioStream() { override fun __new(): COpaquePointer = invokeConstructor("AudioStreamMicrophone", "AudioStreamMicrophone") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamOGGVorbis.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolByteArray import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_PoolByteArray import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_PoolByteArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioStreamOGGVorbis : AudioStream() { open var data: PoolByteArray get() { val mb = getMethodBind("AudioStreamOGGVorbis","get_data") return _icall_PoolByteArray(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamOGGVorbis","set_data") _icall_Unit_PoolByteArray(mb, this.ptr, value) } open var loop: Boolean get() { val mb = getMethodBind("AudioStreamOGGVorbis","has_loop") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamOGGVorbis","set_loop") _icall_Unit_Boolean(mb, this.ptr, value) } open var loopOffset: Double get() { val mb = getMethodBind("AudioStreamOGGVorbis","get_loop_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamOGGVorbis","set_loop_offset") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioStreamOGGVorbis", "AudioStreamOGGVorbis") open fun getData(): PoolByteArray { val mb = getMethodBind("AudioStreamOGGVorbis","get_data") return _icall_PoolByteArray( mb, this.ptr) } open fun getLoopOffset(): Double { val mb = getMethodBind("AudioStreamOGGVorbis","get_loop_offset") return _icall_Double( mb, this.ptr) } open fun hasLoop(): Boolean { val mb = getMethodBind("AudioStreamOGGVorbis","has_loop") return _icall_Boolean( mb, this.ptr) } open fun setData(data: PoolByteArray) { val mb = getMethodBind("AudioStreamOGGVorbis","set_data") _icall_Unit_PoolByteArray( mb, this.ptr, data) } open fun setLoop(enable: Boolean) { val mb = getMethodBind("AudioStreamOGGVorbis","set_loop") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setLoopOffset(seconds: Double) { val mb = getMethodBind("AudioStreamOGGVorbis","set_loop_offset") _icall_Unit_Double( mb, this.ptr, seconds) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamPlayback.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class AudioStreamPlayback internal constructor() : Reference() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamPlaybackResampled.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class AudioStreamPlaybackResampled internal constructor() : AudioStreamPlayback() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamPlayer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AudioStreamPlayer import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_AudioStream import godot.icalls._icall_AudioStreamPlayback import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class AudioStreamPlayer : Node() { val finished: Signal0 by signal() open var autoplay: Boolean get() { val mb = getMethodBind("AudioStreamPlayer","is_autoplay_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer","set_autoplay") _icall_Unit_Boolean(mb, this.ptr, value) } open var bus: String get() { val mb = getMethodBind("AudioStreamPlayer","get_bus") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer","set_bus") _icall_Unit_String(mb, this.ptr, value) } open var mixTarget: Long get() { val mb = getMethodBind("AudioStreamPlayer","get_mix_target") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer","set_mix_target") _icall_Unit_Long(mb, this.ptr, value) } open var pitchScale: Double get() { val mb = getMethodBind("AudioStreamPlayer","get_pitch_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer","set_pitch_scale") _icall_Unit_Double(mb, this.ptr, value) } open val playing: Boolean get() { val mb = getMethodBind("AudioStreamPlayer","is_playing") return _icall_Boolean(mb, this.ptr) } open var stream: AudioStream get() { val mb = getMethodBind("AudioStreamPlayer","get_stream") return _icall_AudioStream(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer","set_stream") _icall_Unit_Object(mb, this.ptr, value) } open var streamPaused: Boolean get() { val mb = getMethodBind("AudioStreamPlayer","get_stream_paused") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer","set_stream_paused") _icall_Unit_Boolean(mb, this.ptr, value) } open var volumeDb: Double get() { val mb = getMethodBind("AudioStreamPlayer","get_volume_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer","set_volume_db") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioStreamPlayer", "AudioStreamPlayer") open fun _busLayoutChanged() { } open fun _isActive(): Boolean { throw NotImplementedError("_is_active is not implemented for AudioStreamPlayer") } open fun _setPlaying(enable: Boolean) { } open fun getBus(): String { val mb = getMethodBind("AudioStreamPlayer","get_bus") return _icall_String( mb, this.ptr) } open fun getMixTarget(): AudioStreamPlayer.MixTarget { val mb = getMethodBind("AudioStreamPlayer","get_mix_target") return AudioStreamPlayer.MixTarget.from( _icall_Long( mb, this.ptr)) } open fun getPitchScale(): Double { val mb = getMethodBind("AudioStreamPlayer","get_pitch_scale") return _icall_Double( mb, this.ptr) } open fun getPlaybackPosition(): Double { val mb = getMethodBind("AudioStreamPlayer","get_playback_position") return _icall_Double( mb, this.ptr) } open fun getStream(): AudioStream { val mb = getMethodBind("AudioStreamPlayer","get_stream") return _icall_AudioStream( mb, this.ptr) } open fun getStreamPaused(): Boolean { val mb = getMethodBind("AudioStreamPlayer","get_stream_paused") return _icall_Boolean( mb, this.ptr) } open fun getStreamPlayback(): AudioStreamPlayback { val mb = getMethodBind("AudioStreamPlayer","get_stream_playback") return _icall_AudioStreamPlayback( mb, this.ptr) } open fun getVolumeDb(): Double { val mb = getMethodBind("AudioStreamPlayer","get_volume_db") return _icall_Double( mb, this.ptr) } open fun isAutoplayEnabled(): Boolean { val mb = getMethodBind("AudioStreamPlayer","is_autoplay_enabled") return _icall_Boolean( mb, this.ptr) } open fun isPlaying(): Boolean { val mb = getMethodBind("AudioStreamPlayer","is_playing") return _icall_Boolean( mb, this.ptr) } open fun play(fromPosition: Double = 0.0) { val mb = getMethodBind("AudioStreamPlayer","play") _icall_Unit_Double( mb, this.ptr, fromPosition) } open fun seek(toPosition: Double) { val mb = getMethodBind("AudioStreamPlayer","seek") _icall_Unit_Double( mb, this.ptr, toPosition) } open fun setAutoplay(enable: Boolean) { val mb = getMethodBind("AudioStreamPlayer","set_autoplay") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setBus(bus: String) { val mb = getMethodBind("AudioStreamPlayer","set_bus") _icall_Unit_String( mb, this.ptr, bus) } open fun setMixTarget(mixTarget: Long) { val mb = getMethodBind("AudioStreamPlayer","set_mix_target") _icall_Unit_Long( mb, this.ptr, mixTarget) } open fun setPitchScale(pitchScale: Double) { val mb = getMethodBind("AudioStreamPlayer","set_pitch_scale") _icall_Unit_Double( mb, this.ptr, pitchScale) } open fun setStream(stream: AudioStream) { val mb = getMethodBind("AudioStreamPlayer","set_stream") _icall_Unit_Object( mb, this.ptr, stream) } open fun setStreamPaused(pause: Boolean) { val mb = getMethodBind("AudioStreamPlayer","set_stream_paused") _icall_Unit_Boolean( mb, this.ptr, pause) } open fun setVolumeDb(volumeDb: Double) { val mb = getMethodBind("AudioStreamPlayer","set_volume_db") _icall_Unit_Double( mb, this.ptr, volumeDb) } open fun stop() { val mb = getMethodBind("AudioStreamPlayer","stop") _icall_Unit( mb, this.ptr) } enum class MixTarget( id: Long ) { MIX_TARGET_STEREO(0), MIX_TARGET_SURROUND(1), MIX_TARGET_CENTER(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamPlayer2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_AudioStream import godot.icalls._icall_AudioStreamPlayback import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class AudioStreamPlayer2D : Node2D() { val finished: Signal0 by signal() open var areaMask: Long get() { val mb = getMethodBind("AudioStreamPlayer2D","get_area_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer2D","set_area_mask") _icall_Unit_Long(mb, this.ptr, value) } open var attenuation: Double get() { val mb = getMethodBind("AudioStreamPlayer2D","get_attenuation") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer2D","set_attenuation") _icall_Unit_Double(mb, this.ptr, value) } open var autoplay: Boolean get() { val mb = getMethodBind("AudioStreamPlayer2D","is_autoplay_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer2D","set_autoplay") _icall_Unit_Boolean(mb, this.ptr, value) } open var bus: String get() { val mb = getMethodBind("AudioStreamPlayer2D","get_bus") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer2D","set_bus") _icall_Unit_String(mb, this.ptr, value) } open var maxDistance: Double get() { val mb = getMethodBind("AudioStreamPlayer2D","get_max_distance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer2D","set_max_distance") _icall_Unit_Double(mb, this.ptr, value) } open var pitchScale: Double get() { val mb = getMethodBind("AudioStreamPlayer2D","get_pitch_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer2D","set_pitch_scale") _icall_Unit_Double(mb, this.ptr, value) } open val playing: Boolean get() { val mb = getMethodBind("AudioStreamPlayer2D","is_playing") return _icall_Boolean(mb, this.ptr) } open var stream: AudioStream get() { val mb = getMethodBind("AudioStreamPlayer2D","get_stream") return _icall_AudioStream(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer2D","set_stream") _icall_Unit_Object(mb, this.ptr, value) } open var streamPaused: Boolean get() { val mb = getMethodBind("AudioStreamPlayer2D","get_stream_paused") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer2D","set_stream_paused") _icall_Unit_Boolean(mb, this.ptr, value) } open var volumeDb: Double get() { val mb = getMethodBind("AudioStreamPlayer2D","get_volume_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer2D","set_volume_db") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioStreamPlayer2D", "AudioStreamPlayer2D") open fun _busLayoutChanged() { } open fun _isActive(): Boolean { throw NotImplementedError("_is_active is not implemented for AudioStreamPlayer2D") } open fun _setPlaying(enable: Boolean) { } open fun getAreaMask(): Long { val mb = getMethodBind("AudioStreamPlayer2D","get_area_mask") return _icall_Long( mb, this.ptr) } open fun getAttenuation(): Double { val mb = getMethodBind("AudioStreamPlayer2D","get_attenuation") return _icall_Double( mb, this.ptr) } open fun getBus(): String { val mb = getMethodBind("AudioStreamPlayer2D","get_bus") return _icall_String( mb, this.ptr) } open fun getMaxDistance(): Double { val mb = getMethodBind("AudioStreamPlayer2D","get_max_distance") return _icall_Double( mb, this.ptr) } open fun getPitchScale(): Double { val mb = getMethodBind("AudioStreamPlayer2D","get_pitch_scale") return _icall_Double( mb, this.ptr) } open fun getPlaybackPosition(): Double { val mb = getMethodBind("AudioStreamPlayer2D","get_playback_position") return _icall_Double( mb, this.ptr) } open fun getStream(): AudioStream { val mb = getMethodBind("AudioStreamPlayer2D","get_stream") return _icall_AudioStream( mb, this.ptr) } open fun getStreamPaused(): Boolean { val mb = getMethodBind("AudioStreamPlayer2D","get_stream_paused") return _icall_Boolean( mb, this.ptr) } open fun getStreamPlayback(): AudioStreamPlayback { val mb = getMethodBind("AudioStreamPlayer2D","get_stream_playback") return _icall_AudioStreamPlayback( mb, this.ptr) } open fun getVolumeDb(): Double { val mb = getMethodBind("AudioStreamPlayer2D","get_volume_db") return _icall_Double( mb, this.ptr) } open fun isAutoplayEnabled(): Boolean { val mb = getMethodBind("AudioStreamPlayer2D","is_autoplay_enabled") return _icall_Boolean( mb, this.ptr) } open fun isPlaying(): Boolean { val mb = getMethodBind("AudioStreamPlayer2D","is_playing") return _icall_Boolean( mb, this.ptr) } open fun play(fromPosition: Double = 0.0) { val mb = getMethodBind("AudioStreamPlayer2D","play") _icall_Unit_Double( mb, this.ptr, fromPosition) } open fun seek(toPosition: Double) { val mb = getMethodBind("AudioStreamPlayer2D","seek") _icall_Unit_Double( mb, this.ptr, toPosition) } open fun setAreaMask(mask: Long) { val mb = getMethodBind("AudioStreamPlayer2D","set_area_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setAttenuation(curve: Double) { val mb = getMethodBind("AudioStreamPlayer2D","set_attenuation") _icall_Unit_Double( mb, this.ptr, curve) } open fun setAutoplay(enable: Boolean) { val mb = getMethodBind("AudioStreamPlayer2D","set_autoplay") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setBus(bus: String) { val mb = getMethodBind("AudioStreamPlayer2D","set_bus") _icall_Unit_String( mb, this.ptr, bus) } open fun setMaxDistance(pixels: Double) { val mb = getMethodBind("AudioStreamPlayer2D","set_max_distance") _icall_Unit_Double( mb, this.ptr, pixels) } open fun setPitchScale(pitchScale: Double) { val mb = getMethodBind("AudioStreamPlayer2D","set_pitch_scale") _icall_Unit_Double( mb, this.ptr, pitchScale) } open fun setStream(stream: AudioStream) { val mb = getMethodBind("AudioStreamPlayer2D","set_stream") _icall_Unit_Object( mb, this.ptr, stream) } open fun setStreamPaused(pause: Boolean) { val mb = getMethodBind("AudioStreamPlayer2D","set_stream_paused") _icall_Unit_Boolean( mb, this.ptr, pause) } open fun setVolumeDb(volumeDb: Double) { val mb = getMethodBind("AudioStreamPlayer2D","set_volume_db") _icall_Unit_Double( mb, this.ptr, volumeDb) } open fun stop() { val mb = getMethodBind("AudioStreamPlayer2D","stop") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamPlayer3D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AudioStreamPlayer3D import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_AudioStream import godot.icalls._icall_AudioStreamPlayback import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class AudioStreamPlayer3D : Spatial() { val finished: Signal0 by signal() open var areaMask: Long get() { val mb = getMethodBind("AudioStreamPlayer3D","get_area_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_area_mask") _icall_Unit_Long(mb, this.ptr, value) } open var attenuationFilterCutoffHz: Double get() { val mb = getMethodBind("AudioStreamPlayer3D","get_attenuation_filter_cutoff_hz") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_attenuation_filter_cutoff_hz") _icall_Unit_Double(mb, this.ptr, value) } open var attenuationFilterDb: Double get() { val mb = getMethodBind("AudioStreamPlayer3D","get_attenuation_filter_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_attenuation_filter_db") _icall_Unit_Double(mb, this.ptr, value) } open var attenuationModel: Long get() { val mb = getMethodBind("AudioStreamPlayer3D","get_attenuation_model") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_attenuation_model") _icall_Unit_Long(mb, this.ptr, value) } open var autoplay: Boolean get() { val mb = getMethodBind("AudioStreamPlayer3D","is_autoplay_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_autoplay") _icall_Unit_Boolean(mb, this.ptr, value) } open var bus: String get() { val mb = getMethodBind("AudioStreamPlayer3D","get_bus") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_bus") _icall_Unit_String(mb, this.ptr, value) } open var dopplerTracking: Long get() { val mb = getMethodBind("AudioStreamPlayer3D","get_doppler_tracking") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_doppler_tracking") _icall_Unit_Long(mb, this.ptr, value) } open var emissionAngleDegrees: Double get() { val mb = getMethodBind("AudioStreamPlayer3D","get_emission_angle") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_emission_angle") _icall_Unit_Double(mb, this.ptr, value) } open var emissionAngleEnabled: Boolean get() { val mb = getMethodBind("AudioStreamPlayer3D","is_emission_angle_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_emission_angle_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var emissionAngleFilterAttenuationDb: Double get() { val mb = getMethodBind("AudioStreamPlayer3D","get_emission_angle_filter_attenuation_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_emission_angle_filter_attenuation_db") _icall_Unit_Double(mb, this.ptr, value) } open var maxDb: Double get() { val mb = getMethodBind("AudioStreamPlayer3D","get_max_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_max_db") _icall_Unit_Double(mb, this.ptr, value) } open var maxDistance: Double get() { val mb = getMethodBind("AudioStreamPlayer3D","get_max_distance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_max_distance") _icall_Unit_Double(mb, this.ptr, value) } open var outOfRangeMode: Long get() { val mb = getMethodBind("AudioStreamPlayer3D","get_out_of_range_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_out_of_range_mode") _icall_Unit_Long(mb, this.ptr, value) } open var pitchScale: Double get() { val mb = getMethodBind("AudioStreamPlayer3D","get_pitch_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_pitch_scale") _icall_Unit_Double(mb, this.ptr, value) } open val playing: Boolean get() { val mb = getMethodBind("AudioStreamPlayer3D","is_playing") return _icall_Boolean(mb, this.ptr) } open var stream: AudioStream get() { val mb = getMethodBind("AudioStreamPlayer3D","get_stream") return _icall_AudioStream(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_stream") _icall_Unit_Object(mb, this.ptr, value) } open var streamPaused: Boolean get() { val mb = getMethodBind("AudioStreamPlayer3D","get_stream_paused") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_stream_paused") _icall_Unit_Boolean(mb, this.ptr, value) } open var unitDb: Double get() { val mb = getMethodBind("AudioStreamPlayer3D","get_unit_db") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_unit_db") _icall_Unit_Double(mb, this.ptr, value) } open var unitSize: Double get() { val mb = getMethodBind("AudioStreamPlayer3D","get_unit_size") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamPlayer3D","set_unit_size") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioStreamPlayer3D", "AudioStreamPlayer3D") open fun _busLayoutChanged() { } open fun _isActive(): Boolean { throw NotImplementedError("_is_active is not implemented for AudioStreamPlayer3D") } open fun _setPlaying(enable: Boolean) { } open fun getAreaMask(): Long { val mb = getMethodBind("AudioStreamPlayer3D","get_area_mask") return _icall_Long( mb, this.ptr) } open fun getAttenuationFilterCutoffHz(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_attenuation_filter_cutoff_hz") return _icall_Double( mb, this.ptr) } open fun getAttenuationFilterDb(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_attenuation_filter_db") return _icall_Double( mb, this.ptr) } open fun getAttenuationModel(): AudioStreamPlayer3D.AttenuationModel { val mb = getMethodBind("AudioStreamPlayer3D","get_attenuation_model") return AudioStreamPlayer3D.AttenuationModel.from( _icall_Long( mb, this.ptr)) } open fun getBus(): String { val mb = getMethodBind("AudioStreamPlayer3D","get_bus") return _icall_String( mb, this.ptr) } open fun getDopplerTracking(): AudioStreamPlayer3D.DopplerTracking { val mb = getMethodBind("AudioStreamPlayer3D","get_doppler_tracking") return AudioStreamPlayer3D.DopplerTracking.from( _icall_Long( mb, this.ptr)) } open fun getEmissionAngle(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_emission_angle") return _icall_Double( mb, this.ptr) } open fun getEmissionAngleFilterAttenuationDb(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_emission_angle_filter_attenuation_db") return _icall_Double( mb, this.ptr) } open fun getMaxDb(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_max_db") return _icall_Double( mb, this.ptr) } open fun getMaxDistance(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_max_distance") return _icall_Double( mb, this.ptr) } open fun getOutOfRangeMode(): AudioStreamPlayer3D.OutOfRangeMode { val mb = getMethodBind("AudioStreamPlayer3D","get_out_of_range_mode") return AudioStreamPlayer3D.OutOfRangeMode.from( _icall_Long( mb, this.ptr)) } open fun getPitchScale(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_pitch_scale") return _icall_Double( mb, this.ptr) } open fun getPlaybackPosition(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_playback_position") return _icall_Double( mb, this.ptr) } open fun getStream(): AudioStream { val mb = getMethodBind("AudioStreamPlayer3D","get_stream") return _icall_AudioStream( mb, this.ptr) } open fun getStreamPaused(): Boolean { val mb = getMethodBind("AudioStreamPlayer3D","get_stream_paused") return _icall_Boolean( mb, this.ptr) } open fun getStreamPlayback(): AudioStreamPlayback { val mb = getMethodBind("AudioStreamPlayer3D","get_stream_playback") return _icall_AudioStreamPlayback( mb, this.ptr) } open fun getUnitDb(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_unit_db") return _icall_Double( mb, this.ptr) } open fun getUnitSize(): Double { val mb = getMethodBind("AudioStreamPlayer3D","get_unit_size") return _icall_Double( mb, this.ptr) } open fun isAutoplayEnabled(): Boolean { val mb = getMethodBind("AudioStreamPlayer3D","is_autoplay_enabled") return _icall_Boolean( mb, this.ptr) } open fun isEmissionAngleEnabled(): Boolean { val mb = getMethodBind("AudioStreamPlayer3D","is_emission_angle_enabled") return _icall_Boolean( mb, this.ptr) } open fun isPlaying(): Boolean { val mb = getMethodBind("AudioStreamPlayer3D","is_playing") return _icall_Boolean( mb, this.ptr) } open fun play(fromPosition: Double = 0.0) { val mb = getMethodBind("AudioStreamPlayer3D","play") _icall_Unit_Double( mb, this.ptr, fromPosition) } open fun seek(toPosition: Double) { val mb = getMethodBind("AudioStreamPlayer3D","seek") _icall_Unit_Double( mb, this.ptr, toPosition) } open fun setAreaMask(mask: Long) { val mb = getMethodBind("AudioStreamPlayer3D","set_area_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setAttenuationFilterCutoffHz(degrees: Double) { val mb = getMethodBind("AudioStreamPlayer3D","set_attenuation_filter_cutoff_hz") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setAttenuationFilterDb(db: Double) { val mb = getMethodBind("AudioStreamPlayer3D","set_attenuation_filter_db") _icall_Unit_Double( mb, this.ptr, db) } open fun setAttenuationModel(model: Long) { val mb = getMethodBind("AudioStreamPlayer3D","set_attenuation_model") _icall_Unit_Long( mb, this.ptr, model) } open fun setAutoplay(enable: Boolean) { val mb = getMethodBind("AudioStreamPlayer3D","set_autoplay") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setBus(bus: String) { val mb = getMethodBind("AudioStreamPlayer3D","set_bus") _icall_Unit_String( mb, this.ptr, bus) } open fun setDopplerTracking(mode: Long) { val mb = getMethodBind("AudioStreamPlayer3D","set_doppler_tracking") _icall_Unit_Long( mb, this.ptr, mode) } open fun setEmissionAngle(degrees: Double) { val mb = getMethodBind("AudioStreamPlayer3D","set_emission_angle") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setEmissionAngleEnabled(enabled: Boolean) { val mb = getMethodBind("AudioStreamPlayer3D","set_emission_angle_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setEmissionAngleFilterAttenuationDb(db: Double) { val mb = getMethodBind("AudioStreamPlayer3D","set_emission_angle_filter_attenuation_db") _icall_Unit_Double( mb, this.ptr, db) } open fun setMaxDb(maxDb: Double) { val mb = getMethodBind("AudioStreamPlayer3D","set_max_db") _icall_Unit_Double( mb, this.ptr, maxDb) } open fun setMaxDistance(metres: Double) { val mb = getMethodBind("AudioStreamPlayer3D","set_max_distance") _icall_Unit_Double( mb, this.ptr, metres) } open fun setOutOfRangeMode(mode: Long) { val mb = getMethodBind("AudioStreamPlayer3D","set_out_of_range_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setPitchScale(pitchScale: Double) { val mb = getMethodBind("AudioStreamPlayer3D","set_pitch_scale") _icall_Unit_Double( mb, this.ptr, pitchScale) } open fun setStream(stream: AudioStream) { val mb = getMethodBind("AudioStreamPlayer3D","set_stream") _icall_Unit_Object( mb, this.ptr, stream) } open fun setStreamPaused(pause: Boolean) { val mb = getMethodBind("AudioStreamPlayer3D","set_stream_paused") _icall_Unit_Boolean( mb, this.ptr, pause) } open fun setUnitDb(unitDb: Double) { val mb = getMethodBind("AudioStreamPlayer3D","set_unit_db") _icall_Unit_Double( mb, this.ptr, unitDb) } open fun setUnitSize(unitSize: Double) { val mb = getMethodBind("AudioStreamPlayer3D","set_unit_size") _icall_Unit_Double( mb, this.ptr, unitSize) } open fun stop() { val mb = getMethodBind("AudioStreamPlayer3D","stop") _icall_Unit( mb, this.ptr) } enum class AttenuationModel( id: Long ) { ATTENUATION_INVERSE_DISTANCE(0), ATTENUATION_INVERSE_SQUARE_DISTANCE(1), ATTENUATION_LOGARITHMIC(2), ATTENUATION_DISABLED(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class OutOfRangeMode( id: Long ) { OUT_OF_RANGE_MIX(0), OUT_OF_RANGE_PAUSE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class DopplerTracking( id: Long ) { DOPPLER_TRACKING_DISABLED(0), DOPPLER_TRACKING_IDLE_STEP(1), DOPPLER_TRACKING_PHYSICS_STEP(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamRandomPitch.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_AudioStream import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class AudioStreamRandomPitch : AudioStream() { open var audioStream: AudioStream get() { val mb = getMethodBind("AudioStreamRandomPitch","get_audio_stream") return _icall_AudioStream(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamRandomPitch","set_audio_stream") _icall_Unit_Object(mb, this.ptr, value) } open var randomPitch: Double get() { val mb = getMethodBind("AudioStreamRandomPitch","get_random_pitch") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamRandomPitch","set_random_pitch") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioStreamRandomPitch", "AudioStreamRandomPitch") open fun getAudioStream(): AudioStream { val mb = getMethodBind("AudioStreamRandomPitch","get_audio_stream") return _icall_AudioStream( mb, this.ptr) } open fun getRandomPitch(): Double { val mb = getMethodBind("AudioStreamRandomPitch","get_random_pitch") return _icall_Double( mb, this.ptr) } open fun setAudioStream(stream: AudioStream) { val mb = getMethodBind("AudioStreamRandomPitch","set_audio_stream") _icall_Unit_Object( mb, this.ptr, stream) } open fun setRandomPitch(scale: Double) { val mb = getMethodBind("AudioStreamRandomPitch","set_random_pitch") _icall_Unit_Double( mb, this.ptr, scale) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/AudioStreamSample.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.AudioStreamSample import godot.core.GodotError import godot.core.PoolByteArray import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_PoolByteArray import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_PoolByteArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class AudioStreamSample : AudioStream() { open var data: PoolByteArray get() { val mb = getMethodBind("AudioStreamSample","get_data") return _icall_PoolByteArray(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamSample","set_data") _icall_Unit_PoolByteArray(mb, this.ptr, value) } open var format: Long get() { val mb = getMethodBind("AudioStreamSample","get_format") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamSample","set_format") _icall_Unit_Long(mb, this.ptr, value) } open var loopBegin: Long get() { val mb = getMethodBind("AudioStreamSample","get_loop_begin") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamSample","set_loop_begin") _icall_Unit_Long(mb, this.ptr, value) } open var loopEnd: Long get() { val mb = getMethodBind("AudioStreamSample","get_loop_end") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamSample","set_loop_end") _icall_Unit_Long(mb, this.ptr, value) } open var loopMode: Long get() { val mb = getMethodBind("AudioStreamSample","get_loop_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamSample","set_loop_mode") _icall_Unit_Long(mb, this.ptr, value) } open var mixRate: Long get() { val mb = getMethodBind("AudioStreamSample","get_mix_rate") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamSample","set_mix_rate") _icall_Unit_Long(mb, this.ptr, value) } open var stereo: Boolean get() { val mb = getMethodBind("AudioStreamSample","is_stereo") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("AudioStreamSample","set_stereo") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("AudioStreamSample", "AudioStreamSample") open fun getData(): PoolByteArray { val mb = getMethodBind("AudioStreamSample","get_data") return _icall_PoolByteArray( mb, this.ptr) } open fun getFormat(): AudioStreamSample.Format { val mb = getMethodBind("AudioStreamSample","get_format") return AudioStreamSample.Format.from( _icall_Long( mb, this.ptr)) } open fun getLoopBegin(): Long { val mb = getMethodBind("AudioStreamSample","get_loop_begin") return _icall_Long( mb, this.ptr) } open fun getLoopEnd(): Long { val mb = getMethodBind("AudioStreamSample","get_loop_end") return _icall_Long( mb, this.ptr) } open fun getLoopMode(): AudioStreamSample.LoopMode { val mb = getMethodBind("AudioStreamSample","get_loop_mode") return AudioStreamSample.LoopMode.from( _icall_Long( mb, this.ptr)) } open fun getMixRate(): Long { val mb = getMethodBind("AudioStreamSample","get_mix_rate") return _icall_Long( mb, this.ptr) } open fun isStereo(): Boolean { val mb = getMethodBind("AudioStreamSample","is_stereo") return _icall_Boolean( mb, this.ptr) } open fun saveToWav(path: String): GodotError { val mb = getMethodBind("AudioStreamSample","save_to_wav") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun setData(data: PoolByteArray) { val mb = getMethodBind("AudioStreamSample","set_data") _icall_Unit_PoolByteArray( mb, this.ptr, data) } open fun setFormat(format: Long) { val mb = getMethodBind("AudioStreamSample","set_format") _icall_Unit_Long( mb, this.ptr, format) } open fun setLoopBegin(loopBegin: Long) { val mb = getMethodBind("AudioStreamSample","set_loop_begin") _icall_Unit_Long( mb, this.ptr, loopBegin) } open fun setLoopEnd(loopEnd: Long) { val mb = getMethodBind("AudioStreamSample","set_loop_end") _icall_Unit_Long( mb, this.ptr, loopEnd) } open fun setLoopMode(loopMode: Long) { val mb = getMethodBind("AudioStreamSample","set_loop_mode") _icall_Unit_Long( mb, this.ptr, loopMode) } open fun setMixRate(mixRate: Long) { val mb = getMethodBind("AudioStreamSample","set_mix_rate") _icall_Unit_Long( mb, this.ptr, mixRate) } open fun setStereo(stereo: Boolean) { val mb = getMethodBind("AudioStreamSample","set_stereo") _icall_Unit_Boolean( mb, this.ptr, stereo) } enum class LoopMode( id: Long ) { LOOP_DISABLED(0), LOOP_FORWARD(1), LOOP_PING_PONG(2), LOOP_BACKWARD(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Format( id: Long ) { FORMAT_8_BITS(0), FORMAT_16_BITS(1), FORMAT_IMA_ADPCM(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BackBufferCopy.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.BackBufferCopy import godot.core.Rect2 import godot.icalls._icall_Long import godot.icalls._icall_Rect2 import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Rect2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class BackBufferCopy : Node2D() { open var copyMode: Long get() { val mb = getMethodBind("BackBufferCopy","get_copy_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("BackBufferCopy","set_copy_mode") _icall_Unit_Long(mb, this.ptr, value) } open var rect: Rect2 get() { val mb = getMethodBind("BackBufferCopy","get_rect") return _icall_Rect2(mb, this.ptr) } set(value) { val mb = getMethodBind("BackBufferCopy","set_rect") _icall_Unit_Rect2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("BackBufferCopy", "BackBufferCopy") open fun rect(schedule: Rect2.() -> Unit): Rect2 = rect.apply{ schedule(this) rect = this } open fun getCopyMode(): BackBufferCopy.CopyMode { val mb = getMethodBind("BackBufferCopy","get_copy_mode") return BackBufferCopy.CopyMode.from( _icall_Long( mb, this.ptr)) } open fun getRect(): Rect2 { val mb = getMethodBind("BackBufferCopy","get_rect") return _icall_Rect2( mb, this.ptr) } open fun setCopyMode(copyMode: Long) { val mb = getMethodBind("BackBufferCopy","set_copy_mode") _icall_Unit_Long( mb, this.ptr, copyMode) } open fun setRect(rect: Rect2) { val mb = getMethodBind("BackBufferCopy","set_rect") _icall_Unit_Rect2( mb, this.ptr, rect) } enum class CopyMode( id: Long ) { COPY_MODE_DISABLED(0), COPY_MODE_RECT(1), COPY_MODE_VIEWPORT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BakedLightmap.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.BakedLightmap import godot.core.Vector3 import godot.icalls._icall_BakedLightmapData import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Long_nObject_Boolean import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class BakedLightmap : VisualInstance() { open var bakeCellSize: Double get() { val mb = getMethodBind("BakedLightmap","get_bake_cell_size") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_bake_cell_size") _icall_Unit_Double(mb, this.ptr, value) } open var bakeDefaultTexelsPerUnit: Double get() { val mb = getMethodBind("BakedLightmap","get_bake_default_texels_per_unit") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_bake_default_texels_per_unit") _icall_Unit_Double(mb, this.ptr, value) } open var bakeEnergy: Double get() { val mb = getMethodBind("BakedLightmap","get_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_energy") _icall_Unit_Double(mb, this.ptr, value) } open var bakeExtents: Vector3 get() { val mb = getMethodBind("BakedLightmap","get_extents") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_extents") _icall_Unit_Vector3(mb, this.ptr, value) } open var bakeHdr: Boolean get() { val mb = getMethodBind("BakedLightmap","is_hdr") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_hdr") _icall_Unit_Boolean(mb, this.ptr, value) } open var bakeMode: Long get() { val mb = getMethodBind("BakedLightmap","get_bake_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_bake_mode") _icall_Unit_Long(mb, this.ptr, value) } open var bakePropagation: Double get() { val mb = getMethodBind("BakedLightmap","get_propagation") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_propagation") _icall_Unit_Double(mb, this.ptr, value) } open var bakeQuality: Long get() { val mb = getMethodBind("BakedLightmap","get_bake_quality") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_bake_quality") _icall_Unit_Long(mb, this.ptr, value) } open var captureCellSize: Double get() { val mb = getMethodBind("BakedLightmap","get_capture_cell_size") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_capture_cell_size") _icall_Unit_Double(mb, this.ptr, value) } open var imagePath: String get() { val mb = getMethodBind("BakedLightmap","get_image_path") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_image_path") _icall_Unit_String(mb, this.ptr, value) } open var lightData: BakedLightmapData get() { val mb = getMethodBind("BakedLightmap","get_light_data") return _icall_BakedLightmapData(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmap","set_light_data") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("BakedLightmap", "BakedLightmap") open fun bakeExtents(schedule: Vector3.() -> Unit): Vector3 = bakeExtents.apply{ schedule(this) bakeExtents = this } open fun bake(fromNode: Node? = null, createVisualDebug: Boolean = false): BakedLightmap.BakeError { val mb = getMethodBind("BakedLightmap","bake") return BakedLightmap.BakeError.from( _icall_Long_nObject_Boolean( mb, this.ptr, fromNode, createVisualDebug)) } open fun debugBake() { val mb = getMethodBind("BakedLightmap","debug_bake") _icall_Unit( mb, this.ptr) } open fun getBakeCellSize(): Double { val mb = getMethodBind("BakedLightmap","get_bake_cell_size") return _icall_Double( mb, this.ptr) } open fun getBakeDefaultTexelsPerUnit(): Double { val mb = getMethodBind("BakedLightmap","get_bake_default_texels_per_unit") return _icall_Double( mb, this.ptr) } open fun getBakeMode(): BakedLightmap.BakeMode { val mb = getMethodBind("BakedLightmap","get_bake_mode") return BakedLightmap.BakeMode.from( _icall_Long( mb, this.ptr)) } open fun getBakeQuality(): BakedLightmap.BakeQuality { val mb = getMethodBind("BakedLightmap","get_bake_quality") return BakedLightmap.BakeQuality.from( _icall_Long( mb, this.ptr)) } open fun getCaptureCellSize(): Double { val mb = getMethodBind("BakedLightmap","get_capture_cell_size") return _icall_Double( mb, this.ptr) } open fun getEnergy(): Double { val mb = getMethodBind("BakedLightmap","get_energy") return _icall_Double( mb, this.ptr) } open fun getExtents(): Vector3 { val mb = getMethodBind("BakedLightmap","get_extents") return _icall_Vector3( mb, this.ptr) } open fun getImagePath(): String { val mb = getMethodBind("BakedLightmap","get_image_path") return _icall_String( mb, this.ptr) } open fun getLightData(): BakedLightmapData { val mb = getMethodBind("BakedLightmap","get_light_data") return _icall_BakedLightmapData( mb, this.ptr) } open fun getPropagation(): Double { val mb = getMethodBind("BakedLightmap","get_propagation") return _icall_Double( mb, this.ptr) } open fun isHdr(): Boolean { val mb = getMethodBind("BakedLightmap","is_hdr") return _icall_Boolean( mb, this.ptr) } open fun setBakeCellSize(bakeCellSize: Double) { val mb = getMethodBind("BakedLightmap","set_bake_cell_size") _icall_Unit_Double( mb, this.ptr, bakeCellSize) } open fun setBakeDefaultTexelsPerUnit(texels: Double) { val mb = getMethodBind("BakedLightmap","set_bake_default_texels_per_unit") _icall_Unit_Double( mb, this.ptr, texels) } open fun setBakeMode(bakeMode: Long) { val mb = getMethodBind("BakedLightmap","set_bake_mode") _icall_Unit_Long( mb, this.ptr, bakeMode) } open fun setBakeQuality(bakeQuality: Long) { val mb = getMethodBind("BakedLightmap","set_bake_quality") _icall_Unit_Long( mb, this.ptr, bakeQuality) } open fun setCaptureCellSize(captureCellSize: Double) { val mb = getMethodBind("BakedLightmap","set_capture_cell_size") _icall_Unit_Double( mb, this.ptr, captureCellSize) } open fun setEnergy(energy: Double) { val mb = getMethodBind("BakedLightmap","set_energy") _icall_Unit_Double( mb, this.ptr, energy) } open fun setExtents(extents: Vector3) { val mb = getMethodBind("BakedLightmap","set_extents") _icall_Unit_Vector3( mb, this.ptr, extents) } open fun setHdr(hdr: Boolean) { val mb = getMethodBind("BakedLightmap","set_hdr") _icall_Unit_Boolean( mb, this.ptr, hdr) } open fun setImagePath(imagePath: String) { val mb = getMethodBind("BakedLightmap","set_image_path") _icall_Unit_String( mb, this.ptr, imagePath) } open fun setLightData(data: BakedLightmapData) { val mb = getMethodBind("BakedLightmap","set_light_data") _icall_Unit_Object( mb, this.ptr, data) } open fun setPropagation(propagation: Double) { val mb = getMethodBind("BakedLightmap","set_propagation") _icall_Unit_Double( mb, this.ptr, propagation) } enum class BakeQuality( id: Long ) { BAKE_QUALITY_LOW(0), BAKE_QUALITY_MEDIUM(1), BAKE_QUALITY_HIGH(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BakeError( id: Long ) { BAKE_ERROR_OK(0), BAKE_ERROR_NO_SAVE_PATH(1), BAKE_ERROR_NO_MESHES(2), BAKE_ERROR_CANT_CREATE_IMAGE(3), BAKE_ERROR_USER_ABORTED(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BakeMode( id: Long ) { BAKE_MODE_CONE_TRACE(0), BAKE_MODE_RAY_TRACE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BakedLightmapData.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.AABB import godot.core.NodePath import godot.core.PoolByteArray import godot.core.Transform import godot.core.VariantArray import godot.icalls._icall_AABB import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_NodePath_Long import godot.icalls._icall_PoolByteArray import godot.icalls._icall_Texture_Long import godot.icalls._icall_Transform import godot.icalls._icall_Unit import godot.icalls._icall_Unit_AABB import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_NodePath_Object_Long import godot.icalls._icall_Unit_PoolByteArray import godot.icalls._icall_Unit_Transform import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class BakedLightmapData : Resource() { open var bounds: AABB get() { val mb = getMethodBind("BakedLightmapData","get_bounds") return _icall_AABB(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmapData","set_bounds") _icall_Unit_AABB(mb, this.ptr, value) } open var cellSpaceTransform: Transform get() { val mb = getMethodBind("BakedLightmapData","get_cell_space_transform") return _icall_Transform(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmapData","set_cell_space_transform") _icall_Unit_Transform(mb, this.ptr, value) } open var cellSubdiv: Long get() { val mb = getMethodBind("BakedLightmapData","get_cell_subdiv") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmapData","set_cell_subdiv") _icall_Unit_Long(mb, this.ptr, value) } open var energy: Double get() { val mb = getMethodBind("BakedLightmapData","get_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmapData","set_energy") _icall_Unit_Double(mb, this.ptr, value) } open var octree: PoolByteArray get() { val mb = getMethodBind("BakedLightmapData","get_octree") return _icall_PoolByteArray(mb, this.ptr) } set(value) { val mb = getMethodBind("BakedLightmapData","set_octree") _icall_Unit_PoolByteArray(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("BakedLightmapData", "BakedLightmapData") open fun bounds(schedule: AABB.() -> Unit): AABB = bounds.apply{ schedule(this) bounds = this } open fun cellSpaceTransform(schedule: Transform.() -> Unit): Transform = cellSpaceTransform.apply{ schedule(this) cellSpaceTransform = this } open fun _getUserData(): VariantArray { throw NotImplementedError("_get_user_data is not implemented for BakedLightmapData") } open fun _setUserData(data: VariantArray) { } open fun addUser( path: NodePath, lightmap: Texture, instance: Long ) { val mb = getMethodBind("BakedLightmapData","add_user") _icall_Unit_NodePath_Object_Long( mb, this.ptr, path, lightmap, instance) } open fun clearUsers() { val mb = getMethodBind("BakedLightmapData","clear_users") _icall_Unit( mb, this.ptr) } open fun getBounds(): AABB { val mb = getMethodBind("BakedLightmapData","get_bounds") return _icall_AABB( mb, this.ptr) } open fun getCellSpaceTransform(): Transform { val mb = getMethodBind("BakedLightmapData","get_cell_space_transform") return _icall_Transform( mb, this.ptr) } open fun getCellSubdiv(): Long { val mb = getMethodBind("BakedLightmapData","get_cell_subdiv") return _icall_Long( mb, this.ptr) } open fun getEnergy(): Double { val mb = getMethodBind("BakedLightmapData","get_energy") return _icall_Double( mb, this.ptr) } open fun getOctree(): PoolByteArray { val mb = getMethodBind("BakedLightmapData","get_octree") return _icall_PoolByteArray( mb, this.ptr) } open fun getUserCount(): Long { val mb = getMethodBind("BakedLightmapData","get_user_count") return _icall_Long( mb, this.ptr) } open fun getUserLightmap(userIdx: Long): Texture { val mb = getMethodBind("BakedLightmapData","get_user_lightmap") return _icall_Texture_Long( mb, this.ptr, userIdx) } open fun getUserPath(userIdx: Long): NodePath { val mb = getMethodBind("BakedLightmapData","get_user_path") return _icall_NodePath_Long( mb, this.ptr, userIdx) } open fun setBounds(bounds: AABB) { val mb = getMethodBind("BakedLightmapData","set_bounds") _icall_Unit_AABB( mb, this.ptr, bounds) } open fun setCellSpaceTransform(xform: Transform) { val mb = getMethodBind("BakedLightmapData","set_cell_space_transform") _icall_Unit_Transform( mb, this.ptr, xform) } open fun setCellSubdiv(cellSubdiv: Long) { val mb = getMethodBind("BakedLightmapData","set_cell_subdiv") _icall_Unit_Long( mb, this.ptr, cellSubdiv) } open fun setEnergy(energy: Double) { val mb = getMethodBind("BakedLightmapData","set_energy") _icall_Unit_Double( mb, this.ptr, energy) } open fun setOctree(octree: PoolByteArray) { val mb = getMethodBind("BakedLightmapData","set_octree") _icall_Unit_PoolByteArray( mb, this.ptr, octree) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BaseButton.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.BaseButton import godot.Control import godot.core.Signal0 import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_ButtonGroup import godot.icalls._icall_Long import godot.icalls._icall_ShortCut import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long open class BaseButton internal constructor() : Control() { val buttonDown: Signal0 by signal() val buttonUp: Signal0 by signal() val signalPressed: Signal0 by signal() val toggled: Signal1 by signal("button_pressed") open var actionMode: Long get() { val mb = getMethodBind("BaseButton","get_action_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_action_mode") _icall_Unit_Long(mb, this.ptr, value) } open var buttonMask: Long get() { val mb = getMethodBind("BaseButton","get_button_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_button_mask") _icall_Unit_Long(mb, this.ptr, value) } open var disabled: Boolean get() { val mb = getMethodBind("BaseButton","is_disabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_disabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var enabledFocusMode: Long get() { val mb = getMethodBind("BaseButton","get_enabled_focus_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_enabled_focus_mode") _icall_Unit_Long(mb, this.ptr, value) } open var group: ButtonGroup get() { val mb = getMethodBind("BaseButton","get_button_group") return _icall_ButtonGroup(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_button_group") _icall_Unit_Object(mb, this.ptr, value) } open var keepPressedOutside: Boolean get() { val mb = getMethodBind("BaseButton","is_keep_pressed_outside") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_keep_pressed_outside") _icall_Unit_Boolean(mb, this.ptr, value) } open var pressed: Boolean get() { val mb = getMethodBind("BaseButton","is_pressed") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_pressed") _icall_Unit_Boolean(mb, this.ptr, value) } open var shortcut: ShortCut get() { val mb = getMethodBind("BaseButton","get_shortcut") return _icall_ShortCut(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_shortcut") _icall_Unit_Object(mb, this.ptr, value) } open var shortcutInTooltip: Boolean get() { val mb = getMethodBind("BaseButton","is_shortcut_in_tooltip_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_shortcut_in_tooltip") _icall_Unit_Boolean(mb, this.ptr, value) } open var toggleMode: Boolean get() { val mb = getMethodBind("BaseButton","is_toggle_mode") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("BaseButton","set_toggle_mode") _icall_Unit_Boolean(mb, this.ptr, value) } override fun _guiInput(arg0: InputEvent) { } open fun _pressed() { } open fun _toggled(buttonPressed: Boolean) { } override fun _unhandledInput(arg0: InputEvent) { } open fun getActionMode(): BaseButton.ActionMode { val mb = getMethodBind("BaseButton","get_action_mode") return BaseButton.ActionMode.from( _icall_Long( mb, this.ptr)) } open fun getButtonGroup(): ButtonGroup { val mb = getMethodBind("BaseButton","get_button_group") return _icall_ButtonGroup( mb, this.ptr) } open fun getButtonMask(): Long { val mb = getMethodBind("BaseButton","get_button_mask") return _icall_Long( mb, this.ptr) } open fun getDrawMode(): BaseButton.DrawMode { val mb = getMethodBind("BaseButton","get_draw_mode") return BaseButton.DrawMode.from( _icall_Long( mb, this.ptr)) } open fun getEnabledFocusMode(): Control.FocusMode { val mb = getMethodBind("BaseButton","get_enabled_focus_mode") return Control.FocusMode.from( _icall_Long( mb, this.ptr)) } open fun getShortcut(): ShortCut { val mb = getMethodBind("BaseButton","get_shortcut") return _icall_ShortCut( mb, this.ptr) } open fun isDisabled(): Boolean { val mb = getMethodBind("BaseButton","is_disabled") return _icall_Boolean( mb, this.ptr) } open fun isHovered(): Boolean { val mb = getMethodBind("BaseButton","is_hovered") return _icall_Boolean( mb, this.ptr) } open fun isKeepPressedOutside(): Boolean { val mb = getMethodBind("BaseButton","is_keep_pressed_outside") return _icall_Boolean( mb, this.ptr) } open fun isPressed(): Boolean { val mb = getMethodBind("BaseButton","is_pressed") return _icall_Boolean( mb, this.ptr) } open fun isShortcutInTooltipEnabled(): Boolean { val mb = getMethodBind("BaseButton","is_shortcut_in_tooltip_enabled") return _icall_Boolean( mb, this.ptr) } open fun isToggleMode(): Boolean { val mb = getMethodBind("BaseButton","is_toggle_mode") return _icall_Boolean( mb, this.ptr) } open fun setActionMode(mode: Long) { val mb = getMethodBind("BaseButton","set_action_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setButtonGroup(buttonGroup: ButtonGroup) { val mb = getMethodBind("BaseButton","set_button_group") _icall_Unit_Object( mb, this.ptr, buttonGroup) } open fun setButtonMask(mask: Long) { val mb = getMethodBind("BaseButton","set_button_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setDisabled(disabled: Boolean) { val mb = getMethodBind("BaseButton","set_disabled") _icall_Unit_Boolean( mb, this.ptr, disabled) } open fun setEnabledFocusMode(mode: Long) { val mb = getMethodBind("BaseButton","set_enabled_focus_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setKeepPressedOutside(enabled: Boolean) { val mb = getMethodBind("BaseButton","set_keep_pressed_outside") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setPressed(pressed: Boolean) { val mb = getMethodBind("BaseButton","set_pressed") _icall_Unit_Boolean( mb, this.ptr, pressed) } open fun setShortcut(shortcut: ShortCut) { val mb = getMethodBind("BaseButton","set_shortcut") _icall_Unit_Object( mb, this.ptr, shortcut) } open fun setShortcutInTooltip(enabled: Boolean) { val mb = getMethodBind("BaseButton","set_shortcut_in_tooltip") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setToggleMode(enabled: Boolean) { val mb = getMethodBind("BaseButton","set_toggle_mode") _icall_Unit_Boolean( mb, this.ptr, enabled) } enum class ActionMode( id: Long ) { ACTION_MODE_BUTTON_PRESS(0), ACTION_MODE_BUTTON_RELEASE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class DrawMode( id: Long ) { DRAW_NORMAL(0), DRAW_PRESSED(1), DRAW_HOVER(2), DRAW_DISABLED(3), DRAW_HOVER_PRESSED(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BitMap.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.Rect2 import godot.core.VariantArray import godot.core.Vector2 import godot.icalls._icall_Boolean_Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long_Rect2 import godot.icalls._icall_Unit_Object_Double import godot.icalls._icall_Unit_Rect2_Boolean import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Unit_Vector2_Boolean import godot.icalls._icall_VariantArray_Rect2_Double import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class BitMap : Resource() { override fun __new(): COpaquePointer = invokeConstructor("BitMap", "BitMap") open fun _getData(): Dictionary { throw NotImplementedError("_get_data is not implemented for BitMap") } open fun _setData(arg0: Dictionary) { } open fun create(size: Vector2) { val mb = getMethodBind("BitMap","create") _icall_Unit_Vector2( mb, this.ptr, size) } open fun createFromImageAlpha(image: Image, threshold: Double = 0.1) { val mb = getMethodBind("BitMap","create_from_image_alpha") _icall_Unit_Object_Double( mb, this.ptr, image, threshold) } open fun getBit(position: Vector2): Boolean { val mb = getMethodBind("BitMap","get_bit") return _icall_Boolean_Vector2( mb, this.ptr, position) } open fun getSize(): Vector2 { val mb = getMethodBind("BitMap","get_size") return _icall_Vector2( mb, this.ptr) } open fun getTrueBitCount(): Long { val mb = getMethodBind("BitMap","get_true_bit_count") return _icall_Long( mb, this.ptr) } open fun growMask(pixels: Long, rect: Rect2) { val mb = getMethodBind("BitMap","grow_mask") _icall_Unit_Long_Rect2( mb, this.ptr, pixels, rect) } open fun opaqueToPolygons(rect: Rect2, epsilon: Double = 2.0): VariantArray { val mb = getMethodBind("BitMap","opaque_to_polygons") return _icall_VariantArray_Rect2_Double( mb, this.ptr, rect, epsilon) } open fun setBit(position: Vector2, bit: Boolean) { val mb = getMethodBind("BitMap","set_bit") _icall_Unit_Vector2_Boolean( mb, this.ptr, position, bit) } open fun setBitRect(rect: Rect2, bit: Boolean) { val mb = getMethodBind("BitMap","set_bit_rect") _icall_Unit_Rect2_Boolean( mb, this.ptr, rect, bit) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BitmapFont.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.PoolIntArray import godot.core.Rect2 import godot.core.VariantArray import godot.core.Vector2 import godot.icalls._icall_BitmapFont import godot.icalls._icall_Long import godot.icalls._icall_Long_Long_Long import godot.icalls._icall_Long_String import godot.icalls._icall_Texture_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long_Long_Long import godot.icalls._icall_Unit_Long_Long_Rect2_Vector2_Double import godot.icalls._icall_Unit_Object import godot.icalls._icall_Vector2_Long_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlin.UninitializedPropertyAccessException import kotlinx.cinterop.COpaquePointer open class BitmapFont : Font() { open var ascent: Double get() { throw UninitializedPropertyAccessException("Cannot access property ascent: has no getter") } set(value) { val mb = getMethodBind("BitmapFont","set_ascent") _icall_Unit_Double(mb, this.ptr, value) } open var distanceField: Boolean get() { throw UninitializedPropertyAccessException("Cannot access property distanceField: has no getter") } set(value) { val mb = getMethodBind("BitmapFont","set_distance_field_hint") _icall_Unit_Boolean(mb, this.ptr, value) } open var fallback: BitmapFont get() { val mb = getMethodBind("BitmapFont","get_fallback") return _icall_BitmapFont(mb, this.ptr) } set(value) { val mb = getMethodBind("BitmapFont","set_fallback") _icall_Unit_Object(mb, this.ptr, value) } open var height: Double get() { throw UninitializedPropertyAccessException("Cannot access property height: has no getter") } set(value) { val mb = getMethodBind("BitmapFont","set_height") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("BitmapFont", "BitmapFont") open fun _getChars(): PoolIntArray { throw NotImplementedError("_get_chars is not implemented for BitmapFont") } open fun _getKernings(): PoolIntArray { throw NotImplementedError("_get_kernings is not implemented for BitmapFont") } open fun _getTextures(): VariantArray { throw NotImplementedError("_get_textures is not implemented for BitmapFont") } open fun _setChars(arg0: PoolIntArray) { } open fun _setKernings(arg0: PoolIntArray) { } open fun _setTextures(arg0: VariantArray) { } open fun addChar( character: Long, texture: Long, rect: Rect2, align: Vector2 = Vector2(0.0, 0.0), advance: Double = -1.0 ) { val mb = getMethodBind("BitmapFont","add_char") _icall_Unit_Long_Long_Rect2_Vector2_Double( mb, this.ptr, character, texture, rect, align, advance) } open fun addKerningPair( charA: Long, charB: Long, kerning: Long ) { val mb = getMethodBind("BitmapFont","add_kerning_pair") _icall_Unit_Long_Long_Long( mb, this.ptr, charA, charB, kerning) } open fun addTexture(texture: Texture) { val mb = getMethodBind("BitmapFont","add_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun clear() { val mb = getMethodBind("BitmapFont","clear") _icall_Unit( mb, this.ptr) } open fun createFromFnt(path: String): GodotError { val mb = getMethodBind("BitmapFont","create_from_fnt") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun getCharSize(char: Long, next: Long = 0): Vector2 { val mb = getMethodBind("BitmapFont","get_char_size") return _icall_Vector2_Long_Long( mb, this.ptr, char, next) } open fun getFallback(): BitmapFont { val mb = getMethodBind("BitmapFont","get_fallback") return _icall_BitmapFont( mb, this.ptr) } open fun getKerningPair(charA: Long, charB: Long): Long { val mb = getMethodBind("BitmapFont","get_kerning_pair") return _icall_Long_Long_Long( mb, this.ptr, charA, charB) } open fun getTexture(idx: Long): Texture { val mb = getMethodBind("BitmapFont","get_texture") return _icall_Texture_Long( mb, this.ptr, idx) } open fun getTextureCount(): Long { val mb = getMethodBind("BitmapFont","get_texture_count") return _icall_Long( mb, this.ptr) } open fun setAscent(px: Double) { val mb = getMethodBind("BitmapFont","set_ascent") _icall_Unit_Double( mb, this.ptr, px) } open fun setDistanceFieldHint(enable: Boolean) { val mb = getMethodBind("BitmapFont","set_distance_field_hint") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setFallback(fallback: BitmapFont) { val mb = getMethodBind("BitmapFont","set_fallback") _icall_Unit_Object( mb, this.ptr, fallback) } open fun setHeight(px: Double) { val mb = getMethodBind("BitmapFont","set_height") _icall_Unit_Double( mb, this.ptr, px) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Bone2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Transform2D import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Transform2D import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Transform2D import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Bone2D : Node2D() { open var defaultLength: Double get() { val mb = getMethodBind("Bone2D","get_default_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Bone2D","set_default_length") _icall_Unit_Double(mb, this.ptr, value) } open var rest: Transform2D get() { val mb = getMethodBind("Bone2D","get_rest") return _icall_Transform2D(mb, this.ptr) } set(value) { val mb = getMethodBind("Bone2D","set_rest") _icall_Unit_Transform2D(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Bone2D", "Bone2D") open fun rest(schedule: Transform2D.() -> Unit): Transform2D = rest.apply{ schedule(this) rest = this } open fun applyRest() { val mb = getMethodBind("Bone2D","apply_rest") _icall_Unit( mb, this.ptr) } open fun getDefaultLength(): Double { val mb = getMethodBind("Bone2D","get_default_length") return _icall_Double( mb, this.ptr) } open fun getIndexInSkeleton(): Long { val mb = getMethodBind("Bone2D","get_index_in_skeleton") return _icall_Long( mb, this.ptr) } open fun getRest(): Transform2D { val mb = getMethodBind("Bone2D","get_rest") return _icall_Transform2D( mb, this.ptr) } open fun getSkeletonRest(): Transform2D { val mb = getMethodBind("Bone2D","get_skeleton_rest") return _icall_Transform2D( mb, this.ptr) } open fun setDefaultLength(defaultLength: Double) { val mb = getMethodBind("Bone2D","set_default_length") _icall_Unit_Double( mb, this.ptr, defaultLength) } open fun setRest(rest: Transform2D) { val mb = getMethodBind("Bone2D","set_rest") _icall_Unit_Transform2D( mb, this.ptr, rest) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BoneAttachment.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_String import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.String import kotlinx.cinterop.COpaquePointer open class BoneAttachment : Spatial() { open var boneName: String get() { val mb = getMethodBind("BoneAttachment","get_bone_name") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("BoneAttachment","set_bone_name") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("BoneAttachment", "BoneAttachment") open fun getBoneName(): String { val mb = getMethodBind("BoneAttachment","get_bone_name") return _icall_String( mb, this.ptr) } open fun setBoneName(boneName: String) { val mb = getMethodBind("BoneAttachment","set_bone_name") _icall_Unit_String( mb, this.ptr, boneName) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BoxContainer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.BoxContainer import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long open class BoxContainer internal constructor() : Container() { open var alignment: Long get() { val mb = getMethodBind("BoxContainer","get_alignment") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("BoxContainer","set_alignment") _icall_Unit_Long(mb, this.ptr, value) } open fun addSpacer(begin: Boolean) { val mb = getMethodBind("BoxContainer","add_spacer") _icall_Unit_Boolean( mb, this.ptr, begin) } open fun getAlignment(): BoxContainer.AlignMode { val mb = getMethodBind("BoxContainer","get_alignment") return BoxContainer.AlignMode.from( _icall_Long( mb, this.ptr)) } open fun setAlignment(alignment: Long) { val mb = getMethodBind("BoxContainer","set_alignment") _icall_Unit_Long( mb, this.ptr, alignment) } enum class AlignMode( id: Long ) { ALIGN_BEGIN(0), ALIGN_CENTER(1), ALIGN_END(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BoxShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector3 import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class BoxShape : Shape() { open var extents: Vector3 get() { val mb = getMethodBind("BoxShape","get_extents") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("BoxShape","set_extents") _icall_Unit_Vector3(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("BoxShape", "BoxShape") open fun extents(schedule: Vector3.() -> Unit): Vector3 = extents.apply{ schedule(this) extents = this } open fun getExtents(): Vector3 { val mb = getMethodBind("BoxShape","get_extents") return _icall_Vector3( mb, this.ptr) } open fun setExtents(extents: Vector3) { val mb = getMethodBind("BoxShape","set_extents") _icall_Unit_Vector3( mb, this.ptr, extents) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/BulletPhysicsDirectBodyState.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class BulletPhysicsDirectBodyState internal constructor() : PhysicsDirectBodyState() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Button.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Button import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class Button : BaseButton() { open var align: Long get() { val mb = getMethodBind("Button","get_text_align") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Button","set_text_align") _icall_Unit_Long(mb, this.ptr, value) } open var clipText: Boolean get() { val mb = getMethodBind("Button","get_clip_text") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Button","set_clip_text") _icall_Unit_Boolean(mb, this.ptr, value) } open var expandIcon: Boolean get() { val mb = getMethodBind("Button","is_expand_icon") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Button","set_expand_icon") _icall_Unit_Boolean(mb, this.ptr, value) } open var flat: Boolean get() { val mb = getMethodBind("Button","is_flat") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Button","set_flat") _icall_Unit_Boolean(mb, this.ptr, value) } open var icon: Texture get() { val mb = getMethodBind("Button","get_button_icon") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("Button","set_button_icon") _icall_Unit_Object(mb, this.ptr, value) } open var text: String get() { val mb = getMethodBind("Button","get_text") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Button","set_text") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Button", "Button") open fun getButtonIcon(): Texture { val mb = getMethodBind("Button","get_button_icon") return _icall_Texture( mb, this.ptr) } open fun getClipText(): Boolean { val mb = getMethodBind("Button","get_clip_text") return _icall_Boolean( mb, this.ptr) } open fun getText(): String { val mb = getMethodBind("Button","get_text") return _icall_String( mb, this.ptr) } open fun getTextAlign(): Button.TextAlign { val mb = getMethodBind("Button","get_text_align") return Button.TextAlign.from( _icall_Long( mb, this.ptr)) } open fun isExpandIcon(): Boolean { val mb = getMethodBind("Button","is_expand_icon") return _icall_Boolean( mb, this.ptr) } open fun isFlat(): Boolean { val mb = getMethodBind("Button","is_flat") return _icall_Boolean( mb, this.ptr) } open fun setButtonIcon(texture: Texture) { val mb = getMethodBind("Button","set_button_icon") _icall_Unit_Object( mb, this.ptr, texture) } open fun setClipText(enabled: Boolean) { val mb = getMethodBind("Button","set_clip_text") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setExpandIcon(arg0: Boolean) { val mb = getMethodBind("Button","set_expand_icon") _icall_Unit_Boolean( mb, this.ptr, arg0) } open fun setFlat(enabled: Boolean) { val mb = getMethodBind("Button","set_flat") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setText(text: String) { val mb = getMethodBind("Button","set_text") _icall_Unit_String( mb, this.ptr, text) } open fun setTextAlign(align: Long) { val mb = getMethodBind("Button","set_text_align") _icall_Unit_Long( mb, this.ptr, align) } enum class TextAlign( id: Long ) { ALIGN_LEFT(0), ALIGN_CENTER(1), ALIGN_RIGHT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ButtonGroup.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.VariantArray import godot.icalls._icall_BaseButton import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class ButtonGroup : Resource() { override fun __new(): COpaquePointer = invokeConstructor("ButtonGroup", "ButtonGroup") open fun getButtons(): VariantArray { val mb = getMethodBind("ButtonGroup","get_buttons") return _icall_VariantArray( mb, this.ptr) } open fun getPressedButton(): BaseButton { val mb = getMethodBind("ButtonGroup","get_pressed_button") return _icall_BaseButton( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CPUParticles.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.CPUParticles import godot.core.Color import godot.core.PoolColorArray import godot.core.PoolVector3Array import godot.core.Vector3 import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Color import godot.icalls._icall_Curve_Long import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Gradient import godot.icalls._icall_Long import godot.icalls._icall_Mesh import godot.icalls._icall_PoolColorArray import godot.icalls._icall_PoolVector3Array import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_PoolColorArray import godot.icalls._icall_Unit_PoolVector3Array import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class CPUParticles : GeometryInstance() { open var amount: Long get() { val mb = getMethodBind("CPUParticles","get_amount") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_amount") _icall_Unit_Long(mb, this.ptr, value) } open var angle: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var angleCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 7, value) } open var angleRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var angularVelocity: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var angularVelocityCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 1, value) } open var angularVelocityRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var animOffset: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 11, value) } open var animOffsetCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 11, value) } open var animOffsetRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 11, value) } open var animSpeed: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 10, value) } open var animSpeedCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 10, value) } open var animSpeedRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 10, value) } open var color: Color get() { val mb = getMethodBind("CPUParticles","get_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_color") _icall_Unit_Color(mb, this.ptr, value) } open var colorRamp: Gradient get() { val mb = getMethodBind("CPUParticles","get_color_ramp") return _icall_Gradient(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_color_ramp") _icall_Unit_Object(mb, this.ptr, value) } open var damping: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var dampingCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 6, value) } open var dampingRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var direction: Vector3 get() { val mb = getMethodBind("CPUParticles","get_direction") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_direction") _icall_Unit_Vector3(mb, this.ptr, value) } open var drawOrder: Long get() { val mb = getMethodBind("CPUParticles","get_draw_order") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_draw_order") _icall_Unit_Long(mb, this.ptr, value) } open var emissionBoxExtents: Vector3 get() { val mb = getMethodBind("CPUParticles","get_emission_box_extents") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_emission_box_extents") _icall_Unit_Vector3(mb, this.ptr, value) } open var emissionColors: PoolColorArray get() { val mb = getMethodBind("CPUParticles","get_emission_colors") return _icall_PoolColorArray(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_emission_colors") _icall_Unit_PoolColorArray(mb, this.ptr, value) } open var emissionNormals: PoolVector3Array get() { val mb = getMethodBind("CPUParticles","get_emission_normals") return _icall_PoolVector3Array(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_emission_normals") _icall_Unit_PoolVector3Array(mb, this.ptr, value) } open var emissionPoints: PoolVector3Array get() { val mb = getMethodBind("CPUParticles","get_emission_points") return _icall_PoolVector3Array(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_emission_points") _icall_Unit_PoolVector3Array(mb, this.ptr, value) } open var emissionShape: Long get() { val mb = getMethodBind("CPUParticles","get_emission_shape") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_emission_shape") _icall_Unit_Long(mb, this.ptr, value) } open var emissionSphereRadius: Double get() { val mb = getMethodBind("CPUParticles","get_emission_sphere_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_emission_sphere_radius") _icall_Unit_Double(mb, this.ptr, value) } open var emitting: Boolean get() { val mb = getMethodBind("CPUParticles","is_emitting") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_emitting") _icall_Unit_Boolean(mb, this.ptr, value) } open var explosiveness: Double get() { val mb = getMethodBind("CPUParticles","get_explosiveness_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_explosiveness_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var fixedFps: Long get() { val mb = getMethodBind("CPUParticles","get_fixed_fps") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_fixed_fps") _icall_Unit_Long(mb, this.ptr, value) } open var flagAlignY: Boolean get() { val mb = getMethodBind("CPUParticles","get_particle_flag") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("CPUParticles","set_particle_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open var flagDisableZ: Boolean get() { val mb = getMethodBind("CPUParticles","get_particle_flag") return _icall_Boolean_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("CPUParticles","set_particle_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 2, value) } open var flagRotateY: Boolean get() { val mb = getMethodBind("CPUParticles","get_particle_flag") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("CPUParticles","set_particle_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var flatness: Double get() { val mb = getMethodBind("CPUParticles","get_flatness") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_flatness") _icall_Unit_Double(mb, this.ptr, value) } open var fractDelta: Boolean get() { val mb = getMethodBind("CPUParticles","get_fractional_delta") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_fractional_delta") _icall_Unit_Boolean(mb, this.ptr, value) } open var gravity: Vector3 get() { val mb = getMethodBind("CPUParticles","get_gravity") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_gravity") _icall_Unit_Vector3(mb, this.ptr, value) } open var hueVariation: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var hueVariationCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 9, value) } open var hueVariationRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var initialVelocity: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var initialVelocityRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var lifetime: Double get() { val mb = getMethodBind("CPUParticles","get_lifetime") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_lifetime") _icall_Unit_Double(mb, this.ptr, value) } open var lifetimeRandomness: Double get() { val mb = getMethodBind("CPUParticles","get_lifetime_randomness") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_lifetime_randomness") _icall_Unit_Double(mb, this.ptr, value) } open var linearAccel: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var linearAccelCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 3, value) } open var linearAccelRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var localCoords: Boolean get() { val mb = getMethodBind("CPUParticles","get_use_local_coordinates") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_use_local_coordinates") _icall_Unit_Boolean(mb, this.ptr, value) } open var mesh: Mesh get() { val mb = getMethodBind("CPUParticles","get_mesh") return _icall_Mesh(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_mesh") _icall_Unit_Object(mb, this.ptr, value) } open var oneShot: Boolean get() { val mb = getMethodBind("CPUParticles","get_one_shot") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_one_shot") _icall_Unit_Boolean(mb, this.ptr, value) } open var orbitVelocity: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var orbitVelocityCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 2, value) } open var orbitVelocityRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var preprocess: Double get() { val mb = getMethodBind("CPUParticles","get_pre_process_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_pre_process_time") _icall_Unit_Double(mb, this.ptr, value) } open var radialAccel: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var radialAccelCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 4, value) } open var radialAccelRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var randomness: Double get() { val mb = getMethodBind("CPUParticles","get_randomness_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_randomness_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var scaleAmount: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var scaleAmountCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 8, value) } open var scaleAmountRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var speedScale: Double get() { val mb = getMethodBind("CPUParticles","get_speed_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_speed_scale") _icall_Unit_Double(mb, this.ptr, value) } open var spread: Double get() { val mb = getMethodBind("CPUParticles","get_spread") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles","set_spread") _icall_Unit_Double(mb, this.ptr, value) } open var tangentialAccel: Double get() { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var tangentialAccelCurve: Curve get() { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 5, value) } open var tangentialAccelRandom: Double get() { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } override fun __new(): COpaquePointer = invokeConstructor("CPUParticles", "CPUParticles") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun direction(schedule: Vector3.() -> Unit): Vector3 = direction.apply{ schedule(this) direction = this } open fun emissionBoxExtents(schedule: Vector3.() -> Unit): Vector3 = emissionBoxExtents.apply{ schedule(this) emissionBoxExtents = this } open fun gravity(schedule: Vector3.() -> Unit): Vector3 = gravity.apply{ schedule(this) gravity = this } open fun _updateRenderThread() { } open fun convertFromParticles(particles: Node) { val mb = getMethodBind("CPUParticles","convert_from_particles") _icall_Unit_Object( mb, this.ptr, particles) } open fun getAmount(): Long { val mb = getMethodBind("CPUParticles","get_amount") return _icall_Long( mb, this.ptr) } open fun getColor(): Color { val mb = getMethodBind("CPUParticles","get_color") return _icall_Color( mb, this.ptr) } open fun getColorRamp(): Gradient { val mb = getMethodBind("CPUParticles","get_color_ramp") return _icall_Gradient( mb, this.ptr) } open fun getDirection(): Vector3 { val mb = getMethodBind("CPUParticles","get_direction") return _icall_Vector3( mb, this.ptr) } open fun getDrawOrder(): CPUParticles.DrawOrder { val mb = getMethodBind("CPUParticles","get_draw_order") return CPUParticles.DrawOrder.from( _icall_Long( mb, this.ptr)) } open fun getEmissionBoxExtents(): Vector3 { val mb = getMethodBind("CPUParticles","get_emission_box_extents") return _icall_Vector3( mb, this.ptr) } open fun getEmissionColors(): PoolColorArray { val mb = getMethodBind("CPUParticles","get_emission_colors") return _icall_PoolColorArray( mb, this.ptr) } open fun getEmissionNormals(): PoolVector3Array { val mb = getMethodBind("CPUParticles","get_emission_normals") return _icall_PoolVector3Array( mb, this.ptr) } open fun getEmissionPoints(): PoolVector3Array { val mb = getMethodBind("CPUParticles","get_emission_points") return _icall_PoolVector3Array( mb, this.ptr) } open fun getEmissionShape(): CPUParticles.EmissionShape { val mb = getMethodBind("CPUParticles","get_emission_shape") return CPUParticles.EmissionShape.from( _icall_Long( mb, this.ptr)) } open fun getEmissionSphereRadius(): Double { val mb = getMethodBind("CPUParticles","get_emission_sphere_radius") return _icall_Double( mb, this.ptr) } open fun getExplosivenessRatio(): Double { val mb = getMethodBind("CPUParticles","get_explosiveness_ratio") return _icall_Double( mb, this.ptr) } open fun getFixedFps(): Long { val mb = getMethodBind("CPUParticles","get_fixed_fps") return _icall_Long( mb, this.ptr) } open fun getFlatness(): Double { val mb = getMethodBind("CPUParticles","get_flatness") return _icall_Double( mb, this.ptr) } open fun getFractionalDelta(): Boolean { val mb = getMethodBind("CPUParticles","get_fractional_delta") return _icall_Boolean( mb, this.ptr) } open fun getGravity(): Vector3 { val mb = getMethodBind("CPUParticles","get_gravity") return _icall_Vector3( mb, this.ptr) } open fun getLifetime(): Double { val mb = getMethodBind("CPUParticles","get_lifetime") return _icall_Double( mb, this.ptr) } open fun getLifetimeRandomness(): Double { val mb = getMethodBind("CPUParticles","get_lifetime_randomness") return _icall_Double( mb, this.ptr) } open fun getMesh(): Mesh { val mb = getMethodBind("CPUParticles","get_mesh") return _icall_Mesh( mb, this.ptr) } open fun getOneShot(): Boolean { val mb = getMethodBind("CPUParticles","get_one_shot") return _icall_Boolean( mb, this.ptr) } open fun getParam(param: Long): Double { val mb = getMethodBind("CPUParticles","get_param") return _icall_Double_Long( mb, this.ptr, param) } open fun getParamCurve(param: Long): Curve { val mb = getMethodBind("CPUParticles","get_param_curve") return _icall_Curve_Long( mb, this.ptr, param) } open fun getParamRandomness(param: Long): Double { val mb = getMethodBind("CPUParticles","get_param_randomness") return _icall_Double_Long( mb, this.ptr, param) } open fun getParticleFlag(flag: Long): Boolean { val mb = getMethodBind("CPUParticles","get_particle_flag") return _icall_Boolean_Long( mb, this.ptr, flag) } open fun getPreProcessTime(): Double { val mb = getMethodBind("CPUParticles","get_pre_process_time") return _icall_Double( mb, this.ptr) } open fun getRandomnessRatio(): Double { val mb = getMethodBind("CPUParticles","get_randomness_ratio") return _icall_Double( mb, this.ptr) } open fun getSpeedScale(): Double { val mb = getMethodBind("CPUParticles","get_speed_scale") return _icall_Double( mb, this.ptr) } open fun getSpread(): Double { val mb = getMethodBind("CPUParticles","get_spread") return _icall_Double( mb, this.ptr) } open fun getUseLocalCoordinates(): Boolean { val mb = getMethodBind("CPUParticles","get_use_local_coordinates") return _icall_Boolean( mb, this.ptr) } open fun isEmitting(): Boolean { val mb = getMethodBind("CPUParticles","is_emitting") return _icall_Boolean( mb, this.ptr) } open fun restart() { val mb = getMethodBind("CPUParticles","restart") _icall_Unit( mb, this.ptr) } open fun setAmount(amount: Long) { val mb = getMethodBind("CPUParticles","set_amount") _icall_Unit_Long( mb, this.ptr, amount) } open fun setColor(color: Color) { val mb = getMethodBind("CPUParticles","set_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setColorRamp(ramp: Gradient) { val mb = getMethodBind("CPUParticles","set_color_ramp") _icall_Unit_Object( mb, this.ptr, ramp) } open fun setDirection(direction: Vector3) { val mb = getMethodBind("CPUParticles","set_direction") _icall_Unit_Vector3( mb, this.ptr, direction) } open fun setDrawOrder(order: Long) { val mb = getMethodBind("CPUParticles","set_draw_order") _icall_Unit_Long( mb, this.ptr, order) } open fun setEmissionBoxExtents(extents: Vector3) { val mb = getMethodBind("CPUParticles","set_emission_box_extents") _icall_Unit_Vector3( mb, this.ptr, extents) } open fun setEmissionColors(array: PoolColorArray) { val mb = getMethodBind("CPUParticles","set_emission_colors") _icall_Unit_PoolColorArray( mb, this.ptr, array) } open fun setEmissionNormals(array: PoolVector3Array) { val mb = getMethodBind("CPUParticles","set_emission_normals") _icall_Unit_PoolVector3Array( mb, this.ptr, array) } open fun setEmissionPoints(array: PoolVector3Array) { val mb = getMethodBind("CPUParticles","set_emission_points") _icall_Unit_PoolVector3Array( mb, this.ptr, array) } open fun setEmissionShape(shape: Long) { val mb = getMethodBind("CPUParticles","set_emission_shape") _icall_Unit_Long( mb, this.ptr, shape) } open fun setEmissionSphereRadius(radius: Double) { val mb = getMethodBind("CPUParticles","set_emission_sphere_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setEmitting(emitting: Boolean) { val mb = getMethodBind("CPUParticles","set_emitting") _icall_Unit_Boolean( mb, this.ptr, emitting) } open fun setExplosivenessRatio(ratio: Double) { val mb = getMethodBind("CPUParticles","set_explosiveness_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setFixedFps(fps: Long) { val mb = getMethodBind("CPUParticles","set_fixed_fps") _icall_Unit_Long( mb, this.ptr, fps) } open fun setFlatness(amount: Double) { val mb = getMethodBind("CPUParticles","set_flatness") _icall_Unit_Double( mb, this.ptr, amount) } open fun setFractionalDelta(enable: Boolean) { val mb = getMethodBind("CPUParticles","set_fractional_delta") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setGravity(accelVec: Vector3) { val mb = getMethodBind("CPUParticles","set_gravity") _icall_Unit_Vector3( mb, this.ptr, accelVec) } open fun setLifetime(secs: Double) { val mb = getMethodBind("CPUParticles","set_lifetime") _icall_Unit_Double( mb, this.ptr, secs) } open fun setLifetimeRandomness(random: Double) { val mb = getMethodBind("CPUParticles","set_lifetime_randomness") _icall_Unit_Double( mb, this.ptr, random) } open fun setMesh(mesh: Mesh) { val mb = getMethodBind("CPUParticles","set_mesh") _icall_Unit_Object( mb, this.ptr, mesh) } open fun setOneShot(enable: Boolean) { val mb = getMethodBind("CPUParticles","set_one_shot") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setParam(param: Long, value: Double) { val mb = getMethodBind("CPUParticles","set_param") _icall_Unit_Long_Double( mb, this.ptr, param, value) } open fun setParamCurve(param: Long, curve: Curve) { val mb = getMethodBind("CPUParticles","set_param_curve") _icall_Unit_Long_Object( mb, this.ptr, param, curve) } open fun setParamRandomness(param: Long, randomness: Double) { val mb = getMethodBind("CPUParticles","set_param_randomness") _icall_Unit_Long_Double( mb, this.ptr, param, randomness) } open fun setParticleFlag(flag: Long, enable: Boolean) { val mb = getMethodBind("CPUParticles","set_particle_flag") _icall_Unit_Long_Boolean( mb, this.ptr, flag, enable) } open fun setPreProcessTime(secs: Double) { val mb = getMethodBind("CPUParticles","set_pre_process_time") _icall_Unit_Double( mb, this.ptr, secs) } open fun setRandomnessRatio(ratio: Double) { val mb = getMethodBind("CPUParticles","set_randomness_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setSpeedScale(scale: Double) { val mb = getMethodBind("CPUParticles","set_speed_scale") _icall_Unit_Double( mb, this.ptr, scale) } open fun setSpread(degrees: Double) { val mb = getMethodBind("CPUParticles","set_spread") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setUseLocalCoordinates(enable: Boolean) { val mb = getMethodBind("CPUParticles","set_use_local_coordinates") _icall_Unit_Boolean( mb, this.ptr, enable) } enum class Flags( id: Long ) { FLAG_ALIGN_Y_TO_VELOCITY(0), FLAG_ROTATE_Y(1), FLAG_DISABLE_Z(2), FLAG_MAX(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class EmissionShape( id: Long ) { EMISSION_SHAPE_POINT(0), EMISSION_SHAPE_SPHERE(1), EMISSION_SHAPE_BOX(2), EMISSION_SHAPE_POINTS(3), EMISSION_SHAPE_DIRECTED_POINTS(4), EMISSION_SHAPE_MAX(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Parameter( id: Long ) { PARAM_INITIAL_LINEAR_VELOCITY(0), PARAM_ANGULAR_VELOCITY(1), PARAM_ORBIT_VELOCITY(2), PARAM_LINEAR_ACCEL(3), PARAM_RADIAL_ACCEL(4), PARAM_TANGENTIAL_ACCEL(5), PARAM_DAMPING(6), PARAM_ANGLE(7), PARAM_SCALE(8), PARAM_HUE_VARIATION(9), PARAM_ANIM_SPEED(10), PARAM_ANIM_OFFSET(11), PARAM_MAX(12); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class DrawOrder( id: Long ) { DRAW_ORDER_INDEX(0), DRAW_ORDER_LIFETIME(1), DRAW_ORDER_VIEW_DEPTH(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CPUParticles2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.CPUParticles2D import godot.core.Color import godot.core.PoolColorArray import godot.core.PoolVector2Array import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Color import godot.icalls._icall_Curve_Long import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Gradient import godot.icalls._icall_Long import godot.icalls._icall_PoolColorArray import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_Texture import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_PoolColorArray import godot.icalls._icall_Unit_PoolVector2Array import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class CPUParticles2D : Node2D() { open var amount: Long get() { val mb = getMethodBind("CPUParticles2D","get_amount") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_amount") _icall_Unit_Long(mb, this.ptr, value) } open var angle: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var angleCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 7, value) } open var angleRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var angularVelocity: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var angularVelocityCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 1, value) } open var angularVelocityRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var animOffset: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 11, value) } open var animOffsetCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 11, value) } open var animOffsetRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 11, value) } open var animSpeed: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 10, value) } open var animSpeedCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 10, value) } open var animSpeedRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 10, value) } open var color: Color get() { val mb = getMethodBind("CPUParticles2D","get_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_color") _icall_Unit_Color(mb, this.ptr, value) } open var colorRamp: Gradient get() { val mb = getMethodBind("CPUParticles2D","get_color_ramp") return _icall_Gradient(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_color_ramp") _icall_Unit_Object(mb, this.ptr, value) } open var damping: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var dampingCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 6, value) } open var dampingRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var direction: Vector2 get() { val mb = getMethodBind("CPUParticles2D","get_direction") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_direction") _icall_Unit_Vector2(mb, this.ptr, value) } open var drawOrder: Long get() { val mb = getMethodBind("CPUParticles2D","get_draw_order") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_draw_order") _icall_Unit_Long(mb, this.ptr, value) } open var emissionColors: PoolColorArray get() { val mb = getMethodBind("CPUParticles2D","get_emission_colors") return _icall_PoolColorArray(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_emission_colors") _icall_Unit_PoolColorArray(mb, this.ptr, value) } open var emissionNormals: PoolVector2Array get() { val mb = getMethodBind("CPUParticles2D","get_emission_normals") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_emission_normals") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } open var emissionPoints: PoolVector2Array get() { val mb = getMethodBind("CPUParticles2D","get_emission_points") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_emission_points") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } open var emissionRectExtents: Vector2 get() { val mb = getMethodBind("CPUParticles2D","get_emission_rect_extents") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_emission_rect_extents") _icall_Unit_Vector2(mb, this.ptr, value) } open var emissionShape: Long get() { val mb = getMethodBind("CPUParticles2D","get_emission_shape") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_emission_shape") _icall_Unit_Long(mb, this.ptr, value) } open var emissionSphereRadius: Double get() { val mb = getMethodBind("CPUParticles2D","get_emission_sphere_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_emission_sphere_radius") _icall_Unit_Double(mb, this.ptr, value) } open var emitting: Boolean get() { val mb = getMethodBind("CPUParticles2D","is_emitting") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_emitting") _icall_Unit_Boolean(mb, this.ptr, value) } open var explosiveness: Double get() { val mb = getMethodBind("CPUParticles2D","get_explosiveness_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_explosiveness_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var fixedFps: Long get() { val mb = getMethodBind("CPUParticles2D","get_fixed_fps") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_fixed_fps") _icall_Unit_Long(mb, this.ptr, value) } open var flagAlignY: Boolean get() { val mb = getMethodBind("CPUParticles2D","get_particle_flag") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("CPUParticles2D","set_particle_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open var fractDelta: Boolean get() { val mb = getMethodBind("CPUParticles2D","get_fractional_delta") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_fractional_delta") _icall_Unit_Boolean(mb, this.ptr, value) } open var gravity: Vector2 get() { val mb = getMethodBind("CPUParticles2D","get_gravity") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_gravity") _icall_Unit_Vector2(mb, this.ptr, value) } open var hueVariation: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var hueVariationCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 9, value) } open var hueVariationRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var initialVelocity: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var initialVelocityRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var lifetime: Double get() { val mb = getMethodBind("CPUParticles2D","get_lifetime") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_lifetime") _icall_Unit_Double(mb, this.ptr, value) } open var lifetimeRandomness: Double get() { val mb = getMethodBind("CPUParticles2D","get_lifetime_randomness") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_lifetime_randomness") _icall_Unit_Double(mb, this.ptr, value) } open var linearAccel: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var linearAccelCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 3, value) } open var linearAccelRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var localCoords: Boolean get() { val mb = getMethodBind("CPUParticles2D","get_use_local_coordinates") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_use_local_coordinates") _icall_Unit_Boolean(mb, this.ptr, value) } open var normalmap: Texture get() { val mb = getMethodBind("CPUParticles2D","get_normalmap") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_normalmap") _icall_Unit_Object(mb, this.ptr, value) } open var oneShot: Boolean get() { val mb = getMethodBind("CPUParticles2D","get_one_shot") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_one_shot") _icall_Unit_Boolean(mb, this.ptr, value) } open var orbitVelocity: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var orbitVelocityCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 2, value) } open var orbitVelocityRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var preprocess: Double get() { val mb = getMethodBind("CPUParticles2D","get_pre_process_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_pre_process_time") _icall_Unit_Double(mb, this.ptr, value) } open var radialAccel: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var radialAccelCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 4, value) } open var radialAccelRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var randomness: Double get() { val mb = getMethodBind("CPUParticles2D","get_randomness_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_randomness_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var scaleAmount: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var scaleAmountCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 8, value) } open var scaleAmountRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var speedScale: Double get() { val mb = getMethodBind("CPUParticles2D","get_speed_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_speed_scale") _icall_Unit_Double(mb, this.ptr, value) } open var spread: Double get() { val mb = getMethodBind("CPUParticles2D","get_spread") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_spread") _icall_Unit_Double(mb, this.ptr, value) } open var tangentialAccel: Double get() { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var tangentialAccelCurve: Curve get() { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object(mb, this.ptr, 5, value) } open var tangentialAccelRandom: Double get() { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var texture: Texture get() { val mb = getMethodBind("CPUParticles2D","get_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("CPUParticles2D","set_texture") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CPUParticles2D", "CPUParticles2D") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun direction(schedule: Vector2.() -> Unit): Vector2 = direction.apply{ schedule(this) direction = this } open fun emissionRectExtents(schedule: Vector2.() -> Unit): Vector2 = emissionRectExtents.apply{ schedule(this) emissionRectExtents = this } open fun gravity(schedule: Vector2.() -> Unit): Vector2 = gravity.apply{ schedule(this) gravity = this } open fun _textureChanged() { } open fun _updateRenderThread() { } open fun convertFromParticles(particles: Node) { val mb = getMethodBind("CPUParticles2D","convert_from_particles") _icall_Unit_Object( mb, this.ptr, particles) } open fun getAmount(): Long { val mb = getMethodBind("CPUParticles2D","get_amount") return _icall_Long( mb, this.ptr) } open fun getColor(): Color { val mb = getMethodBind("CPUParticles2D","get_color") return _icall_Color( mb, this.ptr) } open fun getColorRamp(): Gradient { val mb = getMethodBind("CPUParticles2D","get_color_ramp") return _icall_Gradient( mb, this.ptr) } open fun getDirection(): Vector2 { val mb = getMethodBind("CPUParticles2D","get_direction") return _icall_Vector2( mb, this.ptr) } open fun getDrawOrder(): CPUParticles2D.DrawOrder { val mb = getMethodBind("CPUParticles2D","get_draw_order") return CPUParticles2D.DrawOrder.from( _icall_Long( mb, this.ptr)) } open fun getEmissionColors(): PoolColorArray { val mb = getMethodBind("CPUParticles2D","get_emission_colors") return _icall_PoolColorArray( mb, this.ptr) } open fun getEmissionNormals(): PoolVector2Array { val mb = getMethodBind("CPUParticles2D","get_emission_normals") return _icall_PoolVector2Array( mb, this.ptr) } open fun getEmissionPoints(): PoolVector2Array { val mb = getMethodBind("CPUParticles2D","get_emission_points") return _icall_PoolVector2Array( mb, this.ptr) } open fun getEmissionRectExtents(): Vector2 { val mb = getMethodBind("CPUParticles2D","get_emission_rect_extents") return _icall_Vector2( mb, this.ptr) } open fun getEmissionShape(): CPUParticles2D.EmissionShape { val mb = getMethodBind("CPUParticles2D","get_emission_shape") return CPUParticles2D.EmissionShape.from( _icall_Long( mb, this.ptr)) } open fun getEmissionSphereRadius(): Double { val mb = getMethodBind("CPUParticles2D","get_emission_sphere_radius") return _icall_Double( mb, this.ptr) } open fun getExplosivenessRatio(): Double { val mb = getMethodBind("CPUParticles2D","get_explosiveness_ratio") return _icall_Double( mb, this.ptr) } open fun getFixedFps(): Long { val mb = getMethodBind("CPUParticles2D","get_fixed_fps") return _icall_Long( mb, this.ptr) } open fun getFractionalDelta(): Boolean { val mb = getMethodBind("CPUParticles2D","get_fractional_delta") return _icall_Boolean( mb, this.ptr) } open fun getGravity(): Vector2 { val mb = getMethodBind("CPUParticles2D","get_gravity") return _icall_Vector2( mb, this.ptr) } open fun getLifetime(): Double { val mb = getMethodBind("CPUParticles2D","get_lifetime") return _icall_Double( mb, this.ptr) } open fun getLifetimeRandomness(): Double { val mb = getMethodBind("CPUParticles2D","get_lifetime_randomness") return _icall_Double( mb, this.ptr) } open fun getNormalmap(): Texture { val mb = getMethodBind("CPUParticles2D","get_normalmap") return _icall_Texture( mb, this.ptr) } open fun getOneShot(): Boolean { val mb = getMethodBind("CPUParticles2D","get_one_shot") return _icall_Boolean( mb, this.ptr) } open fun getParam(param: Long): Double { val mb = getMethodBind("CPUParticles2D","get_param") return _icall_Double_Long( mb, this.ptr, param) } open fun getParamCurve(param: Long): Curve { val mb = getMethodBind("CPUParticles2D","get_param_curve") return _icall_Curve_Long( mb, this.ptr, param) } open fun getParamRandomness(param: Long): Double { val mb = getMethodBind("CPUParticles2D","get_param_randomness") return _icall_Double_Long( mb, this.ptr, param) } open fun getParticleFlag(flag: Long): Boolean { val mb = getMethodBind("CPUParticles2D","get_particle_flag") return _icall_Boolean_Long( mb, this.ptr, flag) } open fun getPreProcessTime(): Double { val mb = getMethodBind("CPUParticles2D","get_pre_process_time") return _icall_Double( mb, this.ptr) } open fun getRandomnessRatio(): Double { val mb = getMethodBind("CPUParticles2D","get_randomness_ratio") return _icall_Double( mb, this.ptr) } open fun getSpeedScale(): Double { val mb = getMethodBind("CPUParticles2D","get_speed_scale") return _icall_Double( mb, this.ptr) } open fun getSpread(): Double { val mb = getMethodBind("CPUParticles2D","get_spread") return _icall_Double( mb, this.ptr) } open fun getTexture(): Texture { val mb = getMethodBind("CPUParticles2D","get_texture") return _icall_Texture( mb, this.ptr) } open fun getUseLocalCoordinates(): Boolean { val mb = getMethodBind("CPUParticles2D","get_use_local_coordinates") return _icall_Boolean( mb, this.ptr) } open fun isEmitting(): Boolean { val mb = getMethodBind("CPUParticles2D","is_emitting") return _icall_Boolean( mb, this.ptr) } open fun restart() { val mb = getMethodBind("CPUParticles2D","restart") _icall_Unit( mb, this.ptr) } open fun setAmount(amount: Long) { val mb = getMethodBind("CPUParticles2D","set_amount") _icall_Unit_Long( mb, this.ptr, amount) } open fun setColor(color: Color) { val mb = getMethodBind("CPUParticles2D","set_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setColorRamp(ramp: Gradient) { val mb = getMethodBind("CPUParticles2D","set_color_ramp") _icall_Unit_Object( mb, this.ptr, ramp) } open fun setDirection(direction: Vector2) { val mb = getMethodBind("CPUParticles2D","set_direction") _icall_Unit_Vector2( mb, this.ptr, direction) } open fun setDrawOrder(order: Long) { val mb = getMethodBind("CPUParticles2D","set_draw_order") _icall_Unit_Long( mb, this.ptr, order) } open fun setEmissionColors(array: PoolColorArray) { val mb = getMethodBind("CPUParticles2D","set_emission_colors") _icall_Unit_PoolColorArray( mb, this.ptr, array) } open fun setEmissionNormals(array: PoolVector2Array) { val mb = getMethodBind("CPUParticles2D","set_emission_normals") _icall_Unit_PoolVector2Array( mb, this.ptr, array) } open fun setEmissionPoints(array: PoolVector2Array) { val mb = getMethodBind("CPUParticles2D","set_emission_points") _icall_Unit_PoolVector2Array( mb, this.ptr, array) } open fun setEmissionRectExtents(extents: Vector2) { val mb = getMethodBind("CPUParticles2D","set_emission_rect_extents") _icall_Unit_Vector2( mb, this.ptr, extents) } open fun setEmissionShape(shape: Long) { val mb = getMethodBind("CPUParticles2D","set_emission_shape") _icall_Unit_Long( mb, this.ptr, shape) } open fun setEmissionSphereRadius(radius: Double) { val mb = getMethodBind("CPUParticles2D","set_emission_sphere_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setEmitting(emitting: Boolean) { val mb = getMethodBind("CPUParticles2D","set_emitting") _icall_Unit_Boolean( mb, this.ptr, emitting) } open fun setExplosivenessRatio(ratio: Double) { val mb = getMethodBind("CPUParticles2D","set_explosiveness_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setFixedFps(fps: Long) { val mb = getMethodBind("CPUParticles2D","set_fixed_fps") _icall_Unit_Long( mb, this.ptr, fps) } open fun setFractionalDelta(enable: Boolean) { val mb = getMethodBind("CPUParticles2D","set_fractional_delta") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setGravity(accelVec: Vector2) { val mb = getMethodBind("CPUParticles2D","set_gravity") _icall_Unit_Vector2( mb, this.ptr, accelVec) } open fun setLifetime(secs: Double) { val mb = getMethodBind("CPUParticles2D","set_lifetime") _icall_Unit_Double( mb, this.ptr, secs) } open fun setLifetimeRandomness(random: Double) { val mb = getMethodBind("CPUParticles2D","set_lifetime_randomness") _icall_Unit_Double( mb, this.ptr, random) } open fun setNormalmap(normalmap: Texture) { val mb = getMethodBind("CPUParticles2D","set_normalmap") _icall_Unit_Object( mb, this.ptr, normalmap) } open fun setOneShot(enable: Boolean) { val mb = getMethodBind("CPUParticles2D","set_one_shot") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setParam(param: Long, value: Double) { val mb = getMethodBind("CPUParticles2D","set_param") _icall_Unit_Long_Double( mb, this.ptr, param, value) } open fun setParamCurve(param: Long, curve: Curve) { val mb = getMethodBind("CPUParticles2D","set_param_curve") _icall_Unit_Long_Object( mb, this.ptr, param, curve) } open fun setParamRandomness(param: Long, randomness: Double) { val mb = getMethodBind("CPUParticles2D","set_param_randomness") _icall_Unit_Long_Double( mb, this.ptr, param, randomness) } open fun setParticleFlag(flag: Long, enable: Boolean) { val mb = getMethodBind("CPUParticles2D","set_particle_flag") _icall_Unit_Long_Boolean( mb, this.ptr, flag, enable) } open fun setPreProcessTime(secs: Double) { val mb = getMethodBind("CPUParticles2D","set_pre_process_time") _icall_Unit_Double( mb, this.ptr, secs) } open fun setRandomnessRatio(ratio: Double) { val mb = getMethodBind("CPUParticles2D","set_randomness_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setSpeedScale(scale: Double) { val mb = getMethodBind("CPUParticles2D","set_speed_scale") _icall_Unit_Double( mb, this.ptr, scale) } open fun setSpread(degrees: Double) { val mb = getMethodBind("CPUParticles2D","set_spread") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setTexture(texture: Texture) { val mb = getMethodBind("CPUParticles2D","set_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setUseLocalCoordinates(enable: Boolean) { val mb = getMethodBind("CPUParticles2D","set_use_local_coordinates") _icall_Unit_Boolean( mb, this.ptr, enable) } enum class Flags( id: Long ) { FLAG_ALIGN_Y_TO_VELOCITY(0), FLAG_ROTATE_Y(1), FLAG_DISABLE_Z(2), FLAG_MAX(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class EmissionShape( id: Long ) { EMISSION_SHAPE_POINT(0), EMISSION_SHAPE_SPHERE(1), EMISSION_SHAPE_RECTANGLE(2), EMISSION_SHAPE_POINTS(3), EMISSION_SHAPE_DIRECTED_POINTS(4), EMISSION_SHAPE_MAX(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Parameter( id: Long ) { PARAM_INITIAL_LINEAR_VELOCITY(0), PARAM_ANGULAR_VELOCITY(1), PARAM_ORBIT_VELOCITY(2), PARAM_LINEAR_ACCEL(3), PARAM_RADIAL_ACCEL(4), PARAM_TANGENTIAL_ACCEL(5), PARAM_DAMPING(6), PARAM_ANGLE(7), PARAM_SCALE(8), PARAM_HUE_VARIATION(9), PARAM_ANIM_SPEED(10), PARAM_ANIM_OFFSET(11), PARAM_MAX(12); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class DrawOrder( id: Long ) { DRAW_ORDER_INDEX(0), DRAW_ORDER_LIFETIME(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CSGBox.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Material import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class CSGBox : CSGPrimitive() { open var depth: Double get() { val mb = getMethodBind("CSGBox","get_depth") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGBox","set_depth") _icall_Unit_Double(mb, this.ptr, value) } open var height: Double get() { val mb = getMethodBind("CSGBox","get_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGBox","set_height") _icall_Unit_Double(mb, this.ptr, value) } open var material: Material get() { val mb = getMethodBind("CSGBox","get_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGBox","set_material") _icall_Unit_Object(mb, this.ptr, value) } open var width: Double get() { val mb = getMethodBind("CSGBox","get_width") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGBox","set_width") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CSGBox", "CSGBox") open fun getDepth(): Double { val mb = getMethodBind("CSGBox","get_depth") return _icall_Double( mb, this.ptr) } open fun getHeight(): Double { val mb = getMethodBind("CSGBox","get_height") return _icall_Double( mb, this.ptr) } open fun getMaterial(): Material { val mb = getMethodBind("CSGBox","get_material") return _icall_Material( mb, this.ptr) } open fun getWidth(): Double { val mb = getMethodBind("CSGBox","get_width") return _icall_Double( mb, this.ptr) } open fun setDepth(depth: Double) { val mb = getMethodBind("CSGBox","set_depth") _icall_Unit_Double( mb, this.ptr, depth) } open fun setHeight(height: Double) { val mb = getMethodBind("CSGBox","set_height") _icall_Unit_Double( mb, this.ptr, height) } open fun setMaterial(material: Material) { val mb = getMethodBind("CSGBox","set_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setWidth(width: Double) { val mb = getMethodBind("CSGBox","set_width") _icall_Unit_Double( mb, this.ptr, width) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CSGCombiner.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class CSGCombiner : CSGShape() { override fun __new(): COpaquePointer = invokeConstructor("CSGCombiner", "CSGCombiner") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CSGCylinder.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Material import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class CSGCylinder : CSGPrimitive() { open var cone: Boolean get() { val mb = getMethodBind("CSGCylinder","is_cone") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGCylinder","set_cone") _icall_Unit_Boolean(mb, this.ptr, value) } open var height: Double get() { val mb = getMethodBind("CSGCylinder","get_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGCylinder","set_height") _icall_Unit_Double(mb, this.ptr, value) } open var material: Material get() { val mb = getMethodBind("CSGCylinder","get_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGCylinder","set_material") _icall_Unit_Object(mb, this.ptr, value) } open var radius: Double get() { val mb = getMethodBind("CSGCylinder","get_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGCylinder","set_radius") _icall_Unit_Double(mb, this.ptr, value) } open var sides: Long get() { val mb = getMethodBind("CSGCylinder","get_sides") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGCylinder","set_sides") _icall_Unit_Long(mb, this.ptr, value) } open var smoothFaces: Boolean get() { val mb = getMethodBind("CSGCylinder","get_smooth_faces") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGCylinder","set_smooth_faces") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CSGCylinder", "CSGCylinder") open fun getHeight(): Double { val mb = getMethodBind("CSGCylinder","get_height") return _icall_Double( mb, this.ptr) } open fun getMaterial(): Material { val mb = getMethodBind("CSGCylinder","get_material") return _icall_Material( mb, this.ptr) } open fun getRadius(): Double { val mb = getMethodBind("CSGCylinder","get_radius") return _icall_Double( mb, this.ptr) } open fun getSides(): Long { val mb = getMethodBind("CSGCylinder","get_sides") return _icall_Long( mb, this.ptr) } open fun getSmoothFaces(): Boolean { val mb = getMethodBind("CSGCylinder","get_smooth_faces") return _icall_Boolean( mb, this.ptr) } open fun isCone(): Boolean { val mb = getMethodBind("CSGCylinder","is_cone") return _icall_Boolean( mb, this.ptr) } open fun setCone(cone: Boolean) { val mb = getMethodBind("CSGCylinder","set_cone") _icall_Unit_Boolean( mb, this.ptr, cone) } open fun setHeight(height: Double) { val mb = getMethodBind("CSGCylinder","set_height") _icall_Unit_Double( mb, this.ptr, height) } open fun setMaterial(material: Material) { val mb = getMethodBind("CSGCylinder","set_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setRadius(radius: Double) { val mb = getMethodBind("CSGCylinder","set_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setSides(sides: Long) { val mb = getMethodBind("CSGCylinder","set_sides") _icall_Unit_Long( mb, this.ptr, sides) } open fun setSmoothFaces(smoothFaces: Boolean) { val mb = getMethodBind("CSGCylinder","set_smooth_faces") _icall_Unit_Boolean( mb, this.ptr, smoothFaces) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CSGMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Material import godot.icalls._icall_Mesh import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class CSGMesh : CSGPrimitive() { open var material: Material get() { val mb = getMethodBind("CSGMesh","get_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGMesh","set_material") _icall_Unit_Object(mb, this.ptr, value) } open var mesh: Mesh get() { val mb = getMethodBind("CSGMesh","get_mesh") return _icall_Mesh(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGMesh","set_mesh") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CSGMesh", "CSGMesh") open fun _meshChanged() { } open fun getMaterial(): Material { val mb = getMethodBind("CSGMesh","get_material") return _icall_Material( mb, this.ptr) } open fun getMesh(): Mesh { val mb = getMethodBind("CSGMesh","get_mesh") return _icall_Mesh( mb, this.ptr) } open fun setMaterial(material: Material) { val mb = getMethodBind("CSGMesh","set_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setMesh(mesh: Mesh) { val mb = getMethodBind("CSGMesh","set_mesh") _icall_Unit_Object( mb, this.ptr, mesh) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CSGPolygon.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.CSGPolygon import godot.core.NodePath import godot.core.PoolVector2Array import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Material import godot.icalls._icall_NodePath import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_NodePath import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_PoolVector2Array import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class CSGPolygon : CSGPrimitive() { open var depth: Double get() { val mb = getMethodBind("CSGPolygon","get_depth") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_depth") _icall_Unit_Double(mb, this.ptr, value) } open var material: Material get() { val mb = getMethodBind("CSGPolygon","get_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_material") _icall_Unit_Object(mb, this.ptr, value) } open var mode: Long get() { val mb = getMethodBind("CSGPolygon","get_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_mode") _icall_Unit_Long(mb, this.ptr, value) } open var pathContinuousU: Boolean get() { val mb = getMethodBind("CSGPolygon","is_path_continuous_u") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_path_continuous_u") _icall_Unit_Boolean(mb, this.ptr, value) } open var pathInterval: Double get() { val mb = getMethodBind("CSGPolygon","get_path_interval") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_path_interval") _icall_Unit_Double(mb, this.ptr, value) } open var pathJoined: Boolean get() { val mb = getMethodBind("CSGPolygon","is_path_joined") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_path_joined") _icall_Unit_Boolean(mb, this.ptr, value) } open var pathLocal: Boolean get() { val mb = getMethodBind("CSGPolygon","is_path_local") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_path_local") _icall_Unit_Boolean(mb, this.ptr, value) } open var pathNode: NodePath get() { val mb = getMethodBind("CSGPolygon","get_path_node") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_path_node") _icall_Unit_NodePath(mb, this.ptr, value) } open var pathRotation: Long get() { val mb = getMethodBind("CSGPolygon","get_path_rotation") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_path_rotation") _icall_Unit_Long(mb, this.ptr, value) } open var polygon: PoolVector2Array get() { val mb = getMethodBind("CSGPolygon","get_polygon") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_polygon") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } open var smoothFaces: Boolean get() { val mb = getMethodBind("CSGPolygon","get_smooth_faces") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_smooth_faces") _icall_Unit_Boolean(mb, this.ptr, value) } open var spinDegrees: Double get() { val mb = getMethodBind("CSGPolygon","get_spin_degrees") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_spin_degrees") _icall_Unit_Double(mb, this.ptr, value) } open var spinSides: Long get() { val mb = getMethodBind("CSGPolygon","get_spin_sides") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPolygon","set_spin_sides") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CSGPolygon", "CSGPolygon") open fun _hasEditable3dPolygonNoDepth(): Boolean { throw NotImplementedError("_has_editable_3d_polygon_no_depth is not implemented for CSGPolygon") } open fun _isEditable3dPolygon(): Boolean { throw NotImplementedError("_is_editable_3d_polygon is not implemented for CSGPolygon") } open fun _pathChanged() { } open fun _pathExited() { } open fun getDepth(): Double { val mb = getMethodBind("CSGPolygon","get_depth") return _icall_Double( mb, this.ptr) } open fun getMaterial(): Material { val mb = getMethodBind("CSGPolygon","get_material") return _icall_Material( mb, this.ptr) } open fun getMode(): CSGPolygon.Mode { val mb = getMethodBind("CSGPolygon","get_mode") return CSGPolygon.Mode.from( _icall_Long( mb, this.ptr)) } open fun getPathInterval(): Double { val mb = getMethodBind("CSGPolygon","get_path_interval") return _icall_Double( mb, this.ptr) } open fun getPathNode(): NodePath { val mb = getMethodBind("CSGPolygon","get_path_node") return _icall_NodePath( mb, this.ptr) } open fun getPathRotation(): CSGPolygon.PathRotation { val mb = getMethodBind("CSGPolygon","get_path_rotation") return CSGPolygon.PathRotation.from( _icall_Long( mb, this.ptr)) } open fun getPolygon(): PoolVector2Array { val mb = getMethodBind("CSGPolygon","get_polygon") return _icall_PoolVector2Array( mb, this.ptr) } open fun getSmoothFaces(): Boolean { val mb = getMethodBind("CSGPolygon","get_smooth_faces") return _icall_Boolean( mb, this.ptr) } open fun getSpinDegrees(): Double { val mb = getMethodBind("CSGPolygon","get_spin_degrees") return _icall_Double( mb, this.ptr) } open fun getSpinSides(): Long { val mb = getMethodBind("CSGPolygon","get_spin_sides") return _icall_Long( mb, this.ptr) } open fun isPathContinuousU(): Boolean { val mb = getMethodBind("CSGPolygon","is_path_continuous_u") return _icall_Boolean( mb, this.ptr) } open fun isPathJoined(): Boolean { val mb = getMethodBind("CSGPolygon","is_path_joined") return _icall_Boolean( mb, this.ptr) } open fun isPathLocal(): Boolean { val mb = getMethodBind("CSGPolygon","is_path_local") return _icall_Boolean( mb, this.ptr) } open fun setDepth(depth: Double) { val mb = getMethodBind("CSGPolygon","set_depth") _icall_Unit_Double( mb, this.ptr, depth) } open fun setMaterial(material: Material) { val mb = getMethodBind("CSGPolygon","set_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setMode(mode: Long) { val mb = getMethodBind("CSGPolygon","set_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setPathContinuousU(enable: Boolean) { val mb = getMethodBind("CSGPolygon","set_path_continuous_u") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setPathInterval(distance: Double) { val mb = getMethodBind("CSGPolygon","set_path_interval") _icall_Unit_Double( mb, this.ptr, distance) } open fun setPathJoined(enable: Boolean) { val mb = getMethodBind("CSGPolygon","set_path_joined") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setPathLocal(enable: Boolean) { val mb = getMethodBind("CSGPolygon","set_path_local") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setPathNode(path: NodePath) { val mb = getMethodBind("CSGPolygon","set_path_node") _icall_Unit_NodePath( mb, this.ptr, path) } open fun setPathRotation(mode: Long) { val mb = getMethodBind("CSGPolygon","set_path_rotation") _icall_Unit_Long( mb, this.ptr, mode) } open fun setPolygon(polygon: PoolVector2Array) { val mb = getMethodBind("CSGPolygon","set_polygon") _icall_Unit_PoolVector2Array( mb, this.ptr, polygon) } open fun setSmoothFaces(smoothFaces: Boolean) { val mb = getMethodBind("CSGPolygon","set_smooth_faces") _icall_Unit_Boolean( mb, this.ptr, smoothFaces) } open fun setSpinDegrees(degrees: Double) { val mb = getMethodBind("CSGPolygon","set_spin_degrees") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setSpinSides(spinSides: Long) { val mb = getMethodBind("CSGPolygon","set_spin_sides") _icall_Unit_Long( mb, this.ptr, spinSides) } enum class PathRotation( id: Long ) { PATH_ROTATION_POLYGON(0), PATH_ROTATION_PATH(1), PATH_ROTATION_PATH_FOLLOW(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Mode( id: Long ) { MODE_DEPTH(0), MODE_SPIN(1), MODE_PATH(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CSGPrimitive.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import kotlin.Boolean open class CSGPrimitive internal constructor() : CSGShape() { open var invertFaces: Boolean get() { val mb = getMethodBind("CSGPrimitive","is_inverting_faces") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGPrimitive","set_invert_faces") _icall_Unit_Boolean(mb, this.ptr, value) } open fun isInvertingFaces(): Boolean { val mb = getMethodBind("CSGPrimitive","is_inverting_faces") return _icall_Boolean( mb, this.ptr) } open fun setInvertFaces(invertFaces: Boolean) { val mb = getMethodBind("CSGPrimitive","set_invert_faces") _icall_Unit_Boolean( mb, this.ptr, invertFaces) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CSGShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.CSGShape import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long open class CSGShape internal constructor() : GeometryInstance() { open var calculateTangents: Boolean get() { val mb = getMethodBind("CSGShape","is_calculating_tangents") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGShape","set_calculate_tangents") _icall_Unit_Boolean(mb, this.ptr, value) } open var collisionLayer: Long get() { val mb = getMethodBind("CSGShape","get_collision_layer") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGShape","set_collision_layer") _icall_Unit_Long(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("CSGShape","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGShape","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open var operation: Long get() { val mb = getMethodBind("CSGShape","get_operation") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGShape","set_operation") _icall_Unit_Long(mb, this.ptr, value) } open var snap: Double get() { val mb = getMethodBind("CSGShape","get_snap") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGShape","set_snap") _icall_Unit_Double(mb, this.ptr, value) } open var useCollision: Boolean get() { val mb = getMethodBind("CSGShape","is_using_collision") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGShape","set_use_collision") _icall_Unit_Boolean(mb, this.ptr, value) } open fun _updateShape() { } open fun getCollisionLayer(): Long { val mb = getMethodBind("CSGShape","get_collision_layer") return _icall_Long( mb, this.ptr) } open fun getCollisionLayerBit(bit: Long): Boolean { val mb = getMethodBind("CSGShape","get_collision_layer_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getCollisionMask(): Long { val mb = getMethodBind("CSGShape","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("CSGShape","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getMeshes(): VariantArray { val mb = getMethodBind("CSGShape","get_meshes") return _icall_VariantArray( mb, this.ptr) } open fun getOperation(): CSGShape.Operation { val mb = getMethodBind("CSGShape","get_operation") return CSGShape.Operation.from( _icall_Long( mb, this.ptr)) } open fun getSnap(): Double { val mb = getMethodBind("CSGShape","get_snap") return _icall_Double( mb, this.ptr) } open fun isCalculatingTangents(): Boolean { val mb = getMethodBind("CSGShape","is_calculating_tangents") return _icall_Boolean( mb, this.ptr) } open fun isRootShape(): Boolean { val mb = getMethodBind("CSGShape","is_root_shape") return _icall_Boolean( mb, this.ptr) } open fun isUsingCollision(): Boolean { val mb = getMethodBind("CSGShape","is_using_collision") return _icall_Boolean( mb, this.ptr) } open fun setCalculateTangents(enabled: Boolean) { val mb = getMethodBind("CSGShape","set_calculate_tangents") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setCollisionLayer(layer: Long) { val mb = getMethodBind("CSGShape","set_collision_layer") _icall_Unit_Long( mb, this.ptr, layer) } open fun setCollisionLayerBit(bit: Long, value: Boolean) { val mb = getMethodBind("CSGShape","set_collision_layer_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setCollisionMask(mask: Long) { val mb = getMethodBind("CSGShape","set_collision_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("CSGShape","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setOperation(operation: Long) { val mb = getMethodBind("CSGShape","set_operation") _icall_Unit_Long( mb, this.ptr, operation) } open fun setSnap(snap: Double) { val mb = getMethodBind("CSGShape","set_snap") _icall_Unit_Double( mb, this.ptr, snap) } open fun setUseCollision(operation: Boolean) { val mb = getMethodBind("CSGShape","set_use_collision") _icall_Unit_Boolean( mb, this.ptr, operation) } enum class Operation( id: Long ) { OPERATION_UNION(0), OPERATION_INTERSECTION(1), OPERATION_SUBTRACTION(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CSGSphere.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Material import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class CSGSphere : CSGPrimitive() { open var material: Material get() { val mb = getMethodBind("CSGSphere","get_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGSphere","set_material") _icall_Unit_Object(mb, this.ptr, value) } open var radialSegments: Long get() { val mb = getMethodBind("CSGSphere","get_radial_segments") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGSphere","set_radial_segments") _icall_Unit_Long(mb, this.ptr, value) } open var radius: Double get() { val mb = getMethodBind("CSGSphere","get_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGSphere","set_radius") _icall_Unit_Double(mb, this.ptr, value) } open var rings: Long get() { val mb = getMethodBind("CSGSphere","get_rings") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGSphere","set_rings") _icall_Unit_Long(mb, this.ptr, value) } open var smoothFaces: Boolean get() { val mb = getMethodBind("CSGSphere","get_smooth_faces") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGSphere","set_smooth_faces") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CSGSphere", "CSGSphere") open fun getMaterial(): Material { val mb = getMethodBind("CSGSphere","get_material") return _icall_Material( mb, this.ptr) } open fun getRadialSegments(): Long { val mb = getMethodBind("CSGSphere","get_radial_segments") return _icall_Long( mb, this.ptr) } open fun getRadius(): Double { val mb = getMethodBind("CSGSphere","get_radius") return _icall_Double( mb, this.ptr) } open fun getRings(): Long { val mb = getMethodBind("CSGSphere","get_rings") return _icall_Long( mb, this.ptr) } open fun getSmoothFaces(): Boolean { val mb = getMethodBind("CSGSphere","get_smooth_faces") return _icall_Boolean( mb, this.ptr) } open fun setMaterial(material: Material) { val mb = getMethodBind("CSGSphere","set_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setRadialSegments(radialSegments: Long) { val mb = getMethodBind("CSGSphere","set_radial_segments") _icall_Unit_Long( mb, this.ptr, radialSegments) } open fun setRadius(radius: Double) { val mb = getMethodBind("CSGSphere","set_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setRings(rings: Long) { val mb = getMethodBind("CSGSphere","set_rings") _icall_Unit_Long( mb, this.ptr, rings) } open fun setSmoothFaces(smoothFaces: Boolean) { val mb = getMethodBind("CSGSphere","set_smooth_faces") _icall_Unit_Boolean( mb, this.ptr, smoothFaces) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CSGTorus.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Material import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class CSGTorus : CSGPrimitive() { open var innerRadius: Double get() { val mb = getMethodBind("CSGTorus","get_inner_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGTorus","set_inner_radius") _icall_Unit_Double(mb, this.ptr, value) } open var material: Material get() { val mb = getMethodBind("CSGTorus","get_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGTorus","set_material") _icall_Unit_Object(mb, this.ptr, value) } open var outerRadius: Double get() { val mb = getMethodBind("CSGTorus","get_outer_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGTorus","set_outer_radius") _icall_Unit_Double(mb, this.ptr, value) } open var ringSides: Long get() { val mb = getMethodBind("CSGTorus","get_ring_sides") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGTorus","set_ring_sides") _icall_Unit_Long(mb, this.ptr, value) } open var sides: Long get() { val mb = getMethodBind("CSGTorus","get_sides") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGTorus","set_sides") _icall_Unit_Long(mb, this.ptr, value) } open var smoothFaces: Boolean get() { val mb = getMethodBind("CSGTorus","get_smooth_faces") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CSGTorus","set_smooth_faces") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CSGTorus", "CSGTorus") open fun getInnerRadius(): Double { val mb = getMethodBind("CSGTorus","get_inner_radius") return _icall_Double( mb, this.ptr) } open fun getMaterial(): Material { val mb = getMethodBind("CSGTorus","get_material") return _icall_Material( mb, this.ptr) } open fun getOuterRadius(): Double { val mb = getMethodBind("CSGTorus","get_outer_radius") return _icall_Double( mb, this.ptr) } open fun getRingSides(): Long { val mb = getMethodBind("CSGTorus","get_ring_sides") return _icall_Long( mb, this.ptr) } open fun getSides(): Long { val mb = getMethodBind("CSGTorus","get_sides") return _icall_Long( mb, this.ptr) } open fun getSmoothFaces(): Boolean { val mb = getMethodBind("CSGTorus","get_smooth_faces") return _icall_Boolean( mb, this.ptr) } open fun setInnerRadius(radius: Double) { val mb = getMethodBind("CSGTorus","set_inner_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setMaterial(material: Material) { val mb = getMethodBind("CSGTorus","set_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setOuterRadius(radius: Double) { val mb = getMethodBind("CSGTorus","set_outer_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setRingSides(sides: Long) { val mb = getMethodBind("CSGTorus","set_ring_sides") _icall_Unit_Long( mb, this.ptr, sides) } open fun setSides(sides: Long) { val mb = getMethodBind("CSGTorus","set_sides") _icall_Unit_Long( mb, this.ptr, sides) } open fun setSmoothFaces(smoothFaces: Boolean) { val mb = getMethodBind("CSGTorus","set_smooth_faces") _icall_Unit_Boolean( mb, this.ptr, smoothFaces) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Camera.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Camera import godot.core.RID import godot.core.Transform import godot.core.VariantArray import godot.core.Vector2 import godot.core.Vector3 import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_Vector3 import godot.icalls._icall_Double import godot.icalls._icall_Environment import godot.icalls._icall_Long import godot.icalls._icall_RID import godot.icalls._icall_Transform import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Double_Double_Double import godot.icalls._icall_Unit_Double_Vector2_Double_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_Vector3 import godot.icalls._icall_Vector3_Vector2 import godot.icalls._icall_Vector3_Vector2_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Camera : Spatial() { open var cullMask: Long get() { val mb = getMethodBind("Camera","get_cull_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_cull_mask") _icall_Unit_Long(mb, this.ptr, value) } open var current: Boolean get() { val mb = getMethodBind("Camera","is_current") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_current") _icall_Unit_Boolean(mb, this.ptr, value) } open var dopplerTracking: Long get() { val mb = getMethodBind("Camera","get_doppler_tracking") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_doppler_tracking") _icall_Unit_Long(mb, this.ptr, value) } open var environment: Environment get() { val mb = getMethodBind("Camera","get_environment") return _icall_Environment(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_environment") _icall_Unit_Object(mb, this.ptr, value) } open var far: Double get() { val mb = getMethodBind("Camera","get_zfar") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_zfar") _icall_Unit_Double(mb, this.ptr, value) } open var fov: Double get() { val mb = getMethodBind("Camera","get_fov") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_fov") _icall_Unit_Double(mb, this.ptr, value) } open var frustumOffset: Vector2 get() { val mb = getMethodBind("Camera","get_frustum_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_frustum_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var hOffset: Double get() { val mb = getMethodBind("Camera","get_h_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_h_offset") _icall_Unit_Double(mb, this.ptr, value) } open var keepAspect: Long get() { val mb = getMethodBind("Camera","get_keep_aspect_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_keep_aspect_mode") _icall_Unit_Long(mb, this.ptr, value) } open var near: Double get() { val mb = getMethodBind("Camera","get_znear") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_znear") _icall_Unit_Double(mb, this.ptr, value) } open var projection: Long get() { val mb = getMethodBind("Camera","get_projection") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_projection") _icall_Unit_Long(mb, this.ptr, value) } open var size: Double get() { val mb = getMethodBind("Camera","get_size") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_size") _icall_Unit_Double(mb, this.ptr, value) } open var vOffset: Double get() { val mb = getMethodBind("Camera","get_v_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera","set_v_offset") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Camera", "Camera") open fun frustumOffset(schedule: Vector2.() -> Unit): Vector2 = frustumOffset.apply{ schedule(this) frustumOffset = this } open fun clearCurrent(enableNext: Boolean = true) { val mb = getMethodBind("Camera","clear_current") _icall_Unit_Boolean( mb, this.ptr, enableNext) } open fun getCameraRid(): RID { val mb = getMethodBind("Camera","get_camera_rid") return _icall_RID( mb, this.ptr) } open fun getCameraTransform(): Transform { val mb = getMethodBind("Camera","get_camera_transform") return _icall_Transform( mb, this.ptr) } open fun getCullMask(): Long { val mb = getMethodBind("Camera","get_cull_mask") return _icall_Long( mb, this.ptr) } open fun getCullMaskBit(layer: Long): Boolean { val mb = getMethodBind("Camera","get_cull_mask_bit") return _icall_Boolean_Long( mb, this.ptr, layer) } open fun getDopplerTracking(): Camera.DopplerTracking { val mb = getMethodBind("Camera","get_doppler_tracking") return Camera.DopplerTracking.from( _icall_Long( mb, this.ptr)) } open fun getEnvironment(): Environment { val mb = getMethodBind("Camera","get_environment") return _icall_Environment( mb, this.ptr) } open fun getFov(): Double { val mb = getMethodBind("Camera","get_fov") return _icall_Double( mb, this.ptr) } open fun getFrustum(): VariantArray { val mb = getMethodBind("Camera","get_frustum") return _icall_VariantArray( mb, this.ptr) } open fun getFrustumOffset(): Vector2 { val mb = getMethodBind("Camera","get_frustum_offset") return _icall_Vector2( mb, this.ptr) } open fun getHOffset(): Double { val mb = getMethodBind("Camera","get_h_offset") return _icall_Double( mb, this.ptr) } open fun getKeepAspectMode(): Camera.KeepAspect { val mb = getMethodBind("Camera","get_keep_aspect_mode") return Camera.KeepAspect.from( _icall_Long( mb, this.ptr)) } open fun getProjection(): Camera.Projection { val mb = getMethodBind("Camera","get_projection") return Camera.Projection.from( _icall_Long( mb, this.ptr)) } open fun getSize(): Double { val mb = getMethodBind("Camera","get_size") return _icall_Double( mb, this.ptr) } open fun getVOffset(): Double { val mb = getMethodBind("Camera","get_v_offset") return _icall_Double( mb, this.ptr) } open fun getZfar(): Double { val mb = getMethodBind("Camera","get_zfar") return _icall_Double( mb, this.ptr) } open fun getZnear(): Double { val mb = getMethodBind("Camera","get_znear") return _icall_Double( mb, this.ptr) } open fun isCurrent(): Boolean { val mb = getMethodBind("Camera","is_current") return _icall_Boolean( mb, this.ptr) } open fun isPositionBehind(worldPoint: Vector3): Boolean { val mb = getMethodBind("Camera","is_position_behind") return _icall_Boolean_Vector3( mb, this.ptr, worldPoint) } open fun makeCurrent() { val mb = getMethodBind("Camera","make_current") _icall_Unit( mb, this.ptr) } open fun projectLocalRayNormal(screenPoint: Vector2): Vector3 { val mb = getMethodBind("Camera","project_local_ray_normal") return _icall_Vector3_Vector2( mb, this.ptr, screenPoint) } open fun projectPosition(screenPoint: Vector2, zDepth: Double): Vector3 { val mb = getMethodBind("Camera","project_position") return _icall_Vector3_Vector2_Double( mb, this.ptr, screenPoint, zDepth) } open fun projectRayNormal(screenPoint: Vector2): Vector3 { val mb = getMethodBind("Camera","project_ray_normal") return _icall_Vector3_Vector2( mb, this.ptr, screenPoint) } open fun projectRayOrigin(screenPoint: Vector2): Vector3 { val mb = getMethodBind("Camera","project_ray_origin") return _icall_Vector3_Vector2( mb, this.ptr, screenPoint) } open fun setCullMask(mask: Long) { val mb = getMethodBind("Camera","set_cull_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setCullMaskBit(layer: Long, enable: Boolean) { val mb = getMethodBind("Camera","set_cull_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, layer, enable) } open fun setCurrent(arg0: Boolean) { val mb = getMethodBind("Camera","set_current") _icall_Unit_Boolean( mb, this.ptr, arg0) } open fun setDopplerTracking(mode: Long) { val mb = getMethodBind("Camera","set_doppler_tracking") _icall_Unit_Long( mb, this.ptr, mode) } open fun setEnvironment(env: Environment) { val mb = getMethodBind("Camera","set_environment") _icall_Unit_Object( mb, this.ptr, env) } open fun setFov(arg0: Double) { val mb = getMethodBind("Camera","set_fov") _icall_Unit_Double( mb, this.ptr, arg0) } open fun setFrustum( size: Double, offset: Vector2, zNear: Double, zFar: Double ) { val mb = getMethodBind("Camera","set_frustum") _icall_Unit_Double_Vector2_Double_Double( mb, this.ptr, size, offset, zNear, zFar) } open fun setFrustumOffset(arg0: Vector2) { val mb = getMethodBind("Camera","set_frustum_offset") _icall_Unit_Vector2( mb, this.ptr, arg0) } open fun setHOffset(ofs: Double) { val mb = getMethodBind("Camera","set_h_offset") _icall_Unit_Double( mb, this.ptr, ofs) } open fun setKeepAspectMode(mode: Long) { val mb = getMethodBind("Camera","set_keep_aspect_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setOrthogonal( size: Double, zNear: Double, zFar: Double ) { val mb = getMethodBind("Camera","set_orthogonal") _icall_Unit_Double_Double_Double( mb, this.ptr, size, zNear, zFar) } open fun setPerspective( fov: Double, zNear: Double, zFar: Double ) { val mb = getMethodBind("Camera","set_perspective") _icall_Unit_Double_Double_Double( mb, this.ptr, fov, zNear, zFar) } open fun setProjection(arg0: Long) { val mb = getMethodBind("Camera","set_projection") _icall_Unit_Long( mb, this.ptr, arg0) } open fun setSize(arg0: Double) { val mb = getMethodBind("Camera","set_size") _icall_Unit_Double( mb, this.ptr, arg0) } open fun setVOffset(ofs: Double) { val mb = getMethodBind("Camera","set_v_offset") _icall_Unit_Double( mb, this.ptr, ofs) } open fun setZfar(arg0: Double) { val mb = getMethodBind("Camera","set_zfar") _icall_Unit_Double( mb, this.ptr, arg0) } open fun setZnear(arg0: Double) { val mb = getMethodBind("Camera","set_znear") _icall_Unit_Double( mb, this.ptr, arg0) } open fun unprojectPosition(worldPoint: Vector3): Vector2 { val mb = getMethodBind("Camera","unproject_position") return _icall_Vector2_Vector3( mb, this.ptr, worldPoint) } enum class KeepAspect( id: Long ) { KEEP_WIDTH(0), KEEP_HEIGHT(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Projection( id: Long ) { PROJECTION_PERSPECTIVE(0), PROJECTION_ORTHOGONAL(1), PROJECTION_FRUSTUM(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class DopplerTracking( id: Long ) { DOPPLER_TRACKING_DISABLED(0), DOPPLER_TRACKING_IDLE_STEP(1), DOPPLER_TRACKING_PHYSICS_STEP(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Camera2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Camera2D import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Node import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Camera2D : Node2D() { open var anchorMode: Long get() { val mb = getMethodBind("Camera2D","get_anchor_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_anchor_mode") _icall_Unit_Long(mb, this.ptr, value) } open val current: Boolean get() { val mb = getMethodBind("Camera2D","is_current") return _icall_Boolean(mb, this.ptr) } open var customViewport: Node get() { val mb = getMethodBind("Camera2D","get_custom_viewport") return _icall_Node(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_custom_viewport") _icall_Unit_Object(mb, this.ptr, value) } open var dragMarginBottom: Double get() { val mb = getMethodBind("Camera2D","get_drag_margin") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Camera2D","set_drag_margin") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var dragMarginHEnabled: Boolean get() { val mb = getMethodBind("Camera2D","is_h_drag_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_h_drag_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var dragMarginLeft: Double get() { val mb = getMethodBind("Camera2D","get_drag_margin") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Camera2D","set_drag_margin") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var dragMarginRight: Double get() { val mb = getMethodBind("Camera2D","get_drag_margin") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Camera2D","set_drag_margin") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var dragMarginTop: Double get() { val mb = getMethodBind("Camera2D","get_drag_margin") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Camera2D","set_drag_margin") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var dragMarginVEnabled: Boolean get() { val mb = getMethodBind("Camera2D","is_v_drag_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_v_drag_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var editorDrawDragMargin: Boolean get() { val mb = getMethodBind("Camera2D","is_margin_drawing_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_margin_drawing_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var editorDrawLimits: Boolean get() { val mb = getMethodBind("Camera2D","is_limit_drawing_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_limit_drawing_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var editorDrawScreen: Boolean get() { val mb = getMethodBind("Camera2D","is_screen_drawing_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_screen_drawing_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var limitBottom: Long get() { val mb = getMethodBind("Camera2D","get_limit") return _icall_Long_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Camera2D","set_limit") _icall_Unit_Long_Long(mb, this.ptr, 3, value) } open var limitLeft: Long get() { val mb = getMethodBind("Camera2D","get_limit") return _icall_Long_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Camera2D","set_limit") _icall_Unit_Long_Long(mb, this.ptr, 0, value) } open var limitRight: Long get() { val mb = getMethodBind("Camera2D","get_limit") return _icall_Long_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Camera2D","set_limit") _icall_Unit_Long_Long(mb, this.ptr, 2, value) } open var limitSmoothed: Boolean get() { val mb = getMethodBind("Camera2D","is_limit_smoothing_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_limit_smoothing_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var limitTop: Long get() { val mb = getMethodBind("Camera2D","get_limit") return _icall_Long_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Camera2D","set_limit") _icall_Unit_Long_Long(mb, this.ptr, 1, value) } open var offset: Vector2 get() { val mb = getMethodBind("Camera2D","get_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var offsetH: Double get() { val mb = getMethodBind("Camera2D","get_h_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_h_offset") _icall_Unit_Double(mb, this.ptr, value) } open var offsetV: Double get() { val mb = getMethodBind("Camera2D","get_v_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_v_offset") _icall_Unit_Double(mb, this.ptr, value) } open var processMode: Long get() { val mb = getMethodBind("Camera2D","get_process_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_process_mode") _icall_Unit_Long(mb, this.ptr, value) } open var rotating: Boolean get() { val mb = getMethodBind("Camera2D","is_rotating") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_rotating") _icall_Unit_Boolean(mb, this.ptr, value) } open var smoothingEnabled: Boolean get() { val mb = getMethodBind("Camera2D","is_follow_smoothing_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_enable_follow_smoothing") _icall_Unit_Boolean(mb, this.ptr, value) } open var smoothingSpeed: Double get() { val mb = getMethodBind("Camera2D","get_follow_smoothing") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_follow_smoothing") _icall_Unit_Double(mb, this.ptr, value) } open var zoom: Vector2 get() { val mb = getMethodBind("Camera2D","get_zoom") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Camera2D","set_zoom") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Camera2D", "Camera2D") open fun offset(schedule: Vector2.() -> Unit): Vector2 = offset.apply{ schedule(this) offset = this } open fun zoom(schedule: Vector2.() -> Unit): Vector2 = zoom.apply{ schedule(this) zoom = this } open fun _makeCurrent(arg0: Object) { } open fun _setCurrent(current: Boolean) { } open fun _setOldSmoothing(followSmoothing: Double) { } open fun _updateScroll() { } open fun align() { val mb = getMethodBind("Camera2D","align") _icall_Unit( mb, this.ptr) } open fun clearCurrent() { val mb = getMethodBind("Camera2D","clear_current") _icall_Unit( mb, this.ptr) } open fun forceUpdateScroll() { val mb = getMethodBind("Camera2D","force_update_scroll") _icall_Unit( mb, this.ptr) } open fun getAnchorMode(): Camera2D.AnchorMode { val mb = getMethodBind("Camera2D","get_anchor_mode") return Camera2D.AnchorMode.from( _icall_Long( mb, this.ptr)) } open fun getCameraPosition(): Vector2 { val mb = getMethodBind("Camera2D","get_camera_position") return _icall_Vector2( mb, this.ptr) } open fun getCameraScreenCenter(): Vector2 { val mb = getMethodBind("Camera2D","get_camera_screen_center") return _icall_Vector2( mb, this.ptr) } open fun getCustomViewport(): Node { val mb = getMethodBind("Camera2D","get_custom_viewport") return _icall_Node( mb, this.ptr) } open fun getDragMargin(margin: Long): Double { val mb = getMethodBind("Camera2D","get_drag_margin") return _icall_Double_Long( mb, this.ptr, margin) } open fun getFollowSmoothing(): Double { val mb = getMethodBind("Camera2D","get_follow_smoothing") return _icall_Double( mb, this.ptr) } open fun getHOffset(): Double { val mb = getMethodBind("Camera2D","get_h_offset") return _icall_Double( mb, this.ptr) } open fun getLimit(margin: Long): Long { val mb = getMethodBind("Camera2D","get_limit") return _icall_Long_Long( mb, this.ptr, margin) } open fun getOffset(): Vector2 { val mb = getMethodBind("Camera2D","get_offset") return _icall_Vector2( mb, this.ptr) } open fun getProcessMode(): Camera2D.Camera2DProcessMode { val mb = getMethodBind("Camera2D","get_process_mode") return Camera2D.Camera2DProcessMode.from( _icall_Long( mb, this.ptr)) } open fun getVOffset(): Double { val mb = getMethodBind("Camera2D","get_v_offset") return _icall_Double( mb, this.ptr) } open fun getZoom(): Vector2 { val mb = getMethodBind("Camera2D","get_zoom") return _icall_Vector2( mb, this.ptr) } open fun isCurrent(): Boolean { val mb = getMethodBind("Camera2D","is_current") return _icall_Boolean( mb, this.ptr) } open fun isFollowSmoothingEnabled(): Boolean { val mb = getMethodBind("Camera2D","is_follow_smoothing_enabled") return _icall_Boolean( mb, this.ptr) } open fun isHDragEnabled(): Boolean { val mb = getMethodBind("Camera2D","is_h_drag_enabled") return _icall_Boolean( mb, this.ptr) } open fun isLimitDrawingEnabled(): Boolean { val mb = getMethodBind("Camera2D","is_limit_drawing_enabled") return _icall_Boolean( mb, this.ptr) } open fun isLimitSmoothingEnabled(): Boolean { val mb = getMethodBind("Camera2D","is_limit_smoothing_enabled") return _icall_Boolean( mb, this.ptr) } open fun isMarginDrawingEnabled(): Boolean { val mb = getMethodBind("Camera2D","is_margin_drawing_enabled") return _icall_Boolean( mb, this.ptr) } open fun isRotating(): Boolean { val mb = getMethodBind("Camera2D","is_rotating") return _icall_Boolean( mb, this.ptr) } open fun isScreenDrawingEnabled(): Boolean { val mb = getMethodBind("Camera2D","is_screen_drawing_enabled") return _icall_Boolean( mb, this.ptr) } open fun isVDragEnabled(): Boolean { val mb = getMethodBind("Camera2D","is_v_drag_enabled") return _icall_Boolean( mb, this.ptr) } open fun makeCurrent() { val mb = getMethodBind("Camera2D","make_current") _icall_Unit( mb, this.ptr) } open fun resetSmoothing() { val mb = getMethodBind("Camera2D","reset_smoothing") _icall_Unit( mb, this.ptr) } open fun setAnchorMode(anchorMode: Long) { val mb = getMethodBind("Camera2D","set_anchor_mode") _icall_Unit_Long( mb, this.ptr, anchorMode) } open fun setCustomViewport(viewport: Node) { val mb = getMethodBind("Camera2D","set_custom_viewport") _icall_Unit_Object( mb, this.ptr, viewport) } open fun setDragMargin(margin: Long, dragMargin: Double) { val mb = getMethodBind("Camera2D","set_drag_margin") _icall_Unit_Long_Double( mb, this.ptr, margin, dragMargin) } open fun setEnableFollowSmoothing(followSmoothing: Boolean) { val mb = getMethodBind("Camera2D","set_enable_follow_smoothing") _icall_Unit_Boolean( mb, this.ptr, followSmoothing) } open fun setFollowSmoothing(followSmoothing: Double) { val mb = getMethodBind("Camera2D","set_follow_smoothing") _icall_Unit_Double( mb, this.ptr, followSmoothing) } open fun setHDragEnabled(enabled: Boolean) { val mb = getMethodBind("Camera2D","set_h_drag_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setHOffset(ofs: Double) { val mb = getMethodBind("Camera2D","set_h_offset") _icall_Unit_Double( mb, this.ptr, ofs) } open fun setLimit(margin: Long, limit: Long) { val mb = getMethodBind("Camera2D","set_limit") _icall_Unit_Long_Long( mb, this.ptr, margin, limit) } open fun setLimitDrawingEnabled(limitDrawingEnabled: Boolean) { val mb = getMethodBind("Camera2D","set_limit_drawing_enabled") _icall_Unit_Boolean( mb, this.ptr, limitDrawingEnabled) } open fun setLimitSmoothingEnabled(limitSmoothingEnabled: Boolean) { val mb = getMethodBind("Camera2D","set_limit_smoothing_enabled") _icall_Unit_Boolean( mb, this.ptr, limitSmoothingEnabled) } open fun setMarginDrawingEnabled(marginDrawingEnabled: Boolean) { val mb = getMethodBind("Camera2D","set_margin_drawing_enabled") _icall_Unit_Boolean( mb, this.ptr, marginDrawingEnabled) } open fun setOffset(offset: Vector2) { val mb = getMethodBind("Camera2D","set_offset") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun setProcessMode(mode: Long) { val mb = getMethodBind("Camera2D","set_process_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setRotating(rotating: Boolean) { val mb = getMethodBind("Camera2D","set_rotating") _icall_Unit_Boolean( mb, this.ptr, rotating) } open fun setScreenDrawingEnabled(screenDrawingEnabled: Boolean) { val mb = getMethodBind("Camera2D","set_screen_drawing_enabled") _icall_Unit_Boolean( mb, this.ptr, screenDrawingEnabled) } open fun setVDragEnabled(enabled: Boolean) { val mb = getMethodBind("Camera2D","set_v_drag_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setVOffset(ofs: Double) { val mb = getMethodBind("Camera2D","set_v_offset") _icall_Unit_Double( mb, this.ptr, ofs) } open fun setZoom(zoom: Vector2) { val mb = getMethodBind("Camera2D","set_zoom") _icall_Unit_Vector2( mb, this.ptr, zoom) } enum class Camera2DProcessMode( id: Long ) { CAMERA2D_PROCESS_PHYSICS(0), CAMERA2D_PROCESS_IDLE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class AnchorMode( id: Long ) { ANCHOR_MODE_FIXED_TOP_LEFT(0), ANCHOR_MODE_DRAG_CENTER(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CameraFeed.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.CameraFeed import godot.core.Transform2D import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Transform2D import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Transform2D import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class CameraFeed : Reference() { open var feedIsActive: Boolean get() { val mb = getMethodBind("CameraFeed","is_active") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CameraFeed","set_active") _icall_Unit_Boolean(mb, this.ptr, value) } open var feedTransform: Transform2D get() { val mb = getMethodBind("CameraFeed","get_transform") return _icall_Transform2D(mb, this.ptr) } set(value) { val mb = getMethodBind("CameraFeed","set_transform") _icall_Unit_Transform2D(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CameraFeed", "CameraFeed") open fun feedTransform(schedule: Transform2D.() -> Unit): Transform2D = feedTransform.apply{ schedule(this) feedTransform = this } open fun _allocateTexture( width: Long, height: Long, format: Long, textureType: Long, dataType: Long ) { } open fun _setRGBImg(rgbImg: Image) { } open fun _setYCbCrImg(ycbcrImg: Image) { } open fun _setYCbCrImgs(yImg: Image, cbcrImg: Image) { } open fun _setName(name: String) { } open fun _setPosition(position: Long) { } open fun getId(): Long { val mb = getMethodBind("CameraFeed","get_id") return _icall_Long( mb, this.ptr) } open fun getName(): String { val mb = getMethodBind("CameraFeed","get_name") return _icall_String( mb, this.ptr) } open fun getPosition(): CameraFeed.FeedPosition { val mb = getMethodBind("CameraFeed","get_position") return CameraFeed.FeedPosition.from( _icall_Long( mb, this.ptr)) } open fun getTransform(): Transform2D { val mb = getMethodBind("CameraFeed","get_transform") return _icall_Transform2D( mb, this.ptr) } open fun isActive(): Boolean { val mb = getMethodBind("CameraFeed","is_active") return _icall_Boolean( mb, this.ptr) } open fun setActive(active: Boolean) { val mb = getMethodBind("CameraFeed","set_active") _icall_Unit_Boolean( mb, this.ptr, active) } open fun setTransform(transform: Transform2D) { val mb = getMethodBind("CameraFeed","set_transform") _icall_Unit_Transform2D( mb, this.ptr, transform) } enum class FeedDataType( id: Long ) { FEED_NOIMAGE(0), FEED_RGB(1), FEED_YCBCR(2), FEED_YCBCR_SEP(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class FeedPosition( id: Long ) { FEED_UNSPECIFIED(0), FEED_FRONT(1), FEED_BACK(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CameraServer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.core.Signal1 import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_CameraFeed_Long import godot.icalls._icall_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_VariantArray import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Long import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object CameraServer : Object() { val cameraFeedAdded: Signal1 by signal("id") val cameraFeedRemoved: Signal1 by signal("id") override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("CameraServer".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton CameraServer" } ptr } fun addFeed(feed: CameraFeed) { val mb = getMethodBind("CameraServer","add_feed") _icall_Unit_Object( mb, this.ptr, feed) } fun feeds(): VariantArray { val mb = getMethodBind("CameraServer","feeds") return _icall_VariantArray( mb, this.ptr) } fun getFeed(index: Long): CameraFeed { val mb = getMethodBind("CameraServer","get_feed") return _icall_CameraFeed_Long( mb, this.ptr, index) } fun getFeedCount(): Long { val mb = getMethodBind("CameraServer","get_feed_count") return _icall_Long( mb, this.ptr) } fun removeFeed(feed: CameraFeed) { val mb = getMethodBind("CameraServer","remove_feed") _icall_Unit_Object( mb, this.ptr, feed) } enum class FeedImage( id: Long ) { FEED_RGBA_IMAGE(0), FEED_YCBCR_IMAGE(0), FEED_Y_IMAGE(0), FEED_CBCR_IMAGE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CameraTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.CameraServer import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlinx.cinterop.COpaquePointer open class CameraTexture : Texture() { open var cameraFeedId: Long get() { val mb = getMethodBind("CameraTexture","get_camera_feed_id") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CameraTexture","set_camera_feed_id") _icall_Unit_Long(mb, this.ptr, value) } open var cameraIsActive: Boolean get() { val mb = getMethodBind("CameraTexture","get_camera_active") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CameraTexture","set_camera_active") _icall_Unit_Boolean(mb, this.ptr, value) } open var whichFeed: Long get() { val mb = getMethodBind("CameraTexture","get_which_feed") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CameraTexture","set_which_feed") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CameraTexture", "CameraTexture") open fun getCameraActive(): Boolean { val mb = getMethodBind("CameraTexture","get_camera_active") return _icall_Boolean( mb, this.ptr) } open fun getCameraFeedId(): Long { val mb = getMethodBind("CameraTexture","get_camera_feed_id") return _icall_Long( mb, this.ptr) } open fun getWhichFeed(): CameraServer.FeedImage { val mb = getMethodBind("CameraTexture","get_which_feed") return CameraServer.FeedImage.from( _icall_Long( mb, this.ptr)) } open fun setCameraActive(active: Boolean) { val mb = getMethodBind("CameraTexture","set_camera_active") _icall_Unit_Boolean( mb, this.ptr, active) } open fun setCameraFeedId(feedId: Long) { val mb = getMethodBind("CameraTexture","set_camera_feed_id") _icall_Unit_Long( mb, this.ptr, feedId) } open fun setWhichFeed(whichFeed: Long) { val mb = getMethodBind("CameraTexture","set_which_feed") _icall_Unit_Long( mb, this.ptr, whichFeed) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CanvasItem.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.Dictionary import godot.core.PoolColorArray import godot.core.PoolVector2Array import godot.core.RID import godot.core.Rect2 import godot.core.Signal0 import godot.core.Transform2D import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_Double_Object_Vector2_String_String_Color import godot.icalls._icall_InputEvent_Object import godot.icalls._icall_Long import godot.icalls._icall_Material import godot.icalls._icall_RID import godot.icalls._icall_Rect2 import godot.icalls._icall_Transform2D import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_Object_nObject import godot.icalls._icall_Unit_Object_Object_nObject_Transform2D_Color import godot.icalls._icall_Unit_Object_Rect2 import godot.icalls._icall_Unit_Object_Rect2_Boolean_Color_Boolean_nObject import godot.icalls._icall_Unit_Object_Rect2_Rect2_Color_Boolean_nObject_Boolean import godot.icalls._icall_Unit_Object_Vector2_Color_nObject import godot.icalls._icall_Unit_Object_Vector2_String_Color_Long import godot.icalls._icall_Unit_PoolVector2Array_Color_Double_Boolean import godot.icalls._icall_Unit_PoolVector2Array_Color_PoolVector2Array_nObject_nObject_Boolean import godot.icalls._icall_Unit_PoolVector2Array_PoolColorArray_Double_Boolean import godot.icalls._icall_Unit_PoolVector2Array_PoolColorArray_PoolVector2Array_nObject_Double_nObject import godot.icalls._icall_Unit_PoolVector2Array_PoolColorArray_PoolVector2Array_nObject_nObject_Boolean import godot.icalls._icall_Unit_Rect2_Color_Boolean_Double_Boolean import godot.icalls._icall_Unit_Transform2D import godot.icalls._icall_Unit_Vector2_Double_Color import godot.icalls._icall_Unit_Vector2_Double_Double_Double_Long_Color_Double_Boolean import godot.icalls._icall_Unit_Vector2_Double_Vector2 import godot.icalls._icall_Unit_Vector2_Vector2_Color_Double_Boolean import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_Vector2 import godot.icalls._icall_World2D import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlin.Unit open class CanvasItem internal constructor() : Node() { val draw: Signal0 by signal() val hide: Signal0 by signal() val itemRectChanged: Signal0 by signal() val visibilityChanged: Signal0 by signal() open var lightMask: Long get() { val mb = getMethodBind("CanvasItem","get_light_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItem","set_light_mask") _icall_Unit_Long(mb, this.ptr, value) } open var material: Material get() { val mb = getMethodBind("CanvasItem","get_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItem","set_material") _icall_Unit_Object(mb, this.ptr, value) } open var modulate: Color get() { val mb = getMethodBind("CanvasItem","get_modulate") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItem","set_modulate") _icall_Unit_Color(mb, this.ptr, value) } open var selfModulate: Color get() { val mb = getMethodBind("CanvasItem","get_self_modulate") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItem","set_self_modulate") _icall_Unit_Color(mb, this.ptr, value) } open var showBehindParent: Boolean get() { val mb = getMethodBind("CanvasItem","is_draw_behind_parent_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItem","set_draw_behind_parent") _icall_Unit_Boolean(mb, this.ptr, value) } open var useParentMaterial: Boolean get() { val mb = getMethodBind("CanvasItem","get_use_parent_material") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItem","set_use_parent_material") _icall_Unit_Boolean(mb, this.ptr, value) } open var visible: Boolean get() { val mb = getMethodBind("CanvasItem","is_visible") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItem","set_visible") _icall_Unit_Boolean(mb, this.ptr, value) } open fun modulate(schedule: Color.() -> Unit): Color = modulate.apply{ schedule(this) modulate = this } open fun selfModulate(schedule: Color.() -> Unit): Color = selfModulate.apply{ schedule(this) selfModulate = this } open fun _draw() { } open fun _editGetPivot(): Vector2 { throw NotImplementedError("_edit_get_pivot is not implemented for CanvasItem") } open fun _editGetPosition(): Vector2 { throw NotImplementedError("_edit_get_position is not implemented for CanvasItem") } open fun _editGetRect(): Rect2 { throw NotImplementedError("_edit_get_rect is not implemented for CanvasItem") } open fun _editGetRotation(): Double { throw NotImplementedError("_edit_get_rotation is not implemented for CanvasItem") } open fun _editGetScale(): Vector2 { throw NotImplementedError("_edit_get_scale is not implemented for CanvasItem") } open fun _editGetState(): Dictionary { throw NotImplementedError("_edit_get_state is not implemented for CanvasItem") } open fun _editGetTransform(): Transform2D { throw NotImplementedError("_edit_get_transform is not implemented for CanvasItem") } open fun _editSetPivot(pivot: Vector2) { } open fun _editSetPosition(position: Vector2) { } open fun _editSetRect(rect: Rect2) { } open fun _editSetRotation(degrees: Double) { } open fun _editSetScale(scale: Vector2) { } open fun _editSetState(state: Dictionary) { } open fun _editUsePivot(): Boolean { throw NotImplementedError("_edit_use_pivot is not implemented for CanvasItem") } open fun _editUseRect(): Boolean { throw NotImplementedError("_edit_use_rect is not implemented for CanvasItem") } open fun _editUseRotation(): Boolean { throw NotImplementedError("_edit_use_rotation is not implemented for CanvasItem") } open fun _isOnTop(): Boolean { throw NotImplementedError("_is_on_top is not implemented for CanvasItem") } open fun _setOnTop(onTop: Boolean) { } open fun _toplevelRaiseSelf() { } open fun _updateCallback() { } open fun drawArc( center: Vector2, radius: Double, startAngle: Double, endAngle: Double, pointCount: Long, color: Color, width: Double = 1.0, antialiased: Boolean = false ) { val mb = getMethodBind("CanvasItem","draw_arc") _icall_Unit_Vector2_Double_Double_Double_Long_Color_Double_Boolean( mb, this.ptr, center, radius, startAngle, endAngle, pointCount, color, width, antialiased) } open fun drawChar( font: Font, position: Vector2, char: String, next: String, modulate: Color = Color(1,1,1,1) ): Double { val mb = getMethodBind("CanvasItem","draw_char") return _icall_Double_Object_Vector2_String_String_Color( mb, this.ptr, font, position, char, next, modulate) } open fun drawCircle( position: Vector2, radius: Double, color: Color ) { val mb = getMethodBind("CanvasItem","draw_circle") _icall_Unit_Vector2_Double_Color( mb, this.ptr, position, radius, color) } open fun drawColoredPolygon( points: PoolVector2Array, color: Color, uvs: PoolVector2Array = PoolVector2Array(), texture: Texture? = null, normalMap: Texture? = null, antialiased: Boolean = false ) { val mb = getMethodBind("CanvasItem","draw_colored_polygon") _icall_Unit_PoolVector2Array_Color_PoolVector2Array_nObject_nObject_Boolean( mb, this.ptr, points, color, uvs, texture, normalMap, antialiased) } open fun drawLine( from: Vector2, to: Vector2, color: Color, width: Double = 1.0, antialiased: Boolean = false ) { val mb = getMethodBind("CanvasItem","draw_line") _icall_Unit_Vector2_Vector2_Color_Double_Boolean( mb, this.ptr, from, to, color, width, antialiased) } open fun drawMesh( mesh: Mesh, texture: Texture, normalMap: Texture? = null, transform: Transform2D = Transform2D(), modulate: Color = Color(1,1,1,1) ) { val mb = getMethodBind("CanvasItem","draw_mesh") _icall_Unit_Object_Object_nObject_Transform2D_Color( mb, this.ptr, mesh, texture, normalMap, transform, modulate) } open fun drawMultiline( points: PoolVector2Array, color: Color, width: Double = 1.0, antialiased: Boolean = false ) { val mb = getMethodBind("CanvasItem","draw_multiline") _icall_Unit_PoolVector2Array_Color_Double_Boolean( mb, this.ptr, points, color, width, antialiased) } open fun drawMultilineColors( points: PoolVector2Array, colors: PoolColorArray, width: Double = 1.0, antialiased: Boolean = false ) { val mb = getMethodBind("CanvasItem","draw_multiline_colors") _icall_Unit_PoolVector2Array_PoolColorArray_Double_Boolean( mb, this.ptr, points, colors, width, antialiased) } open fun drawMultimesh( multimesh: MultiMesh, texture: Texture, normalMap: Texture? = null ) { val mb = getMethodBind("CanvasItem","draw_multimesh") _icall_Unit_Object_Object_nObject( mb, this.ptr, multimesh, texture, normalMap) } open fun drawPolygon( points: PoolVector2Array, colors: PoolColorArray, uvs: PoolVector2Array = PoolVector2Array(), texture: Texture? = null, normalMap: Texture? = null, antialiased: Boolean = false ) { val mb = getMethodBind("CanvasItem","draw_polygon") _icall_Unit_PoolVector2Array_PoolColorArray_PoolVector2Array_nObject_nObject_Boolean( mb, this.ptr, points, colors, uvs, texture, normalMap, antialiased) } open fun drawPolyline( points: PoolVector2Array, color: Color, width: Double = 1.0, antialiased: Boolean = false ) { val mb = getMethodBind("CanvasItem","draw_polyline") _icall_Unit_PoolVector2Array_Color_Double_Boolean( mb, this.ptr, points, color, width, antialiased) } open fun drawPolylineColors( points: PoolVector2Array, colors: PoolColorArray, width: Double = 1.0, antialiased: Boolean = false ) { val mb = getMethodBind("CanvasItem","draw_polyline_colors") _icall_Unit_PoolVector2Array_PoolColorArray_Double_Boolean( mb, this.ptr, points, colors, width, antialiased) } open fun drawPrimitive( points: PoolVector2Array, colors: PoolColorArray, uvs: PoolVector2Array, texture: Texture? = null, width: Double = 1.0, normalMap: Texture? = null ) { val mb = getMethodBind("CanvasItem","draw_primitive") _icall_Unit_PoolVector2Array_PoolColorArray_PoolVector2Array_nObject_Double_nObject( mb, this.ptr, points, colors, uvs, texture, width, normalMap) } open fun drawRect( rect: Rect2, color: Color, filled: Boolean = true, width: Double = 1.0, antialiased: Boolean = false ) { val mb = getMethodBind("CanvasItem","draw_rect") _icall_Unit_Rect2_Color_Boolean_Double_Boolean( mb, this.ptr, rect, color, filled, width, antialiased) } open fun drawSetTransform( position: Vector2, rotation: Double, scale: Vector2 ) { val mb = getMethodBind("CanvasItem","draw_set_transform") _icall_Unit_Vector2_Double_Vector2( mb, this.ptr, position, rotation, scale) } open fun drawSetTransformMatrix(xform: Transform2D) { val mb = getMethodBind("CanvasItem","draw_set_transform_matrix") _icall_Unit_Transform2D( mb, this.ptr, xform) } open fun drawString( font: Font, position: Vector2, text: String, modulate: Color = Color(1,1,1,1), clipW: Long = -1 ) { val mb = getMethodBind("CanvasItem","draw_string") _icall_Unit_Object_Vector2_String_Color_Long( mb, this.ptr, font, position, text, modulate, clipW) } open fun drawStyleBox(styleBox: StyleBox, rect: Rect2) { val mb = getMethodBind("CanvasItem","draw_style_box") _icall_Unit_Object_Rect2( mb, this.ptr, styleBox, rect) } open fun drawTexture( texture: Texture, position: Vector2, modulate: Color = Color(1,1,1,1), normalMap: Texture? = null ) { val mb = getMethodBind("CanvasItem","draw_texture") _icall_Unit_Object_Vector2_Color_nObject( mb, this.ptr, texture, position, modulate, normalMap) } open fun drawTextureRect( texture: Texture, rect: Rect2, tile: Boolean, modulate: Color = Color(1,1,1,1), transpose: Boolean = false, normalMap: Texture? = null ) { val mb = getMethodBind("CanvasItem","draw_texture_rect") _icall_Unit_Object_Rect2_Boolean_Color_Boolean_nObject( mb, this.ptr, texture, rect, tile, modulate, transpose, normalMap) } open fun drawTextureRectRegion( texture: Texture, rect: Rect2, srcRect: Rect2, modulate: Color = Color(1,1,1,1), transpose: Boolean = false, normalMap: Texture? = null, clipUv: Boolean = true ) { val mb = getMethodBind("CanvasItem","draw_texture_rect_region") _icall_Unit_Object_Rect2_Rect2_Color_Boolean_nObject_Boolean( mb, this.ptr, texture, rect, srcRect, modulate, transpose, normalMap, clipUv) } open fun forceUpdateTransform() { val mb = getMethodBind("CanvasItem","force_update_transform") _icall_Unit( mb, this.ptr) } open fun getCanvas(): RID { val mb = getMethodBind("CanvasItem","get_canvas") return _icall_RID( mb, this.ptr) } open fun getCanvasItem(): RID { val mb = getMethodBind("CanvasItem","get_canvas_item") return _icall_RID( mb, this.ptr) } open fun getCanvasTransform(): Transform2D { val mb = getMethodBind("CanvasItem","get_canvas_transform") return _icall_Transform2D( mb, this.ptr) } open fun getGlobalMousePosition(): Vector2 { val mb = getMethodBind("CanvasItem","get_global_mouse_position") return _icall_Vector2( mb, this.ptr) } open fun getGlobalTransform(): Transform2D { val mb = getMethodBind("CanvasItem","get_global_transform") return _icall_Transform2D( mb, this.ptr) } open fun getGlobalTransformWithCanvas(): Transform2D { val mb = getMethodBind("CanvasItem","get_global_transform_with_canvas") return _icall_Transform2D( mb, this.ptr) } open fun getLightMask(): Long { val mb = getMethodBind("CanvasItem","get_light_mask") return _icall_Long( mb, this.ptr) } open fun getLocalMousePosition(): Vector2 { val mb = getMethodBind("CanvasItem","get_local_mouse_position") return _icall_Vector2( mb, this.ptr) } open fun getMaterial(): Material { val mb = getMethodBind("CanvasItem","get_material") return _icall_Material( mb, this.ptr) } open fun getModulate(): Color { val mb = getMethodBind("CanvasItem","get_modulate") return _icall_Color( mb, this.ptr) } open fun getSelfModulate(): Color { val mb = getMethodBind("CanvasItem","get_self_modulate") return _icall_Color( mb, this.ptr) } open fun getTransform(): Transform2D { val mb = getMethodBind("CanvasItem","get_transform") return _icall_Transform2D( mb, this.ptr) } open fun getUseParentMaterial(): Boolean { val mb = getMethodBind("CanvasItem","get_use_parent_material") return _icall_Boolean( mb, this.ptr) } open fun getViewportRect(): Rect2 { val mb = getMethodBind("CanvasItem","get_viewport_rect") return _icall_Rect2( mb, this.ptr) } open fun getViewportTransform(): Transform2D { val mb = getMethodBind("CanvasItem","get_viewport_transform") return _icall_Transform2D( mb, this.ptr) } open fun getWorld2d(): World2D { val mb = getMethodBind("CanvasItem","get_world_2d") return _icall_World2D( mb, this.ptr) } open fun hide() { val mb = getMethodBind("CanvasItem","hide") _icall_Unit( mb, this.ptr) } open fun isDrawBehindParentEnabled(): Boolean { val mb = getMethodBind("CanvasItem","is_draw_behind_parent_enabled") return _icall_Boolean( mb, this.ptr) } open fun isLocalTransformNotificationEnabled(): Boolean { val mb = getMethodBind("CanvasItem","is_local_transform_notification_enabled") return _icall_Boolean( mb, this.ptr) } open fun isSetAsToplevel(): Boolean { val mb = getMethodBind("CanvasItem","is_set_as_toplevel") return _icall_Boolean( mb, this.ptr) } open fun isTransformNotificationEnabled(): Boolean { val mb = getMethodBind("CanvasItem","is_transform_notification_enabled") return _icall_Boolean( mb, this.ptr) } open fun isVisible(): Boolean { val mb = getMethodBind("CanvasItem","is_visible") return _icall_Boolean( mb, this.ptr) } open fun isVisibleInTree(): Boolean { val mb = getMethodBind("CanvasItem","is_visible_in_tree") return _icall_Boolean( mb, this.ptr) } open fun makeCanvasPositionLocal(screenPoint: Vector2): Vector2 { val mb = getMethodBind("CanvasItem","make_canvas_position_local") return _icall_Vector2_Vector2( mb, this.ptr, screenPoint) } open fun makeInputLocal(event: InputEvent): InputEvent { val mb = getMethodBind("CanvasItem","make_input_local") return _icall_InputEvent_Object( mb, this.ptr, event) } open fun setAsToplevel(enable: Boolean) { val mb = getMethodBind("CanvasItem","set_as_toplevel") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setDrawBehindParent(enable: Boolean) { val mb = getMethodBind("CanvasItem","set_draw_behind_parent") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setLightMask(lightMask: Long) { val mb = getMethodBind("CanvasItem","set_light_mask") _icall_Unit_Long( mb, this.ptr, lightMask) } open fun setMaterial(material: Material) { val mb = getMethodBind("CanvasItem","set_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setModulate(modulate: Color) { val mb = getMethodBind("CanvasItem","set_modulate") _icall_Unit_Color( mb, this.ptr, modulate) } open fun setNotifyLocalTransform(enable: Boolean) { val mb = getMethodBind("CanvasItem","set_notify_local_transform") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setNotifyTransform(enable: Boolean) { val mb = getMethodBind("CanvasItem","set_notify_transform") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setSelfModulate(selfModulate: Color) { val mb = getMethodBind("CanvasItem","set_self_modulate") _icall_Unit_Color( mb, this.ptr, selfModulate) } open fun setUseParentMaterial(enable: Boolean) { val mb = getMethodBind("CanvasItem","set_use_parent_material") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setVisible(visible: Boolean) { val mb = getMethodBind("CanvasItem","set_visible") _icall_Unit_Boolean( mb, this.ptr, visible) } open fun show() { val mb = getMethodBind("CanvasItem","show") _icall_Unit( mb, this.ptr) } open fun update() { val mb = getMethodBind("CanvasItem","update") _icall_Unit( mb, this.ptr) } enum class BlendMode( id: Long ) { BLEND_MODE_MIX(0), BLEND_MODE_ADD(1), BLEND_MODE_SUB(2), BLEND_MODE_MUL(3), BLEND_MODE_PREMULT_ALPHA(4), BLEND_MODE_DISABLED(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object { final const val NOTIFICATION_DRAW: Long = 30 final const val NOTIFICATION_ENTER_CANVAS: Long = 32 final const val NOTIFICATION_EXIT_CANVAS: Long = 33 final const val NOTIFICATION_TRANSFORM_CHANGED: Long = 2000 final const val NOTIFICATION_VISIBILITY_CHANGED: Long = 31 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CanvasItemMaterial.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.CanvasItemMaterial import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlinx.cinterop.COpaquePointer open class CanvasItemMaterial : Material() { open var blendMode: Long get() { val mb = getMethodBind("CanvasItemMaterial","get_blend_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItemMaterial","set_blend_mode") _icall_Unit_Long(mb, this.ptr, value) } open var lightMode: Long get() { val mb = getMethodBind("CanvasItemMaterial","get_light_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItemMaterial","set_light_mode") _icall_Unit_Long(mb, this.ptr, value) } open var particlesAnimHFrames: Long get() { val mb = getMethodBind("CanvasItemMaterial","get_particles_anim_h_frames") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItemMaterial","set_particles_anim_h_frames") _icall_Unit_Long(mb, this.ptr, value) } open var particlesAnimLoop: Boolean get() { val mb = getMethodBind("CanvasItemMaterial","get_particles_anim_loop") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItemMaterial","set_particles_anim_loop") _icall_Unit_Boolean(mb, this.ptr, value) } open var particlesAnimVFrames: Long get() { val mb = getMethodBind("CanvasItemMaterial","get_particles_anim_v_frames") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItemMaterial","set_particles_anim_v_frames") _icall_Unit_Long(mb, this.ptr, value) } open var particlesAnimation: Boolean get() { val mb = getMethodBind("CanvasItemMaterial","get_particles_animation") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasItemMaterial","set_particles_animation") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CanvasItemMaterial", "CanvasItemMaterial") open fun getBlendMode(): CanvasItemMaterial.BlendMode { val mb = getMethodBind("CanvasItemMaterial","get_blend_mode") return CanvasItemMaterial.BlendMode.from( _icall_Long( mb, this.ptr)) } open fun getLightMode(): CanvasItemMaterial.LightMode { val mb = getMethodBind("CanvasItemMaterial","get_light_mode") return CanvasItemMaterial.LightMode.from( _icall_Long( mb, this.ptr)) } open fun getParticlesAnimHFrames(): Long { val mb = getMethodBind("CanvasItemMaterial","get_particles_anim_h_frames") return _icall_Long( mb, this.ptr) } open fun getParticlesAnimLoop(): Boolean { val mb = getMethodBind("CanvasItemMaterial","get_particles_anim_loop") return _icall_Boolean( mb, this.ptr) } open fun getParticlesAnimVFrames(): Long { val mb = getMethodBind("CanvasItemMaterial","get_particles_anim_v_frames") return _icall_Long( mb, this.ptr) } open fun getParticlesAnimation(): Boolean { val mb = getMethodBind("CanvasItemMaterial","get_particles_animation") return _icall_Boolean( mb, this.ptr) } open fun setBlendMode(blendMode: Long) { val mb = getMethodBind("CanvasItemMaterial","set_blend_mode") _icall_Unit_Long( mb, this.ptr, blendMode) } open fun setLightMode(lightMode: Long) { val mb = getMethodBind("CanvasItemMaterial","set_light_mode") _icall_Unit_Long( mb, this.ptr, lightMode) } open fun setParticlesAnimHFrames(frames: Long) { val mb = getMethodBind("CanvasItemMaterial","set_particles_anim_h_frames") _icall_Unit_Long( mb, this.ptr, frames) } open fun setParticlesAnimLoop(loop: Boolean) { val mb = getMethodBind("CanvasItemMaterial","set_particles_anim_loop") _icall_Unit_Boolean( mb, this.ptr, loop) } open fun setParticlesAnimVFrames(frames: Long) { val mb = getMethodBind("CanvasItemMaterial","set_particles_anim_v_frames") _icall_Unit_Long( mb, this.ptr, frames) } open fun setParticlesAnimation(particlesAnim: Boolean) { val mb = getMethodBind("CanvasItemMaterial","set_particles_animation") _icall_Unit_Boolean( mb, this.ptr, particlesAnim) } enum class LightMode( id: Long ) { LIGHT_MODE_NORMAL(0), LIGHT_MODE_UNSHADED(1), LIGHT_MODE_LIGHT_ONLY(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BlendMode( id: Long ) { BLEND_MODE_MIX(0), BLEND_MODE_ADD(1), BLEND_MODE_SUB(2), BLEND_MODE_MUL(3), BLEND_MODE_PREMULT_ALPHA(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CanvasLayer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Transform2D import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Node import godot.icalls._icall_RID import godot.icalls._icall_Transform2D import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Transform2D import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class CanvasLayer : Node() { open var customViewport: Node get() { val mb = getMethodBind("CanvasLayer","get_custom_viewport") return _icall_Node(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasLayer","set_custom_viewport") _icall_Unit_Object(mb, this.ptr, value) } open var followViewportEnable: Boolean get() { val mb = getMethodBind("CanvasLayer","is_following_viewport") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasLayer","set_follow_viewport") _icall_Unit_Boolean(mb, this.ptr, value) } open var followViewportScale: Double get() { val mb = getMethodBind("CanvasLayer","get_follow_viewport_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasLayer","set_follow_viewport_scale") _icall_Unit_Double(mb, this.ptr, value) } open var layer: Long get() { val mb = getMethodBind("CanvasLayer","get_layer") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasLayer","set_layer") _icall_Unit_Long(mb, this.ptr, value) } open var offset: Vector2 get() { val mb = getMethodBind("CanvasLayer","get_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasLayer","set_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var rotation: Double get() { val mb = getMethodBind("CanvasLayer","get_rotation") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasLayer","set_rotation") _icall_Unit_Double(mb, this.ptr, value) } open var rotationDegrees: Double get() { val mb = getMethodBind("CanvasLayer","get_rotation_degrees") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasLayer","set_rotation_degrees") _icall_Unit_Double(mb, this.ptr, value) } open var scale: Vector2 get() { val mb = getMethodBind("CanvasLayer","get_scale") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasLayer","set_scale") _icall_Unit_Vector2(mb, this.ptr, value) } open var transform: Transform2D get() { val mb = getMethodBind("CanvasLayer","get_transform") return _icall_Transform2D(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasLayer","set_transform") _icall_Unit_Transform2D(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CanvasLayer", "CanvasLayer") open fun offset(schedule: Vector2.() -> Unit): Vector2 = offset.apply{ schedule(this) offset = this } open fun scale(schedule: Vector2.() -> Unit): Vector2 = scale.apply{ schedule(this) scale = this } open fun transform(schedule: Transform2D.() -> Unit): Transform2D = transform.apply{ schedule(this) transform = this } open fun getCanvas(): RID { val mb = getMethodBind("CanvasLayer","get_canvas") return _icall_RID( mb, this.ptr) } open fun getCustomViewport(): Node { val mb = getMethodBind("CanvasLayer","get_custom_viewport") return _icall_Node( mb, this.ptr) } open fun getFollowViewportScale(): Double { val mb = getMethodBind("CanvasLayer","get_follow_viewport_scale") return _icall_Double( mb, this.ptr) } open fun getLayer(): Long { val mb = getMethodBind("CanvasLayer","get_layer") return _icall_Long( mb, this.ptr) } open fun getOffset(): Vector2 { val mb = getMethodBind("CanvasLayer","get_offset") return _icall_Vector2( mb, this.ptr) } open fun getRotation(): Double { val mb = getMethodBind("CanvasLayer","get_rotation") return _icall_Double( mb, this.ptr) } open fun getRotationDegrees(): Double { val mb = getMethodBind("CanvasLayer","get_rotation_degrees") return _icall_Double( mb, this.ptr) } open fun getScale(): Vector2 { val mb = getMethodBind("CanvasLayer","get_scale") return _icall_Vector2( mb, this.ptr) } open fun getTransform(): Transform2D { val mb = getMethodBind("CanvasLayer","get_transform") return _icall_Transform2D( mb, this.ptr) } open fun isFollowingViewport(): Boolean { val mb = getMethodBind("CanvasLayer","is_following_viewport") return _icall_Boolean( mb, this.ptr) } open fun setCustomViewport(viewport: Node) { val mb = getMethodBind("CanvasLayer","set_custom_viewport") _icall_Unit_Object( mb, this.ptr, viewport) } open fun setFollowViewport(enable: Boolean) { val mb = getMethodBind("CanvasLayer","set_follow_viewport") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setFollowViewportScale(scale: Double) { val mb = getMethodBind("CanvasLayer","set_follow_viewport_scale") _icall_Unit_Double( mb, this.ptr, scale) } open fun setLayer(layer: Long) { val mb = getMethodBind("CanvasLayer","set_layer") _icall_Unit_Long( mb, this.ptr, layer) } open fun setOffset(offset: Vector2) { val mb = getMethodBind("CanvasLayer","set_offset") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun setRotation(radians: Double) { val mb = getMethodBind("CanvasLayer","set_rotation") _icall_Unit_Double( mb, this.ptr, radians) } open fun setRotationDegrees(degrees: Double) { val mb = getMethodBind("CanvasLayer","set_rotation_degrees") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setScale(scale: Vector2) { val mb = getMethodBind("CanvasLayer","set_scale") _icall_Unit_Vector2( mb, this.ptr, scale) } open fun setTransform(transform: Transform2D) { val mb = getMethodBind("CanvasLayer","set_transform") _icall_Unit_Transform2D( mb, this.ptr, transform) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CanvasModulate.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.icalls._icall_Color import godot.icalls._icall_Unit_Color import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class CanvasModulate : Node2D() { open var color: Color get() { val mb = getMethodBind("CanvasModulate","get_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("CanvasModulate","set_color") _icall_Unit_Color(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CanvasModulate", "CanvasModulate") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun getColor(): Color { val mb = getMethodBind("CanvasModulate","get_color") return _icall_Color( mb, this.ptr) } open fun setColor(color: Color) { val mb = getMethodBind("CanvasModulate","set_color") _icall_Unit_Color( mb, this.ptr, color) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CapsuleMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class CapsuleMesh : PrimitiveMesh() { open var midHeight: Double get() { val mb = getMethodBind("CapsuleMesh","get_mid_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CapsuleMesh","set_mid_height") _icall_Unit_Double(mb, this.ptr, value) } open var radialSegments: Long get() { val mb = getMethodBind("CapsuleMesh","get_radial_segments") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CapsuleMesh","set_radial_segments") _icall_Unit_Long(mb, this.ptr, value) } open var radius: Double get() { val mb = getMethodBind("CapsuleMesh","get_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CapsuleMesh","set_radius") _icall_Unit_Double(mb, this.ptr, value) } open var rings: Long get() { val mb = getMethodBind("CapsuleMesh","get_rings") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CapsuleMesh","set_rings") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CapsuleMesh", "CapsuleMesh") open fun getMidHeight(): Double { val mb = getMethodBind("CapsuleMesh","get_mid_height") return _icall_Double( mb, this.ptr) } open fun getRadialSegments(): Long { val mb = getMethodBind("CapsuleMesh","get_radial_segments") return _icall_Long( mb, this.ptr) } open fun getRadius(): Double { val mb = getMethodBind("CapsuleMesh","get_radius") return _icall_Double( mb, this.ptr) } open fun getRings(): Long { val mb = getMethodBind("CapsuleMesh","get_rings") return _icall_Long( mb, this.ptr) } open fun setMidHeight(midHeight: Double) { val mb = getMethodBind("CapsuleMesh","set_mid_height") _icall_Unit_Double( mb, this.ptr, midHeight) } open fun setRadialSegments(segments: Long) { val mb = getMethodBind("CapsuleMesh","set_radial_segments") _icall_Unit_Long( mb, this.ptr, segments) } open fun setRadius(radius: Double) { val mb = getMethodBind("CapsuleMesh","set_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setRings(rings: Long) { val mb = getMethodBind("CapsuleMesh","set_rings") _icall_Unit_Long( mb, this.ptr, rings) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CapsuleShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class CapsuleShape : Shape() { open var height: Double get() { val mb = getMethodBind("CapsuleShape","get_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CapsuleShape","set_height") _icall_Unit_Double(mb, this.ptr, value) } open var radius: Double get() { val mb = getMethodBind("CapsuleShape","get_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CapsuleShape","set_radius") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CapsuleShape", "CapsuleShape") open fun getHeight(): Double { val mb = getMethodBind("CapsuleShape","get_height") return _icall_Double( mb, this.ptr) } open fun getRadius(): Double { val mb = getMethodBind("CapsuleShape","get_radius") return _icall_Double( mb, this.ptr) } open fun setHeight(height: Double) { val mb = getMethodBind("CapsuleShape","set_height") _icall_Unit_Double( mb, this.ptr, height) } open fun setRadius(radius: Double) { val mb = getMethodBind("CapsuleShape","set_radius") _icall_Unit_Double( mb, this.ptr, radius) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CapsuleShape2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class CapsuleShape2D : Shape2D() { open var height: Double get() { val mb = getMethodBind("CapsuleShape2D","get_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CapsuleShape2D","set_height") _icall_Unit_Double(mb, this.ptr, value) } open var radius: Double get() { val mb = getMethodBind("CapsuleShape2D","get_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CapsuleShape2D","set_radius") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CapsuleShape2D", "CapsuleShape2D") open fun getHeight(): Double { val mb = getMethodBind("CapsuleShape2D","get_height") return _icall_Double( mb, this.ptr) } open fun getRadius(): Double { val mb = getMethodBind("CapsuleShape2D","get_radius") return _icall_Double( mb, this.ptr) } open fun setHeight(height: Double) { val mb = getMethodBind("CapsuleShape2D","set_height") _icall_Unit_Double( mb, this.ptr, height) } open fun setRadius(radius: Double) { val mb = getMethodBind("CapsuleShape2D","set_radius") _icall_Unit_Double( mb, this.ptr, radius) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CenterContainer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class CenterContainer : Container() { open var useTopLeft: Boolean get() { val mb = getMethodBind("CenterContainer","is_using_top_left") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CenterContainer","set_use_top_left") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CenterContainer", "CenterContainer") open fun isUsingTopLeft(): Boolean { val mb = getMethodBind("CenterContainer","is_using_top_left") return _icall_Boolean( mb, this.ptr) } open fun setUseTopLeft(enable: Boolean) { val mb = getMethodBind("CenterContainer","set_use_top_left") _icall_Unit_Boolean( mb, this.ptr, enable) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CharFXTransform.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.Dictionary import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_Dictionary import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Dictionary import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class CharFXTransform : Reference() { open var absoluteIndex: Long get() { val mb = getMethodBind("CharFXTransform","get_absolute_index") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CharFXTransform","set_absolute_index") _icall_Unit_Long(mb, this.ptr, value) } open var character: Long get() { val mb = getMethodBind("CharFXTransform","get_character") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CharFXTransform","set_character") _icall_Unit_Long(mb, this.ptr, value) } open var color: Color get() { val mb = getMethodBind("CharFXTransform","get_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("CharFXTransform","set_color") _icall_Unit_Color(mb, this.ptr, value) } open var elapsedTime: Double get() { val mb = getMethodBind("CharFXTransform","get_elapsed_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CharFXTransform","set_elapsed_time") _icall_Unit_Double(mb, this.ptr, value) } open var env: Dictionary get() { val mb = getMethodBind("CharFXTransform","get_environment") return _icall_Dictionary(mb, this.ptr) } set(value) { val mb = getMethodBind("CharFXTransform","set_environment") _icall_Unit_Dictionary(mb, this.ptr, value) } open var offset: Vector2 get() { val mb = getMethodBind("CharFXTransform","get_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("CharFXTransform","set_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var relativeIndex: Long get() { val mb = getMethodBind("CharFXTransform","get_relative_index") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CharFXTransform","set_relative_index") _icall_Unit_Long(mb, this.ptr, value) } open var visible: Boolean get() { val mb = getMethodBind("CharFXTransform","is_visible") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CharFXTransform","set_visibility") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CharFXTransform", "CharFXTransform") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun offset(schedule: Vector2.() -> Unit): Vector2 = offset.apply{ schedule(this) offset = this } open fun getAbsoluteIndex(): Long { val mb = getMethodBind("CharFXTransform","get_absolute_index") return _icall_Long( mb, this.ptr) } open fun getCharacter(): Long { val mb = getMethodBind("CharFXTransform","get_character") return _icall_Long( mb, this.ptr) } open fun getColor(): Color { val mb = getMethodBind("CharFXTransform","get_color") return _icall_Color( mb, this.ptr) } open fun getElapsedTime(): Double { val mb = getMethodBind("CharFXTransform","get_elapsed_time") return _icall_Double( mb, this.ptr) } open fun getEnvironment(): Dictionary { val mb = getMethodBind("CharFXTransform","get_environment") return _icall_Dictionary( mb, this.ptr) } open fun getOffset(): Vector2 { val mb = getMethodBind("CharFXTransform","get_offset") return _icall_Vector2( mb, this.ptr) } open fun getRelativeIndex(): Long { val mb = getMethodBind("CharFXTransform","get_relative_index") return _icall_Long( mb, this.ptr) } open fun isVisible(): Boolean { val mb = getMethodBind("CharFXTransform","is_visible") return _icall_Boolean( mb, this.ptr) } open fun setAbsoluteIndex(index: Long) { val mb = getMethodBind("CharFXTransform","set_absolute_index") _icall_Unit_Long( mb, this.ptr, index) } open fun setCharacter(character: Long) { val mb = getMethodBind("CharFXTransform","set_character") _icall_Unit_Long( mb, this.ptr, character) } open fun setColor(color: Color) { val mb = getMethodBind("CharFXTransform","set_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setElapsedTime(time: Double) { val mb = getMethodBind("CharFXTransform","set_elapsed_time") _icall_Unit_Double( mb, this.ptr, time) } open fun setEnvironment(environment: Dictionary) { val mb = getMethodBind("CharFXTransform","set_environment") _icall_Unit_Dictionary( mb, this.ptr, environment) } open fun setOffset(offset: Vector2) { val mb = getMethodBind("CharFXTransform","set_offset") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun setRelativeIndex(index: Long) { val mb = getMethodBind("CharFXTransform","set_relative_index") _icall_Unit_Long( mb, this.ptr, index) } open fun setVisibility(visibility: Boolean) { val mb = getMethodBind("CharFXTransform","set_visibility") _icall_Unit_Boolean( mb, this.ptr, visibility) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CheckBox.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class CheckBox : Button() { override fun __new(): COpaquePointer = invokeConstructor("CheckBox", "CheckBox") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CheckButton.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class CheckButton : Button() { override fun __new(): COpaquePointer = invokeConstructor("CheckButton", "CheckButton") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CircleShape2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class CircleShape2D : Shape2D() { open var radius: Double get() { val mb = getMethodBind("CircleShape2D","get_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CircleShape2D","set_radius") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CircleShape2D", "CircleShape2D") open fun getRadius(): Double { val mb = getMethodBind("CircleShape2D","get_radius") return _icall_Double( mb, this.ptr) } open fun setRadius(radius: Double) { val mb = getMethodBind("CircleShape2D","set_radius") _icall_Unit_Double( mb, this.ptr, radius) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ClassDB.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.Godot import godot.core.GodotError import godot.core.PoolStringArray import godot.core.Variant import godot.core.VariantArray import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_String import godot.icalls._icall_Boolean_String_String_Boolean import godot.icalls._icall_Dictionary_String_String import godot.icalls._icall_Long_Object_String_Variant import godot.icalls._icall_Long_String_String import godot.icalls._icall_PoolStringArray import godot.icalls._icall_PoolStringArray_String import godot.icalls._icall_PoolStringArray_String_Boolean import godot.icalls._icall_String_String import godot.icalls._icall_VariantArray_String_Boolean import godot.icalls._icall_Variant_Object_String import godot.icalls._icall_Variant_String import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object ClassDB : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("ClassDB".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton ClassDB" } ptr } fun canInstance(_class: String): Boolean { val mb = getMethodBind("_ClassDB","can_instance") return _icall_Boolean_String( mb, this.ptr, _class) } fun classExists(_class: String): Boolean { val mb = getMethodBind("_ClassDB","class_exists") return _icall_Boolean_String( mb, this.ptr, _class) } fun classGetCategory(_class: String): String { val mb = getMethodBind("_ClassDB","class_get_category") return _icall_String_String( mb, this.ptr, _class) } fun classGetIntegerConstant(_class: String, name: String): Long { val mb = getMethodBind("_ClassDB","class_get_integer_constant") return _icall_Long_String_String( mb, this.ptr, _class, name) } fun classGetIntegerConstantList(_class: String, noInheritance: Boolean = false): PoolStringArray { val mb = getMethodBind("_ClassDB","class_get_integer_constant_list") return _icall_PoolStringArray_String_Boolean( mb, this.ptr, _class, noInheritance) } fun classGetMethodList(_class: String, noInheritance: Boolean = false): VariantArray { val mb = getMethodBind("_ClassDB","class_get_method_list") return _icall_VariantArray_String_Boolean( mb, this.ptr, _class, noInheritance) } fun classGetProperty(_object: Object, property: String): Variant { val mb = getMethodBind("_ClassDB","class_get_property") return _icall_Variant_Object_String( mb, this.ptr, _object, property) } fun classGetPropertyList(_class: String, noInheritance: Boolean = false): VariantArray { val mb = getMethodBind("_ClassDB","class_get_property_list") return _icall_VariantArray_String_Boolean( mb, this.ptr, _class, noInheritance) } fun classGetSignal(_class: String, signal: String): Dictionary { val mb = getMethodBind("_ClassDB","class_get_signal") return _icall_Dictionary_String_String( mb, this.ptr, _class, signal) } fun classGetSignalList(_class: String, noInheritance: Boolean = false): VariantArray { val mb = getMethodBind("_ClassDB","class_get_signal_list") return _icall_VariantArray_String_Boolean( mb, this.ptr, _class, noInheritance) } fun classHasIntegerConstant(_class: String, name: String): Boolean { val mb = getMethodBind("_ClassDB","class_has_integer_constant") return _icall_Boolean_String_String( mb, this.ptr, _class, name) } fun classHasMethod( _class: String, method: String, noInheritance: Boolean = false ): Boolean { val mb = getMethodBind("_ClassDB","class_has_method") return _icall_Boolean_String_String_Boolean( mb, this.ptr, _class, method, noInheritance) } fun classHasSignal(_class: String, signal: String): Boolean { val mb = getMethodBind("_ClassDB","class_has_signal") return _icall_Boolean_String_String( mb, this.ptr, _class, signal) } fun classSetProperty( _object: Object, property: String, value: Variant ): GodotError { val mb = getMethodBind("_ClassDB","class_set_property") return GodotError.byValue( _icall_Long_Object_String_Variant( mb, this.ptr, _object, property, value).toUInt()) } fun getClassList(): PoolStringArray { val mb = getMethodBind("_ClassDB","get_class_list") return _icall_PoolStringArray( mb, this.ptr) } fun getInheritersFromClass(_class: String): PoolStringArray { val mb = getMethodBind("_ClassDB","get_inheriters_from_class") return _icall_PoolStringArray_String( mb, this.ptr, _class) } fun getParentClass(_class: String): String { val mb = getMethodBind("_ClassDB","get_parent_class") return _icall_String_String( mb, this.ptr, _class) } fun instance(_class: String): Variant { val mb = getMethodBind("_ClassDB","instance") return _icall_Variant_String( mb, this.ptr, _class) } fun isClassEnabled(_class: String): Boolean { val mb = getMethodBind("_ClassDB","is_class_enabled") return _icall_Boolean_String( mb, this.ptr, _class) } fun isParentClass(_class: String, inherits: String): Boolean { val mb = getMethodBind("_ClassDB","is_parent_class") return _icall_Boolean_String_String( mb, this.ptr, _class, inherits) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ClippedCamera.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.ClippedCamera import godot.core.RID import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_RID import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class ClippedCamera : Camera() { open var clipToAreas: Boolean get() { val mb = getMethodBind("ClippedCamera","is_clip_to_areas_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ClippedCamera","set_clip_to_areas") _icall_Unit_Boolean(mb, this.ptr, value) } open var clipToBodies: Boolean get() { val mb = getMethodBind("ClippedCamera","is_clip_to_bodies_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ClippedCamera","set_clip_to_bodies") _icall_Unit_Boolean(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("ClippedCamera","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ClippedCamera","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open var margin: Double get() { val mb = getMethodBind("ClippedCamera","get_margin") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ClippedCamera","set_margin") _icall_Unit_Double(mb, this.ptr, value) } open var processMode: Long get() { val mb = getMethodBind("ClippedCamera","get_process_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ClippedCamera","set_process_mode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ClippedCamera", "ClippedCamera") open fun addException(node: Object) { val mb = getMethodBind("ClippedCamera","add_exception") _icall_Unit_Object( mb, this.ptr, node) } open fun addExceptionRid(rid: RID) { val mb = getMethodBind("ClippedCamera","add_exception_rid") _icall_Unit_RID( mb, this.ptr, rid) } open fun clearExceptions() { val mb = getMethodBind("ClippedCamera","clear_exceptions") _icall_Unit( mb, this.ptr) } open fun getClipOffset(): Double { val mb = getMethodBind("ClippedCamera","get_clip_offset") return _icall_Double( mb, this.ptr) } open fun getCollisionMask(): Long { val mb = getMethodBind("ClippedCamera","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("ClippedCamera","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getMargin(): Double { val mb = getMethodBind("ClippedCamera","get_margin") return _icall_Double( mb, this.ptr) } open fun getProcessMode(): ClippedCamera.ProcessMode { val mb = getMethodBind("ClippedCamera","get_process_mode") return ClippedCamera.ProcessMode.from( _icall_Long( mb, this.ptr)) } open fun isClipToAreasEnabled(): Boolean { val mb = getMethodBind("ClippedCamera","is_clip_to_areas_enabled") return _icall_Boolean( mb, this.ptr) } open fun isClipToBodiesEnabled(): Boolean { val mb = getMethodBind("ClippedCamera","is_clip_to_bodies_enabled") return _icall_Boolean( mb, this.ptr) } open fun removeException(node: Object) { val mb = getMethodBind("ClippedCamera","remove_exception") _icall_Unit_Object( mb, this.ptr, node) } open fun removeExceptionRid(rid: RID) { val mb = getMethodBind("ClippedCamera","remove_exception_rid") _icall_Unit_RID( mb, this.ptr, rid) } open fun setClipToAreas(enable: Boolean) { val mb = getMethodBind("ClippedCamera","set_clip_to_areas") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setClipToBodies(enable: Boolean) { val mb = getMethodBind("ClippedCamera","set_clip_to_bodies") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollisionMask(mask: Long) { val mb = getMethodBind("ClippedCamera","set_collision_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("ClippedCamera","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setMargin(margin: Double) { val mb = getMethodBind("ClippedCamera","set_margin") _icall_Unit_Double( mb, this.ptr, margin) } open fun setProcessMode(processMode: Long) { val mb = getMethodBind("ClippedCamera","set_process_mode") _icall_Unit_Long( mb, this.ptr, processMode) } enum class ProcessMode( id: Long ) { CLIP_PROCESS_PHYSICS(0), CLIP_PROCESS_IDLE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CollisionObject.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Signal0 import godot.core.Signal5 import godot.core.Transform import godot.core.VariantArray import godot.core.Vector3 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_Long_Long import godot.icalls._icall_Long_Object import godot.icalls._icall_Object_Long import godot.icalls._icall_RID import godot.icalls._icall_Shape_Long_Long import godot.icalls._icall_Transform_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Long_Transform import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long open class CollisionObject internal constructor() : Spatial() { val inputEvent: Signal5 by signal("camera", "event", "click_position", "click_normal", "shape_idx") val mouseEntered: Signal0 by signal() val mouseExited: Signal0 by signal() open var inputCaptureOnDrag: Boolean get() { val mb = getMethodBind("CollisionObject","get_capture_input_on_drag") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionObject","set_capture_input_on_drag") _icall_Unit_Boolean(mb, this.ptr, value) } open var inputRayPickable: Boolean get() { val mb = getMethodBind("CollisionObject","is_ray_pickable") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionObject","set_ray_pickable") _icall_Unit_Boolean(mb, this.ptr, value) } open fun _inputEvent( camera: Object, event: InputEvent, clickPosition: Vector3, clickNormal: Vector3, shapeIdx: Long ) { } open fun createShapeOwner(owner: Object): Long { val mb = getMethodBind("CollisionObject","create_shape_owner") return _icall_Long_Object( mb, this.ptr, owner) } open fun getCaptureInputOnDrag(): Boolean { val mb = getMethodBind("CollisionObject","get_capture_input_on_drag") return _icall_Boolean( mb, this.ptr) } open fun getRid(): RID { val mb = getMethodBind("CollisionObject","get_rid") return _icall_RID( mb, this.ptr) } open fun getShapeOwners(): VariantArray { val mb = getMethodBind("CollisionObject","get_shape_owners") return _icall_VariantArray( mb, this.ptr) } open fun isRayPickable(): Boolean { val mb = getMethodBind("CollisionObject","is_ray_pickable") return _icall_Boolean( mb, this.ptr) } open fun isShapeOwnerDisabled(ownerId: Long): Boolean { val mb = getMethodBind("CollisionObject","is_shape_owner_disabled") return _icall_Boolean_Long( mb, this.ptr, ownerId) } open fun removeShapeOwner(ownerId: Long) { val mb = getMethodBind("CollisionObject","remove_shape_owner") _icall_Unit_Long( mb, this.ptr, ownerId) } open fun setCaptureInputOnDrag(enable: Boolean) { val mb = getMethodBind("CollisionObject","set_capture_input_on_drag") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setRayPickable(rayPickable: Boolean) { val mb = getMethodBind("CollisionObject","set_ray_pickable") _icall_Unit_Boolean( mb, this.ptr, rayPickable) } open fun shapeFindOwner(shapeIndex: Long): Long { val mb = getMethodBind("CollisionObject","shape_find_owner") return _icall_Long_Long( mb, this.ptr, shapeIndex) } open fun shapeOwnerAddShape(ownerId: Long, shape: Shape) { val mb = getMethodBind("CollisionObject","shape_owner_add_shape") _icall_Unit_Long_Object( mb, this.ptr, ownerId, shape) } open fun shapeOwnerClearShapes(ownerId: Long) { val mb = getMethodBind("CollisionObject","shape_owner_clear_shapes") _icall_Unit_Long( mb, this.ptr, ownerId) } open fun shapeOwnerGetOwner(ownerId: Long): Object { val mb = getMethodBind("CollisionObject","shape_owner_get_owner") return _icall_Object_Long( mb, this.ptr, ownerId) } open fun shapeOwnerGetShape(ownerId: Long, shapeId: Long): Shape { val mb = getMethodBind("CollisionObject","shape_owner_get_shape") return _icall_Shape_Long_Long( mb, this.ptr, ownerId, shapeId) } open fun shapeOwnerGetShapeCount(ownerId: Long): Long { val mb = getMethodBind("CollisionObject","shape_owner_get_shape_count") return _icall_Long_Long( mb, this.ptr, ownerId) } open fun shapeOwnerGetShapeIndex(ownerId: Long, shapeId: Long): Long { val mb = getMethodBind("CollisionObject","shape_owner_get_shape_index") return _icall_Long_Long_Long( mb, this.ptr, ownerId, shapeId) } open fun shapeOwnerGetTransform(ownerId: Long): Transform { val mb = getMethodBind("CollisionObject","shape_owner_get_transform") return _icall_Transform_Long( mb, this.ptr, ownerId) } open fun shapeOwnerRemoveShape(ownerId: Long, shapeId: Long) { val mb = getMethodBind("CollisionObject","shape_owner_remove_shape") _icall_Unit_Long_Long( mb, this.ptr, ownerId, shapeId) } open fun shapeOwnerSetDisabled(ownerId: Long, disabled: Boolean) { val mb = getMethodBind("CollisionObject","shape_owner_set_disabled") _icall_Unit_Long_Boolean( mb, this.ptr, ownerId, disabled) } open fun shapeOwnerSetTransform(ownerId: Long, transform: Transform) { val mb = getMethodBind("CollisionObject","shape_owner_set_transform") _icall_Unit_Long_Transform( mb, this.ptr, ownerId, transform) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CollisionObject2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Signal0 import godot.core.Signal3 import godot.core.Transform2D import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_Long_Long import godot.icalls._icall_Long_Object import godot.icalls._icall_Object_Long import godot.icalls._icall_RID import godot.icalls._icall_Shape2D_Long_Long import godot.icalls._icall_Transform2D_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Long_Transform2D import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long open class CollisionObject2D internal constructor() : Node2D() { val inputEvent: Signal3 by signal("viewport", "event", "shape_idx") val mouseEntered: Signal0 by signal() val mouseExited: Signal0 by signal() open var inputPickable: Boolean get() { val mb = getMethodBind("CollisionObject2D","is_pickable") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionObject2D","set_pickable") _icall_Unit_Boolean(mb, this.ptr, value) } open fun _inputEvent( viewport: Object, event: InputEvent, shapeIdx: Long ) { } open fun createShapeOwner(owner: Object): Long { val mb = getMethodBind("CollisionObject2D","create_shape_owner") return _icall_Long_Object( mb, this.ptr, owner) } open fun getRid(): RID { val mb = getMethodBind("CollisionObject2D","get_rid") return _icall_RID( mb, this.ptr) } open fun getShapeOwnerOneWayCollisionMargin(ownerId: Long): Double { val mb = getMethodBind("CollisionObject2D","get_shape_owner_one_way_collision_margin") return _icall_Double_Long( mb, this.ptr, ownerId) } open fun getShapeOwners(): VariantArray { val mb = getMethodBind("CollisionObject2D","get_shape_owners") return _icall_VariantArray( mb, this.ptr) } open fun isPickable(): Boolean { val mb = getMethodBind("CollisionObject2D","is_pickable") return _icall_Boolean( mb, this.ptr) } open fun isShapeOwnerDisabled(ownerId: Long): Boolean { val mb = getMethodBind("CollisionObject2D","is_shape_owner_disabled") return _icall_Boolean_Long( mb, this.ptr, ownerId) } open fun isShapeOwnerOneWayCollisionEnabled(ownerId: Long): Boolean { val mb = getMethodBind("CollisionObject2D","is_shape_owner_one_way_collision_enabled") return _icall_Boolean_Long( mb, this.ptr, ownerId) } open fun removeShapeOwner(ownerId: Long) { val mb = getMethodBind("CollisionObject2D","remove_shape_owner") _icall_Unit_Long( mb, this.ptr, ownerId) } open fun setPickable(enabled: Boolean) { val mb = getMethodBind("CollisionObject2D","set_pickable") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun shapeFindOwner(shapeIndex: Long): Long { val mb = getMethodBind("CollisionObject2D","shape_find_owner") return _icall_Long_Long( mb, this.ptr, shapeIndex) } open fun shapeOwnerAddShape(ownerId: Long, shape: Shape2D) { val mb = getMethodBind("CollisionObject2D","shape_owner_add_shape") _icall_Unit_Long_Object( mb, this.ptr, ownerId, shape) } open fun shapeOwnerClearShapes(ownerId: Long) { val mb = getMethodBind("CollisionObject2D","shape_owner_clear_shapes") _icall_Unit_Long( mb, this.ptr, ownerId) } open fun shapeOwnerGetOwner(ownerId: Long): Object { val mb = getMethodBind("CollisionObject2D","shape_owner_get_owner") return _icall_Object_Long( mb, this.ptr, ownerId) } open fun shapeOwnerGetShape(ownerId: Long, shapeId: Long): Shape2D { val mb = getMethodBind("CollisionObject2D","shape_owner_get_shape") return _icall_Shape2D_Long_Long( mb, this.ptr, ownerId, shapeId) } open fun shapeOwnerGetShapeCount(ownerId: Long): Long { val mb = getMethodBind("CollisionObject2D","shape_owner_get_shape_count") return _icall_Long_Long( mb, this.ptr, ownerId) } open fun shapeOwnerGetShapeIndex(ownerId: Long, shapeId: Long): Long { val mb = getMethodBind("CollisionObject2D","shape_owner_get_shape_index") return _icall_Long_Long_Long( mb, this.ptr, ownerId, shapeId) } open fun shapeOwnerGetTransform(ownerId: Long): Transform2D { val mb = getMethodBind("CollisionObject2D","shape_owner_get_transform") return _icall_Transform2D_Long( mb, this.ptr, ownerId) } open fun shapeOwnerRemoveShape(ownerId: Long, shapeId: Long) { val mb = getMethodBind("CollisionObject2D","shape_owner_remove_shape") _icall_Unit_Long_Long( mb, this.ptr, ownerId, shapeId) } open fun shapeOwnerSetDisabled(ownerId: Long, disabled: Boolean) { val mb = getMethodBind("CollisionObject2D","shape_owner_set_disabled") _icall_Unit_Long_Boolean( mb, this.ptr, ownerId, disabled) } open fun shapeOwnerSetOneWayCollision(ownerId: Long, enable: Boolean) { val mb = getMethodBind("CollisionObject2D","shape_owner_set_one_way_collision") _icall_Unit_Long_Boolean( mb, this.ptr, ownerId, enable) } open fun shapeOwnerSetOneWayCollisionMargin(ownerId: Long, margin: Double) { val mb = getMethodBind("CollisionObject2D","shape_owner_set_one_way_collision_margin") _icall_Unit_Long_Double( mb, this.ptr, ownerId, margin) } open fun shapeOwnerSetTransform(ownerId: Long, transform: Transform2D) { val mb = getMethodBind("CollisionObject2D","shape_owner_set_transform") _icall_Unit_Long_Transform2D( mb, this.ptr, ownerId, transform) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CollisionPolygon.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolVector2Array import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_PoolVector2Array import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class CollisionPolygon : Spatial() { open var depth: Double get() { val mb = getMethodBind("CollisionPolygon","get_depth") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionPolygon","set_depth") _icall_Unit_Double(mb, this.ptr, value) } open var disabled: Boolean get() { val mb = getMethodBind("CollisionPolygon","is_disabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionPolygon","set_disabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var polygon: PoolVector2Array get() { val mb = getMethodBind("CollisionPolygon","get_polygon") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionPolygon","set_polygon") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CollisionPolygon", "CollisionPolygon") open fun _isEditable3dPolygon(): Boolean { throw NotImplementedError("_is_editable_3d_polygon is not implemented for CollisionPolygon") } open fun getDepth(): Double { val mb = getMethodBind("CollisionPolygon","get_depth") return _icall_Double( mb, this.ptr) } open fun getPolygon(): PoolVector2Array { val mb = getMethodBind("CollisionPolygon","get_polygon") return _icall_PoolVector2Array( mb, this.ptr) } open fun isDisabled(): Boolean { val mb = getMethodBind("CollisionPolygon","is_disabled") return _icall_Boolean( mb, this.ptr) } open fun setDepth(depth: Double) { val mb = getMethodBind("CollisionPolygon","set_depth") _icall_Unit_Double( mb, this.ptr, depth) } open fun setDisabled(disabled: Boolean) { val mb = getMethodBind("CollisionPolygon","set_disabled") _icall_Unit_Boolean( mb, this.ptr, disabled) } open fun setPolygon(polygon: PoolVector2Array) { val mb = getMethodBind("CollisionPolygon","set_polygon") _icall_Unit_PoolVector2Array( mb, this.ptr, polygon) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CollisionPolygon2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.CollisionPolygon2D import godot.core.PoolVector2Array import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_PoolVector2Array import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class CollisionPolygon2D : Node2D() { open var buildMode: Long get() { val mb = getMethodBind("CollisionPolygon2D","get_build_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionPolygon2D","set_build_mode") _icall_Unit_Long(mb, this.ptr, value) } open var disabled: Boolean get() { val mb = getMethodBind("CollisionPolygon2D","is_disabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionPolygon2D","set_disabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var oneWayCollision: Boolean get() { val mb = getMethodBind("CollisionPolygon2D","is_one_way_collision_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionPolygon2D","set_one_way_collision") _icall_Unit_Boolean(mb, this.ptr, value) } open var oneWayCollisionMargin: Double get() { val mb = getMethodBind("CollisionPolygon2D","get_one_way_collision_margin") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionPolygon2D","set_one_way_collision_margin") _icall_Unit_Double(mb, this.ptr, value) } open var polygon: PoolVector2Array get() { val mb = getMethodBind("CollisionPolygon2D","get_polygon") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionPolygon2D","set_polygon") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CollisionPolygon2D", "CollisionPolygon2D") open fun getBuildMode(): CollisionPolygon2D.BuildMode { val mb = getMethodBind("CollisionPolygon2D","get_build_mode") return CollisionPolygon2D.BuildMode.from( _icall_Long( mb, this.ptr)) } open fun getOneWayCollisionMargin(): Double { val mb = getMethodBind("CollisionPolygon2D","get_one_way_collision_margin") return _icall_Double( mb, this.ptr) } open fun getPolygon(): PoolVector2Array { val mb = getMethodBind("CollisionPolygon2D","get_polygon") return _icall_PoolVector2Array( mb, this.ptr) } open fun isDisabled(): Boolean { val mb = getMethodBind("CollisionPolygon2D","is_disabled") return _icall_Boolean( mb, this.ptr) } open fun isOneWayCollisionEnabled(): Boolean { val mb = getMethodBind("CollisionPolygon2D","is_one_way_collision_enabled") return _icall_Boolean( mb, this.ptr) } open fun setBuildMode(buildMode: Long) { val mb = getMethodBind("CollisionPolygon2D","set_build_mode") _icall_Unit_Long( mb, this.ptr, buildMode) } open fun setDisabled(disabled: Boolean) { val mb = getMethodBind("CollisionPolygon2D","set_disabled") _icall_Unit_Boolean( mb, this.ptr, disabled) } open fun setOneWayCollision(enabled: Boolean) { val mb = getMethodBind("CollisionPolygon2D","set_one_way_collision") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setOneWayCollisionMargin(margin: Double) { val mb = getMethodBind("CollisionPolygon2D","set_one_way_collision_margin") _icall_Unit_Double( mb, this.ptr, margin) } open fun setPolygon(polygon: PoolVector2Array) { val mb = getMethodBind("CollisionPolygon2D","set_polygon") _icall_Unit_PoolVector2Array( mb, this.ptr, polygon) } enum class BuildMode( id: Long ) { BUILD_SOLIDS(0), BUILD_SEGMENTS(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CollisionShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Shape import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class CollisionShape : Spatial() { open var disabled: Boolean get() { val mb = getMethodBind("CollisionShape","is_disabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionShape","set_disabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var shape: Shape get() { val mb = getMethodBind("CollisionShape","get_shape") return _icall_Shape(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionShape","set_shape") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CollisionShape", "CollisionShape") open fun _shapeChanged() { } open fun _updateDebugShape() { } open fun getShape(): Shape { val mb = getMethodBind("CollisionShape","get_shape") return _icall_Shape( mb, this.ptr) } open fun isDisabled(): Boolean { val mb = getMethodBind("CollisionShape","is_disabled") return _icall_Boolean( mb, this.ptr) } open fun makeConvexFromBrothers() { val mb = getMethodBind("CollisionShape","make_convex_from_brothers") _icall_Unit( mb, this.ptr) } open fun resourceChanged(resource: Resource) { val mb = getMethodBind("CollisionShape","resource_changed") _icall_Unit_Object( mb, this.ptr, resource) } open fun setDisabled(enable: Boolean) { val mb = getMethodBind("CollisionShape","set_disabled") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setShape(shape: Shape) { val mb = getMethodBind("CollisionShape","set_shape") _icall_Unit_Object( mb, this.ptr, shape) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CollisionShape2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Shape2D import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlinx.cinterop.COpaquePointer open class CollisionShape2D : Node2D() { open var disabled: Boolean get() { val mb = getMethodBind("CollisionShape2D","is_disabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionShape2D","set_disabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var oneWayCollision: Boolean get() { val mb = getMethodBind("CollisionShape2D","is_one_way_collision_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionShape2D","set_one_way_collision") _icall_Unit_Boolean(mb, this.ptr, value) } open var oneWayCollisionMargin: Double get() { val mb = getMethodBind("CollisionShape2D","get_one_way_collision_margin") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionShape2D","set_one_way_collision_margin") _icall_Unit_Double(mb, this.ptr, value) } open var shape: Shape2D get() { val mb = getMethodBind("CollisionShape2D","get_shape") return _icall_Shape2D(mb, this.ptr) } set(value) { val mb = getMethodBind("CollisionShape2D","set_shape") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CollisionShape2D", "CollisionShape2D") open fun _shapeChanged() { } open fun getOneWayCollisionMargin(): Double { val mb = getMethodBind("CollisionShape2D","get_one_way_collision_margin") return _icall_Double( mb, this.ptr) } open fun getShape(): Shape2D { val mb = getMethodBind("CollisionShape2D","get_shape") return _icall_Shape2D( mb, this.ptr) } open fun isDisabled(): Boolean { val mb = getMethodBind("CollisionShape2D","is_disabled") return _icall_Boolean( mb, this.ptr) } open fun isOneWayCollisionEnabled(): Boolean { val mb = getMethodBind("CollisionShape2D","is_one_way_collision_enabled") return _icall_Boolean( mb, this.ptr) } open fun setDisabled(disabled: Boolean) { val mb = getMethodBind("CollisionShape2D","set_disabled") _icall_Unit_Boolean( mb, this.ptr, disabled) } open fun setOneWayCollision(enabled: Boolean) { val mb = getMethodBind("CollisionShape2D","set_one_way_collision") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setOneWayCollisionMargin(margin: Double) { val mb = getMethodBind("CollisionShape2D","set_one_way_collision_margin") _icall_Unit_Double( mb, this.ptr, margin) } open fun setShape(shape: Shape2D) { val mb = getMethodBind("CollisionShape2D","set_shape") _icall_Unit_Object( mb, this.ptr, shape) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ColorPicker.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.PoolColorArray import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_PoolColorArray import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ColorPicker : BoxContainer() { val colorChanged: Signal1 by signal("color") val presetAdded: Signal1 by signal("color") val presetRemoved: Signal1 by signal("color") open var color: Color get() { val mb = getMethodBind("ColorPicker","get_pick_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorPicker","set_pick_color") _icall_Unit_Color(mb, this.ptr, value) } open var deferredMode: Boolean get() { val mb = getMethodBind("ColorPicker","is_deferred_mode") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorPicker","set_deferred_mode") _icall_Unit_Boolean(mb, this.ptr, value) } open var editAlpha: Boolean get() { val mb = getMethodBind("ColorPicker","is_editing_alpha") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorPicker","set_edit_alpha") _icall_Unit_Boolean(mb, this.ptr, value) } open var hsvMode: Boolean get() { val mb = getMethodBind("ColorPicker","is_hsv_mode") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorPicker","set_hsv_mode") _icall_Unit_Boolean(mb, this.ptr, value) } open var presetsEnabled: Boolean get() { val mb = getMethodBind("ColorPicker","are_presets_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorPicker","set_presets_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var presetsVisible: Boolean get() { val mb = getMethodBind("ColorPicker","are_presets_visible") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorPicker","set_presets_visible") _icall_Unit_Boolean(mb, this.ptr, value) } open var rawMode: Boolean get() { val mb = getMethodBind("ColorPicker","is_raw_mode") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorPicker","set_raw_mode") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ColorPicker", "ColorPicker") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun _addPresetPressed() { } open fun _focusEnter() { } open fun _focusExit() { } open fun _hsvDraw(arg0: Long, arg1: Control) { } open fun _htmlEntered(arg0: String) { } open fun _htmlFocusExit() { } open fun _presetInput(arg0: InputEvent) { } open fun _sampleDraw() { } open fun _screenInput(arg0: InputEvent) { } open fun _screenPickPressed() { } open fun _textTypeToggled() { } open fun _updatePresets() { } open fun _uvInput(arg0: InputEvent) { } open fun _valueChanged(arg0: Double) { } open fun _wInput(arg0: InputEvent) { } open fun addPreset(color: Color) { val mb = getMethodBind("ColorPicker","add_preset") _icall_Unit_Color( mb, this.ptr, color) } open fun arePresetsEnabled(): Boolean { val mb = getMethodBind("ColorPicker","are_presets_enabled") return _icall_Boolean( mb, this.ptr) } open fun arePresetsVisible(): Boolean { val mb = getMethodBind("ColorPicker","are_presets_visible") return _icall_Boolean( mb, this.ptr) } open fun erasePreset(color: Color) { val mb = getMethodBind("ColorPicker","erase_preset") _icall_Unit_Color( mb, this.ptr, color) } open fun getPickColor(): Color { val mb = getMethodBind("ColorPicker","get_pick_color") return _icall_Color( mb, this.ptr) } open fun getPresets(): PoolColorArray { val mb = getMethodBind("ColorPicker","get_presets") return _icall_PoolColorArray( mb, this.ptr) } open fun isDeferredMode(): Boolean { val mb = getMethodBind("ColorPicker","is_deferred_mode") return _icall_Boolean( mb, this.ptr) } open fun isEditingAlpha(): Boolean { val mb = getMethodBind("ColorPicker","is_editing_alpha") return _icall_Boolean( mb, this.ptr) } open fun isHsvMode(): Boolean { val mb = getMethodBind("ColorPicker","is_hsv_mode") return _icall_Boolean( mb, this.ptr) } open fun isRawMode(): Boolean { val mb = getMethodBind("ColorPicker","is_raw_mode") return _icall_Boolean( mb, this.ptr) } open fun setDeferredMode(mode: Boolean) { val mb = getMethodBind("ColorPicker","set_deferred_mode") _icall_Unit_Boolean( mb, this.ptr, mode) } open fun setEditAlpha(show: Boolean) { val mb = getMethodBind("ColorPicker","set_edit_alpha") _icall_Unit_Boolean( mb, this.ptr, show) } open fun setHsvMode(mode: Boolean) { val mb = getMethodBind("ColorPicker","set_hsv_mode") _icall_Unit_Boolean( mb, this.ptr, mode) } open fun setPickColor(color: Color) { val mb = getMethodBind("ColorPicker","set_pick_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setPresetsEnabled(enabled: Boolean) { val mb = getMethodBind("ColorPicker","set_presets_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setPresetsVisible(visible: Boolean) { val mb = getMethodBind("ColorPicker","set_presets_visible") _icall_Unit_Boolean( mb, this.ptr, visible) } open fun setRawMode(mode: Boolean) { val mb = getMethodBind("ColorPicker","set_raw_mode") _icall_Unit_Boolean( mb, this.ptr, mode) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ColorPickerButton.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.Signal0 import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_ColorPicker import godot.icalls._icall_PopupPanel import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ColorPickerButton : Button() { val colorChanged: Signal1 by signal("color") val pickerCreated: Signal0 by signal() val popupClosed: Signal0 by signal() open var color: Color get() { val mb = getMethodBind("ColorPickerButton","get_pick_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorPickerButton","set_pick_color") _icall_Unit_Color(mb, this.ptr, value) } open var editAlpha: Boolean get() { val mb = getMethodBind("ColorPickerButton","is_editing_alpha") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorPickerButton","set_edit_alpha") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ColorPickerButton", "ColorPickerButton") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun _colorChanged(arg0: Color) { } open fun _modalClosed() { } open fun getPickColor(): Color { val mb = getMethodBind("ColorPickerButton","get_pick_color") return _icall_Color( mb, this.ptr) } open fun getPicker(): ColorPicker { val mb = getMethodBind("ColorPickerButton","get_picker") return _icall_ColorPicker( mb, this.ptr) } open fun getPopup(): PopupPanel { val mb = getMethodBind("ColorPickerButton","get_popup") return _icall_PopupPanel( mb, this.ptr) } open fun isEditingAlpha(): Boolean { val mb = getMethodBind("ColorPickerButton","is_editing_alpha") return _icall_Boolean( mb, this.ptr) } open fun setEditAlpha(show: Boolean) { val mb = getMethodBind("ColorPickerButton","set_edit_alpha") _icall_Unit_Boolean( mb, this.ptr, show) } open fun setPickColor(color: Color) { val mb = getMethodBind("ColorPickerButton","set_pick_color") _icall_Unit_Color( mb, this.ptr, color) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ColorRect.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.icalls._icall_Color import godot.icalls._icall_Unit_Color import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ColorRect : Control() { open var color: Color get() { val mb = getMethodBind("ColorRect","get_frame_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ColorRect","set_frame_color") _icall_Unit_Color(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ColorRect", "ColorRect") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun getFrameColor(): Color { val mb = getMethodBind("ColorRect","get_frame_color") return _icall_Color( mb, this.ptr) } open fun setFrameColor(color: Color) { val mb = getMethodBind("ColorRect","set_frame_color") _icall_Unit_Color( mb, this.ptr, color) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ConcavePolygonShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolVector3Array import godot.icalls._icall_PoolVector3Array import godot.icalls._icall_Unit_PoolVector3Array import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class ConcavePolygonShape : Shape() { open var data: PoolVector3Array get() { val mb = getMethodBind("ConcavePolygonShape","get_faces") return _icall_PoolVector3Array(mb, this.ptr) } set(value) { val mb = getMethodBind("ConcavePolygonShape","set_faces") _icall_Unit_PoolVector3Array(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ConcavePolygonShape", "ConcavePolygonShape") open fun getFaces(): PoolVector3Array { val mb = getMethodBind("ConcavePolygonShape","get_faces") return _icall_PoolVector3Array( mb, this.ptr) } open fun setFaces(faces: PoolVector3Array) { val mb = getMethodBind("ConcavePolygonShape","set_faces") _icall_Unit_PoolVector3Array( mb, this.ptr, faces) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ConcavePolygonShape2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolVector2Array import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_Unit_PoolVector2Array import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class ConcavePolygonShape2D : Shape2D() { open var segments: PoolVector2Array get() { val mb = getMethodBind("ConcavePolygonShape2D","get_segments") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("ConcavePolygonShape2D","set_segments") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ConcavePolygonShape2D", "ConcavePolygonShape2D") open fun getSegments(): PoolVector2Array { val mb = getMethodBind("ConcavePolygonShape2D","get_segments") return _icall_PoolVector2Array( mb, this.ptr) } open fun setSegments(segments: PoolVector2Array) { val mb = getMethodBind("ConcavePolygonShape2D","set_segments") _icall_Unit_PoolVector2Array( mb, this.ptr, segments) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ConeTwistJoint.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double_Long import godot.icalls._icall_Unit_Long_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class ConeTwistJoint : Joint() { open var bias: Double get() { val mb = getMethodBind("ConeTwistJoint","get_param") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("ConeTwistJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var relaxation: Double get() { val mb = getMethodBind("ConeTwistJoint","get_param") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("ConeTwistJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var softness: Double get() { val mb = getMethodBind("ConeTwistJoint","get_param") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("ConeTwistJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } override fun __new(): COpaquePointer = invokeConstructor("ConeTwistJoint", "ConeTwistJoint") open fun _getSwingSpan(): Double { throw NotImplementedError("_get_swing_span is not implemented for ConeTwistJoint") } open fun _getTwistSpan(): Double { throw NotImplementedError("_get_twist_span is not implemented for ConeTwistJoint") } open fun _setSwingSpan(swingSpan: Double) { } open fun _setTwistSpan(twistSpan: Double) { } open fun getParam(param: Long): Double { val mb = getMethodBind("ConeTwistJoint","get_param") return _icall_Double_Long( mb, this.ptr, param) } open fun setParam(param: Long, value: Double) { val mb = getMethodBind("ConeTwistJoint","set_param") _icall_Unit_Long_Double( mb, this.ptr, param, value) } enum class Param( id: Long ) { PARAM_SWING_SPAN(0), PARAM_TWIST_SPAN(1), PARAM_BIAS(2), PARAM_SOFTNESS(3), PARAM_RELAXATION(4), PARAM_MAX(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ConfigFile.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.PoolByteArray import godot.core.PoolStringArray import godot.core.Variant import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_String import godot.icalls._icall_Long_String import godot.icalls._icall_Long_String_PoolByteArray import godot.icalls._icall_Long_String_String import godot.icalls._icall_PoolStringArray import godot.icalls._icall_PoolStringArray_String import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_String import godot.icalls._icall_Unit_String_String_Variant import godot.icalls._icall_Variant_String_String_nVariant import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.String import kotlinx.cinterop.COpaquePointer open class ConfigFile : Reference() { override fun __new(): COpaquePointer = invokeConstructor("ConfigFile", "ConfigFile") open fun eraseSection(section: String) { val mb = getMethodBind("ConfigFile","erase_section") _icall_Unit_String( mb, this.ptr, section) } open fun eraseSectionKey(section: String, key: String) { val mb = getMethodBind("ConfigFile","erase_section_key") _icall_Unit_String_String( mb, this.ptr, section, key) } open fun getSectionKeys(section: String): PoolStringArray { val mb = getMethodBind("ConfigFile","get_section_keys") return _icall_PoolStringArray_String( mb, this.ptr, section) } open fun getSections(): PoolStringArray { val mb = getMethodBind("ConfigFile","get_sections") return _icall_PoolStringArray( mb, this.ptr) } open fun getValue( section: String, key: String, default: Variant? = null ): Variant { val mb = getMethodBind("ConfigFile","get_value") return _icall_Variant_String_String_nVariant( mb, this.ptr, section, key, default) } open fun hasSection(section: String): Boolean { val mb = getMethodBind("ConfigFile","has_section") return _icall_Boolean_String( mb, this.ptr, section) } open fun hasSectionKey(section: String, key: String): Boolean { val mb = getMethodBind("ConfigFile","has_section_key") return _icall_Boolean_String_String( mb, this.ptr, section, key) } open fun load(path: String): GodotError { val mb = getMethodBind("ConfigFile","load") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun loadEncrypted(path: String, key: PoolByteArray): GodotError { val mb = getMethodBind("ConfigFile","load_encrypted") return GodotError.byValue( _icall_Long_String_PoolByteArray( mb, this.ptr, path, key).toUInt()) } open fun loadEncryptedPass(path: String, password: String): GodotError { val mb = getMethodBind("ConfigFile","load_encrypted_pass") return GodotError.byValue( _icall_Long_String_String( mb, this.ptr, path, password).toUInt()) } open fun parse(data: String): GodotError { val mb = getMethodBind("ConfigFile","parse") return GodotError.byValue( _icall_Long_String( mb, this.ptr, data).toUInt()) } open fun save(path: String): GodotError { val mb = getMethodBind("ConfigFile","save") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun saveEncrypted(path: String, key: PoolByteArray): GodotError { val mb = getMethodBind("ConfigFile","save_encrypted") return GodotError.byValue( _icall_Long_String_PoolByteArray( mb, this.ptr, path, key).toUInt()) } open fun saveEncryptedPass(path: String, password: String): GodotError { val mb = getMethodBind("ConfigFile","save_encrypted_pass") return GodotError.byValue( _icall_Long_String_String( mb, this.ptr, path, password).toUInt()) } open fun setValue( section: String, key: String, value: Variant ) { val mb = getMethodBind("ConfigFile","set_value") _icall_Unit_String_String_Variant( mb, this.ptr, section, key, value) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ConfirmationDialog.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Button import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class ConfirmationDialog : AcceptDialog() { override fun __new(): COpaquePointer = invokeConstructor("ConfirmationDialog", "ConfirmationDialog") open fun getCancel(): Button { val mb = getMethodBind("ConfirmationDialog","get_cancel") return _icall_Button( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Container.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Rect2 import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Object_Rect2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class Container : Control() { val sortChildren: Signal0 by signal() override fun __new(): COpaquePointer = invokeConstructor("Container", "Container") open fun _childMinsizeChanged() { } open fun _sortChildren() { } open fun fitChildInRect(child: Control, rect: Rect2) { val mb = getMethodBind("Container","fit_child_in_rect") _icall_Unit_Object_Rect2( mb, this.ptr, child, rect) } open fun queueSort() { val mb = getMethodBind("Container","queue_sort") _icall_Unit( mb, this.ptr) } companion object { final const val NOTIFICATION_SORT_CHILDREN: Long = 50 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Control.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Control import godot.core.Color import godot.core.NodePath import godot.core.Rect2 import godot.core.Signal0 import godot.core.Signal1 import godot.core.Variant import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_String import godot.icalls._icall_Color_String_String import godot.icalls._icall_Control import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Font_String_String import godot.icalls._icall_Long import godot.icalls._icall_Long_String_String import godot.icalls._icall_Long_Vector2 import godot.icalls._icall_NodePath import godot.icalls._icall_NodePath_Long import godot.icalls._icall_Rect2 import godot.icalls._icall_String_Vector2 import godot.icalls._icall_StyleBox_String_String import godot.icalls._icall_Texture_String_String import godot.icalls._icall_Theme import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Double_Boolean_Boolean import godot.icalls._icall_Unit_Long_Double_Double_Boolean import godot.icalls._icall_Unit_Long_Long_Long import godot.icalls._icall_Unit_Long_NodePath import godot.icalls._icall_Unit_NodePath import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Color import godot.icalls._icall_Unit_String_Long import godot.icalls._icall_Unit_String_Object import godot.icalls._icall_Unit_Variant_Object import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Unit_Vector2_Boolean import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlin.UninitializedPropertyAccessException import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Control : CanvasItem() { val focusEntered: Signal0 by signal() val focusExited: Signal0 by signal() val guiInput: Signal1 by signal("event") val minimumSizeChanged: Signal0 by signal() val modalClosed: Signal0 by signal() val mouseEntered: Signal0 by signal() val mouseExited: Signal0 by signal() val resized: Signal0 by signal() val sizeFlagsChanged: Signal0 by signal() open val anchorBottom: Double get() { val mb = getMethodBind("Control","get_anchor") return _icall_Double_Long(mb, this.ptr, 3) } open val anchorLeft: Double get() { val mb = getMethodBind("Control","get_anchor") return _icall_Double_Long(mb, this.ptr, 0) } open val anchorRight: Double get() { val mb = getMethodBind("Control","get_anchor") return _icall_Double_Long(mb, this.ptr, 2) } open val anchorTop: Double get() { val mb = getMethodBind("Control","get_anchor") return _icall_Double_Long(mb, this.ptr, 1) } open var focusMode: Long get() { val mb = getMethodBind("Control","get_focus_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_focus_mode") _icall_Unit_Long(mb, this.ptr, value) } open var focusNeighbourBottom: NodePath get() { val mb = getMethodBind("Control","get_focus_neighbour") return _icall_NodePath_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Control","set_focus_neighbour") _icall_Unit_Long_NodePath(mb, this.ptr, 3, value) } open var focusNeighbourLeft: NodePath get() { val mb = getMethodBind("Control","get_focus_neighbour") return _icall_NodePath_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Control","set_focus_neighbour") _icall_Unit_Long_NodePath(mb, this.ptr, 0, value) } open var focusNeighbourRight: NodePath get() { val mb = getMethodBind("Control","get_focus_neighbour") return _icall_NodePath_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Control","set_focus_neighbour") _icall_Unit_Long_NodePath(mb, this.ptr, 2, value) } open var focusNeighbourTop: NodePath get() { val mb = getMethodBind("Control","get_focus_neighbour") return _icall_NodePath_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Control","set_focus_neighbour") _icall_Unit_Long_NodePath(mb, this.ptr, 1, value) } open var focusNext: NodePath get() { val mb = getMethodBind("Control","get_focus_next") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_focus_next") _icall_Unit_NodePath(mb, this.ptr, value) } open var focusPrevious: NodePath get() { val mb = getMethodBind("Control","get_focus_previous") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_focus_previous") _icall_Unit_NodePath(mb, this.ptr, value) } open var growHorizontal: Long get() { val mb = getMethodBind("Control","get_h_grow_direction") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_h_grow_direction") _icall_Unit_Long(mb, this.ptr, value) } open var growVertical: Long get() { val mb = getMethodBind("Control","get_v_grow_direction") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_v_grow_direction") _icall_Unit_Long(mb, this.ptr, value) } open var hintTooltip: String get() { throw UninitializedPropertyAccessException("Cannot access property hintTooltip: has no getter") } set(value) { val mb = getMethodBind("Control","set_tooltip") _icall_Unit_String(mb, this.ptr, value) } open var marginBottom: Double get() { val mb = getMethodBind("Control","get_margin") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Control","set_margin") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var marginLeft: Double get() { val mb = getMethodBind("Control","get_margin") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Control","set_margin") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var marginRight: Double get() { val mb = getMethodBind("Control","get_margin") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Control","set_margin") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var marginTop: Double get() { val mb = getMethodBind("Control","get_margin") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Control","set_margin") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var mouseDefaultCursorShape: Long get() { val mb = getMethodBind("Control","get_default_cursor_shape") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_default_cursor_shape") _icall_Unit_Long(mb, this.ptr, value) } open var mouseFilter: Long get() { val mb = getMethodBind("Control","get_mouse_filter") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_mouse_filter") _icall_Unit_Long(mb, this.ptr, value) } open var rectClipContent: Boolean get() { val mb = getMethodBind("Control","is_clipping_contents") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_clip_contents") _icall_Unit_Boolean(mb, this.ptr, value) } open val rectGlobalPosition: Vector2 get() { val mb = getMethodBind("Control","get_global_position") return _icall_Vector2(mb, this.ptr) } open var rectMinSize: Vector2 get() { val mb = getMethodBind("Control","get_custom_minimum_size") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_custom_minimum_size") _icall_Unit_Vector2(mb, this.ptr, value) } open var rectPivotOffset: Vector2 get() { val mb = getMethodBind("Control","get_pivot_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_pivot_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open val rectPosition: Vector2 get() { val mb = getMethodBind("Control","get_position") return _icall_Vector2(mb, this.ptr) } open var rectRotation: Double get() { val mb = getMethodBind("Control","get_rotation_degrees") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_rotation_degrees") _icall_Unit_Double(mb, this.ptr, value) } open var rectScale: Vector2 get() { val mb = getMethodBind("Control","get_scale") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_scale") _icall_Unit_Vector2(mb, this.ptr, value) } open val rectSize: Vector2 get() { val mb = getMethodBind("Control","get_size") return _icall_Vector2(mb, this.ptr) } open var sizeFlagsHorizontal: Long get() { val mb = getMethodBind("Control","get_h_size_flags") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_h_size_flags") _icall_Unit_Long(mb, this.ptr, value) } open var sizeFlagsStretchRatio: Double get() { val mb = getMethodBind("Control","get_stretch_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_stretch_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var sizeFlagsVertical: Long get() { val mb = getMethodBind("Control","get_v_size_flags") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_v_size_flags") _icall_Unit_Long(mb, this.ptr, value) } open var theme: Theme get() { val mb = getMethodBind("Control","get_theme") return _icall_Theme(mb, this.ptr) } set(value) { val mb = getMethodBind("Control","set_theme") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Control", "Control") open fun rectMinSize(schedule: Vector2.() -> Unit): Vector2 = rectMinSize.apply{ schedule(this) rectMinSize = this } open fun rectPivotOffset(schedule: Vector2.() -> Unit): Vector2 = rectPivotOffset.apply{ schedule(this) rectPivotOffset = this } open fun rectScale(schedule: Vector2.() -> Unit): Vector2 = rectScale.apply{ schedule(this) rectScale = this } open fun _clipsInput(): Boolean { throw NotImplementedError("_clips_input is not implemented for Control") } open fun _getMinimumSize(): Vector2 { throw NotImplementedError("_get_minimum_size is not implemented for Control") } open fun _getTooltip(): String { throw NotImplementedError("_get_tooltip is not implemented for Control") } open fun _guiInput(event: InputEvent) { } open fun _makeCustomTooltip(forText: String): Object { throw NotImplementedError("_make_custom_tooltip is not implemented for Control") } open fun _overrideChanged() { } open fun _setAnchor(margin: Long, anchor: Double) { } open fun _setGlobalPosition(position: Vector2) { } open fun _setPosition(margin: Vector2) { } open fun _setSize(size: Vector2) { } open fun _sizeChanged() { } open fun _themeChanged() { } open fun _updateMinimumSize() { } open fun acceptEvent() { val mb = getMethodBind("Control","accept_event") _icall_Unit( mb, this.ptr) } open fun addColorOverride(name: String, color: Color) { val mb = getMethodBind("Control","add_color_override") _icall_Unit_String_Color( mb, this.ptr, name, color) } open fun addConstantOverride(name: String, constant: Long) { val mb = getMethodBind("Control","add_constant_override") _icall_Unit_String_Long( mb, this.ptr, name, constant) } open fun addFontOverride(name: String, font: Font) { val mb = getMethodBind("Control","add_font_override") _icall_Unit_String_Object( mb, this.ptr, name, font) } open fun addIconOverride(name: String, texture: Texture) { val mb = getMethodBind("Control","add_icon_override") _icall_Unit_String_Object( mb, this.ptr, name, texture) } open fun addShaderOverride(name: String, shader: Shader) { val mb = getMethodBind("Control","add_shader_override") _icall_Unit_String_Object( mb, this.ptr, name, shader) } open fun addStyleboxOverride(name: String, stylebox: StyleBox) { val mb = getMethodBind("Control","add_stylebox_override") _icall_Unit_String_Object( mb, this.ptr, name, stylebox) } open fun canDropData(position: Vector2, data: Variant): Boolean { throw NotImplementedError("can_drop_data is not implemented for Control") } open fun dropData(position: Vector2, data: Variant) { } open fun forceDrag(data: Variant, preview: Control) { val mb = getMethodBind("Control","force_drag") _icall_Unit_Variant_Object( mb, this.ptr, data, preview) } open fun getAnchor(margin: Long): Double { val mb = getMethodBind("Control","get_anchor") return _icall_Double_Long( mb, this.ptr, margin) } open fun getBegin(): Vector2 { val mb = getMethodBind("Control","get_begin") return _icall_Vector2( mb, this.ptr) } open fun getColor(name: String, type: String = ""): Color { val mb = getMethodBind("Control","get_color") return _icall_Color_String_String( mb, this.ptr, name, type) } open fun getCombinedMinimumSize(): Vector2 { val mb = getMethodBind("Control","get_combined_minimum_size") return _icall_Vector2( mb, this.ptr) } open fun getConstant(name: String, type: String = ""): Long { val mb = getMethodBind("Control","get_constant") return _icall_Long_String_String( mb, this.ptr, name, type) } open fun getCursorShape(position: Vector2 = Vector2(0.0, 0.0)): Control.CursorShape { val mb = getMethodBind("Control","get_cursor_shape") return Control.CursorShape.from( _icall_Long_Vector2( mb, this.ptr, position)) } open fun getCustomMinimumSize(): Vector2 { val mb = getMethodBind("Control","get_custom_minimum_size") return _icall_Vector2( mb, this.ptr) } open fun getDefaultCursorShape(): Control.CursorShape { val mb = getMethodBind("Control","get_default_cursor_shape") return Control.CursorShape.from( _icall_Long( mb, this.ptr)) } open fun getDragData(position: Vector2): Variant { throw NotImplementedError("get_drag_data is not implemented for Control") } open fun getEnd(): Vector2 { val mb = getMethodBind("Control","get_end") return _icall_Vector2( mb, this.ptr) } open fun getFocusMode(): Control.FocusMode { val mb = getMethodBind("Control","get_focus_mode") return Control.FocusMode.from( _icall_Long( mb, this.ptr)) } open fun getFocusNeighbour(margin: Long): NodePath { val mb = getMethodBind("Control","get_focus_neighbour") return _icall_NodePath_Long( mb, this.ptr, margin) } open fun getFocusNext(): NodePath { val mb = getMethodBind("Control","get_focus_next") return _icall_NodePath( mb, this.ptr) } open fun getFocusOwner(): Control { val mb = getMethodBind("Control","get_focus_owner") return _icall_Control( mb, this.ptr) } open fun getFocusPrevious(): NodePath { val mb = getMethodBind("Control","get_focus_previous") return _icall_NodePath( mb, this.ptr) } open fun getFont(name: String, type: String = ""): Font { val mb = getMethodBind("Control","get_font") return _icall_Font_String_String( mb, this.ptr, name, type) } open fun getGlobalPosition(): Vector2 { val mb = getMethodBind("Control","get_global_position") return _icall_Vector2( mb, this.ptr) } open fun getGlobalRect(): Rect2 { val mb = getMethodBind("Control","get_global_rect") return _icall_Rect2( mb, this.ptr) } open fun getHGrowDirection(): Control.GrowDirection { val mb = getMethodBind("Control","get_h_grow_direction") return Control.GrowDirection.from( _icall_Long( mb, this.ptr)) } open fun getHSizeFlags(): Long { val mb = getMethodBind("Control","get_h_size_flags") return _icall_Long( mb, this.ptr) } open fun getIcon(name: String, type: String = ""): Texture { val mb = getMethodBind("Control","get_icon") return _icall_Texture_String_String( mb, this.ptr, name, type) } open fun getMargin(margin: Long): Double { val mb = getMethodBind("Control","get_margin") return _icall_Double_Long( mb, this.ptr, margin) } open fun getMinimumSize(): Vector2 { val mb = getMethodBind("Control","get_minimum_size") return _icall_Vector2( mb, this.ptr) } open fun getMouseFilter(): Control.MouseFilter { val mb = getMethodBind("Control","get_mouse_filter") return Control.MouseFilter.from( _icall_Long( mb, this.ptr)) } open fun getParentAreaSize(): Vector2 { val mb = getMethodBind("Control","get_parent_area_size") return _icall_Vector2( mb, this.ptr) } open fun getParentControl(): Control { val mb = getMethodBind("Control","get_parent_control") return _icall_Control( mb, this.ptr) } open fun getPivotOffset(): Vector2 { val mb = getMethodBind("Control","get_pivot_offset") return _icall_Vector2( mb, this.ptr) } open fun getPosition(): Vector2 { val mb = getMethodBind("Control","get_position") return _icall_Vector2( mb, this.ptr) } open fun getRect(): Rect2 { val mb = getMethodBind("Control","get_rect") return _icall_Rect2( mb, this.ptr) } open fun getRotation(): Double { val mb = getMethodBind("Control","get_rotation") return _icall_Double( mb, this.ptr) } open fun getRotationDegrees(): Double { val mb = getMethodBind("Control","get_rotation_degrees") return _icall_Double( mb, this.ptr) } open fun getScale(): Vector2 { val mb = getMethodBind("Control","get_scale") return _icall_Vector2( mb, this.ptr) } open fun getSize(): Vector2 { val mb = getMethodBind("Control","get_size") return _icall_Vector2( mb, this.ptr) } open fun getStretchRatio(): Double { val mb = getMethodBind("Control","get_stretch_ratio") return _icall_Double( mb, this.ptr) } open fun getStylebox(name: String, type: String = ""): StyleBox { val mb = getMethodBind("Control","get_stylebox") return _icall_StyleBox_String_String( mb, this.ptr, name, type) } open fun getTheme(): Theme { val mb = getMethodBind("Control","get_theme") return _icall_Theme( mb, this.ptr) } open fun getTooltip(atPosition: Vector2 = Vector2(0.0, 0.0)): String { val mb = getMethodBind("Control","get_tooltip") return _icall_String_Vector2( mb, this.ptr, atPosition) } open fun getVGrowDirection(): Control.GrowDirection { val mb = getMethodBind("Control","get_v_grow_direction") return Control.GrowDirection.from( _icall_Long( mb, this.ptr)) } open fun getVSizeFlags(): Long { val mb = getMethodBind("Control","get_v_size_flags") return _icall_Long( mb, this.ptr) } open fun grabClickFocus() { val mb = getMethodBind("Control","grab_click_focus") _icall_Unit( mb, this.ptr) } open fun grabFocus() { val mb = getMethodBind("Control","grab_focus") _icall_Unit( mb, this.ptr) } open fun hasColor(name: String, type: String = ""): Boolean { val mb = getMethodBind("Control","has_color") return _icall_Boolean_String_String( mb, this.ptr, name, type) } open fun hasColorOverride(name: String): Boolean { val mb = getMethodBind("Control","has_color_override") return _icall_Boolean_String( mb, this.ptr, name) } open fun hasConstant(name: String, type: String = ""): Boolean { val mb = getMethodBind("Control","has_constant") return _icall_Boolean_String_String( mb, this.ptr, name, type) } open fun hasConstantOverride(name: String): Boolean { val mb = getMethodBind("Control","has_constant_override") return _icall_Boolean_String( mb, this.ptr, name) } open fun hasFocus(): Boolean { val mb = getMethodBind("Control","has_focus") return _icall_Boolean( mb, this.ptr) } open fun hasFont(name: String, type: String = ""): Boolean { val mb = getMethodBind("Control","has_font") return _icall_Boolean_String_String( mb, this.ptr, name, type) } open fun hasFontOverride(name: String): Boolean { val mb = getMethodBind("Control","has_font_override") return _icall_Boolean_String( mb, this.ptr, name) } open fun hasIcon(name: String, type: String = ""): Boolean { val mb = getMethodBind("Control","has_icon") return _icall_Boolean_String_String( mb, this.ptr, name, type) } open fun hasIconOverride(name: String): Boolean { val mb = getMethodBind("Control","has_icon_override") return _icall_Boolean_String( mb, this.ptr, name) } open fun hasPoint(point: Vector2): Boolean { throw NotImplementedError("has_point is not implemented for Control") } open fun hasShaderOverride(name: String): Boolean { val mb = getMethodBind("Control","has_shader_override") return _icall_Boolean_String( mb, this.ptr, name) } open fun hasStylebox(name: String, type: String = ""): Boolean { val mb = getMethodBind("Control","has_stylebox") return _icall_Boolean_String_String( mb, this.ptr, name, type) } open fun hasStyleboxOverride(name: String): Boolean { val mb = getMethodBind("Control","has_stylebox_override") return _icall_Boolean_String( mb, this.ptr, name) } open fun isClippingContents(): Boolean { val mb = getMethodBind("Control","is_clipping_contents") return _icall_Boolean( mb, this.ptr) } open fun minimumSizeChanged() { val mb = getMethodBind("Control","minimum_size_changed") _icall_Unit( mb, this.ptr) } open fun releaseFocus() { val mb = getMethodBind("Control","release_focus") _icall_Unit( mb, this.ptr) } open fun setAnchor( margin: Long, anchor: Double, keepMargin: Boolean = false, pushOppositeAnchor: Boolean = true ) { val mb = getMethodBind("Control","set_anchor") _icall_Unit_Long_Double_Boolean_Boolean( mb, this.ptr, margin, anchor, keepMargin, pushOppositeAnchor) } open fun setAnchorAndMargin( margin: Long, anchor: Double, offset: Double, pushOppositeAnchor: Boolean = false ) { val mb = getMethodBind("Control","set_anchor_and_margin") _icall_Unit_Long_Double_Double_Boolean( mb, this.ptr, margin, anchor, offset, pushOppositeAnchor) } open fun setAnchorsAndMarginsPreset( preset: Long, resizeMode: Long = 0, margin: Long = 0 ) { val mb = getMethodBind("Control","set_anchors_and_margins_preset") _icall_Unit_Long_Long_Long( mb, this.ptr, preset, resizeMode, margin) } open fun setAnchorsPreset(preset: Long, keepMargins: Boolean = false) { val mb = getMethodBind("Control","set_anchors_preset") _icall_Unit_Long_Boolean( mb, this.ptr, preset, keepMargins) } open fun setBegin(position: Vector2) { val mb = getMethodBind("Control","set_begin") _icall_Unit_Vector2( mb, this.ptr, position) } open fun setClipContents(enable: Boolean) { val mb = getMethodBind("Control","set_clip_contents") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCustomMinimumSize(size: Vector2) { val mb = getMethodBind("Control","set_custom_minimum_size") _icall_Unit_Vector2( mb, this.ptr, size) } open fun setDefaultCursorShape(shape: Long) { val mb = getMethodBind("Control","set_default_cursor_shape") _icall_Unit_Long( mb, this.ptr, shape) } open fun setDragForwarding(target: Control) { val mb = getMethodBind("Control","set_drag_forwarding") _icall_Unit_Object( mb, this.ptr, target) } open fun setDragPreview(control: Control) { val mb = getMethodBind("Control","set_drag_preview") _icall_Unit_Object( mb, this.ptr, control) } open fun setEnd(position: Vector2) { val mb = getMethodBind("Control","set_end") _icall_Unit_Vector2( mb, this.ptr, position) } open fun setFocusMode(mode: Long) { val mb = getMethodBind("Control","set_focus_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setFocusNeighbour(margin: Long, neighbour: NodePath) { val mb = getMethodBind("Control","set_focus_neighbour") _icall_Unit_Long_NodePath( mb, this.ptr, margin, neighbour) } open fun setFocusNext(next: NodePath) { val mb = getMethodBind("Control","set_focus_next") _icall_Unit_NodePath( mb, this.ptr, next) } open fun setFocusPrevious(previous: NodePath) { val mb = getMethodBind("Control","set_focus_previous") _icall_Unit_NodePath( mb, this.ptr, previous) } open fun setGlobalPosition(position: Vector2, keepMargins: Boolean = false) { val mb = getMethodBind("Control","set_global_position") _icall_Unit_Vector2_Boolean( mb, this.ptr, position, keepMargins) } open fun setHGrowDirection(direction: Long) { val mb = getMethodBind("Control","set_h_grow_direction") _icall_Unit_Long( mb, this.ptr, direction) } open fun setHSizeFlags(flags: Long) { val mb = getMethodBind("Control","set_h_size_flags") _icall_Unit_Long( mb, this.ptr, flags) } open fun setMargin(margin: Long, offset: Double) { val mb = getMethodBind("Control","set_margin") _icall_Unit_Long_Double( mb, this.ptr, margin, offset) } open fun setMarginsPreset( preset: Long, resizeMode: Long = 0, margin: Long = 0 ) { val mb = getMethodBind("Control","set_margins_preset") _icall_Unit_Long_Long_Long( mb, this.ptr, preset, resizeMode, margin) } open fun setMouseFilter(filter: Long) { val mb = getMethodBind("Control","set_mouse_filter") _icall_Unit_Long( mb, this.ptr, filter) } open fun setPivotOffset(pivotOffset: Vector2) { val mb = getMethodBind("Control","set_pivot_offset") _icall_Unit_Vector2( mb, this.ptr, pivotOffset) } open fun setPosition(position: Vector2, keepMargins: Boolean = false) { val mb = getMethodBind("Control","set_position") _icall_Unit_Vector2_Boolean( mb, this.ptr, position, keepMargins) } open fun setRotation(radians: Double) { val mb = getMethodBind("Control","set_rotation") _icall_Unit_Double( mb, this.ptr, radians) } open fun setRotationDegrees(degrees: Double) { val mb = getMethodBind("Control","set_rotation_degrees") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setScale(scale: Vector2) { val mb = getMethodBind("Control","set_scale") _icall_Unit_Vector2( mb, this.ptr, scale) } open fun setSize(size: Vector2, keepMargins: Boolean = false) { val mb = getMethodBind("Control","set_size") _icall_Unit_Vector2_Boolean( mb, this.ptr, size, keepMargins) } open fun setStretchRatio(ratio: Double) { val mb = getMethodBind("Control","set_stretch_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setTheme(theme: Theme) { val mb = getMethodBind("Control","set_theme") _icall_Unit_Object( mb, this.ptr, theme) } open fun setTooltip(tooltip: String) { val mb = getMethodBind("Control","set_tooltip") _icall_Unit_String( mb, this.ptr, tooltip) } open fun setVGrowDirection(direction: Long) { val mb = getMethodBind("Control","set_v_grow_direction") _icall_Unit_Long( mb, this.ptr, direction) } open fun setVSizeFlags(flags: Long) { val mb = getMethodBind("Control","set_v_size_flags") _icall_Unit_Long( mb, this.ptr, flags) } open fun showModal(exclusive: Boolean = false) { val mb = getMethodBind("Control","show_modal") _icall_Unit_Boolean( mb, this.ptr, exclusive) } open fun warpMouse(toPosition: Vector2) { val mb = getMethodBind("Control","warp_mouse") _icall_Unit_Vector2( mb, this.ptr, toPosition) } enum class Anchor( id: Long ) { ANCHOR_BEGIN(0), ANCHOR_END(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class FocusMode( id: Long ) { FOCUS_NONE(0), FOCUS_CLICK(1), FOCUS_ALL(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class LayoutPresetMode( id: Long ) { PRESET_MODE_MINSIZE(0), PRESET_MODE_KEEP_WIDTH(1), PRESET_MODE_KEEP_HEIGHT(2), PRESET_MODE_KEEP_SIZE(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class MouseFilter( id: Long ) { MOUSE_FILTER_STOP(0), MOUSE_FILTER_PASS(1), MOUSE_FILTER_IGNORE(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class CursorShape( id: Long ) { CURSOR_ARROW(0), CURSOR_IBEAM(1), CURSOR_POINTING_HAND(2), CURSOR_CROSS(3), CURSOR_WAIT(4), CURSOR_BUSY(5), CURSOR_DRAG(6), CURSOR_CAN_DROP(7), CURSOR_FORBIDDEN(8), CURSOR_VSIZE(9), CURSOR_HSIZE(10), CURSOR_BDIAGSIZE(11), CURSOR_FDIAGSIZE(12), CURSOR_MOVE(13), CURSOR_VSPLIT(14), CURSOR_HSPLIT(15), CURSOR_HELP(16); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class GrowDirection( id: Long ) { GROW_DIRECTION_BEGIN(0), GROW_DIRECTION_END(1), GROW_DIRECTION_BOTH(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class SizeFlags( id: Long ) { SIZE_FILL(1), SIZE_EXPAND(2), SIZE_EXPAND_FILL(3), SIZE_SHRINK_CENTER(4), SIZE_SHRINK_END(8); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class LayoutPreset( id: Long ) { PRESET_TOP_LEFT(0), PRESET_TOP_RIGHT(1), PRESET_BOTTOM_LEFT(2), PRESET_BOTTOM_RIGHT(3), PRESET_CENTER_LEFT(4), PRESET_CENTER_TOP(5), PRESET_CENTER_RIGHT(6), PRESET_CENTER_BOTTOM(7), PRESET_CENTER(8), PRESET_LEFT_WIDE(9), PRESET_TOP_WIDE(10), PRESET_RIGHT_WIDE(11), PRESET_BOTTOM_WIDE(12), PRESET_VCENTER_WIDE(13), PRESET_HCENTER_WIDE(14), PRESET_WIDE(15); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object { final const val NOTIFICATION_FOCUS_ENTER: Long = 43 final const val NOTIFICATION_FOCUS_EXIT: Long = 44 final const val NOTIFICATION_MODAL_CLOSE: Long = 46 final const val NOTIFICATION_MOUSE_ENTER: Long = 41 final const val NOTIFICATION_MOUSE_EXIT: Long = 42 final const val NOTIFICATION_RESIZED: Long = 40 final const val NOTIFICATION_SCROLL_BEGIN: Long = 47 final const val NOTIFICATION_SCROLL_END: Long = 48 final const val NOTIFICATION_THEME_CHANGED: Long = 45 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ConvexPolygonShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolVector3Array import godot.icalls._icall_PoolVector3Array import godot.icalls._icall_Unit_PoolVector3Array import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class ConvexPolygonShape : Shape() { open var points: PoolVector3Array get() { val mb = getMethodBind("ConvexPolygonShape","get_points") return _icall_PoolVector3Array(mb, this.ptr) } set(value) { val mb = getMethodBind("ConvexPolygonShape","set_points") _icall_Unit_PoolVector3Array(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ConvexPolygonShape", "ConvexPolygonShape") open fun getPoints(): PoolVector3Array { val mb = getMethodBind("ConvexPolygonShape","get_points") return _icall_PoolVector3Array( mb, this.ptr) } open fun setPoints(points: PoolVector3Array) { val mb = getMethodBind("ConvexPolygonShape","set_points") _icall_Unit_PoolVector3Array( mb, this.ptr, points) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ConvexPolygonShape2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolVector2Array import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_Unit_PoolVector2Array import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class ConvexPolygonShape2D : Shape2D() { open var points: PoolVector2Array get() { val mb = getMethodBind("ConvexPolygonShape2D","get_points") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("ConvexPolygonShape2D","set_points") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ConvexPolygonShape2D", "ConvexPolygonShape2D") open fun getPoints(): PoolVector2Array { val mb = getMethodBind("ConvexPolygonShape2D","get_points") return _icall_PoolVector2Array( mb, this.ptr) } open fun setPointCloud(pointCloud: PoolVector2Array) { val mb = getMethodBind("ConvexPolygonShape2D","set_point_cloud") _icall_Unit_PoolVector2Array( mb, this.ptr, pointCloud) } open fun setPoints(points: PoolVector2Array) { val mb = getMethodBind("ConvexPolygonShape2D","set_points") _icall_Unit_PoolVector2Array( mb, this.ptr, points) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Crypto.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolByteArray import godot.icalls._icall_CryptoKey_Long import godot.icalls._icall_PoolByteArray_Long import godot.icalls._icall_X509Certificate_Object_String_String_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class Crypto : Reference() { override fun __new(): COpaquePointer = invokeConstructor("Crypto", "Crypto") open fun generateRandomBytes(size: Long): PoolByteArray { val mb = getMethodBind("Crypto","generate_random_bytes") return _icall_PoolByteArray_Long( mb, this.ptr, size) } open fun generateRsa(size: Long): CryptoKey { val mb = getMethodBind("Crypto","generate_rsa") return _icall_CryptoKey_Long( mb, this.ptr, size) } open fun generateSelfSignedCertificate( key: CryptoKey, issuerName: String = "CN=myserver,O=myorganisation,C=IT", notBefore: String = "20140101000000", notAfter: String = "20340101000000" ): X509Certificate { val mb = getMethodBind("Crypto","generate_self_signed_certificate") return _icall_X509Certificate_Object_String_String_String( mb, this.ptr, key, issuerName, notBefore, notAfter) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CryptoKey.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.icalls._icall_Long_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.String import kotlinx.cinterop.COpaquePointer open class CryptoKey : Resource() { override fun __new(): COpaquePointer = invokeConstructor("CryptoKey", "CryptoKey") open fun load(path: String): GodotError { val mb = getMethodBind("CryptoKey","load") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun save(path: String): GodotError { val mb = getMethodBind("CryptoKey","save") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CubeMap.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.CubeMap import godot.icalls._icall_Double import godot.icalls._icall_Image_Long import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class CubeMap : Resource() { open var flags: Long get() { val mb = getMethodBind("CubeMap","get_flags") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CubeMap","set_flags") _icall_Unit_Long(mb, this.ptr, value) } open var lossyStorageQuality: Double get() { val mb = getMethodBind("CubeMap","get_lossy_storage_quality") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CubeMap","set_lossy_storage_quality") _icall_Unit_Double(mb, this.ptr, value) } open var storageMode: Long get() { val mb = getMethodBind("CubeMap","get_storage") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CubeMap","set_storage") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CubeMap", "CubeMap") open fun getFlags(): Long { val mb = getMethodBind("CubeMap","get_flags") return _icall_Long( mb, this.ptr) } open fun getHeight(): Long { val mb = getMethodBind("CubeMap","get_height") return _icall_Long( mb, this.ptr) } open fun getLossyStorageQuality(): Double { val mb = getMethodBind("CubeMap","get_lossy_storage_quality") return _icall_Double( mb, this.ptr) } open fun getSide(side: Long): Image { val mb = getMethodBind("CubeMap","get_side") return _icall_Image_Long( mb, this.ptr, side) } open fun getStorage(): CubeMap.Storage { val mb = getMethodBind("CubeMap","get_storage") return CubeMap.Storage.from( _icall_Long( mb, this.ptr)) } open fun getWidth(): Long { val mb = getMethodBind("CubeMap","get_width") return _icall_Long( mb, this.ptr) } open fun setFlags(flags: Long) { val mb = getMethodBind("CubeMap","set_flags") _icall_Unit_Long( mb, this.ptr, flags) } open fun setLossyStorageQuality(quality: Double) { val mb = getMethodBind("CubeMap","set_lossy_storage_quality") _icall_Unit_Double( mb, this.ptr, quality) } open fun setSide(side: Long, image: Image) { val mb = getMethodBind("CubeMap","set_side") _icall_Unit_Long_Object( mb, this.ptr, side, image) } open fun setStorage(mode: Long) { val mb = getMethodBind("CubeMap","set_storage") _icall_Unit_Long( mb, this.ptr, mode) } enum class Flags( id: Long ) { FLAG_MIPMAPS(1), FLAG_REPEAT(2), FLAG_FILTER(4), FLAGS_DEFAULT(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Side( id: Long ) { SIDE_LEFT(0), SIDE_RIGHT(1), SIDE_BOTTOM(2), SIDE_TOP(3), SIDE_FRONT(4), SIDE_BACK(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Storage( id: Long ) { STORAGE_RAW(0), STORAGE_COMPRESS_LOSSY(1), STORAGE_COMPRESS_LOSSLESS(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CubeMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector3 import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class CubeMesh : PrimitiveMesh() { open var size: Vector3 get() { val mb = getMethodBind("CubeMesh","get_size") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("CubeMesh","set_size") _icall_Unit_Vector3(mb, this.ptr, value) } open var subdivideDepth: Long get() { val mb = getMethodBind("CubeMesh","get_subdivide_depth") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CubeMesh","set_subdivide_depth") _icall_Unit_Long(mb, this.ptr, value) } open var subdivideHeight: Long get() { val mb = getMethodBind("CubeMesh","get_subdivide_height") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CubeMesh","set_subdivide_height") _icall_Unit_Long(mb, this.ptr, value) } open var subdivideWidth: Long get() { val mb = getMethodBind("CubeMesh","get_subdivide_width") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CubeMesh","set_subdivide_width") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CubeMesh", "CubeMesh") open fun size(schedule: Vector3.() -> Unit): Vector3 = size.apply{ schedule(this) size = this } open fun getSize(): Vector3 { val mb = getMethodBind("CubeMesh","get_size") return _icall_Vector3( mb, this.ptr) } open fun getSubdivideDepth(): Long { val mb = getMethodBind("CubeMesh","get_subdivide_depth") return _icall_Long( mb, this.ptr) } open fun getSubdivideHeight(): Long { val mb = getMethodBind("CubeMesh","get_subdivide_height") return _icall_Long( mb, this.ptr) } open fun getSubdivideWidth(): Long { val mb = getMethodBind("CubeMesh","get_subdivide_width") return _icall_Long( mb, this.ptr) } open fun setSize(size: Vector3) { val mb = getMethodBind("CubeMesh","set_size") _icall_Unit_Vector3( mb, this.ptr, size) } open fun setSubdivideDepth(divisions: Long) { val mb = getMethodBind("CubeMesh","set_subdivide_depth") _icall_Unit_Long( mb, this.ptr, divisions) } open fun setSubdivideHeight(divisions: Long) { val mb = getMethodBind("CubeMesh","set_subdivide_height") _icall_Unit_Long( mb, this.ptr, divisions) } open fun setSubdivideWidth(subdivide: Long) { val mb = getMethodBind("CubeMesh","set_subdivide_width") _icall_Unit_Long( mb, this.ptr, subdivide) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Curve.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Curve import godot.core.Signal0 import godot.core.VariantArray import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Double import godot.icalls._icall_Double_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_Long_Double import godot.icalls._icall_Long_Vector2_Double_Double_Long_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Vector2_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class Curve : Resource() { val rangeChanged: Signal0 by signal() open var bakeResolution: Long get() { val mb = getMethodBind("Curve","get_bake_resolution") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Curve","set_bake_resolution") _icall_Unit_Long(mb, this.ptr, value) } open var maxValue: Double get() { val mb = getMethodBind("Curve","get_max_value") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Curve","set_max_value") _icall_Unit_Double(mb, this.ptr, value) } open var minValue: Double get() { val mb = getMethodBind("Curve","get_min_value") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Curve","set_min_value") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Curve", "Curve") open fun _getData(): VariantArray { throw NotImplementedError("_get_data is not implemented for Curve") } open fun _setData(data: VariantArray) { } open fun addPoint( position: Vector2, leftTangent: Double = 0.0, rightTangent: Double = 0.0, leftMode: Long = 0, rightMode: Long = 0 ): Long { val mb = getMethodBind("Curve","add_point") return _icall_Long_Vector2_Double_Double_Long_Long( mb, this.ptr, position, leftTangent, rightTangent, leftMode, rightMode) } open fun bake() { val mb = getMethodBind("Curve","bake") _icall_Unit( mb, this.ptr) } open fun cleanDupes() { val mb = getMethodBind("Curve","clean_dupes") _icall_Unit( mb, this.ptr) } open fun clearPoints() { val mb = getMethodBind("Curve","clear_points") _icall_Unit( mb, this.ptr) } open fun getBakeResolution(): Long { val mb = getMethodBind("Curve","get_bake_resolution") return _icall_Long( mb, this.ptr) } open fun getMaxValue(): Double { val mb = getMethodBind("Curve","get_max_value") return _icall_Double( mb, this.ptr) } open fun getMinValue(): Double { val mb = getMethodBind("Curve","get_min_value") return _icall_Double( mb, this.ptr) } open fun getPointCount(): Long { val mb = getMethodBind("Curve","get_point_count") return _icall_Long( mb, this.ptr) } open fun getPointLeftMode(index: Long): Curve.TangentMode { val mb = getMethodBind("Curve","get_point_left_mode") return Curve.TangentMode.from( _icall_Long_Long( mb, this.ptr, index)) } open fun getPointLeftTangent(index: Long): Double { val mb = getMethodBind("Curve","get_point_left_tangent") return _icall_Double_Long( mb, this.ptr, index) } open fun getPointPosition(index: Long): Vector2 { val mb = getMethodBind("Curve","get_point_position") return _icall_Vector2_Long( mb, this.ptr, index) } open fun getPointRightMode(index: Long): Curve.TangentMode { val mb = getMethodBind("Curve","get_point_right_mode") return Curve.TangentMode.from( _icall_Long_Long( mb, this.ptr, index)) } open fun getPointRightTangent(index: Long): Double { val mb = getMethodBind("Curve","get_point_right_tangent") return _icall_Double_Long( mb, this.ptr, index) } open fun interpolate(offset: Double): Double { val mb = getMethodBind("Curve","interpolate") return _icall_Double_Double( mb, this.ptr, offset) } open fun interpolateBaked(offset: Double): Double { val mb = getMethodBind("Curve","interpolate_baked") return _icall_Double_Double( mb, this.ptr, offset) } open fun removePoint(index: Long) { val mb = getMethodBind("Curve","remove_point") _icall_Unit_Long( mb, this.ptr, index) } open fun setBakeResolution(resolution: Long) { val mb = getMethodBind("Curve","set_bake_resolution") _icall_Unit_Long( mb, this.ptr, resolution) } open fun setMaxValue(max: Double) { val mb = getMethodBind("Curve","set_max_value") _icall_Unit_Double( mb, this.ptr, max) } open fun setMinValue(min: Double) { val mb = getMethodBind("Curve","set_min_value") _icall_Unit_Double( mb, this.ptr, min) } open fun setPointLeftMode(index: Long, mode: Long) { val mb = getMethodBind("Curve","set_point_left_mode") _icall_Unit_Long_Long( mb, this.ptr, index, mode) } open fun setPointLeftTangent(index: Long, tangent: Double) { val mb = getMethodBind("Curve","set_point_left_tangent") _icall_Unit_Long_Double( mb, this.ptr, index, tangent) } open fun setPointOffset(index: Long, offset: Double): Long { val mb = getMethodBind("Curve","set_point_offset") return _icall_Long_Long_Double( mb, this.ptr, index, offset) } open fun setPointRightMode(index: Long, mode: Long) { val mb = getMethodBind("Curve","set_point_right_mode") _icall_Unit_Long_Long( mb, this.ptr, index, mode) } open fun setPointRightTangent(index: Long, tangent: Double) { val mb = getMethodBind("Curve","set_point_right_tangent") _icall_Unit_Long_Double( mb, this.ptr, index, tangent) } open fun setPointValue(index: Long, y: Double) { val mb = getMethodBind("Curve","set_point_value") _icall_Unit_Long_Double( mb, this.ptr, index, y) } enum class TangentMode( id: Long ) { TANGENT_FREE(0), TANGENT_LINEAR(1), TANGENT_MODE_COUNT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Curve2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.PoolVector2Array import godot.core.Vector2 import godot.icalls._icall_Double import godot.icalls._icall_Double_Vector2 import godot.icalls._icall_Long import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_PoolVector2Array_Long_Double import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Vector2 import godot.icalls._icall_Unit_Vector2_Vector2_Vector2_Long import godot.icalls._icall_Vector2_Double import godot.icalls._icall_Vector2_Double_Boolean import godot.icalls._icall_Vector2_Long import godot.icalls._icall_Vector2_Long_Double import godot.icalls._icall_Vector2_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class Curve2D : Resource() { open var bakeInterval: Double get() { val mb = getMethodBind("Curve2D","get_bake_interval") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Curve2D","set_bake_interval") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Curve2D", "Curve2D") open fun _getData(): Dictionary { throw NotImplementedError("_get_data is not implemented for Curve2D") } open fun _setData(arg0: Dictionary) { } open fun addPoint( position: Vector2, _in: Vector2 = Vector2(0.0, 0.0), out: Vector2 = Vector2(0.0, 0.0), atPosition: Long = -1 ) { val mb = getMethodBind("Curve2D","add_point") _icall_Unit_Vector2_Vector2_Vector2_Long( mb, this.ptr, position, _in, out, atPosition) } open fun clearPoints() { val mb = getMethodBind("Curve2D","clear_points") _icall_Unit( mb, this.ptr) } open fun getBakeInterval(): Double { val mb = getMethodBind("Curve2D","get_bake_interval") return _icall_Double( mb, this.ptr) } open fun getBakedLength(): Double { val mb = getMethodBind("Curve2D","get_baked_length") return _icall_Double( mb, this.ptr) } open fun getBakedPoints(): PoolVector2Array { val mb = getMethodBind("Curve2D","get_baked_points") return _icall_PoolVector2Array( mb, this.ptr) } open fun getClosestOffset(toPoint: Vector2): Double { val mb = getMethodBind("Curve2D","get_closest_offset") return _icall_Double_Vector2( mb, this.ptr, toPoint) } open fun getClosestPoint(toPoint: Vector2): Vector2 { val mb = getMethodBind("Curve2D","get_closest_point") return _icall_Vector2_Vector2( mb, this.ptr, toPoint) } open fun getPointCount(): Long { val mb = getMethodBind("Curve2D","get_point_count") return _icall_Long( mb, this.ptr) } open fun getPointIn(idx: Long): Vector2 { val mb = getMethodBind("Curve2D","get_point_in") return _icall_Vector2_Long( mb, this.ptr, idx) } open fun getPointOut(idx: Long): Vector2 { val mb = getMethodBind("Curve2D","get_point_out") return _icall_Vector2_Long( mb, this.ptr, idx) } open fun getPointPosition(idx: Long): Vector2 { val mb = getMethodBind("Curve2D","get_point_position") return _icall_Vector2_Long( mb, this.ptr, idx) } open fun interpolate(idx: Long, t: Double): Vector2 { val mb = getMethodBind("Curve2D","interpolate") return _icall_Vector2_Long_Double( mb, this.ptr, idx, t) } open fun interpolateBaked(offset: Double, cubic: Boolean = false): Vector2 { val mb = getMethodBind("Curve2D","interpolate_baked") return _icall_Vector2_Double_Boolean( mb, this.ptr, offset, cubic) } open fun interpolatef(fofs: Double): Vector2 { val mb = getMethodBind("Curve2D","interpolatef") return _icall_Vector2_Double( mb, this.ptr, fofs) } open fun removePoint(idx: Long) { val mb = getMethodBind("Curve2D","remove_point") _icall_Unit_Long( mb, this.ptr, idx) } open fun setBakeInterval(distance: Double) { val mb = getMethodBind("Curve2D","set_bake_interval") _icall_Unit_Double( mb, this.ptr, distance) } open fun setPointIn(idx: Long, position: Vector2) { val mb = getMethodBind("Curve2D","set_point_in") _icall_Unit_Long_Vector2( mb, this.ptr, idx, position) } open fun setPointOut(idx: Long, position: Vector2) { val mb = getMethodBind("Curve2D","set_point_out") _icall_Unit_Long_Vector2( mb, this.ptr, idx, position) } open fun setPointPosition(idx: Long, position: Vector2) { val mb = getMethodBind("Curve2D","set_point_position") _icall_Unit_Long_Vector2( mb, this.ptr, idx, position) } open fun tessellate(maxStages: Long = 5, toleranceDegrees: Double = 4.0): PoolVector2Array { val mb = getMethodBind("Curve2D","tessellate") return _icall_PoolVector2Array_Long_Double( mb, this.ptr, maxStages, toleranceDegrees) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Curve3D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.PoolRealArray import godot.core.PoolVector3Array import godot.core.Vector3 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Double_Vector3 import godot.icalls._icall_Long import godot.icalls._icall_PoolRealArray import godot.icalls._icall_PoolVector3Array import godot.icalls._icall_PoolVector3Array_Long_Double import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Vector3 import godot.icalls._icall_Unit_Vector3_Vector3_Vector3_Long import godot.icalls._icall_Vector3_Double import godot.icalls._icall_Vector3_Double_Boolean import godot.icalls._icall_Vector3_Long import godot.icalls._icall_Vector3_Long_Double import godot.icalls._icall_Vector3_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class Curve3D : Resource() { open var bakeInterval: Double get() { val mb = getMethodBind("Curve3D","get_bake_interval") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Curve3D","set_bake_interval") _icall_Unit_Double(mb, this.ptr, value) } open var upVectorEnabled: Boolean get() { val mb = getMethodBind("Curve3D","is_up_vector_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Curve3D","set_up_vector_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Curve3D", "Curve3D") open fun _getData(): Dictionary { throw NotImplementedError("_get_data is not implemented for Curve3D") } open fun _setData(arg0: Dictionary) { } open fun addPoint( position: Vector3, _in: Vector3 = Vector3(0.0, 0.0, 0.0), out: Vector3 = Vector3(0.0, 0.0, 0.0), atPosition: Long = -1 ) { val mb = getMethodBind("Curve3D","add_point") _icall_Unit_Vector3_Vector3_Vector3_Long( mb, this.ptr, position, _in, out, atPosition) } open fun clearPoints() { val mb = getMethodBind("Curve3D","clear_points") _icall_Unit( mb, this.ptr) } open fun getBakeInterval(): Double { val mb = getMethodBind("Curve3D","get_bake_interval") return _icall_Double( mb, this.ptr) } open fun getBakedLength(): Double { val mb = getMethodBind("Curve3D","get_baked_length") return _icall_Double( mb, this.ptr) } open fun getBakedPoints(): PoolVector3Array { val mb = getMethodBind("Curve3D","get_baked_points") return _icall_PoolVector3Array( mb, this.ptr) } open fun getBakedTilts(): PoolRealArray { val mb = getMethodBind("Curve3D","get_baked_tilts") return _icall_PoolRealArray( mb, this.ptr) } open fun getBakedUpVectors(): PoolVector3Array { val mb = getMethodBind("Curve3D","get_baked_up_vectors") return _icall_PoolVector3Array( mb, this.ptr) } open fun getClosestOffset(toPoint: Vector3): Double { val mb = getMethodBind("Curve3D","get_closest_offset") return _icall_Double_Vector3( mb, this.ptr, toPoint) } open fun getClosestPoint(toPoint: Vector3): Vector3 { val mb = getMethodBind("Curve3D","get_closest_point") return _icall_Vector3_Vector3( mb, this.ptr, toPoint) } open fun getPointCount(): Long { val mb = getMethodBind("Curve3D","get_point_count") return _icall_Long( mb, this.ptr) } open fun getPointIn(idx: Long): Vector3 { val mb = getMethodBind("Curve3D","get_point_in") return _icall_Vector3_Long( mb, this.ptr, idx) } open fun getPointOut(idx: Long): Vector3 { val mb = getMethodBind("Curve3D","get_point_out") return _icall_Vector3_Long( mb, this.ptr, idx) } open fun getPointPosition(idx: Long): Vector3 { val mb = getMethodBind("Curve3D","get_point_position") return _icall_Vector3_Long( mb, this.ptr, idx) } open fun getPointTilt(idx: Long): Double { val mb = getMethodBind("Curve3D","get_point_tilt") return _icall_Double_Long( mb, this.ptr, idx) } open fun interpolate(idx: Long, t: Double): Vector3 { val mb = getMethodBind("Curve3D","interpolate") return _icall_Vector3_Long_Double( mb, this.ptr, idx, t) } open fun interpolateBaked(offset: Double, cubic: Boolean = false): Vector3 { val mb = getMethodBind("Curve3D","interpolate_baked") return _icall_Vector3_Double_Boolean( mb, this.ptr, offset, cubic) } open fun interpolateBakedUpVector(offset: Double, applyTilt: Boolean = false): Vector3 { val mb = getMethodBind("Curve3D","interpolate_baked_up_vector") return _icall_Vector3_Double_Boolean( mb, this.ptr, offset, applyTilt) } open fun interpolatef(fofs: Double): Vector3 { val mb = getMethodBind("Curve3D","interpolatef") return _icall_Vector3_Double( mb, this.ptr, fofs) } open fun isUpVectorEnabled(): Boolean { val mb = getMethodBind("Curve3D","is_up_vector_enabled") return _icall_Boolean( mb, this.ptr) } open fun removePoint(idx: Long) { val mb = getMethodBind("Curve3D","remove_point") _icall_Unit_Long( mb, this.ptr, idx) } open fun setBakeInterval(distance: Double) { val mb = getMethodBind("Curve3D","set_bake_interval") _icall_Unit_Double( mb, this.ptr, distance) } open fun setPointIn(idx: Long, position: Vector3) { val mb = getMethodBind("Curve3D","set_point_in") _icall_Unit_Long_Vector3( mb, this.ptr, idx, position) } open fun setPointOut(idx: Long, position: Vector3) { val mb = getMethodBind("Curve3D","set_point_out") _icall_Unit_Long_Vector3( mb, this.ptr, idx, position) } open fun setPointPosition(idx: Long, position: Vector3) { val mb = getMethodBind("Curve3D","set_point_position") _icall_Unit_Long_Vector3( mb, this.ptr, idx, position) } open fun setPointTilt(idx: Long, tilt: Double) { val mb = getMethodBind("Curve3D","set_point_tilt") _icall_Unit_Long_Double( mb, this.ptr, idx, tilt) } open fun setUpVectorEnabled(enable: Boolean) { val mb = getMethodBind("Curve3D","set_up_vector_enabled") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun tessellate(maxStages: Long = 5, toleranceDegrees: Double = 4.0): PoolVector3Array { val mb = getMethodBind("Curve3D","tessellate") return _icall_PoolVector3Array_Long_Double( mb, this.ptr, maxStages, toleranceDegrees) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CurveTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Curve import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.UninitializedPropertyAccessException import kotlinx.cinterop.COpaquePointer open class CurveTexture : Texture() { open var curve: Curve get() { val mb = getMethodBind("CurveTexture","get_curve") return _icall_Curve(mb, this.ptr) } set(value) { val mb = getMethodBind("CurveTexture","set_curve") _icall_Unit_Object(mb, this.ptr, value) } open var width: Long get() { throw UninitializedPropertyAccessException("Cannot access property width: has no getter") } set(value) { val mb = getMethodBind("CurveTexture","set_width") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CurveTexture", "CurveTexture") open fun _update() { } open fun getCurve(): Curve { val mb = getMethodBind("CurveTexture","get_curve") return _icall_Curve( mb, this.ptr) } open fun setCurve(curve: Curve) { val mb = getMethodBind("CurveTexture","set_curve") _icall_Unit_Object( mb, this.ptr, curve) } open fun setWidth(width: Long) { val mb = getMethodBind("CurveTexture","set_width") _icall_Unit_Long( mb, this.ptr, width) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CylinderMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class CylinderMesh : PrimitiveMesh() { open var bottomRadius: Double get() { val mb = getMethodBind("CylinderMesh","get_bottom_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CylinderMesh","set_bottom_radius") _icall_Unit_Double(mb, this.ptr, value) } open var height: Double get() { val mb = getMethodBind("CylinderMesh","get_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CylinderMesh","set_height") _icall_Unit_Double(mb, this.ptr, value) } open var radialSegments: Long get() { val mb = getMethodBind("CylinderMesh","get_radial_segments") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CylinderMesh","set_radial_segments") _icall_Unit_Long(mb, this.ptr, value) } open var rings: Long get() { val mb = getMethodBind("CylinderMesh","get_rings") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("CylinderMesh","set_rings") _icall_Unit_Long(mb, this.ptr, value) } open var topRadius: Double get() { val mb = getMethodBind("CylinderMesh","get_top_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CylinderMesh","set_top_radius") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CylinderMesh", "CylinderMesh") open fun getBottomRadius(): Double { val mb = getMethodBind("CylinderMesh","get_bottom_radius") return _icall_Double( mb, this.ptr) } open fun getHeight(): Double { val mb = getMethodBind("CylinderMesh","get_height") return _icall_Double( mb, this.ptr) } open fun getRadialSegments(): Long { val mb = getMethodBind("CylinderMesh","get_radial_segments") return _icall_Long( mb, this.ptr) } open fun getRings(): Long { val mb = getMethodBind("CylinderMesh","get_rings") return _icall_Long( mb, this.ptr) } open fun getTopRadius(): Double { val mb = getMethodBind("CylinderMesh","get_top_radius") return _icall_Double( mb, this.ptr) } open fun setBottomRadius(radius: Double) { val mb = getMethodBind("CylinderMesh","set_bottom_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setHeight(height: Double) { val mb = getMethodBind("CylinderMesh","set_height") _icall_Unit_Double( mb, this.ptr, height) } open fun setRadialSegments(segments: Long) { val mb = getMethodBind("CylinderMesh","set_radial_segments") _icall_Unit_Long( mb, this.ptr, segments) } open fun setRings(rings: Long) { val mb = getMethodBind("CylinderMesh","set_rings") _icall_Unit_Long( mb, this.ptr, rings) } open fun setTopRadius(radius: Double) { val mb = getMethodBind("CylinderMesh","set_top_radius") _icall_Unit_Double( mb, this.ptr, radius) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/CylinderShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class CylinderShape : Shape() { open var height: Double get() { val mb = getMethodBind("CylinderShape","get_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CylinderShape","set_height") _icall_Unit_Double(mb, this.ptr, value) } open var radius: Double get() { val mb = getMethodBind("CylinderShape","get_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("CylinderShape","set_radius") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("CylinderShape", "CylinderShape") open fun getHeight(): Double { val mb = getMethodBind("CylinderShape","get_height") return _icall_Double( mb, this.ptr) } open fun getRadius(): Double { val mb = getMethodBind("CylinderShape","get_radius") return _icall_Double( mb, this.ptr) } open fun setHeight(height: Double) { val mb = getMethodBind("CylinderShape","set_height") _icall_Unit_Double( mb, this.ptr, height) } open fun setRadius(radius: Double) { val mb = getMethodBind("CylinderShape","set_radius") _icall_Unit_Double( mb, this.ptr, radius) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/DTLSServer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.icalls._icall_Long_Object_Object_nObject import godot.icalls._icall_PacketPeerDTLS_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class DTLSServer : Reference() { override fun __new(): COpaquePointer = invokeConstructor("DTLSServer", "DTLSServer") open fun setup( key: CryptoKey, certificate: X509Certificate, chain: X509Certificate? = null ): GodotError { val mb = getMethodBind("DTLSServer","setup") return GodotError.byValue( _icall_Long_Object_Object_nObject( mb, this.ptr, key, certificate, chain).toUInt()) } open fun takeConnection(udpPeer: PacketPeerUDP): PacketPeerDTLS { val mb = getMethodBind("DTLSServer","take_connection") return _icall_PacketPeerDTLS_Object( mb, this.ptr, udpPeer) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/DampedSpringJoint2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class DampedSpringJoint2D : Joint2D() { open var damping: Double get() { val mb = getMethodBind("DampedSpringJoint2D","get_damping") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("DampedSpringJoint2D","set_damping") _icall_Unit_Double(mb, this.ptr, value) } open var length: Double get() { val mb = getMethodBind("DampedSpringJoint2D","get_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("DampedSpringJoint2D","set_length") _icall_Unit_Double(mb, this.ptr, value) } open var restLength: Double get() { val mb = getMethodBind("DampedSpringJoint2D","get_rest_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("DampedSpringJoint2D","set_rest_length") _icall_Unit_Double(mb, this.ptr, value) } open var stiffness: Double get() { val mb = getMethodBind("DampedSpringJoint2D","get_stiffness") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("DampedSpringJoint2D","set_stiffness") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("DampedSpringJoint2D", "DampedSpringJoint2D") open fun getDamping(): Double { val mb = getMethodBind("DampedSpringJoint2D","get_damping") return _icall_Double( mb, this.ptr) } open fun getLength(): Double { val mb = getMethodBind("DampedSpringJoint2D","get_length") return _icall_Double( mb, this.ptr) } open fun getRestLength(): Double { val mb = getMethodBind("DampedSpringJoint2D","get_rest_length") return _icall_Double( mb, this.ptr) } open fun getStiffness(): Double { val mb = getMethodBind("DampedSpringJoint2D","get_stiffness") return _icall_Double( mb, this.ptr) } open fun setDamping(damping: Double) { val mb = getMethodBind("DampedSpringJoint2D","set_damping") _icall_Unit_Double( mb, this.ptr, damping) } open fun setLength(length: Double) { val mb = getMethodBind("DampedSpringJoint2D","set_length") _icall_Unit_Double( mb, this.ptr, length) } open fun setRestLength(restLength: Double) { val mb = getMethodBind("DampedSpringJoint2D","set_rest_length") _icall_Unit_Double( mb, this.ptr, restLength) } open fun setStiffness(stiffness: Double) { val mb = getMethodBind("DampedSpringJoint2D","set_stiffness") _icall_Unit_Double( mb, this.ptr, stiffness) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/DirectionalLight.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.DirectionalLight import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlinx.cinterop.COpaquePointer open class DirectionalLight : Light() { open var directionalShadowBlendSplits: Boolean get() { val mb = getMethodBind("DirectionalLight","is_blend_splits_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("DirectionalLight","set_blend_splits") _icall_Unit_Boolean(mb, this.ptr, value) } open var directionalShadowDepthRange: Long get() { val mb = getMethodBind("DirectionalLight","get_shadow_depth_range") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("DirectionalLight","set_shadow_depth_range") _icall_Unit_Long(mb, this.ptr, value) } open var directionalShadowMode: Long get() { val mb = getMethodBind("DirectionalLight","get_shadow_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("DirectionalLight","set_shadow_mode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("DirectionalLight", "DirectionalLight") open fun getShadowDepthRange(): DirectionalLight.ShadowDepthRange { val mb = getMethodBind("DirectionalLight","get_shadow_depth_range") return DirectionalLight.ShadowDepthRange.from( _icall_Long( mb, this.ptr)) } open fun getShadowMode(): DirectionalLight.ShadowMode { val mb = getMethodBind("DirectionalLight","get_shadow_mode") return DirectionalLight.ShadowMode.from( _icall_Long( mb, this.ptr)) } open fun isBlendSplitsEnabled(): Boolean { val mb = getMethodBind("DirectionalLight","is_blend_splits_enabled") return _icall_Boolean( mb, this.ptr) } open fun setBlendSplits(enabled: Boolean) { val mb = getMethodBind("DirectionalLight","set_blend_splits") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setShadowDepthRange(mode: Long) { val mb = getMethodBind("DirectionalLight","set_shadow_depth_range") _icall_Unit_Long( mb, this.ptr, mode) } open fun setShadowMode(mode: Long) { val mb = getMethodBind("DirectionalLight","set_shadow_mode") _icall_Unit_Long( mb, this.ptr, mode) } enum class ShadowMode( id: Long ) { SHADOW_ORTHOGONAL(0), SHADOW_PARALLEL_2_SPLITS(1), SHADOW_PARALLEL_4_SPLITS(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ShadowDepthRange( id: Long ) { SHADOW_DEPTH_RANGE_STABLE(0), SHADOW_DEPTH_RANGE_OPTIMIZED(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Directory.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_String import godot.icalls._icall_Long import godot.icalls._icall_Long_Boolean_Boolean import godot.icalls._icall_Long_String import godot.icalls._icall_Long_String_String import godot.icalls._icall_String import godot.icalls._icall_String_Long import godot.icalls._icall_Unit import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class Directory : Reference() { override fun __new(): COpaquePointer = invokeConstructor("Directory", "_Directory") open fun changeDir(todir: String): GodotError { val mb = getMethodBind("_Directory","change_dir") return GodotError.byValue( _icall_Long_String( mb, this.ptr, todir).toUInt()) } open fun copy(from: String, to: String): GodotError { val mb = getMethodBind("_Directory","copy") return GodotError.byValue( _icall_Long_String_String( mb, this.ptr, from, to).toUInt()) } open fun currentIsDir(): Boolean { val mb = getMethodBind("_Directory","current_is_dir") return _icall_Boolean( mb, this.ptr) } open fun dirExists(path: String): Boolean { val mb = getMethodBind("_Directory","dir_exists") return _icall_Boolean_String( mb, this.ptr, path) } open fun fileExists(path: String): Boolean { val mb = getMethodBind("_Directory","file_exists") return _icall_Boolean_String( mb, this.ptr, path) } open fun getCurrentDir(): String { val mb = getMethodBind("_Directory","get_current_dir") return _icall_String( mb, this.ptr) } open fun getCurrentDrive(): Long { val mb = getMethodBind("_Directory","get_current_drive") return _icall_Long( mb, this.ptr) } open fun getDrive(idx: Long): String { val mb = getMethodBind("_Directory","get_drive") return _icall_String_Long( mb, this.ptr, idx) } open fun getDriveCount(): Long { val mb = getMethodBind("_Directory","get_drive_count") return _icall_Long( mb, this.ptr) } open fun getNext(): String { val mb = getMethodBind("_Directory","get_next") return _icall_String( mb, this.ptr) } open fun getSpaceLeft(): Long { val mb = getMethodBind("_Directory","get_space_left") return _icall_Long( mb, this.ptr) } open fun listDirBegin(skipNavigational: Boolean = false, skipHidden: Boolean = false): GodotError { val mb = getMethodBind("_Directory","list_dir_begin") return GodotError.byValue( _icall_Long_Boolean_Boolean( mb, this.ptr, skipNavigational, skipHidden).toUInt()) } open fun listDirEnd() { val mb = getMethodBind("_Directory","list_dir_end") _icall_Unit( mb, this.ptr) } open fun makeDir(path: String): GodotError { val mb = getMethodBind("_Directory","make_dir") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun makeDirRecursive(path: String): GodotError { val mb = getMethodBind("_Directory","make_dir_recursive") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun open(path: String): GodotError { val mb = getMethodBind("_Directory","open") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun remove(path: String): GodotError { val mb = getMethodBind("_Directory","remove") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun rename(from: String, to: String): GodotError { val mb = getMethodBind("_Directory","rename") return GodotError.byValue( _icall_Long_String_String( mb, this.ptr, from, to).toUInt()) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/DynamicFont.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_DynamicFontData import godot.icalls._icall_DynamicFontData_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class DynamicFont : Font() { open var extraSpacingBottom: Long get() { val mb = getMethodBind("DynamicFont","get_spacing") return _icall_Long_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("DynamicFont","set_spacing") _icall_Unit_Long_Long(mb, this.ptr, 1, value) } open var extraSpacingChar: Long get() { val mb = getMethodBind("DynamicFont","get_spacing") return _icall_Long_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("DynamicFont","set_spacing") _icall_Unit_Long_Long(mb, this.ptr, 2, value) } open var extraSpacingSpace: Long get() { val mb = getMethodBind("DynamicFont","get_spacing") return _icall_Long_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("DynamicFont","set_spacing") _icall_Unit_Long_Long(mb, this.ptr, 3, value) } open var extraSpacingTop: Long get() { val mb = getMethodBind("DynamicFont","get_spacing") return _icall_Long_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("DynamicFont","set_spacing") _icall_Unit_Long_Long(mb, this.ptr, 0, value) } open var fontData: DynamicFontData get() { val mb = getMethodBind("DynamicFont","get_font_data") return _icall_DynamicFontData(mb, this.ptr) } set(value) { val mb = getMethodBind("DynamicFont","set_font_data") _icall_Unit_Object(mb, this.ptr, value) } open var outlineColor: Color get() { val mb = getMethodBind("DynamicFont","get_outline_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("DynamicFont","set_outline_color") _icall_Unit_Color(mb, this.ptr, value) } open var outlineSize: Long get() { val mb = getMethodBind("DynamicFont","get_outline_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("DynamicFont","set_outline_size") _icall_Unit_Long(mb, this.ptr, value) } open var size: Long get() { val mb = getMethodBind("DynamicFont","get_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("DynamicFont","set_size") _icall_Unit_Long(mb, this.ptr, value) } open var useFilter: Boolean get() { val mb = getMethodBind("DynamicFont","get_use_filter") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("DynamicFont","set_use_filter") _icall_Unit_Boolean(mb, this.ptr, value) } open var useMipmaps: Boolean get() { val mb = getMethodBind("DynamicFont","get_use_mipmaps") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("DynamicFont","set_use_mipmaps") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("DynamicFont", "DynamicFont") open fun outlineColor(schedule: Color.() -> Unit): Color = outlineColor.apply{ schedule(this) outlineColor = this } open fun addFallback(data: DynamicFontData) { val mb = getMethodBind("DynamicFont","add_fallback") _icall_Unit_Object( mb, this.ptr, data) } open fun getFallback(idx: Long): DynamicFontData { val mb = getMethodBind("DynamicFont","get_fallback") return _icall_DynamicFontData_Long( mb, this.ptr, idx) } open fun getFallbackCount(): Long { val mb = getMethodBind("DynamicFont","get_fallback_count") return _icall_Long( mb, this.ptr) } open fun getFontData(): DynamicFontData { val mb = getMethodBind("DynamicFont","get_font_data") return _icall_DynamicFontData( mb, this.ptr) } open fun getOutlineColor(): Color { val mb = getMethodBind("DynamicFont","get_outline_color") return _icall_Color( mb, this.ptr) } open fun getOutlineSize(): Long { val mb = getMethodBind("DynamicFont","get_outline_size") return _icall_Long( mb, this.ptr) } open fun getSize(): Long { val mb = getMethodBind("DynamicFont","get_size") return _icall_Long( mb, this.ptr) } open fun getSpacing(type: Long): Long { val mb = getMethodBind("DynamicFont","get_spacing") return _icall_Long_Long( mb, this.ptr, type) } open fun getUseFilter(): Boolean { val mb = getMethodBind("DynamicFont","get_use_filter") return _icall_Boolean( mb, this.ptr) } open fun getUseMipmaps(): Boolean { val mb = getMethodBind("DynamicFont","get_use_mipmaps") return _icall_Boolean( mb, this.ptr) } open fun removeFallback(idx: Long) { val mb = getMethodBind("DynamicFont","remove_fallback") _icall_Unit_Long( mb, this.ptr, idx) } open fun setFallback(idx: Long, data: DynamicFontData) { val mb = getMethodBind("DynamicFont","set_fallback") _icall_Unit_Long_Object( mb, this.ptr, idx, data) } open fun setFontData(data: DynamicFontData) { val mb = getMethodBind("DynamicFont","set_font_data") _icall_Unit_Object( mb, this.ptr, data) } open fun setOutlineColor(color: Color) { val mb = getMethodBind("DynamicFont","set_outline_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setOutlineSize(size: Long) { val mb = getMethodBind("DynamicFont","set_outline_size") _icall_Unit_Long( mb, this.ptr, size) } open fun setSize(data: Long) { val mb = getMethodBind("DynamicFont","set_size") _icall_Unit_Long( mb, this.ptr, data) } open fun setSpacing(type: Long, value: Long) { val mb = getMethodBind("DynamicFont","set_spacing") _icall_Unit_Long_Long( mb, this.ptr, type, value) } open fun setUseFilter(enable: Boolean) { val mb = getMethodBind("DynamicFont","set_use_filter") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setUseMipmaps(enable: Boolean) { val mb = getMethodBind("DynamicFont","set_use_mipmaps") _icall_Unit_Boolean( mb, this.ptr, enable) } enum class SpacingType( id: Long ) { SPACING_TOP(0), SPACING_BOTTOM(1), SPACING_CHAR(2), SPACING_SPACE(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/DynamicFontData.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.DynamicFontData import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class DynamicFontData : Resource() { open var antialiased: Boolean get() { val mb = getMethodBind("DynamicFontData","is_antialiased") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("DynamicFontData","set_antialiased") _icall_Unit_Boolean(mb, this.ptr, value) } open var fontPath: String get() { val mb = getMethodBind("DynamicFontData","get_font_path") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("DynamicFontData","set_font_path") _icall_Unit_String(mb, this.ptr, value) } open var hinting: Long get() { val mb = getMethodBind("DynamicFontData","get_hinting") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("DynamicFontData","set_hinting") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("DynamicFontData", "DynamicFontData") open fun getFontPath(): String { val mb = getMethodBind("DynamicFontData","get_font_path") return _icall_String( mb, this.ptr) } open fun getHinting(): DynamicFontData.Hinting { val mb = getMethodBind("DynamicFontData","get_hinting") return DynamicFontData.Hinting.from( _icall_Long( mb, this.ptr)) } open fun isAntialiased(): Boolean { val mb = getMethodBind("DynamicFontData","is_antialiased") return _icall_Boolean( mb, this.ptr) } open fun setAntialiased(antialiased: Boolean) { val mb = getMethodBind("DynamicFontData","set_antialiased") _icall_Unit_Boolean( mb, this.ptr, antialiased) } open fun setFontPath(path: String) { val mb = getMethodBind("DynamicFontData","set_font_path") _icall_Unit_String( mb, this.ptr, path) } open fun setHinting(mode: Long) { val mb = getMethodBind("DynamicFontData","set_hinting") _icall_Unit_Long( mb, this.ptr, mode) } enum class Hinting( id: Long ) { HINTING_NONE(0), HINTING_LIGHT(1), HINTING_NORMAL(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorExportPlugin.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolByteArray import godot.core.PoolStringArray import godot.icalls._icall_Unit import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_PoolByteArray_Boolean import godot.icalls._icall_Unit_String_PoolStringArray import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class EditorExportPlugin internal constructor() : Reference() { open fun _exportBegin( features: PoolStringArray, isDebug: Boolean, path: String, flags: Long ) { } open fun _exportEnd() { } open fun _exportFile( path: String, type: String, features: PoolStringArray ) { } open fun addFile( path: String, file: PoolByteArray, remap: Boolean ) { val mb = getMethodBind("EditorExportPlugin","add_file") _icall_Unit_String_PoolByteArray_Boolean( mb, this.ptr, path, file, remap) } open fun addIosBundleFile(path: String) { val mb = getMethodBind("EditorExportPlugin","add_ios_bundle_file") _icall_Unit_String( mb, this.ptr, path) } open fun addIosCppCode(code: String) { val mb = getMethodBind("EditorExportPlugin","add_ios_cpp_code") _icall_Unit_String( mb, this.ptr, code) } open fun addIosFramework(path: String) { val mb = getMethodBind("EditorExportPlugin","add_ios_framework") _icall_Unit_String( mb, this.ptr, path) } open fun addIosLinkerFlags(flags: String) { val mb = getMethodBind("EditorExportPlugin","add_ios_linker_flags") _icall_Unit_String( mb, this.ptr, flags) } open fun addIosPlistContent(plistContent: String) { val mb = getMethodBind("EditorExportPlugin","add_ios_plist_content") _icall_Unit_String( mb, this.ptr, plistContent) } open fun addIosProjectStaticLib(path: String) { val mb = getMethodBind("EditorExportPlugin","add_ios_project_static_lib") _icall_Unit_String( mb, this.ptr, path) } open fun addSharedObject(path: String, tags: PoolStringArray) { val mb = getMethodBind("EditorExportPlugin","add_shared_object") _icall_Unit_String_PoolStringArray( mb, this.ptr, path, tags) } open fun skip() { val mb = getMethodBind("EditorExportPlugin","skip") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorFeatureProfile.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_String import godot.icalls._icall_Long_String import godot.icalls._icall_String_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_String_Boolean import godot.icalls._icall_Unit_String_String_Boolean import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class EditorFeatureProfile internal constructor() : Reference() { open fun getFeatureName(feature: Long): String { val mb = getMethodBind("EditorFeatureProfile","get_feature_name") return _icall_String_Long( mb, this.ptr, feature) } open fun isClassDisabled(className: String): Boolean { val mb = getMethodBind("EditorFeatureProfile","is_class_disabled") return _icall_Boolean_String( mb, this.ptr, className) } open fun isClassEditorDisabled(className: String): Boolean { val mb = getMethodBind("EditorFeatureProfile","is_class_editor_disabled") return _icall_Boolean_String( mb, this.ptr, className) } open fun isClassPropertyDisabled(className: String, property: String): Boolean { val mb = getMethodBind("EditorFeatureProfile","is_class_property_disabled") return _icall_Boolean_String_String( mb, this.ptr, className, property) } open fun isFeatureDisabled(feature: Long): Boolean { val mb = getMethodBind("EditorFeatureProfile","is_feature_disabled") return _icall_Boolean_Long( mb, this.ptr, feature) } open fun loadFromFile(path: String): GodotError { val mb = getMethodBind("EditorFeatureProfile","load_from_file") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun saveToFile(path: String): GodotError { val mb = getMethodBind("EditorFeatureProfile","save_to_file") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun setDisableClass(className: String, disable: Boolean) { val mb = getMethodBind("EditorFeatureProfile","set_disable_class") _icall_Unit_String_Boolean( mb, this.ptr, className, disable) } open fun setDisableClassEditor(className: String, disable: Boolean) { val mb = getMethodBind("EditorFeatureProfile","set_disable_class_editor") _icall_Unit_String_Boolean( mb, this.ptr, className, disable) } open fun setDisableClassProperty( className: String, property: String, disable: Boolean ) { val mb = getMethodBind("EditorFeatureProfile","set_disable_class_property") _icall_Unit_String_String_Boolean( mb, this.ptr, className, property, disable) } open fun setDisableFeature(feature: Long, disable: Boolean) { val mb = getMethodBind("EditorFeatureProfile","set_disable_feature") _icall_Unit_Long_Boolean( mb, this.ptr, feature, disable) } enum class Feature( id: Long ) { FEATURE_3D(0), FEATURE_SCRIPT(1), FEATURE_ASSET_LIB(2), FEATURE_SCENE_TREE(3), FEATURE_IMPORT_DOCK(4), FEATURE_NODE_DOCK(5), FEATURE_FILESYSTEM_DOCK(6), FEATURE_MAX(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorFileDialog.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.EditorFileDialog import godot.core.PoolStringArray import godot.core.Signal1 import godot.core.Variant import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_String import godot.icalls._icall_VBoxContainer import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class EditorFileDialog internal constructor() : ConfirmationDialog() { val dirSelected: Signal1 by signal("dir") val fileSelected: Signal1 by signal("path") val filesSelected: Signal1 by signal("paths") open var access: Long get() { val mb = getMethodBind("EditorFileDialog","get_access") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorFileDialog","set_access") _icall_Unit_Long(mb, this.ptr, value) } open var currentDir: String get() { val mb = getMethodBind("EditorFileDialog","get_current_dir") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorFileDialog","set_current_dir") _icall_Unit_String(mb, this.ptr, value) } open var currentFile: String get() { val mb = getMethodBind("EditorFileDialog","get_current_file") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorFileDialog","set_current_file") _icall_Unit_String(mb, this.ptr, value) } open var currentPath: String get() { val mb = getMethodBind("EditorFileDialog","get_current_path") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorFileDialog","set_current_path") _icall_Unit_String(mb, this.ptr, value) } open var disableOverwriteWarning: Boolean get() { val mb = getMethodBind("EditorFileDialog","is_overwrite_warning_disabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorFileDialog","set_disable_overwrite_warning") _icall_Unit_Boolean(mb, this.ptr, value) } open var displayMode: Long get() { val mb = getMethodBind("EditorFileDialog","get_display_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorFileDialog","set_display_mode") _icall_Unit_Long(mb, this.ptr, value) } open var mode: Long get() { val mb = getMethodBind("EditorFileDialog","get_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorFileDialog","set_mode") _icall_Unit_Long(mb, this.ptr, value) } open var showHiddenFiles: Boolean get() { val mb = getMethodBind("EditorFileDialog","is_showing_hidden_files") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorFileDialog","set_show_hidden_files") _icall_Unit_Boolean(mb, this.ptr, value) } open fun _actionPressed() { } open fun _cancelPressed() { } open fun _dirEntered(arg0: String) { } open fun _favoriteMoveDown() { } open fun _favoriteMoveUp() { } open fun _favoritePressed() { } open fun _favoriteSelected(arg0: Long) { } open fun _fileEntered(arg0: String) { } open fun _filterSelected(arg0: Long) { } open fun _goBack() { } open fun _goForward() { } open fun _goUp() { } open fun _itemDbSelected(arg0: Long) { } open fun _itemListItemRmbSelected(arg0: Long, arg1: Vector2) { } open fun _itemListRmbClicked(arg0: Vector2) { } open fun _itemMenuIdPressed(arg0: Long) { } open fun _itemSelected(arg0: Long) { } open fun _itemsClearSelection() { } open fun _makeDir() { } open fun _makeDirConfirm() { } open fun _multiSelected(arg0: Long, arg1: Boolean) { } open fun _recentSelected(arg0: Long) { } open fun _saveConfirmPressed() { } open fun _selectDrive(arg0: Long) { } open fun _thumbnailDone( arg0: String, arg1: Texture, arg2: Texture, arg3: Variant ) { } open fun _thumbnailResult( arg0: String, arg1: Texture, arg2: Texture, arg3: Variant ) { } override fun _unhandledInput(arg0: InputEvent) { } open fun _updateDir() { } open fun _updateFileList() { } open fun _updateFileName() { } open fun addFilter(filter: String) { val mb = getMethodBind("EditorFileDialog","add_filter") _icall_Unit_String( mb, this.ptr, filter) } open fun clearFilters() { val mb = getMethodBind("EditorFileDialog","clear_filters") _icall_Unit( mb, this.ptr) } open fun getAccess(): EditorFileDialog.Access { val mb = getMethodBind("EditorFileDialog","get_access") return EditorFileDialog.Access.from( _icall_Long( mb, this.ptr)) } open fun getCurrentDir(): String { val mb = getMethodBind("EditorFileDialog","get_current_dir") return _icall_String( mb, this.ptr) } open fun getCurrentFile(): String { val mb = getMethodBind("EditorFileDialog","get_current_file") return _icall_String( mb, this.ptr) } open fun getCurrentPath(): String { val mb = getMethodBind("EditorFileDialog","get_current_path") return _icall_String( mb, this.ptr) } open fun getDisplayMode(): EditorFileDialog.DisplayMode { val mb = getMethodBind("EditorFileDialog","get_display_mode") return EditorFileDialog.DisplayMode.from( _icall_Long( mb, this.ptr)) } open fun getMode(): EditorFileDialog.Mode { val mb = getMethodBind("EditorFileDialog","get_mode") return EditorFileDialog.Mode.from( _icall_Long( mb, this.ptr)) } open fun getVbox(): VBoxContainer { val mb = getMethodBind("EditorFileDialog","get_vbox") return _icall_VBoxContainer( mb, this.ptr) } open fun invalidate() { val mb = getMethodBind("EditorFileDialog","invalidate") _icall_Unit( mb, this.ptr) } open fun isOverwriteWarningDisabled(): Boolean { val mb = getMethodBind("EditorFileDialog","is_overwrite_warning_disabled") return _icall_Boolean( mb, this.ptr) } open fun isShowingHiddenFiles(): Boolean { val mb = getMethodBind("EditorFileDialog","is_showing_hidden_files") return _icall_Boolean( mb, this.ptr) } open fun setAccess(access: Long) { val mb = getMethodBind("EditorFileDialog","set_access") _icall_Unit_Long( mb, this.ptr, access) } open fun setCurrentDir(dir: String) { val mb = getMethodBind("EditorFileDialog","set_current_dir") _icall_Unit_String( mb, this.ptr, dir) } open fun setCurrentFile(file: String) { val mb = getMethodBind("EditorFileDialog","set_current_file") _icall_Unit_String( mb, this.ptr, file) } open fun setCurrentPath(path: String) { val mb = getMethodBind("EditorFileDialog","set_current_path") _icall_Unit_String( mb, this.ptr, path) } open fun setDisableOverwriteWarning(disable: Boolean) { val mb = getMethodBind("EditorFileDialog","set_disable_overwrite_warning") _icall_Unit_Boolean( mb, this.ptr, disable) } open fun setDisplayMode(mode: Long) { val mb = getMethodBind("EditorFileDialog","set_display_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setMode(mode: Long) { val mb = getMethodBind("EditorFileDialog","set_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setShowHiddenFiles(show: Boolean) { val mb = getMethodBind("EditorFileDialog","set_show_hidden_files") _icall_Unit_Boolean( mb, this.ptr, show) } enum class DisplayMode( id: Long ) { DISPLAY_THUMBNAILS(0), DISPLAY_LIST(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Mode( id: Long ) { MODE_OPEN_FILE(0), MODE_OPEN_FILES(1), MODE_OPEN_DIR(2), MODE_OPEN_ANY(3), MODE_SAVE_FILE(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Access( id: Long ) { ACCESS_RESOURCES(0), ACCESS_USERDATA(1), ACCESS_FILESYSTEM(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorFileSystem.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.core.Signal0 import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_EditorFileSystemDirectory import godot.icalls._icall_EditorFileSystemDirectory_String import godot.icalls._icall_String_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.String open class EditorFileSystem internal constructor() : Node() { val filesystemChanged: Signal0 by signal() val resourcesReimported: Signal1 by signal("resources") val resourcesReload: Signal1 by signal("resources") val sourcesChanged: Signal1 by signal("exist") open fun getFileType(path: String): String { val mb = getMethodBind("EditorFileSystem","get_file_type") return _icall_String_String( mb, this.ptr, path) } open fun getFilesystem(): EditorFileSystemDirectory { val mb = getMethodBind("EditorFileSystem","get_filesystem") return _icall_EditorFileSystemDirectory( mb, this.ptr) } open fun getFilesystemPath(path: String): EditorFileSystemDirectory { val mb = getMethodBind("EditorFileSystem","get_filesystem_path") return _icall_EditorFileSystemDirectory_String( mb, this.ptr, path) } open fun getScanningProgress(): Double { val mb = getMethodBind("EditorFileSystem","get_scanning_progress") return _icall_Double( mb, this.ptr) } open fun isScanning(): Boolean { val mb = getMethodBind("EditorFileSystem","is_scanning") return _icall_Boolean( mb, this.ptr) } open fun scan() { val mb = getMethodBind("EditorFileSystem","scan") _icall_Unit( mb, this.ptr) } open fun scanSources() { val mb = getMethodBind("EditorFileSystem","scan_sources") _icall_Unit( mb, this.ptr) } open fun updateFile(path: String) { val mb = getMethodBind("EditorFileSystem","update_file") _icall_Unit_String( mb, this.ptr, path) } open fun updateScriptClasses() { val mb = getMethodBind("EditorFileSystem","update_script_classes") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorFileSystemDirectory.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean_Long import godot.icalls._icall_EditorFileSystemDirectory import godot.icalls._icall_EditorFileSystemDirectory_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_String import godot.icalls._icall_String_Long import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class EditorFileSystemDirectory internal constructor() : Object() { open fun findDirIndex(name: String): Long { val mb = getMethodBind("EditorFileSystemDirectory","find_dir_index") return _icall_Long_String( mb, this.ptr, name) } open fun findFileIndex(name: String): Long { val mb = getMethodBind("EditorFileSystemDirectory","find_file_index") return _icall_Long_String( mb, this.ptr, name) } open fun getFile(idx: Long): String { val mb = getMethodBind("EditorFileSystemDirectory","get_file") return _icall_String_Long( mb, this.ptr, idx) } open fun getFileCount(): Long { val mb = getMethodBind("EditorFileSystemDirectory","get_file_count") return _icall_Long( mb, this.ptr) } open fun getFileImportIsValid(idx: Long): Boolean { val mb = getMethodBind("EditorFileSystemDirectory","get_file_import_is_valid") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun getFilePath(idx: Long): String { val mb = getMethodBind("EditorFileSystemDirectory","get_file_path") return _icall_String_Long( mb, this.ptr, idx) } open fun getFileScriptClassExtends(idx: Long): String { val mb = getMethodBind("EditorFileSystemDirectory","get_file_script_class_extends") return _icall_String_Long( mb, this.ptr, idx) } open fun getFileScriptClassName(idx: Long): String { val mb = getMethodBind("EditorFileSystemDirectory","get_file_script_class_name") return _icall_String_Long( mb, this.ptr, idx) } open fun getFileType(idx: Long): String { val mb = getMethodBind("EditorFileSystemDirectory","get_file_type") return _icall_String_Long( mb, this.ptr, idx) } open fun getName(): String { val mb = getMethodBind("EditorFileSystemDirectory","get_name") return _icall_String( mb, this.ptr) } open fun getParent(): EditorFileSystemDirectory { val mb = getMethodBind("EditorFileSystemDirectory","get_parent") return _icall_EditorFileSystemDirectory( mb, this.ptr) } open fun getPath(): String { val mb = getMethodBind("EditorFileSystemDirectory","get_path") return _icall_String( mb, this.ptr) } open fun getSubdir(idx: Long): EditorFileSystemDirectory { val mb = getMethodBind("EditorFileSystemDirectory","get_subdir") return _icall_EditorFileSystemDirectory_Long( mb, this.ptr, idx) } open fun getSubdirCount(): Long { val mb = getMethodBind("EditorFileSystemDirectory","get_subdir_count") return _icall_Long( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorImportPlugin.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.VariantArray import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String open class EditorImportPlugin internal constructor() : ResourceImporter() { open fun getImportOptions(preset: Long): VariantArray { throw NotImplementedError("get_import_options is not implemented for EditorImportPlugin") } open fun getImportOrder(): Long { throw NotImplementedError("get_import_order is not implemented for EditorImportPlugin") } open fun getImporterName(): String { throw NotImplementedError("get_importer_name is not implemented for EditorImportPlugin") } open fun getOptionVisibility(option: String, options: Dictionary): Boolean { throw NotImplementedError("get_option_visibility is not implemented for EditorImportPlugin") } open fun getPresetCount(): Long { throw NotImplementedError("get_preset_count is not implemented for EditorImportPlugin") } open fun getPresetName(preset: Long): String { throw NotImplementedError("get_preset_name is not implemented for EditorImportPlugin") } open fun getPriority(): Double { throw NotImplementedError("get_priority is not implemented for EditorImportPlugin") } open fun getRecognizedExtensions(): VariantArray { throw NotImplementedError("get_recognized_extensions is not implemented for EditorImportPlugin") } open fun getResourceType(): String { throw NotImplementedError("get_resource_type is not implemented for EditorImportPlugin") } open fun getSaveExtension(): String { throw NotImplementedError("get_save_extension is not implemented for EditorImportPlugin") } open fun getVisibleName(): String { throw NotImplementedError("get_visible_name is not implemented for EditorImportPlugin") } open fun import( sourceFile: String, savePath: String, options: Dictionary, platformVariants: VariantArray, genFiles: VariantArray ): Long { throw NotImplementedError("import is not implemented for EditorImportPlugin") } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorInspector.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal2 import godot.core.Variant import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Unit import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String open class EditorInspector internal constructor() : ScrollContainer() { val objectIdSelected: Signal1 by signal("id") val propertyEdited: Signal1 by signal("property") val propertyKeyed: Signal1 by signal("property") val propertySelected: Signal1 by signal("property") val propertyToggled: Signal2 by signal("property", "checked") val resourceSelected: Signal2 by signal("res", "prop") val restartRequested: Signal0 by signal() open fun _editRequestChange(arg0: Object, arg1: String) { } open fun _featureProfileChanged() { } open fun _filterChanged(arg0: String) { } open fun _multiplePropertiesChanged(arg0: PoolStringArray, arg1: VariantArray) { } open fun _nodeRemoved(arg0: Node) { } open fun _objectIdSelected(arg0: String, arg1: Long) { } open fun _propertyChanged( arg0: String, arg1: Variant, arg2: String = "", arg3: Boolean = false ) { } open fun _propertyChangedUpdateAll( arg0: String, arg1: Variant, arg2: String, arg3: Boolean ) { } open fun _propertyChecked(arg0: String, arg1: Boolean) { } open fun _propertyKeyed(arg0: String, arg1: Boolean) { } open fun _propertyKeyedWithValue( arg0: String, arg1: Variant, arg2: Boolean ) { } open fun _propertySelected(arg0: String, arg1: Long) { } open fun _resourceSelected(arg0: String, arg1: Resource) { } open fun _vscrollChanged(arg0: Double) { } open fun refresh() { val mb = getMethodBind("EditorInspector","refresh") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorInspectorPlugin.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String_Object import godot.icalls._icall_Unit_String_PoolStringArray_Object import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlin.String open class EditorInspectorPlugin internal constructor() : Reference() { open fun addCustomControl(control: Control) { val mb = getMethodBind("EditorInspectorPlugin","add_custom_control") _icall_Unit_Object( mb, this.ptr, control) } open fun addPropertyEditor(property: String, editor: Control) { val mb = getMethodBind("EditorInspectorPlugin","add_property_editor") _icall_Unit_String_Object( mb, this.ptr, property, editor) } open fun addPropertyEditorForMultipleProperties( label: String, properties: PoolStringArray, editor: Control ) { val mb = getMethodBind("EditorInspectorPlugin","add_property_editor_for_multiple_properties") _icall_Unit_String_PoolStringArray_Object( mb, this.ptr, label, properties, editor) } open fun canHandle(_object: Object): Boolean { throw NotImplementedError("can_handle is not implemented for EditorInspectorPlugin") } open fun parseBegin(_object: Object) { } open fun parseCategory(_object: Object, category: String) { } open fun parseEnd() { } open fun parseProperty( _object: Object, type: Long, path: String, hint: Long, hintText: String, usage: Long ): Boolean { throw NotImplementedError("parse_property is not implemented for EditorInspectorPlugin") } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorInterface.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.VariantArray import godot.icalls._icall_Boolean_String import godot.icalls._icall_Control import godot.icalls._icall_EditorFileSystem import godot.icalls._icall_EditorInspector import godot.icalls._icall_EditorResourcePreview import godot.icalls._icall_EditorSelection import godot.icalls._icall_EditorSettings import godot.icalls._icall_FileSystemDock import godot.icalls._icall_Long import godot.icalls._icall_Node import godot.icalls._icall_ScriptEditor import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_String import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Boolean import godot.icalls._icall_VariantArray import godot.icalls._icall_VariantArray_VariantArray_Long import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class EditorInterface internal constructor() : Node() { open fun editResource(resource: Resource) { val mb = getMethodBind("EditorInterface","edit_resource") _icall_Unit_Object( mb, this.ptr, resource) } open fun getBaseControl(): Control { val mb = getMethodBind("EditorInterface","get_base_control") return _icall_Control( mb, this.ptr) } open fun getCurrentPath(): String { val mb = getMethodBind("EditorInterface","get_current_path") return _icall_String( mb, this.ptr) } open fun getEditedSceneRoot(): Node { val mb = getMethodBind("EditorInterface","get_edited_scene_root") return _icall_Node( mb, this.ptr) } open fun getEditorSettings(): EditorSettings { val mb = getMethodBind("EditorInterface","get_editor_settings") return _icall_EditorSettings( mb, this.ptr) } open fun getEditorViewport(): Control { val mb = getMethodBind("EditorInterface","get_editor_viewport") return _icall_Control( mb, this.ptr) } open fun getFileSystemDock(): FileSystemDock { val mb = getMethodBind("EditorInterface","get_file_system_dock") return _icall_FileSystemDock( mb, this.ptr) } open fun getInspector(): EditorInspector { val mb = getMethodBind("EditorInterface","get_inspector") return _icall_EditorInspector( mb, this.ptr) } open fun getOpenScenes(): VariantArray { val mb = getMethodBind("EditorInterface","get_open_scenes") return _icall_VariantArray( mb, this.ptr) } open fun getResourceFilesystem(): EditorFileSystem { val mb = getMethodBind("EditorInterface","get_resource_filesystem") return _icall_EditorFileSystem( mb, this.ptr) } open fun getResourcePreviewer(): EditorResourcePreview { val mb = getMethodBind("EditorInterface","get_resource_previewer") return _icall_EditorResourcePreview( mb, this.ptr) } open fun getScriptEditor(): ScriptEditor { val mb = getMethodBind("EditorInterface","get_script_editor") return _icall_ScriptEditor( mb, this.ptr) } open fun getSelectedPath(): String { val mb = getMethodBind("EditorInterface","get_selected_path") return _icall_String( mb, this.ptr) } open fun getSelection(): EditorSelection { val mb = getMethodBind("EditorInterface","get_selection") return _icall_EditorSelection( mb, this.ptr) } open fun inspectObject(_object: Object, forProperty: String = "") { val mb = getMethodBind("EditorInterface","inspect_object") _icall_Unit_Object_String( mb, this.ptr, _object, forProperty) } open fun isPluginEnabled(plugin: String): Boolean { val mb = getMethodBind("EditorInterface","is_plugin_enabled") return _icall_Boolean_String( mb, this.ptr, plugin) } open fun makeMeshPreviews(meshes: VariantArray, previewSize: Long): VariantArray { val mb = getMethodBind("EditorInterface","make_mesh_previews") return _icall_VariantArray_VariantArray_Long( mb, this.ptr, meshes, previewSize) } open fun openSceneFromPath(sceneFilepath: String) { val mb = getMethodBind("EditorInterface","open_scene_from_path") _icall_Unit_String( mb, this.ptr, sceneFilepath) } open fun reloadSceneFromPath(sceneFilepath: String) { val mb = getMethodBind("EditorInterface","reload_scene_from_path") _icall_Unit_String( mb, this.ptr, sceneFilepath) } open fun saveScene(): GodotError { val mb = getMethodBind("EditorInterface","save_scene") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } open fun saveSceneAs(path: String, withPreview: Boolean = true) { val mb = getMethodBind("EditorInterface","save_scene_as") _icall_Unit_String_Boolean( mb, this.ptr, path, withPreview) } open fun selectFile(file: String) { val mb = getMethodBind("EditorInterface","select_file") _icall_Unit_String( mb, this.ptr, file) } open fun setDistractionFreeMode(enter: Boolean) { val mb = getMethodBind("EditorInterface","set_distraction_free_mode") _icall_Unit_Boolean( mb, this.ptr, enter) } open fun setMainScreenEditor(name: String) { val mb = getMethodBind("EditorInterface","set_main_screen_editor") _icall_Unit_String( mb, this.ptr, name) } open fun setPluginEnabled(plugin: String, enabled: Boolean) { val mb = getMethodBind("EditorInterface","set_plugin_enabled") _icall_Unit_String_Boolean( mb, this.ptr, plugin, enabled) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorNavigationMeshGenerator.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_Object import godot.internal.utils.getMethodBind open class EditorNavigationMeshGenerator internal constructor() : Object() { open fun bake(navMesh: NavigationMesh, rootNode: Node) { val mb = getMethodBind("EditorNavigationMeshGenerator","bake") _icall_Unit_Object_Object( mb, this.ptr, navMesh, rootNode) } open fun clear(navMesh: NavigationMesh) { val mb = getMethodBind("EditorNavigationMeshGenerator","clear") _icall_Unit_Object( mb, this.ptr, navMesh) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorPlugin.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.PoolStringArray import godot.core.Signal1 import godot.core.Variant import godot.core.signal import godot.icalls._icall_EditorInterface import godot.icalls._icall_Long import godot.icalls._icall_ScriptCreateDialog import godot.icalls._icall_ToolButton_Object_String import godot.icalls._icall_UndoRedo import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Object import godot.icalls._icall_Unit_String_Object_String_nVariant import godot.icalls._icall_Unit_String_String import godot.icalls._icall_Unit_String_String_Object_Object import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlin.String open class EditorPlugin internal constructor() : Node() { val mainScreenChanged: Signal1 by signal("screen_name") val resourceSaved: Signal1 by signal("resource") val sceneChanged: Signal1 by signal("scene_root") val sceneClosed: Signal1 by signal("filepath") open fun addAutoloadSingleton(name: String, path: String) { val mb = getMethodBind("EditorPlugin","add_autoload_singleton") _icall_Unit_String_String( mb, this.ptr, name, path) } open fun addControlToBottomPanel(control: Control, title: String): ToolButton { val mb = getMethodBind("EditorPlugin","add_control_to_bottom_panel") return _icall_ToolButton_Object_String( mb, this.ptr, control, title) } open fun addControlToContainer(container: Long, control: Control) { val mb = getMethodBind("EditorPlugin","add_control_to_container") _icall_Unit_Long_Object( mb, this.ptr, container, control) } open fun addControlToDock(slot: Long, control: Control) { val mb = getMethodBind("EditorPlugin","add_control_to_dock") _icall_Unit_Long_Object( mb, this.ptr, slot, control) } open fun addCustomType( type: String, base: String, script: Script, icon: Texture ) { val mb = getMethodBind("EditorPlugin","add_custom_type") _icall_Unit_String_String_Object_Object( mb, this.ptr, type, base, script, icon) } open fun addExportPlugin(plugin: EditorExportPlugin) { val mb = getMethodBind("EditorPlugin","add_export_plugin") _icall_Unit_Object( mb, this.ptr, plugin) } open fun addImportPlugin(importer: EditorImportPlugin) { val mb = getMethodBind("EditorPlugin","add_import_plugin") _icall_Unit_Object( mb, this.ptr, importer) } open fun addInspectorPlugin(plugin: EditorInspectorPlugin) { val mb = getMethodBind("EditorPlugin","add_inspector_plugin") _icall_Unit_Object( mb, this.ptr, plugin) } open fun addSceneImportPlugin(sceneImporter: EditorSceneImporter) { val mb = getMethodBind("EditorPlugin","add_scene_import_plugin") _icall_Unit_Object( mb, this.ptr, sceneImporter) } open fun addSpatialGizmoPlugin(plugin: EditorSpatialGizmoPlugin) { val mb = getMethodBind("EditorPlugin","add_spatial_gizmo_plugin") _icall_Unit_Object( mb, this.ptr, plugin) } open fun addToolMenuItem( name: String, handler: Object, callback: String, ud: Variant? = null ) { val mb = getMethodBind("EditorPlugin","add_tool_menu_item") _icall_Unit_String_Object_String_nVariant( mb, this.ptr, name, handler, callback, ud) } open fun addToolSubmenuItem(name: String, submenu: Object) { val mb = getMethodBind("EditorPlugin","add_tool_submenu_item") _icall_Unit_String_Object( mb, this.ptr, name, submenu) } open fun applyChanges() { } open fun build(): Boolean { throw NotImplementedError("build is not implemented for EditorPlugin") } open fun clear() { } open fun disablePlugin() { } open fun edit(_object: Object) { } open fun enablePlugin() { } open fun forwardCanvasDrawOverViewport(overlay: Control) { } open fun forwardCanvasForceDrawOverViewport(overlay: Control) { } open fun forwardCanvasGuiInput(event: InputEvent): Boolean { throw NotImplementedError("forward_canvas_gui_input is not implemented for EditorPlugin") } open fun forwardSpatialGuiInput(camera: Camera, event: InputEvent): Boolean { throw NotImplementedError("forward_spatial_gui_input is not implemented for EditorPlugin") } open fun getBreakpoints(): PoolStringArray { throw NotImplementedError("get_breakpoints is not implemented for EditorPlugin") } open fun getEditorInterface(): EditorInterface { val mb = getMethodBind("EditorPlugin","get_editor_interface") return _icall_EditorInterface( mb, this.ptr) } open fun getPluginIcon(): Texture { throw NotImplementedError("get_plugin_icon is not implemented for EditorPlugin") } open fun getPluginName(): String { throw NotImplementedError("get_plugin_name is not implemented for EditorPlugin") } open fun getScriptCreateDialog(): ScriptCreateDialog { val mb = getMethodBind("EditorPlugin","get_script_create_dialog") return _icall_ScriptCreateDialog( mb, this.ptr) } open fun getState(): Dictionary { throw NotImplementedError("get_state is not implemented for EditorPlugin") } open fun getUndoRedo(): UndoRedo { val mb = getMethodBind("EditorPlugin","get_undo_redo") return _icall_UndoRedo( mb, this.ptr) } open fun getWindowLayout(layout: ConfigFile) { } open fun handles(_object: Object): Boolean { throw NotImplementedError("handles is not implemented for EditorPlugin") } open fun hasMainScreen(): Boolean { throw NotImplementedError("has_main_screen is not implemented for EditorPlugin") } open fun hideBottomPanel() { val mb = getMethodBind("EditorPlugin","hide_bottom_panel") _icall_Unit( mb, this.ptr) } open fun makeBottomPanelItemVisible(item: Control) { val mb = getMethodBind("EditorPlugin","make_bottom_panel_item_visible") _icall_Unit_Object( mb, this.ptr, item) } open fun makeVisible(visible: Boolean) { } open fun queueSaveLayout() { val mb = getMethodBind("EditorPlugin","queue_save_layout") _icall_Unit( mb, this.ptr) } open fun removeAutoloadSingleton(name: String) { val mb = getMethodBind("EditorPlugin","remove_autoload_singleton") _icall_Unit_String( mb, this.ptr, name) } open fun removeControlFromBottomPanel(control: Control) { val mb = getMethodBind("EditorPlugin","remove_control_from_bottom_panel") _icall_Unit_Object( mb, this.ptr, control) } open fun removeControlFromContainer(container: Long, control: Control) { val mb = getMethodBind("EditorPlugin","remove_control_from_container") _icall_Unit_Long_Object( mb, this.ptr, container, control) } open fun removeControlFromDocks(control: Control) { val mb = getMethodBind("EditorPlugin","remove_control_from_docks") _icall_Unit_Object( mb, this.ptr, control) } open fun removeCustomType(type: String) { val mb = getMethodBind("EditorPlugin","remove_custom_type") _icall_Unit_String( mb, this.ptr, type) } open fun removeExportPlugin(plugin: EditorExportPlugin) { val mb = getMethodBind("EditorPlugin","remove_export_plugin") _icall_Unit_Object( mb, this.ptr, plugin) } open fun removeImportPlugin(importer: EditorImportPlugin) { val mb = getMethodBind("EditorPlugin","remove_import_plugin") _icall_Unit_Object( mb, this.ptr, importer) } open fun removeInspectorPlugin(plugin: EditorInspectorPlugin) { val mb = getMethodBind("EditorPlugin","remove_inspector_plugin") _icall_Unit_Object( mb, this.ptr, plugin) } open fun removeSceneImportPlugin(sceneImporter: EditorSceneImporter) { val mb = getMethodBind("EditorPlugin","remove_scene_import_plugin") _icall_Unit_Object( mb, this.ptr, sceneImporter) } open fun removeSpatialGizmoPlugin(plugin: EditorSpatialGizmoPlugin) { val mb = getMethodBind("EditorPlugin","remove_spatial_gizmo_plugin") _icall_Unit_Object( mb, this.ptr, plugin) } open fun removeToolMenuItem(name: String) { val mb = getMethodBind("EditorPlugin","remove_tool_menu_item") _icall_Unit_String( mb, this.ptr, name) } open fun saveExternalData() { } open fun setForceDrawOverForwardingEnabled() { val mb = getMethodBind("EditorPlugin","set_force_draw_over_forwarding_enabled") _icall_Unit( mb, this.ptr) } open fun setInputEventForwardingAlwaysEnabled() { val mb = getMethodBind("EditorPlugin","set_input_event_forwarding_always_enabled") _icall_Unit( mb, this.ptr) } open fun setState(state: Dictionary) { } open fun setWindowLayout(layout: ConfigFile) { } open fun updateOverlays(): Long { val mb = getMethodBind("EditorPlugin","update_overlays") return _icall_Long( mb, this.ptr) } enum class DockSlot( id: Long ) { DOCK_SLOT_LEFT_UL(0), DOCK_SLOT_LEFT_BL(1), DOCK_SLOT_LEFT_UR(2), DOCK_SLOT_LEFT_BR(3), DOCK_SLOT_RIGHT_UL(4), DOCK_SLOT_RIGHT_BL(5), DOCK_SLOT_RIGHT_UR(6), DOCK_SLOT_RIGHT_BR(7), DOCK_SLOT_MAX(8); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class CustomControlContainer( id: Long ) { CONTAINER_TOOLBAR(0), CONTAINER_SPATIAL_EDITOR_MENU(1), CONTAINER_SPATIAL_EDITOR_SIDE_LEFT(2), CONTAINER_SPATIAL_EDITOR_SIDE_RIGHT(3), CONTAINER_SPATIAL_EDITOR_BOTTOM(4), CONTAINER_CANVAS_EDITOR_MENU(5), CONTAINER_CANVAS_EDITOR_SIDE_LEFT(6), CONTAINER_CANVAS_EDITOR_SIDE_RIGHT(7), CONTAINER_CANVAS_EDITOR_BOTTOM(8), CONTAINER_PROPERTY_EDITOR_BOTTOM(9), CONTAINER_PROJECT_SETTING_TAB_LEFT(10), CONTAINER_PROJECT_SETTING_TAB_RIGHT(11); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorProperty.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.core.Signal1 import godot.core.Signal2 import godot.core.Variant import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Object import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Variant_String_Boolean import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class EditorProperty internal constructor() : Container() { val multiplePropertiesChanged: Signal2 by signal("properties", "value") val objectIdSelected: Signal2 by signal("property", "id") val propertyChanged: Signal2 by signal("property", "value") val propertyChecked: Signal2 by signal("property", "bool") val propertyKeyed: Signal1 by signal("property") val propertyKeyedWithValue: Signal2 by signal("property", "value") val resourceSelected: Signal2 by signal("path", "resource") val selected: Signal2 by signal("path", "focusable_idx") open var checkable: Boolean get() { val mb = getMethodBind("EditorProperty","is_checkable") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorProperty","set_checkable") _icall_Unit_Boolean(mb, this.ptr, value) } open var checked: Boolean get() { val mb = getMethodBind("EditorProperty","is_checked") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorProperty","set_checked") _icall_Unit_Boolean(mb, this.ptr, value) } open var drawRed: Boolean get() { val mb = getMethodBind("EditorProperty","is_draw_red") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorProperty","set_draw_red") _icall_Unit_Boolean(mb, this.ptr, value) } open var keying: Boolean get() { val mb = getMethodBind("EditorProperty","is_keying") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorProperty","set_keying") _icall_Unit_Boolean(mb, this.ptr, value) } open var label: String get() { val mb = getMethodBind("EditorProperty","get_label") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorProperty","set_label") _icall_Unit_String(mb, this.ptr, value) } open var readOnly: Boolean get() { val mb = getMethodBind("EditorProperty","is_read_only") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorProperty","set_read_only") _icall_Unit_Boolean(mb, this.ptr, value) } open fun _focusableFocused(arg0: Long) { } override fun _guiInput(arg0: InputEvent) { } open fun addFocusable(control: Control) { val mb = getMethodBind("EditorProperty","add_focusable") _icall_Unit_Object( mb, this.ptr, control) } open fun emitChanged( property: String, value: Variant, field: String = "", changing: Boolean = false ) { val mb = getMethodBind("EditorProperty","emit_changed") _icall_Unit_String_Variant_String_Boolean( mb, this.ptr, property, value, field, changing) } open fun getEditedObject(): Object { val mb = getMethodBind("EditorProperty","get_edited_object") return _icall_Object( mb, this.ptr) } open fun getEditedProperty(): String { val mb = getMethodBind("EditorProperty","get_edited_property") return _icall_String( mb, this.ptr) } open fun getLabel(): String { val mb = getMethodBind("EditorProperty","get_label") return _icall_String( mb, this.ptr) } open fun getTooltipText(): String { val mb = getMethodBind("EditorProperty","get_tooltip_text") return _icall_String( mb, this.ptr) } open fun isCheckable(): Boolean { val mb = getMethodBind("EditorProperty","is_checkable") return _icall_Boolean( mb, this.ptr) } open fun isChecked(): Boolean { val mb = getMethodBind("EditorProperty","is_checked") return _icall_Boolean( mb, this.ptr) } open fun isDrawRed(): Boolean { val mb = getMethodBind("EditorProperty","is_draw_red") return _icall_Boolean( mb, this.ptr) } open fun isKeying(): Boolean { val mb = getMethodBind("EditorProperty","is_keying") return _icall_Boolean( mb, this.ptr) } open fun isReadOnly(): Boolean { val mb = getMethodBind("EditorProperty","is_read_only") return _icall_Boolean( mb, this.ptr) } open fun setBottomEditor(editor: Control) { val mb = getMethodBind("EditorProperty","set_bottom_editor") _icall_Unit_Object( mb, this.ptr, editor) } open fun setCheckable(checkable: Boolean) { val mb = getMethodBind("EditorProperty","set_checkable") _icall_Unit_Boolean( mb, this.ptr, checkable) } open fun setChecked(checked: Boolean) { val mb = getMethodBind("EditorProperty","set_checked") _icall_Unit_Boolean( mb, this.ptr, checked) } open fun setDrawRed(drawRed: Boolean) { val mb = getMethodBind("EditorProperty","set_draw_red") _icall_Unit_Boolean( mb, this.ptr, drawRed) } open fun setKeying(keying: Boolean) { val mb = getMethodBind("EditorProperty","set_keying") _icall_Unit_Boolean( mb, this.ptr, keying) } open fun setLabel(text: String) { val mb = getMethodBind("EditorProperty","set_label") _icall_Unit_String( mb, this.ptr, text) } open fun setReadOnly(readOnly: Boolean) { val mb = getMethodBind("EditorProperty","set_read_only") _icall_Unit_Boolean( mb, this.ptr, readOnly) } open fun updateProperty() { } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorResourceConversionPlugin.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import kotlin.NotImplementedError import kotlin.String open class EditorResourceConversionPlugin internal constructor() : Reference() { open fun _convert(resource: Resource): Resource { throw NotImplementedError("_convert is not implemented for EditorResourceConversionPlugin") } open fun _convertsTo(): String { throw NotImplementedError("_converts_to is not implemented for EditorResourceConversionPlugin") } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorResourcePreview.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal1 import godot.core.Variant import godot.core.signal import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_Object_String_Variant import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Object_String_Variant import godot.internal.utils.getMethodBind import kotlin.Long import kotlin.String open class EditorResourcePreview internal constructor() : Node() { val previewInvalidated: Signal1 by signal("path") open fun _previewReady( arg0: String, arg1: Texture, arg2: Texture, arg3: Long, arg4: String, arg5: Variant ) { } open fun addPreviewGenerator(generator: EditorResourcePreviewGenerator) { val mb = getMethodBind("EditorResourcePreview","add_preview_generator") _icall_Unit_Object( mb, this.ptr, generator) } open fun checkForInvalidation(path: String) { val mb = getMethodBind("EditorResourcePreview","check_for_invalidation") _icall_Unit_String( mb, this.ptr, path) } open fun queueEditedResourcePreview( resource: Resource, receiver: Object, receiverFunc: String, userdata: Variant ) { val mb = getMethodBind("EditorResourcePreview","queue_edited_resource_preview") _icall_Unit_Object_Object_String_Variant( mb, this.ptr, resource, receiver, receiverFunc, userdata) } open fun queueResourcePreview( path: String, receiver: Object, receiverFunc: String, userdata: Variant ) { val mb = getMethodBind("EditorResourcePreview","queue_resource_preview") _icall_Unit_String_Object_String_Variant( mb, this.ptr, path, receiver, receiverFunc, userdata) } open fun removePreviewGenerator(generator: EditorResourcePreviewGenerator) { val mb = getMethodBind("EditorResourcePreview","remove_preview_generator") _icall_Unit_Object( mb, this.ptr, generator) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorResourcePreviewGenerator.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import kotlin.Boolean import kotlin.NotImplementedError import kotlin.String open class EditorResourcePreviewGenerator internal constructor() : Reference() { open fun canGenerateSmallPreview(): Boolean { throw NotImplementedError("can_generate_small_preview is not implemented for EditorResourcePreviewGenerator") } open fun generate(from: Resource, size: Vector2): Texture { throw NotImplementedError("generate is not implemented for EditorResourcePreviewGenerator") } open fun generateFromPath(path: String, size: Vector2): Texture { throw NotImplementedError("generate_from_path is not implemented for EditorResourcePreviewGenerator") } open fun generateSmallPreviewAutomatically(): Boolean { throw NotImplementedError("generate_small_preview_automatically is not implemented for EditorResourcePreviewGenerator") } open fun handles(type: String): Boolean { throw NotImplementedError("handles is not implemented for EditorResourcePreviewGenerator") } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorSceneImporter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.VariantArray import godot.icalls._icall_Animation_String_Long_Long import godot.icalls._icall_Node_String_Long_Long import godot.internal.utils.getMethodBind import kotlin.Long import kotlin.NotImplementedError import kotlin.String open class EditorSceneImporter internal constructor() : Reference() { open fun _getExtensions(): VariantArray { throw NotImplementedError("_get_extensions is not implemented for EditorSceneImporter") } open fun _getImportFlags(): Long { throw NotImplementedError("_get_import_flags is not implemented for EditorSceneImporter") } open fun _importAnimation( path: String, flags: Long, bakeFps: Long ): Animation { throw NotImplementedError("_import_animation is not implemented for EditorSceneImporter") } open fun _importScene( path: String, flags: Long, bakeFps: Long ): Node { throw NotImplementedError("_import_scene is not implemented for EditorSceneImporter") } open fun importAnimationFromOtherImporter( path: String, flags: Long, bakeFps: Long ): Animation { val mb = getMethodBind("EditorSceneImporter","import_animation_from_other_importer") return _icall_Animation_String_Long_Long( mb, this.ptr, path, flags, bakeFps) } open fun importSceneFromOtherImporter( path: String, flags: Long, bakeFps: Long ): Node { val mb = getMethodBind("EditorSceneImporter","import_scene_from_other_importer") return _icall_Node_String_Long_Long( mb, this.ptr, path, flags, bakeFps) } companion object { final const val IMPORT_ANIMATION: Long = 2 final const val IMPORT_ANIMATION_DETECT_LOOP: Long = 4 final const val IMPORT_ANIMATION_FORCE_ALL_TRACKS_IN_ALL_CLIPS: Long = 16 final const val IMPORT_ANIMATION_KEEP_VALUE_TRACKS: Long = 32 final const val IMPORT_ANIMATION_OPTIMIZE: Long = 8 final const val IMPORT_FAIL_ON_MISSING_DEPENDENCIES: Long = 512 final const val IMPORT_GENERATE_TANGENT_ARRAYS: Long = 256 final const val IMPORT_MATERIALS_IN_INSTANCES: Long = 1024 final const val IMPORT_SCENE: Long = 1 final const val IMPORT_USE_COMPRESSION: Long = 2048 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorSceneImporterAssimp.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class EditorSceneImporterAssimp internal constructor() : EditorSceneImporter() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorScenePostImport.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_String import godot.internal.utils.getMethodBind import kotlin.NotImplementedError import kotlin.String open class EditorScenePostImport internal constructor() : Reference() { open fun getSourceFile(): String { val mb = getMethodBind("EditorScenePostImport","get_source_file") return _icall_String( mb, this.ptr) } open fun getSourceFolder(): String { val mb = getMethodBind("EditorScenePostImport","get_source_folder") return _icall_String( mb, this.ptr) } open fun postImport(scene: Object): Object { throw NotImplementedError("post_import is not implemented for EditorScenePostImport") } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorScript.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_EditorInterface import godot.icalls._icall_Node import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind open class EditorScript internal constructor() : Reference() { open fun _run() { } open fun addRootNode(node: Node) { val mb = getMethodBind("EditorScript","add_root_node") _icall_Unit_Object( mb, this.ptr, node) } open fun getEditorInterface(): EditorInterface { val mb = getMethodBind("EditorScript","get_editor_interface") return _icall_EditorInterface( mb, this.ptr) } open fun getScene(): Node { val mb = getMethodBind("EditorScript","get_scene") return _icall_Node( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorSelection.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Object import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind open class EditorSelection internal constructor() : Object() { val selectionChanged: Signal0 by signal() open fun _emitChange() { } open fun _nodeRemoved(arg0: Node) { } open fun addNode(node: Node) { val mb = getMethodBind("EditorSelection","add_node") _icall_Unit_Object( mb, this.ptr, node) } open fun clear() { val mb = getMethodBind("EditorSelection","clear") _icall_Unit( mb, this.ptr) } open fun getSelectedNodes(): VariantArray { val mb = getMethodBind("EditorSelection","get_selected_nodes") return _icall_VariantArray( mb, this.ptr) } open fun getTransformableSelectedNodes(): VariantArray { val mb = getMethodBind("EditorSelection","get_transformable_selected_nodes") return _icall_VariantArray( mb, this.ptr) } open fun removeNode(node: Node) { val mb = getMethodBind("EditorSelection","remove_node") _icall_Unit_Object( mb, this.ptr, node) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorSettings.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.PoolStringArray import godot.core.Signal0 import godot.core.Variant import godot.core.signal import godot.icalls._icall_Boolean_String import godot.icalls._icall_PoolStringArray import godot.icalls._icall_String import godot.icalls._icall_Unit_Dictionary import godot.icalls._icall_Unit_PoolStringArray import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_String_Variant import godot.icalls._icall_Unit_String_Variant import godot.icalls._icall_Unit_String_Variant_Boolean import godot.icalls._icall_Variant_String import godot.icalls._icall_Variant_String_String_nVariant import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class EditorSettings internal constructor() : Resource() { val settingsChanged: Signal0 by signal() open fun addPropertyInfo(info: Dictionary) { val mb = getMethodBind("EditorSettings","add_property_info") _icall_Unit_Dictionary( mb, this.ptr, info) } open fun erase(property: String) { val mb = getMethodBind("EditorSettings","erase") _icall_Unit_String( mb, this.ptr, property) } open fun getFavorites(): PoolStringArray { val mb = getMethodBind("EditorSettings","get_favorites") return _icall_PoolStringArray( mb, this.ptr) } open fun getProjectMetadata( section: String, key: String, default: Variant? = null ): Variant { val mb = getMethodBind("EditorSettings","get_project_metadata") return _icall_Variant_String_String_nVariant( mb, this.ptr, section, key, default) } open fun getProjectSettingsDir(): String { val mb = getMethodBind("EditorSettings","get_project_settings_dir") return _icall_String( mb, this.ptr) } open fun getRecentDirs(): PoolStringArray { val mb = getMethodBind("EditorSettings","get_recent_dirs") return _icall_PoolStringArray( mb, this.ptr) } open fun getSetting(name: String): Variant { val mb = getMethodBind("EditorSettings","get_setting") return _icall_Variant_String( mb, this.ptr, name) } open fun getSettingsDir(): String { val mb = getMethodBind("EditorSettings","get_settings_dir") return _icall_String( mb, this.ptr) } open fun hasSetting(name: String): Boolean { val mb = getMethodBind("EditorSettings","has_setting") return _icall_Boolean_String( mb, this.ptr, name) } open fun propertyCanRevert(name: String): Boolean { val mb = getMethodBind("EditorSettings","property_can_revert") return _icall_Boolean_String( mb, this.ptr, name) } open fun propertyGetRevert(name: String): Variant { val mb = getMethodBind("EditorSettings","property_get_revert") return _icall_Variant_String( mb, this.ptr, name) } open fun setFavorites(dirs: PoolStringArray) { val mb = getMethodBind("EditorSettings","set_favorites") _icall_Unit_PoolStringArray( mb, this.ptr, dirs) } open fun setInitialValue( name: String, value: Variant, updateCurrent: Boolean ) { val mb = getMethodBind("EditorSettings","set_initial_value") _icall_Unit_String_Variant_Boolean( mb, this.ptr, name, value, updateCurrent) } open fun setProjectMetadata( section: String, key: String, data: Variant ) { val mb = getMethodBind("EditorSettings","set_project_metadata") _icall_Unit_String_String_Variant( mb, this.ptr, section, key, data) } open fun setRecentDirs(dirs: PoolStringArray) { val mb = getMethodBind("EditorSettings","set_recent_dirs") _icall_Unit_PoolStringArray( mb, this.ptr, dirs) } open fun setSetting(name: String, value: Variant) { val mb = getMethodBind("EditorSettings","set_setting") _icall_Unit_String_Variant( mb, this.ptr, name, value) } companion object { final const val NOTIFICATION_EDITOR_SETTINGS_CHANGED: Long = 10000 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorSpatialGizmo.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.PoolVector3Array import godot.core.Variant import godot.core.Vector2 import godot.icalls._icall_EditorSpatialGizmoPlugin import godot.icalls._icall_Spatial import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_Boolean_nObject_nObject import godot.icalls._icall_Unit_Object_Double_Color import godot.icalls._icall_Unit_PoolVector3Array import godot.icalls._icall_Unit_PoolVector3Array_Object_Boolean_Boolean import godot.icalls._icall_Unit_PoolVector3Array_Object_Boolean_Color import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String open class EditorSpatialGizmo internal constructor() : SpatialGizmo() { open fun addCollisionSegments(segments: PoolVector3Array) { val mb = getMethodBind("EditorSpatialGizmo","add_collision_segments") _icall_Unit_PoolVector3Array( mb, this.ptr, segments) } open fun addCollisionTriangles(triangles: TriangleMesh) { val mb = getMethodBind("EditorSpatialGizmo","add_collision_triangles") _icall_Unit_Object( mb, this.ptr, triangles) } open fun addHandles( handles: PoolVector3Array, material: Material, billboard: Boolean = false, secondary: Boolean = false ) { val mb = getMethodBind("EditorSpatialGizmo","add_handles") _icall_Unit_PoolVector3Array_Object_Boolean_Boolean( mb, this.ptr, handles, material, billboard, secondary) } open fun addLines( lines: PoolVector3Array, material: Material, billboard: Boolean = false, modulate: Color = Color(1,1,1,1) ) { val mb = getMethodBind("EditorSpatialGizmo","add_lines") _icall_Unit_PoolVector3Array_Object_Boolean_Color( mb, this.ptr, lines, material, billboard, modulate) } open fun addMesh( mesh: ArrayMesh, billboard: Boolean = false, skeleton: SkinReference? = null, material: Material? = null ) { val mb = getMethodBind("EditorSpatialGizmo","add_mesh") _icall_Unit_Object_Boolean_nObject_nObject( mb, this.ptr, mesh, billboard, skeleton, material) } open fun addUnscaledBillboard( material: Material, defaultScale: Double = 1.0, modulate: Color = Color(1,1,1,1) ) { val mb = getMethodBind("EditorSpatialGizmo","add_unscaled_billboard") _icall_Unit_Object_Double_Color( mb, this.ptr, material, defaultScale, modulate) } open fun clear() { val mb = getMethodBind("EditorSpatialGizmo","clear") _icall_Unit( mb, this.ptr) } open fun commitHandle( index: Long, restore: Variant, cancel: Boolean ) { } open fun getHandleName(index: Long): String { throw NotImplementedError("get_handle_name is not implemented for EditorSpatialGizmo") } open fun getHandleValue(index: Long): Variant { throw NotImplementedError("get_handle_value is not implemented for EditorSpatialGizmo") } open fun getPlugin(): EditorSpatialGizmoPlugin { val mb = getMethodBind("EditorSpatialGizmo","get_plugin") return _icall_EditorSpatialGizmoPlugin( mb, this.ptr) } open fun getSpatialNode(): Spatial { val mb = getMethodBind("EditorSpatialGizmo","get_spatial_node") return _icall_Spatial( mb, this.ptr) } open fun isHandleHighlighted(index: Long): Boolean { throw NotImplementedError("is_handle_highlighted is not implemented for EditorSpatialGizmo") } open fun redraw() { } open fun setHandle( index: Long, camera: Camera, point: Vector2 ) { } open fun setHidden(hidden: Boolean) { val mb = getMethodBind("EditorSpatialGizmo","set_hidden") _icall_Unit_Boolean( mb, this.ptr, hidden) } open fun setSpatialNode(node: Node) { val mb = getMethodBind("EditorSpatialGizmo","set_spatial_node") _icall_Unit_Object( mb, this.ptr, node) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorSpatialGizmoPlugin.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.Variant import godot.core.Vector2 import godot.icalls._icall_SpatialMaterial_String_Object import godot.icalls._icall_Unit_String_Boolean import godot.icalls._icall_Unit_String_Color_Boolean_Boolean_Boolean import godot.icalls._icall_Unit_String_Object import godot.icalls._icall_Unit_String_Object_Boolean_Color import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlin.String open class EditorSpatialGizmoPlugin internal constructor() : Resource() { open fun addMaterial(name: String, material: SpatialMaterial) { val mb = getMethodBind("EditorSpatialGizmoPlugin","add_material") _icall_Unit_String_Object( mb, this.ptr, name, material) } open fun canBeHidden(): Boolean { throw NotImplementedError("can_be_hidden is not implemented for EditorSpatialGizmoPlugin") } open fun commitHandle( gizmo: EditorSpatialGizmo, index: Long, restore: Variant, cancel: Boolean ) { } open fun createGizmo(spatial: Spatial): EditorSpatialGizmo { throw NotImplementedError("create_gizmo is not implemented for EditorSpatialGizmoPlugin") } open fun createHandleMaterial(name: String, billboard: Boolean = false) { val mb = getMethodBind("EditorSpatialGizmoPlugin","create_handle_material") _icall_Unit_String_Boolean( mb, this.ptr, name, billboard) } open fun createIconMaterial( name: String, texture: Texture, onTop: Boolean = false, color: Color = Color(1,1,1,1) ) { val mb = getMethodBind("EditorSpatialGizmoPlugin","create_icon_material") _icall_Unit_String_Object_Boolean_Color( mb, this.ptr, name, texture, onTop, color) } open fun createMaterial( name: String, color: Color, billboard: Boolean = false, onTop: Boolean = false, useVertexColor: Boolean = false ) { val mb = getMethodBind("EditorSpatialGizmoPlugin","create_material") _icall_Unit_String_Color_Boolean_Boolean_Boolean( mb, this.ptr, name, color, billboard, onTop, useVertexColor) } open fun getHandleName(gizmo: EditorSpatialGizmo, index: Long): String { throw NotImplementedError("get_handle_name is not implemented for EditorSpatialGizmoPlugin") } open fun getHandleValue(gizmo: EditorSpatialGizmo, index: Long): Variant { throw NotImplementedError("get_handle_value is not implemented for EditorSpatialGizmoPlugin") } open fun getMaterial(name: String, gizmo: EditorSpatialGizmo): SpatialMaterial { val mb = getMethodBind("EditorSpatialGizmoPlugin","get_material") return _icall_SpatialMaterial_String_Object( mb, this.ptr, name, gizmo) } override fun getName(): String { throw NotImplementedError("get_name is not implemented for EditorSpatialGizmoPlugin") } open fun getPriority(): String { throw NotImplementedError("get_priority is not implemented for EditorSpatialGizmoPlugin") } open fun hasGizmo(spatial: Spatial): Boolean { throw NotImplementedError("has_gizmo is not implemented for EditorSpatialGizmoPlugin") } open fun isHandleHighlighted(gizmo: EditorSpatialGizmo, index: Long): Boolean { throw NotImplementedError("is_handle_highlighted is not implemented for EditorSpatialGizmoPlugin") } open fun isSelectableWhenHidden(): Boolean { throw NotImplementedError("is_selectable_when_hidden is not implemented for EditorSpatialGizmoPlugin") } open fun redraw(gizmo: EditorSpatialGizmo) { } open fun setHandle( gizmo: EditorSpatialGizmo, index: Long, camera: Camera, point: Vector2 ) { } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorSpinSlider.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.String open class EditorSpinSlider internal constructor() : Range() { open var flat: Boolean get() { val mb = getMethodBind("EditorSpinSlider","is_flat") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorSpinSlider","set_flat") _icall_Unit_Boolean(mb, this.ptr, value) } open var label: String get() { val mb = getMethodBind("EditorSpinSlider","get_label") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorSpinSlider","set_label") _icall_Unit_String(mb, this.ptr, value) } open var readOnly: Boolean get() { val mb = getMethodBind("EditorSpinSlider","is_read_only") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("EditorSpinSlider","set_read_only") _icall_Unit_Boolean(mb, this.ptr, value) } open fun _grabberGuiInput(arg0: InputEvent) { } open fun _grabberMouseEntered() { } open fun _grabberMouseExited() { } override fun _guiInput(arg0: InputEvent) { } open fun _valueFocusExited() { } open fun _valueInputClosed() { } open fun _valueInputEntered(arg0: String) { } open fun getLabel(): String { val mb = getMethodBind("EditorSpinSlider","get_label") return _icall_String( mb, this.ptr) } open fun isFlat(): Boolean { val mb = getMethodBind("EditorSpinSlider","is_flat") return _icall_Boolean( mb, this.ptr) } open fun isReadOnly(): Boolean { val mb = getMethodBind("EditorSpinSlider","is_read_only") return _icall_Boolean( mb, this.ptr) } open fun setFlat(flat: Boolean) { val mb = getMethodBind("EditorSpinSlider","set_flat") _icall_Unit_Boolean( mb, this.ptr, flat) } open fun setLabel(label: String) { val mb = getMethodBind("EditorSpinSlider","set_label") _icall_Unit_String( mb, this.ptr, label) } open fun setReadOnly(readOnly: Boolean) { val mb = getMethodBind("EditorSpinSlider","set_read_only") _icall_Unit_Boolean( mb, this.ptr, readOnly) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EditorVCSInterface.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_String import godot.icalls._icall_Dictionary import godot.icalls._icall_String import godot.icalls._icall_Unit_String import godot.icalls._icall_VariantArray_String import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.NotImplementedError import kotlin.String open class EditorVCSInterface internal constructor() : Object() { open fun _commit(msg: String) { } open fun _getFileDiff(filePath: String): VariantArray { throw NotImplementedError("_get_file_diff is not implemented for EditorVCSInterface") } open fun _getModifiedFilesData(): Dictionary { throw NotImplementedError("_get_modified_files_data is not implemented for EditorVCSInterface") } open fun _getProjectName(): String { throw NotImplementedError("_get_project_name is not implemented for EditorVCSInterface") } open fun _getVcsName(): String { throw NotImplementedError("_get_vcs_name is not implemented for EditorVCSInterface") } open fun _initialize(projectRootPath: String): Boolean { throw NotImplementedError("_initialize is not implemented for EditorVCSInterface") } open fun _isVcsInitialized(): Boolean { throw NotImplementedError("_is_vcs_initialized is not implemented for EditorVCSInterface") } open fun _shutDown(): Boolean { throw NotImplementedError("_shut_down is not implemented for EditorVCSInterface") } open fun _stageFile(filePath: String) { } open fun _unstageFile(filePath: String) { } open fun commit(msg: String) { val mb = getMethodBind("EditorVCSInterface","commit") _icall_Unit_String( mb, this.ptr, msg) } open fun getFileDiff(filePath: String): VariantArray { val mb = getMethodBind("EditorVCSInterface","get_file_diff") return _icall_VariantArray_String( mb, this.ptr, filePath) } open fun getModifiedFilesData(): Dictionary { val mb = getMethodBind("EditorVCSInterface","get_modified_files_data") return _icall_Dictionary( mb, this.ptr) } open fun getProjectName(): String { val mb = getMethodBind("EditorVCSInterface","get_project_name") return _icall_String( mb, this.ptr) } open fun getVcsName(): String { val mb = getMethodBind("EditorVCSInterface","get_vcs_name") return _icall_String( mb, this.ptr) } open fun initialize(projectRootPath: String): Boolean { val mb = getMethodBind("EditorVCSInterface","initialize") return _icall_Boolean_String( mb, this.ptr, projectRootPath) } open fun isAddonReady(): Boolean { val mb = getMethodBind("EditorVCSInterface","is_addon_ready") return _icall_Boolean( mb, this.ptr) } open fun isVcsInitialized(): Boolean { val mb = getMethodBind("EditorVCSInterface","is_vcs_initialized") return _icall_Boolean( mb, this.ptr) } open fun shutDown(): Boolean { val mb = getMethodBind("EditorVCSInterface","shut_down") return _icall_Boolean( mb, this.ptr) } open fun stageFile(filePath: String) { val mb = getMethodBind("EditorVCSInterface","stage_file") _icall_Unit_String( mb, this.ptr, filePath) } open fun unstageFile(filePath: String) { val mb = getMethodBind("EditorVCSInterface","unstage_file") _icall_Unit_String( mb, this.ptr, filePath) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/EncodedObjectAsID.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class EncodedObjectAsID : Reference() { open var objectId: Long get() { val mb = getMethodBind("EncodedObjectAsID","get_object_id") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("EncodedObjectAsID","set_object_id") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("EncodedObjectAsID", "EncodedObjectAsID") open fun getObjectId(): Long { val mb = getMethodBind("EncodedObjectAsID","get_object_id") return _icall_Long( mb, this.ptr) } open fun setObjectId(id: Long) { val mb = getMethodBind("EncodedObjectAsID","set_object_id") _icall_Unit_Long( mb, this.ptr, id) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Engine.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.Godot import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_String import godot.icalls._icall_Dictionary import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_MainLoop import godot.icalls._icall_Object_String import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_VariantArray import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object Engine : Object() { var editorHint: Boolean get() { val mb = getMethodBind("_Engine","is_editor_hint") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_Engine","set_editor_hint") _icall_Unit_Boolean(mb, this.ptr, value) } var iterationsPerSecond: Long get() { val mb = getMethodBind("_Engine","get_iterations_per_second") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("_Engine","set_iterations_per_second") _icall_Unit_Long(mb, this.ptr, value) } var physicsJitterFix: Double get() { val mb = getMethodBind("_Engine","get_physics_jitter_fix") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("_Engine","set_physics_jitter_fix") _icall_Unit_Double(mb, this.ptr, value) } var targetFps: Long get() { val mb = getMethodBind("_Engine","get_target_fps") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("_Engine","set_target_fps") _icall_Unit_Long(mb, this.ptr, value) } var timeScale: Double get() { val mb = getMethodBind("_Engine","get_time_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("_Engine","set_time_scale") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("Engine".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton Engine" } ptr } fun getAuthorInfo(): Dictionary { val mb = getMethodBind("_Engine","get_author_info") return _icall_Dictionary( mb, this.ptr) } fun getCopyrightInfo(): VariantArray { val mb = getMethodBind("_Engine","get_copyright_info") return _icall_VariantArray( mb, this.ptr) } fun getDonorInfo(): Dictionary { val mb = getMethodBind("_Engine","get_donor_info") return _icall_Dictionary( mb, this.ptr) } fun getFramesDrawn(): Long { val mb = getMethodBind("_Engine","get_frames_drawn") return _icall_Long( mb, this.ptr) } fun getFramesPerSecond(): Double { val mb = getMethodBind("_Engine","get_frames_per_second") return _icall_Double( mb, this.ptr) } fun getIdleFrames(): Long { val mb = getMethodBind("_Engine","get_idle_frames") return _icall_Long( mb, this.ptr) } fun getIterationsPerSecond(): Long { val mb = getMethodBind("_Engine","get_iterations_per_second") return _icall_Long( mb, this.ptr) } fun getLicenseInfo(): Dictionary { val mb = getMethodBind("_Engine","get_license_info") return _icall_Dictionary( mb, this.ptr) } fun getLicenseText(): String { val mb = getMethodBind("_Engine","get_license_text") return _icall_String( mb, this.ptr) } fun getMainLoop(): MainLoop { val mb = getMethodBind("_Engine","get_main_loop") return _icall_MainLoop( mb, this.ptr) } fun getPhysicsFrames(): Long { val mb = getMethodBind("_Engine","get_physics_frames") return _icall_Long( mb, this.ptr) } fun getPhysicsInterpolationFraction(): Double { val mb = getMethodBind("_Engine","get_physics_interpolation_fraction") return _icall_Double( mb, this.ptr) } fun getPhysicsJitterFix(): Double { val mb = getMethodBind("_Engine","get_physics_jitter_fix") return _icall_Double( mb, this.ptr) } fun getSingleton(name: String): Object { val mb = getMethodBind("_Engine","get_singleton") return _icall_Object_String( mb, this.ptr, name) } fun getTargetFps(): Long { val mb = getMethodBind("_Engine","get_target_fps") return _icall_Long( mb, this.ptr) } fun getTimeScale(): Double { val mb = getMethodBind("_Engine","get_time_scale") return _icall_Double( mb, this.ptr) } fun getVersionInfo(): Dictionary { val mb = getMethodBind("_Engine","get_version_info") return _icall_Dictionary( mb, this.ptr) } fun hasSingleton(name: String): Boolean { val mb = getMethodBind("_Engine","has_singleton") return _icall_Boolean_String( mb, this.ptr, name) } fun isEditorHint(): Boolean { val mb = getMethodBind("_Engine","is_editor_hint") return _icall_Boolean( mb, this.ptr) } fun isInPhysicsFrame(): Boolean { val mb = getMethodBind("_Engine","is_in_physics_frame") return _icall_Boolean( mb, this.ptr) } fun setEditorHint(enabled: Boolean) { val mb = getMethodBind("_Engine","set_editor_hint") _icall_Unit_Boolean( mb, this.ptr, enabled) } fun setIterationsPerSecond(iterationsPerSecond: Long) { val mb = getMethodBind("_Engine","set_iterations_per_second") _icall_Unit_Long( mb, this.ptr, iterationsPerSecond) } fun setPhysicsJitterFix(physicsJitterFix: Double) { val mb = getMethodBind("_Engine","set_physics_jitter_fix") _icall_Unit_Double( mb, this.ptr, physicsJitterFix) } fun setTargetFps(targetFps: Long) { val mb = getMethodBind("_Engine","set_target_fps") _icall_Unit_Long( mb, this.ptr, targetFps) } fun setTimeScale(timeScale: Double) { val mb = getMethodBind("_Engine","set_time_scale") _icall_Unit_Double( mb, this.ptr, timeScale) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Environment.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Environment import godot.core.Basis import godot.core.Color import godot.core.Vector3 import godot.icalls._icall_Basis import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Color import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Sky import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Basis import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Environment : Resource() { open var adjustmentBrightness: Double get() { val mb = getMethodBind("Environment","get_adjustment_brightness") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_adjustment_brightness") _icall_Unit_Double(mb, this.ptr, value) } open var adjustmentColorCorrection: Texture get() { val mb = getMethodBind("Environment","get_adjustment_color_correction") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_adjustment_color_correction") _icall_Unit_Object(mb, this.ptr, value) } open var adjustmentContrast: Double get() { val mb = getMethodBind("Environment","get_adjustment_contrast") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_adjustment_contrast") _icall_Unit_Double(mb, this.ptr, value) } open var adjustmentEnabled: Boolean get() { val mb = getMethodBind("Environment","is_adjustment_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_adjustment_enable") _icall_Unit_Boolean(mb, this.ptr, value) } open var adjustmentSaturation: Double get() { val mb = getMethodBind("Environment","get_adjustment_saturation") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_adjustment_saturation") _icall_Unit_Double(mb, this.ptr, value) } open var ambientLightColor: Color get() { val mb = getMethodBind("Environment","get_ambient_light_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ambient_light_color") _icall_Unit_Color(mb, this.ptr, value) } open var ambientLightEnergy: Double get() { val mb = getMethodBind("Environment","get_ambient_light_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ambient_light_energy") _icall_Unit_Double(mb, this.ptr, value) } open var ambientLightSkyContribution: Double get() { val mb = getMethodBind("Environment","get_ambient_light_sky_contribution") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ambient_light_sky_contribution") _icall_Unit_Double(mb, this.ptr, value) } open var autoExposureEnabled: Boolean get() { val mb = getMethodBind("Environment","get_tonemap_auto_exposure") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure") _icall_Unit_Boolean(mb, this.ptr, value) } open var autoExposureMaxLuma: Double get() { val mb = getMethodBind("Environment","get_tonemap_auto_exposure_max") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure_max") _icall_Unit_Double(mb, this.ptr, value) } open var autoExposureMinLuma: Double get() { val mb = getMethodBind("Environment","get_tonemap_auto_exposure_min") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure_min") _icall_Unit_Double(mb, this.ptr, value) } open var autoExposureScale: Double get() { val mb = getMethodBind("Environment","get_tonemap_auto_exposure_grey") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure_grey") _icall_Unit_Double(mb, this.ptr, value) } open var autoExposureSpeed: Double get() { val mb = getMethodBind("Environment","get_tonemap_auto_exposure_speed") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure_speed") _icall_Unit_Double(mb, this.ptr, value) } open var backgroundCameraFeedId: Long get() { val mb = getMethodBind("Environment","get_camera_feed_id") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_camera_feed_id") _icall_Unit_Long(mb, this.ptr, value) } open var backgroundCanvasMaxLayer: Long get() { val mb = getMethodBind("Environment","get_canvas_max_layer") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_canvas_max_layer") _icall_Unit_Long(mb, this.ptr, value) } open var backgroundColor: Color get() { val mb = getMethodBind("Environment","get_bg_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_bg_color") _icall_Unit_Color(mb, this.ptr, value) } open var backgroundEnergy: Double get() { val mb = getMethodBind("Environment","get_bg_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_bg_energy") _icall_Unit_Double(mb, this.ptr, value) } open var backgroundMode: Long get() { val mb = getMethodBind("Environment","get_background") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_background") _icall_Unit_Long(mb, this.ptr, value) } open var backgroundSky: Sky get() { val mb = getMethodBind("Environment","get_sky") return _icall_Sky(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_sky") _icall_Unit_Object(mb, this.ptr, value) } open var backgroundSkyCustomFov: Double get() { val mb = getMethodBind("Environment","get_sky_custom_fov") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_sky_custom_fov") _icall_Unit_Double(mb, this.ptr, value) } open var backgroundSkyOrientation: Basis get() { val mb = getMethodBind("Environment","get_sky_orientation") return _icall_Basis(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_sky_orientation") _icall_Unit_Basis(mb, this.ptr, value) } open var backgroundSkyRotation: Vector3 get() { val mb = getMethodBind("Environment","get_sky_rotation") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_sky_rotation") _icall_Unit_Vector3(mb, this.ptr, value) } open var backgroundSkyRotationDegrees: Vector3 get() { val mb = getMethodBind("Environment","get_sky_rotation_degrees") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_sky_rotation_degrees") _icall_Unit_Vector3(mb, this.ptr, value) } open var dofBlurFarAmount: Double get() { val mb = getMethodBind("Environment","get_dof_blur_far_amount") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_far_amount") _icall_Unit_Double(mb, this.ptr, value) } open var dofBlurFarDistance: Double get() { val mb = getMethodBind("Environment","get_dof_blur_far_distance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_far_distance") _icall_Unit_Double(mb, this.ptr, value) } open var dofBlurFarEnabled: Boolean get() { val mb = getMethodBind("Environment","is_dof_blur_far_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_far_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var dofBlurFarQuality: Long get() { val mb = getMethodBind("Environment","get_dof_blur_far_quality") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_far_quality") _icall_Unit_Long(mb, this.ptr, value) } open var dofBlurFarTransition: Double get() { val mb = getMethodBind("Environment","get_dof_blur_far_transition") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_far_transition") _icall_Unit_Double(mb, this.ptr, value) } open var dofBlurNearAmount: Double get() { val mb = getMethodBind("Environment","get_dof_blur_near_amount") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_near_amount") _icall_Unit_Double(mb, this.ptr, value) } open var dofBlurNearDistance: Double get() { val mb = getMethodBind("Environment","get_dof_blur_near_distance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_near_distance") _icall_Unit_Double(mb, this.ptr, value) } open var dofBlurNearEnabled: Boolean get() { val mb = getMethodBind("Environment","is_dof_blur_near_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_near_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var dofBlurNearQuality: Long get() { val mb = getMethodBind("Environment","get_dof_blur_near_quality") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_near_quality") _icall_Unit_Long(mb, this.ptr, value) } open var dofBlurNearTransition: Double get() { val mb = getMethodBind("Environment","get_dof_blur_near_transition") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_dof_blur_near_transition") _icall_Unit_Double(mb, this.ptr, value) } open var fogColor: Color get() { val mb = getMethodBind("Environment","get_fog_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_color") _icall_Unit_Color(mb, this.ptr, value) } open var fogDepthBegin: Double get() { val mb = getMethodBind("Environment","get_fog_depth_begin") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_depth_begin") _icall_Unit_Double(mb, this.ptr, value) } open var fogDepthCurve: Double get() { val mb = getMethodBind("Environment","get_fog_depth_curve") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_depth_curve") _icall_Unit_Double(mb, this.ptr, value) } open var fogDepthEnabled: Boolean get() { val mb = getMethodBind("Environment","is_fog_depth_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_depth_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var fogDepthEnd: Double get() { val mb = getMethodBind("Environment","get_fog_depth_end") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_depth_end") _icall_Unit_Double(mb, this.ptr, value) } open var fogEnabled: Boolean get() { val mb = getMethodBind("Environment","is_fog_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var fogHeightCurve: Double get() { val mb = getMethodBind("Environment","get_fog_height_curve") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_height_curve") _icall_Unit_Double(mb, this.ptr, value) } open var fogHeightEnabled: Boolean get() { val mb = getMethodBind("Environment","is_fog_height_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_height_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var fogHeightMax: Double get() { val mb = getMethodBind("Environment","get_fog_height_max") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_height_max") _icall_Unit_Double(mb, this.ptr, value) } open var fogHeightMin: Double get() { val mb = getMethodBind("Environment","get_fog_height_min") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_height_min") _icall_Unit_Double(mb, this.ptr, value) } open var fogSunAmount: Double get() { val mb = getMethodBind("Environment","get_fog_sun_amount") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_sun_amount") _icall_Unit_Double(mb, this.ptr, value) } open var fogSunColor: Color get() { val mb = getMethodBind("Environment","get_fog_sun_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_sun_color") _icall_Unit_Color(mb, this.ptr, value) } open var fogTransmitCurve: Double get() { val mb = getMethodBind("Environment","get_fog_transmit_curve") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_transmit_curve") _icall_Unit_Double(mb, this.ptr, value) } open var fogTransmitEnabled: Boolean get() { val mb = getMethodBind("Environment","is_fog_transmit_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_fog_transmit_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var glowBicubicUpscale: Boolean get() { val mb = getMethodBind("Environment","is_glow_bicubic_upscale_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_glow_bicubic_upscale") _icall_Unit_Boolean(mb, this.ptr, value) } open var glowBlendMode: Long get() { val mb = getMethodBind("Environment","get_glow_blend_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_glow_blend_mode") _icall_Unit_Long(mb, this.ptr, value) } open var glowBloom: Double get() { val mb = getMethodBind("Environment","get_glow_bloom") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_glow_bloom") _icall_Unit_Double(mb, this.ptr, value) } open var glowEnabled: Boolean get() { val mb = getMethodBind("Environment","is_glow_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_glow_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var glowHdrLuminanceCap: Double get() { val mb = getMethodBind("Environment","get_glow_hdr_luminance_cap") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_glow_hdr_luminance_cap") _icall_Unit_Double(mb, this.ptr, value) } open var glowHdrScale: Double get() { val mb = getMethodBind("Environment","get_glow_hdr_bleed_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_glow_hdr_bleed_scale") _icall_Unit_Double(mb, this.ptr, value) } open var glowHdrThreshold: Double get() { val mb = getMethodBind("Environment","get_glow_hdr_bleed_threshold") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_glow_hdr_bleed_threshold") _icall_Unit_Double(mb, this.ptr, value) } open var glowIntensity: Double get() { val mb = getMethodBind("Environment","get_glow_intensity") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_glow_intensity") _icall_Unit_Double(mb, this.ptr, value) } open var glowLevels_1: Boolean get() { val mb = getMethodBind("Environment","is_glow_level_enabled") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Environment","set_glow_level") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open var glowLevels_2: Boolean get() { val mb = getMethodBind("Environment","is_glow_level_enabled") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Environment","set_glow_level") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var glowLevels_3: Boolean get() { val mb = getMethodBind("Environment","is_glow_level_enabled") return _icall_Boolean_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Environment","set_glow_level") _icall_Unit_Long_Boolean(mb, this.ptr, 2, value) } open var glowLevels_4: Boolean get() { val mb = getMethodBind("Environment","is_glow_level_enabled") return _icall_Boolean_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Environment","set_glow_level") _icall_Unit_Long_Boolean(mb, this.ptr, 3, value) } open var glowLevels_5: Boolean get() { val mb = getMethodBind("Environment","is_glow_level_enabled") return _icall_Boolean_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("Environment","set_glow_level") _icall_Unit_Long_Boolean(mb, this.ptr, 4, value) } open var glowLevels_6: Boolean get() { val mb = getMethodBind("Environment","is_glow_level_enabled") return _icall_Boolean_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("Environment","set_glow_level") _icall_Unit_Long_Boolean(mb, this.ptr, 5, value) } open var glowLevels_7: Boolean get() { val mb = getMethodBind("Environment","is_glow_level_enabled") return _icall_Boolean_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("Environment","set_glow_level") _icall_Unit_Long_Boolean(mb, this.ptr, 6, value) } open var glowStrength: Double get() { val mb = getMethodBind("Environment","get_glow_strength") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_glow_strength") _icall_Unit_Double(mb, this.ptr, value) } open var ssReflectionsDepthTolerance: Double get() { val mb = getMethodBind("Environment","get_ssr_depth_tolerance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssr_depth_tolerance") _icall_Unit_Double(mb, this.ptr, value) } open var ssReflectionsEnabled: Boolean get() { val mb = getMethodBind("Environment","is_ssr_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssr_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var ssReflectionsFadeIn: Double get() { val mb = getMethodBind("Environment","get_ssr_fade_in") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssr_fade_in") _icall_Unit_Double(mb, this.ptr, value) } open var ssReflectionsFadeOut: Double get() { val mb = getMethodBind("Environment","get_ssr_fade_out") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssr_fade_out") _icall_Unit_Double(mb, this.ptr, value) } open var ssReflectionsMaxSteps: Long get() { val mb = getMethodBind("Environment","get_ssr_max_steps") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssr_max_steps") _icall_Unit_Long(mb, this.ptr, value) } open var ssReflectionsRoughness: Boolean get() { val mb = getMethodBind("Environment","is_ssr_rough") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssr_rough") _icall_Unit_Boolean(mb, this.ptr, value) } open var ssaoAoChannelAffect: Double get() { val mb = getMethodBind("Environment","get_ssao_ao_channel_affect") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_ao_channel_affect") _icall_Unit_Double(mb, this.ptr, value) } open var ssaoBias: Double get() { val mb = getMethodBind("Environment","get_ssao_bias") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_bias") _icall_Unit_Double(mb, this.ptr, value) } open var ssaoBlur: Long get() { val mb = getMethodBind("Environment","get_ssao_blur") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_blur") _icall_Unit_Long(mb, this.ptr, value) } open var ssaoColor: Color get() { val mb = getMethodBind("Environment","get_ssao_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_color") _icall_Unit_Color(mb, this.ptr, value) } open var ssaoEdgeSharpness: Double get() { val mb = getMethodBind("Environment","get_ssao_edge_sharpness") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_edge_sharpness") _icall_Unit_Double(mb, this.ptr, value) } open var ssaoEnabled: Boolean get() { val mb = getMethodBind("Environment","is_ssao_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var ssaoIntensity: Double get() { val mb = getMethodBind("Environment","get_ssao_intensity") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_intensity") _icall_Unit_Double(mb, this.ptr, value) } open var ssaoIntensity2: Double get() { val mb = getMethodBind("Environment","get_ssao_intensity2") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_intensity2") _icall_Unit_Double(mb, this.ptr, value) } open var ssaoLightAffect: Double get() { val mb = getMethodBind("Environment","get_ssao_direct_light_affect") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_direct_light_affect") _icall_Unit_Double(mb, this.ptr, value) } open var ssaoQuality: Long get() { val mb = getMethodBind("Environment","get_ssao_quality") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_quality") _icall_Unit_Long(mb, this.ptr, value) } open var ssaoRadius: Double get() { val mb = getMethodBind("Environment","get_ssao_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_radius") _icall_Unit_Double(mb, this.ptr, value) } open var ssaoRadius2: Double get() { val mb = getMethodBind("Environment","get_ssao_radius2") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_ssao_radius2") _icall_Unit_Double(mb, this.ptr, value) } open var tonemapExposure: Double get() { val mb = getMethodBind("Environment","get_tonemap_exposure") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_tonemap_exposure") _icall_Unit_Double(mb, this.ptr, value) } open var tonemapMode: Long get() { val mb = getMethodBind("Environment","get_tonemapper") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_tonemapper") _icall_Unit_Long(mb, this.ptr, value) } open var tonemapWhite: Double get() { val mb = getMethodBind("Environment","get_tonemap_white") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Environment","set_tonemap_white") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Environment", "Environment") open fun ambientLightColor(schedule: Color.() -> Unit): Color = ambientLightColor.apply{ schedule(this) ambientLightColor = this } open fun backgroundColor(schedule: Color.() -> Unit): Color = backgroundColor.apply{ schedule(this) backgroundColor = this } open fun backgroundSkyOrientation(schedule: Basis.() -> Unit): Basis = backgroundSkyOrientation.apply{ schedule(this) backgroundSkyOrientation = this } open fun backgroundSkyRotation(schedule: Vector3.() -> Unit): Vector3 = backgroundSkyRotation.apply{ schedule(this) backgroundSkyRotation = this } open fun backgroundSkyRotationDegrees(schedule: Vector3.() -> Unit): Vector3 = backgroundSkyRotationDegrees.apply{ schedule(this) backgroundSkyRotationDegrees = this } open fun fogColor(schedule: Color.() -> Unit): Color = fogColor.apply{ schedule(this) fogColor = this } open fun fogSunColor(schedule: Color.() -> Unit): Color = fogSunColor.apply{ schedule(this) fogSunColor = this } open fun ssaoColor(schedule: Color.() -> Unit): Color = ssaoColor.apply{ schedule(this) ssaoColor = this } open fun getAdjustmentBrightness(): Double { val mb = getMethodBind("Environment","get_adjustment_brightness") return _icall_Double( mb, this.ptr) } open fun getAdjustmentColorCorrection(): Texture { val mb = getMethodBind("Environment","get_adjustment_color_correction") return _icall_Texture( mb, this.ptr) } open fun getAdjustmentContrast(): Double { val mb = getMethodBind("Environment","get_adjustment_contrast") return _icall_Double( mb, this.ptr) } open fun getAdjustmentSaturation(): Double { val mb = getMethodBind("Environment","get_adjustment_saturation") return _icall_Double( mb, this.ptr) } open fun getAmbientLightColor(): Color { val mb = getMethodBind("Environment","get_ambient_light_color") return _icall_Color( mb, this.ptr) } open fun getAmbientLightEnergy(): Double { val mb = getMethodBind("Environment","get_ambient_light_energy") return _icall_Double( mb, this.ptr) } open fun getAmbientLightSkyContribution(): Double { val mb = getMethodBind("Environment","get_ambient_light_sky_contribution") return _icall_Double( mb, this.ptr) } open fun getBackground(): Environment.BGMode { val mb = getMethodBind("Environment","get_background") return Environment.BGMode.from( _icall_Long( mb, this.ptr)) } open fun getBgColor(): Color { val mb = getMethodBind("Environment","get_bg_color") return _icall_Color( mb, this.ptr) } open fun getBgEnergy(): Double { val mb = getMethodBind("Environment","get_bg_energy") return _icall_Double( mb, this.ptr) } open fun getCameraFeedId(): Long { val mb = getMethodBind("Environment","get_camera_feed_id") return _icall_Long( mb, this.ptr) } open fun getCanvasMaxLayer(): Long { val mb = getMethodBind("Environment","get_canvas_max_layer") return _icall_Long( mb, this.ptr) } open fun getDofBlurFarAmount(): Double { val mb = getMethodBind("Environment","get_dof_blur_far_amount") return _icall_Double( mb, this.ptr) } open fun getDofBlurFarDistance(): Double { val mb = getMethodBind("Environment","get_dof_blur_far_distance") return _icall_Double( mb, this.ptr) } open fun getDofBlurFarQuality(): Environment.DOFBlurQuality { val mb = getMethodBind("Environment","get_dof_blur_far_quality") return Environment.DOFBlurQuality.from( _icall_Long( mb, this.ptr)) } open fun getDofBlurFarTransition(): Double { val mb = getMethodBind("Environment","get_dof_blur_far_transition") return _icall_Double( mb, this.ptr) } open fun getDofBlurNearAmount(): Double { val mb = getMethodBind("Environment","get_dof_blur_near_amount") return _icall_Double( mb, this.ptr) } open fun getDofBlurNearDistance(): Double { val mb = getMethodBind("Environment","get_dof_blur_near_distance") return _icall_Double( mb, this.ptr) } open fun getDofBlurNearQuality(): Environment.DOFBlurQuality { val mb = getMethodBind("Environment","get_dof_blur_near_quality") return Environment.DOFBlurQuality.from( _icall_Long( mb, this.ptr)) } open fun getDofBlurNearTransition(): Double { val mb = getMethodBind("Environment","get_dof_blur_near_transition") return _icall_Double( mb, this.ptr) } open fun getFogColor(): Color { val mb = getMethodBind("Environment","get_fog_color") return _icall_Color( mb, this.ptr) } open fun getFogDepthBegin(): Double { val mb = getMethodBind("Environment","get_fog_depth_begin") return _icall_Double( mb, this.ptr) } open fun getFogDepthCurve(): Double { val mb = getMethodBind("Environment","get_fog_depth_curve") return _icall_Double( mb, this.ptr) } open fun getFogDepthEnd(): Double { val mb = getMethodBind("Environment","get_fog_depth_end") return _icall_Double( mb, this.ptr) } open fun getFogHeightCurve(): Double { val mb = getMethodBind("Environment","get_fog_height_curve") return _icall_Double( mb, this.ptr) } open fun getFogHeightMax(): Double { val mb = getMethodBind("Environment","get_fog_height_max") return _icall_Double( mb, this.ptr) } open fun getFogHeightMin(): Double { val mb = getMethodBind("Environment","get_fog_height_min") return _icall_Double( mb, this.ptr) } open fun getFogSunAmount(): Double { val mb = getMethodBind("Environment","get_fog_sun_amount") return _icall_Double( mb, this.ptr) } open fun getFogSunColor(): Color { val mb = getMethodBind("Environment","get_fog_sun_color") return _icall_Color( mb, this.ptr) } open fun getFogTransmitCurve(): Double { val mb = getMethodBind("Environment","get_fog_transmit_curve") return _icall_Double( mb, this.ptr) } open fun getGlowBlendMode(): Environment.GlowBlendMode { val mb = getMethodBind("Environment","get_glow_blend_mode") return Environment.GlowBlendMode.from( _icall_Long( mb, this.ptr)) } open fun getGlowBloom(): Double { val mb = getMethodBind("Environment","get_glow_bloom") return _icall_Double( mb, this.ptr) } open fun getGlowHdrBleedScale(): Double { val mb = getMethodBind("Environment","get_glow_hdr_bleed_scale") return _icall_Double( mb, this.ptr) } open fun getGlowHdrBleedThreshold(): Double { val mb = getMethodBind("Environment","get_glow_hdr_bleed_threshold") return _icall_Double( mb, this.ptr) } open fun getGlowHdrLuminanceCap(): Double { val mb = getMethodBind("Environment","get_glow_hdr_luminance_cap") return _icall_Double( mb, this.ptr) } open fun getGlowIntensity(): Double { val mb = getMethodBind("Environment","get_glow_intensity") return _icall_Double( mb, this.ptr) } open fun getGlowStrength(): Double { val mb = getMethodBind("Environment","get_glow_strength") return _icall_Double( mb, this.ptr) } open fun getSky(): Sky { val mb = getMethodBind("Environment","get_sky") return _icall_Sky( mb, this.ptr) } open fun getSkyCustomFov(): Double { val mb = getMethodBind("Environment","get_sky_custom_fov") return _icall_Double( mb, this.ptr) } open fun getSkyOrientation(): Basis { val mb = getMethodBind("Environment","get_sky_orientation") return _icall_Basis( mb, this.ptr) } open fun getSkyRotation(): Vector3 { val mb = getMethodBind("Environment","get_sky_rotation") return _icall_Vector3( mb, this.ptr) } open fun getSkyRotationDegrees(): Vector3 { val mb = getMethodBind("Environment","get_sky_rotation_degrees") return _icall_Vector3( mb, this.ptr) } open fun getSsaoAoChannelAffect(): Double { val mb = getMethodBind("Environment","get_ssao_ao_channel_affect") return _icall_Double( mb, this.ptr) } open fun getSsaoBias(): Double { val mb = getMethodBind("Environment","get_ssao_bias") return _icall_Double( mb, this.ptr) } open fun getSsaoBlur(): Environment.SSAOBlur { val mb = getMethodBind("Environment","get_ssao_blur") return Environment.SSAOBlur.from( _icall_Long( mb, this.ptr)) } open fun getSsaoColor(): Color { val mb = getMethodBind("Environment","get_ssao_color") return _icall_Color( mb, this.ptr) } open fun getSsaoDirectLightAffect(): Double { val mb = getMethodBind("Environment","get_ssao_direct_light_affect") return _icall_Double( mb, this.ptr) } open fun getSsaoEdgeSharpness(): Double { val mb = getMethodBind("Environment","get_ssao_edge_sharpness") return _icall_Double( mb, this.ptr) } open fun getSsaoIntensity(): Double { val mb = getMethodBind("Environment","get_ssao_intensity") return _icall_Double( mb, this.ptr) } open fun getSsaoIntensity2(): Double { val mb = getMethodBind("Environment","get_ssao_intensity2") return _icall_Double( mb, this.ptr) } open fun getSsaoQuality(): Environment.SSAOQuality { val mb = getMethodBind("Environment","get_ssao_quality") return Environment.SSAOQuality.from( _icall_Long( mb, this.ptr)) } open fun getSsaoRadius(): Double { val mb = getMethodBind("Environment","get_ssao_radius") return _icall_Double( mb, this.ptr) } open fun getSsaoRadius2(): Double { val mb = getMethodBind("Environment","get_ssao_radius2") return _icall_Double( mb, this.ptr) } open fun getSsrDepthTolerance(): Double { val mb = getMethodBind("Environment","get_ssr_depth_tolerance") return _icall_Double( mb, this.ptr) } open fun getSsrFadeIn(): Double { val mb = getMethodBind("Environment","get_ssr_fade_in") return _icall_Double( mb, this.ptr) } open fun getSsrFadeOut(): Double { val mb = getMethodBind("Environment","get_ssr_fade_out") return _icall_Double( mb, this.ptr) } open fun getSsrMaxSteps(): Long { val mb = getMethodBind("Environment","get_ssr_max_steps") return _icall_Long( mb, this.ptr) } open fun getTonemapAutoExposure(): Boolean { val mb = getMethodBind("Environment","get_tonemap_auto_exposure") return _icall_Boolean( mb, this.ptr) } open fun getTonemapAutoExposureGrey(): Double { val mb = getMethodBind("Environment","get_tonemap_auto_exposure_grey") return _icall_Double( mb, this.ptr) } open fun getTonemapAutoExposureMax(): Double { val mb = getMethodBind("Environment","get_tonemap_auto_exposure_max") return _icall_Double( mb, this.ptr) } open fun getTonemapAutoExposureMin(): Double { val mb = getMethodBind("Environment","get_tonemap_auto_exposure_min") return _icall_Double( mb, this.ptr) } open fun getTonemapAutoExposureSpeed(): Double { val mb = getMethodBind("Environment","get_tonemap_auto_exposure_speed") return _icall_Double( mb, this.ptr) } open fun getTonemapExposure(): Double { val mb = getMethodBind("Environment","get_tonemap_exposure") return _icall_Double( mb, this.ptr) } open fun getTonemapWhite(): Double { val mb = getMethodBind("Environment","get_tonemap_white") return _icall_Double( mb, this.ptr) } open fun getTonemapper(): Environment.ToneMapper { val mb = getMethodBind("Environment","get_tonemapper") return Environment.ToneMapper.from( _icall_Long( mb, this.ptr)) } open fun isAdjustmentEnabled(): Boolean { val mb = getMethodBind("Environment","is_adjustment_enabled") return _icall_Boolean( mb, this.ptr) } open fun isDofBlurFarEnabled(): Boolean { val mb = getMethodBind("Environment","is_dof_blur_far_enabled") return _icall_Boolean( mb, this.ptr) } open fun isDofBlurNearEnabled(): Boolean { val mb = getMethodBind("Environment","is_dof_blur_near_enabled") return _icall_Boolean( mb, this.ptr) } open fun isFogDepthEnabled(): Boolean { val mb = getMethodBind("Environment","is_fog_depth_enabled") return _icall_Boolean( mb, this.ptr) } open fun isFogEnabled(): Boolean { val mb = getMethodBind("Environment","is_fog_enabled") return _icall_Boolean( mb, this.ptr) } open fun isFogHeightEnabled(): Boolean { val mb = getMethodBind("Environment","is_fog_height_enabled") return _icall_Boolean( mb, this.ptr) } open fun isFogTransmitEnabled(): Boolean { val mb = getMethodBind("Environment","is_fog_transmit_enabled") return _icall_Boolean( mb, this.ptr) } open fun isGlowBicubicUpscaleEnabled(): Boolean { val mb = getMethodBind("Environment","is_glow_bicubic_upscale_enabled") return _icall_Boolean( mb, this.ptr) } open fun isGlowEnabled(): Boolean { val mb = getMethodBind("Environment","is_glow_enabled") return _icall_Boolean( mb, this.ptr) } open fun isGlowLevelEnabled(idx: Long): Boolean { val mb = getMethodBind("Environment","is_glow_level_enabled") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isSsaoEnabled(): Boolean { val mb = getMethodBind("Environment","is_ssao_enabled") return _icall_Boolean( mb, this.ptr) } open fun isSsrEnabled(): Boolean { val mb = getMethodBind("Environment","is_ssr_enabled") return _icall_Boolean( mb, this.ptr) } open fun isSsrRough(): Boolean { val mb = getMethodBind("Environment","is_ssr_rough") return _icall_Boolean( mb, this.ptr) } open fun setAdjustmentBrightness(brightness: Double) { val mb = getMethodBind("Environment","set_adjustment_brightness") _icall_Unit_Double( mb, this.ptr, brightness) } open fun setAdjustmentColorCorrection(colorCorrection: Texture) { val mb = getMethodBind("Environment","set_adjustment_color_correction") _icall_Unit_Object( mb, this.ptr, colorCorrection) } open fun setAdjustmentContrast(contrast: Double) { val mb = getMethodBind("Environment","set_adjustment_contrast") _icall_Unit_Double( mb, this.ptr, contrast) } open fun setAdjustmentEnable(enabled: Boolean) { val mb = getMethodBind("Environment","set_adjustment_enable") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setAdjustmentSaturation(saturation: Double) { val mb = getMethodBind("Environment","set_adjustment_saturation") _icall_Unit_Double( mb, this.ptr, saturation) } open fun setAmbientLightColor(color: Color) { val mb = getMethodBind("Environment","set_ambient_light_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setAmbientLightEnergy(energy: Double) { val mb = getMethodBind("Environment","set_ambient_light_energy") _icall_Unit_Double( mb, this.ptr, energy) } open fun setAmbientLightSkyContribution(energy: Double) { val mb = getMethodBind("Environment","set_ambient_light_sky_contribution") _icall_Unit_Double( mb, this.ptr, energy) } open fun setBackground(mode: Long) { val mb = getMethodBind("Environment","set_background") _icall_Unit_Long( mb, this.ptr, mode) } open fun setBgColor(color: Color) { val mb = getMethodBind("Environment","set_bg_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setBgEnergy(energy: Double) { val mb = getMethodBind("Environment","set_bg_energy") _icall_Unit_Double( mb, this.ptr, energy) } open fun setCameraFeedId(cameraFeedId: Long) { val mb = getMethodBind("Environment","set_camera_feed_id") _icall_Unit_Long( mb, this.ptr, cameraFeedId) } open fun setCanvasMaxLayer(layer: Long) { val mb = getMethodBind("Environment","set_canvas_max_layer") _icall_Unit_Long( mb, this.ptr, layer) } open fun setDofBlurFarAmount(intensity: Double) { val mb = getMethodBind("Environment","set_dof_blur_far_amount") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setDofBlurFarDistance(intensity: Double) { val mb = getMethodBind("Environment","set_dof_blur_far_distance") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setDofBlurFarEnabled(enabled: Boolean) { val mb = getMethodBind("Environment","set_dof_blur_far_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setDofBlurFarQuality(intensity: Long) { val mb = getMethodBind("Environment","set_dof_blur_far_quality") _icall_Unit_Long( mb, this.ptr, intensity) } open fun setDofBlurFarTransition(intensity: Double) { val mb = getMethodBind("Environment","set_dof_blur_far_transition") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setDofBlurNearAmount(intensity: Double) { val mb = getMethodBind("Environment","set_dof_blur_near_amount") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setDofBlurNearDistance(intensity: Double) { val mb = getMethodBind("Environment","set_dof_blur_near_distance") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setDofBlurNearEnabled(enabled: Boolean) { val mb = getMethodBind("Environment","set_dof_blur_near_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setDofBlurNearQuality(level: Long) { val mb = getMethodBind("Environment","set_dof_blur_near_quality") _icall_Unit_Long( mb, this.ptr, level) } open fun setDofBlurNearTransition(intensity: Double) { val mb = getMethodBind("Environment","set_dof_blur_near_transition") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setFogColor(color: Color) { val mb = getMethodBind("Environment","set_fog_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setFogDepthBegin(distance: Double) { val mb = getMethodBind("Environment","set_fog_depth_begin") _icall_Unit_Double( mb, this.ptr, distance) } open fun setFogDepthCurve(curve: Double) { val mb = getMethodBind("Environment","set_fog_depth_curve") _icall_Unit_Double( mb, this.ptr, curve) } open fun setFogDepthEnabled(enabled: Boolean) { val mb = getMethodBind("Environment","set_fog_depth_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setFogDepthEnd(distance: Double) { val mb = getMethodBind("Environment","set_fog_depth_end") _icall_Unit_Double( mb, this.ptr, distance) } open fun setFogEnabled(enabled: Boolean) { val mb = getMethodBind("Environment","set_fog_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setFogHeightCurve(curve: Double) { val mb = getMethodBind("Environment","set_fog_height_curve") _icall_Unit_Double( mb, this.ptr, curve) } open fun setFogHeightEnabled(enabled: Boolean) { val mb = getMethodBind("Environment","set_fog_height_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setFogHeightMax(height: Double) { val mb = getMethodBind("Environment","set_fog_height_max") _icall_Unit_Double( mb, this.ptr, height) } open fun setFogHeightMin(height: Double) { val mb = getMethodBind("Environment","set_fog_height_min") _icall_Unit_Double( mb, this.ptr, height) } open fun setFogSunAmount(amount: Double) { val mb = getMethodBind("Environment","set_fog_sun_amount") _icall_Unit_Double( mb, this.ptr, amount) } open fun setFogSunColor(color: Color) { val mb = getMethodBind("Environment","set_fog_sun_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setFogTransmitCurve(curve: Double) { val mb = getMethodBind("Environment","set_fog_transmit_curve") _icall_Unit_Double( mb, this.ptr, curve) } open fun setFogTransmitEnabled(enabled: Boolean) { val mb = getMethodBind("Environment","set_fog_transmit_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setGlowBicubicUpscale(enabled: Boolean) { val mb = getMethodBind("Environment","set_glow_bicubic_upscale") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setGlowBlendMode(mode: Long) { val mb = getMethodBind("Environment","set_glow_blend_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setGlowBloom(amount: Double) { val mb = getMethodBind("Environment","set_glow_bloom") _icall_Unit_Double( mb, this.ptr, amount) } open fun setGlowEnabled(enabled: Boolean) { val mb = getMethodBind("Environment","set_glow_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setGlowHdrBleedScale(scale: Double) { val mb = getMethodBind("Environment","set_glow_hdr_bleed_scale") _icall_Unit_Double( mb, this.ptr, scale) } open fun setGlowHdrBleedThreshold(threshold: Double) { val mb = getMethodBind("Environment","set_glow_hdr_bleed_threshold") _icall_Unit_Double( mb, this.ptr, threshold) } open fun setGlowHdrLuminanceCap(amount: Double) { val mb = getMethodBind("Environment","set_glow_hdr_luminance_cap") _icall_Unit_Double( mb, this.ptr, amount) } open fun setGlowIntensity(intensity: Double) { val mb = getMethodBind("Environment","set_glow_intensity") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setGlowLevel(idx: Long, enabled: Boolean) { val mb = getMethodBind("Environment","set_glow_level") _icall_Unit_Long_Boolean( mb, this.ptr, idx, enabled) } open fun setGlowStrength(strength: Double) { val mb = getMethodBind("Environment","set_glow_strength") _icall_Unit_Double( mb, this.ptr, strength) } open fun setSky(sky: Sky) { val mb = getMethodBind("Environment","set_sky") _icall_Unit_Object( mb, this.ptr, sky) } open fun setSkyCustomFov(scale: Double) { val mb = getMethodBind("Environment","set_sky_custom_fov") _icall_Unit_Double( mb, this.ptr, scale) } open fun setSkyOrientation(orientation: Basis) { val mb = getMethodBind("Environment","set_sky_orientation") _icall_Unit_Basis( mb, this.ptr, orientation) } open fun setSkyRotation(eulerRadians: Vector3) { val mb = getMethodBind("Environment","set_sky_rotation") _icall_Unit_Vector3( mb, this.ptr, eulerRadians) } open fun setSkyRotationDegrees(eulerDegrees: Vector3) { val mb = getMethodBind("Environment","set_sky_rotation_degrees") _icall_Unit_Vector3( mb, this.ptr, eulerDegrees) } open fun setSsaoAoChannelAffect(amount: Double) { val mb = getMethodBind("Environment","set_ssao_ao_channel_affect") _icall_Unit_Double( mb, this.ptr, amount) } open fun setSsaoBias(bias: Double) { val mb = getMethodBind("Environment","set_ssao_bias") _icall_Unit_Double( mb, this.ptr, bias) } open fun setSsaoBlur(mode: Long) { val mb = getMethodBind("Environment","set_ssao_blur") _icall_Unit_Long( mb, this.ptr, mode) } open fun setSsaoColor(color: Color) { val mb = getMethodBind("Environment","set_ssao_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setSsaoDirectLightAffect(amount: Double) { val mb = getMethodBind("Environment","set_ssao_direct_light_affect") _icall_Unit_Double( mb, this.ptr, amount) } open fun setSsaoEdgeSharpness(edgeSharpness: Double) { val mb = getMethodBind("Environment","set_ssao_edge_sharpness") _icall_Unit_Double( mb, this.ptr, edgeSharpness) } open fun setSsaoEnabled(enabled: Boolean) { val mb = getMethodBind("Environment","set_ssao_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setSsaoIntensity(intensity: Double) { val mb = getMethodBind("Environment","set_ssao_intensity") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setSsaoIntensity2(intensity: Double) { val mb = getMethodBind("Environment","set_ssao_intensity2") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setSsaoQuality(quality: Long) { val mb = getMethodBind("Environment","set_ssao_quality") _icall_Unit_Long( mb, this.ptr, quality) } open fun setSsaoRadius(radius: Double) { val mb = getMethodBind("Environment","set_ssao_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setSsaoRadius2(radius: Double) { val mb = getMethodBind("Environment","set_ssao_radius2") _icall_Unit_Double( mb, this.ptr, radius) } open fun setSsrDepthTolerance(depthTolerance: Double) { val mb = getMethodBind("Environment","set_ssr_depth_tolerance") _icall_Unit_Double( mb, this.ptr, depthTolerance) } open fun setSsrEnabled(enabled: Boolean) { val mb = getMethodBind("Environment","set_ssr_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setSsrFadeIn(fadeIn: Double) { val mb = getMethodBind("Environment","set_ssr_fade_in") _icall_Unit_Double( mb, this.ptr, fadeIn) } open fun setSsrFadeOut(fadeOut: Double) { val mb = getMethodBind("Environment","set_ssr_fade_out") _icall_Unit_Double( mb, this.ptr, fadeOut) } open fun setSsrMaxSteps(maxSteps: Long) { val mb = getMethodBind("Environment","set_ssr_max_steps") _icall_Unit_Long( mb, this.ptr, maxSteps) } open fun setSsrRough(rough: Boolean) { val mb = getMethodBind("Environment","set_ssr_rough") _icall_Unit_Boolean( mb, this.ptr, rough) } open fun setTonemapAutoExposure(autoExposure: Boolean) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure") _icall_Unit_Boolean( mb, this.ptr, autoExposure) } open fun setTonemapAutoExposureGrey(exposureGrey: Double) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure_grey") _icall_Unit_Double( mb, this.ptr, exposureGrey) } open fun setTonemapAutoExposureMax(exposureMax: Double) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure_max") _icall_Unit_Double( mb, this.ptr, exposureMax) } open fun setTonemapAutoExposureMin(exposureMin: Double) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure_min") _icall_Unit_Double( mb, this.ptr, exposureMin) } open fun setTonemapAutoExposureSpeed(exposureSpeed: Double) { val mb = getMethodBind("Environment","set_tonemap_auto_exposure_speed") _icall_Unit_Double( mb, this.ptr, exposureSpeed) } open fun setTonemapExposure(exposure: Double) { val mb = getMethodBind("Environment","set_tonemap_exposure") _icall_Unit_Double( mb, this.ptr, exposure) } open fun setTonemapWhite(white: Double) { val mb = getMethodBind("Environment","set_tonemap_white") _icall_Unit_Double( mb, this.ptr, white) } open fun setTonemapper(mode: Long) { val mb = getMethodBind("Environment","set_tonemapper") _icall_Unit_Long( mb, this.ptr, mode) } enum class SSAOBlur( id: Long ) { SSAO_BLUR_DISABLED(0), SSAO_BLUR_1x1(1), SSAO_BLUR_2x2(2), SSAO_BLUR_3x3(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ToneMapper( id: Long ) { TONE_MAPPER_LINEAR(0), TONE_MAPPER_REINHARDT(1), TONE_MAPPER_FILMIC(2), TONE_MAPPER_ACES(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class GlowBlendMode( id: Long ) { GLOW_BLEND_MODE_ADDITIVE(0), GLOW_BLEND_MODE_SCREEN(1), GLOW_BLEND_MODE_SOFTLIGHT(2), GLOW_BLEND_MODE_REPLACE(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BGMode( id: Long ) { BG_CLEAR_COLOR(0), BG_COLOR(1), BG_SKY(2), BG_COLOR_SKY(3), BG_CANVAS(4), BG_KEEP(5), BG_CAMERA_FEED(6), BG_MAX(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class SSAOQuality( id: Long ) { SSAO_QUALITY_LOW(0), SSAO_QUALITY_MEDIUM(1), SSAO_QUALITY_HIGH(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class DOFBlurQuality( id: Long ) { DOF_BLUR_QUALITY_LOW(0), DOF_BLUR_QUALITY_MEDIUM(1), DOF_BLUR_QUALITY_HIGH(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Expression.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.PoolStringArray import godot.core.Variant import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_Long_String_PoolStringArray import godot.icalls._icall_String import godot.icalls._icall_Variant_VariantArray_nObject_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.String import kotlinx.cinterop.COpaquePointer open class Expression : Reference() { override fun __new(): COpaquePointer = invokeConstructor("Expression", "Expression") open fun execute( inputs: VariantArray = VariantArray(), baseInstance: Object? = null, showError: Boolean = true ): Variant { val mb = getMethodBind("Expression","execute") return _icall_Variant_VariantArray_nObject_Boolean( mb, this.ptr, inputs, baseInstance, showError) } open fun getErrorText(): String { val mb = getMethodBind("Expression","get_error_text") return _icall_String( mb, this.ptr) } open fun hasExecuteFailed(): Boolean { val mb = getMethodBind("Expression","has_execute_failed") return _icall_Boolean( mb, this.ptr) } open fun parse(expression: String, inputNames: PoolStringArray = PoolStringArray()): GodotError { val mb = getMethodBind("Expression","parse") return GodotError.byValue( _icall_Long_String_PoolStringArray( mb, this.ptr, expression, inputNames).toUInt()) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ExternalTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Unit_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.UninitializedPropertyAccessException import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ExternalTexture : Texture() { open var size: Vector2 get() { throw UninitializedPropertyAccessException("Cannot access property size: has no getter") } set(value) { val mb = getMethodBind("ExternalTexture","set_size") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ExternalTexture", "ExternalTexture") open fun size(schedule: Vector2.() -> Unit): Vector2 = size.apply{ schedule(this) size = this } open fun getExternalTextureId(): Long { val mb = getMethodBind("ExternalTexture","get_external_texture_id") return _icall_Long( mb, this.ptr) } open fun setSize(size: Vector2) { val mb = getMethodBind("ExternalTexture","set_size") _icall_Unit_Vector2( mb, this.ptr, size) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/File.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.PoolByteArray import godot.core.PoolStringArray import godot.core.Variant import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_String import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_Long_String_Long import godot.icalls._icall_Long_String_Long_Long import godot.icalls._icall_Long_String_Long_PoolByteArray import godot.icalls._icall_Long_String_Long_String import godot.icalls._icall_PoolByteArray_Long import godot.icalls._icall_PoolStringArray_String import godot.icalls._icall_String import godot.icalls._icall_String_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_PoolByteArray import godot.icalls._icall_Unit_PoolStringArray_String import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_Variant_Boolean import godot.icalls._icall_Variant_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class File : Reference() { open var endianSwap: Boolean get() { val mb = getMethodBind("_File","get_endian_swap") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_File","set_endian_swap") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("File", "_File") open fun close() { val mb = getMethodBind("_File","close") _icall_Unit( mb, this.ptr) } open fun eofReached(): Boolean { val mb = getMethodBind("_File","eof_reached") return _icall_Boolean( mb, this.ptr) } open fun fileExists(path: String): Boolean { val mb = getMethodBind("_File","file_exists") return _icall_Boolean_String( mb, this.ptr, path) } open fun get16(): Long { val mb = getMethodBind("_File","get_16") return _icall_Long( mb, this.ptr) } open fun get32(): Long { val mb = getMethodBind("_File","get_32") return _icall_Long( mb, this.ptr) } open fun get64(): Long { val mb = getMethodBind("_File","get_64") return _icall_Long( mb, this.ptr) } open fun get8(): Long { val mb = getMethodBind("_File","get_8") return _icall_Long( mb, this.ptr) } open fun getAsText(): String { val mb = getMethodBind("_File","get_as_text") return _icall_String( mb, this.ptr) } open fun getBuffer(len: Long): PoolByteArray { val mb = getMethodBind("_File","get_buffer") return _icall_PoolByteArray_Long( mb, this.ptr, len) } open fun getCsvLine(delim: String = ","): PoolStringArray { val mb = getMethodBind("_File","get_csv_line") return _icall_PoolStringArray_String( mb, this.ptr, delim) } open fun getDouble(): Double { val mb = getMethodBind("_File","get_double") return _icall_Double( mb, this.ptr) } open fun getEndianSwap(): Boolean { val mb = getMethodBind("_File","get_endian_swap") return _icall_Boolean( mb, this.ptr) } open fun getError(): GodotError { val mb = getMethodBind("_File","get_error") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } open fun getFloat(): Double { val mb = getMethodBind("_File","get_float") return _icall_Double( mb, this.ptr) } open fun getLen(): Long { val mb = getMethodBind("_File","get_len") return _icall_Long( mb, this.ptr) } open fun getLine(): String { val mb = getMethodBind("_File","get_line") return _icall_String( mb, this.ptr) } open fun getMd5(path: String): String { val mb = getMethodBind("_File","get_md5") return _icall_String_String( mb, this.ptr, path) } open fun getModifiedTime(file: String): Long { val mb = getMethodBind("_File","get_modified_time") return _icall_Long_String( mb, this.ptr, file) } open fun getPascalString(): String { val mb = getMethodBind("_File","get_pascal_string") return _icall_String( mb, this.ptr) } open fun getPath(): String { val mb = getMethodBind("_File","get_path") return _icall_String( mb, this.ptr) } open fun getPathAbsolute(): String { val mb = getMethodBind("_File","get_path_absolute") return _icall_String( mb, this.ptr) } open fun getPosition(): Long { val mb = getMethodBind("_File","get_position") return _icall_Long( mb, this.ptr) } open fun getReal(): Double { val mb = getMethodBind("_File","get_real") return _icall_Double( mb, this.ptr) } open fun getSha256(path: String): String { val mb = getMethodBind("_File","get_sha256") return _icall_String_String( mb, this.ptr, path) } open fun getVar(allowObjects: Boolean = false): Variant { val mb = getMethodBind("_File","get_var") return _icall_Variant_Boolean( mb, this.ptr, allowObjects) } open fun isOpen(): Boolean { val mb = getMethodBind("_File","is_open") return _icall_Boolean( mb, this.ptr) } open fun open(path: String, flags: Long): GodotError { val mb = getMethodBind("_File","open") return GodotError.byValue( _icall_Long_String_Long( mb, this.ptr, path, flags).toUInt()) } open fun openCompressed( path: String, modeFlags: Long, compressionMode: Long = 0 ): GodotError { val mb = getMethodBind("_File","open_compressed") return GodotError.byValue( _icall_Long_String_Long_Long( mb, this.ptr, path, modeFlags, compressionMode).toUInt()) } open fun openEncrypted( path: String, modeFlags: Long, key: PoolByteArray ): GodotError { val mb = getMethodBind("_File","open_encrypted") return GodotError.byValue( _icall_Long_String_Long_PoolByteArray( mb, this.ptr, path, modeFlags, key).toUInt()) } open fun openEncryptedWithPass( path: String, modeFlags: Long, pass: String ): GodotError { val mb = getMethodBind("_File","open_encrypted_with_pass") return GodotError.byValue( _icall_Long_String_Long_String( mb, this.ptr, path, modeFlags, pass).toUInt()) } open fun seek(position: Long) { val mb = getMethodBind("_File","seek") _icall_Unit_Long( mb, this.ptr, position) } open fun seekEnd(position: Long = 0) { val mb = getMethodBind("_File","seek_end") _icall_Unit_Long( mb, this.ptr, position) } open fun setEndianSwap(enable: Boolean) { val mb = getMethodBind("_File","set_endian_swap") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun store16(value: Long) { val mb = getMethodBind("_File","store_16") _icall_Unit_Long( mb, this.ptr, value) } open fun store32(value: Long) { val mb = getMethodBind("_File","store_32") _icall_Unit_Long( mb, this.ptr, value) } open fun store64(value: Long) { val mb = getMethodBind("_File","store_64") _icall_Unit_Long( mb, this.ptr, value) } open fun store8(value: Long) { val mb = getMethodBind("_File","store_8") _icall_Unit_Long( mb, this.ptr, value) } open fun storeBuffer(buffer: PoolByteArray) { val mb = getMethodBind("_File","store_buffer") _icall_Unit_PoolByteArray( mb, this.ptr, buffer) } open fun storeCsvLine(values: PoolStringArray, delim: String = ",") { val mb = getMethodBind("_File","store_csv_line") _icall_Unit_PoolStringArray_String( mb, this.ptr, values, delim) } open fun storeDouble(value: Double) { val mb = getMethodBind("_File","store_double") _icall_Unit_Double( mb, this.ptr, value) } open fun storeFloat(value: Double) { val mb = getMethodBind("_File","store_float") _icall_Unit_Double( mb, this.ptr, value) } open fun storeLine(line: String) { val mb = getMethodBind("_File","store_line") _icall_Unit_String( mb, this.ptr, line) } open fun storePascalString(string: String) { val mb = getMethodBind("_File","store_pascal_string") _icall_Unit_String( mb, this.ptr, string) } open fun storeReal(value: Double) { val mb = getMethodBind("_File","store_real") _icall_Unit_Double( mb, this.ptr, value) } open fun storeString(string: String) { val mb = getMethodBind("_File","store_string") _icall_Unit_String( mb, this.ptr, string) } open fun storeVar(value: Variant, fullObjects: Boolean = false) { val mb = getMethodBind("_File","store_var") _icall_Unit_Variant_Boolean( mb, this.ptr, value, fullObjects) } enum class CompressionMode( id: Long ) { COMPRESSION_FASTLZ(0), COMPRESSION_DEFLATE(1), COMPRESSION_ZSTD(2), COMPRESSION_GZIP(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ModeFlags( id: Long ) { READ(1), WRITE(2), READ_WRITE(3), WRITE_READ(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/FileDialog.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.FileDialog import godot.core.PoolStringArray import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_LineEdit import godot.icalls._icall_Long import godot.icalls._icall_PoolStringArray import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_PoolStringArray import godot.icalls._icall_Unit_String import godot.icalls._icall_VBoxContainer import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class FileDialog : ConfirmationDialog() { val dirSelected: Signal1 by signal("dir") val fileSelected: Signal1 by signal("path") val filesSelected: Signal1 by signal("paths") open var access: Long get() { val mb = getMethodBind("FileDialog","get_access") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("FileDialog","set_access") _icall_Unit_Long(mb, this.ptr, value) } open var currentDir: String get() { val mb = getMethodBind("FileDialog","get_current_dir") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("FileDialog","set_current_dir") _icall_Unit_String(mb, this.ptr, value) } open var currentFile: String get() { val mb = getMethodBind("FileDialog","get_current_file") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("FileDialog","set_current_file") _icall_Unit_String(mb, this.ptr, value) } open var currentPath: String get() { val mb = getMethodBind("FileDialog","get_current_path") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("FileDialog","set_current_path") _icall_Unit_String(mb, this.ptr, value) } open var filters: PoolStringArray get() { val mb = getMethodBind("FileDialog","get_filters") return _icall_PoolStringArray(mb, this.ptr) } set(value) { val mb = getMethodBind("FileDialog","set_filters") _icall_Unit_PoolStringArray(mb, this.ptr, value) } open var mode: Long get() { val mb = getMethodBind("FileDialog","get_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("FileDialog","set_mode") _icall_Unit_Long(mb, this.ptr, value) } open var modeOverridesTitle: Boolean get() { val mb = getMethodBind("FileDialog","is_mode_overriding_title") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("FileDialog","set_mode_overrides_title") _icall_Unit_Boolean(mb, this.ptr, value) } open var showHiddenFiles: Boolean get() { val mb = getMethodBind("FileDialog","is_showing_hidden_files") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("FileDialog","set_show_hidden_files") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("FileDialog", "FileDialog") open fun _actionPressed() { } open fun _cancelPressed() { } open fun _dirEntered(arg0: String) { } open fun _fileEntered(arg0: String) { } open fun _filterSelected(arg0: Long) { } open fun _goUp() { } open fun _makeDir() { } open fun _makeDirConfirm() { } open fun _saveConfirmPressed() { } open fun _selectDrive(arg0: Long) { } open fun _treeItemActivated() { } open fun _treeMultiSelected( arg0: Object, arg1: Long, arg2: Boolean ) { } open fun _treeSelected() { } override fun _unhandledInput(arg0: InputEvent) { } open fun _updateDir() { } open fun _updateFileList() { } open fun _updateFileName() { } open fun addFilter(filter: String) { val mb = getMethodBind("FileDialog","add_filter") _icall_Unit_String( mb, this.ptr, filter) } open fun clearFilters() { val mb = getMethodBind("FileDialog","clear_filters") _icall_Unit( mb, this.ptr) } open fun deselectItems() { val mb = getMethodBind("FileDialog","deselect_items") _icall_Unit( mb, this.ptr) } open fun getAccess(): FileDialog.Access { val mb = getMethodBind("FileDialog","get_access") return FileDialog.Access.from( _icall_Long( mb, this.ptr)) } open fun getCurrentDir(): String { val mb = getMethodBind("FileDialog","get_current_dir") return _icall_String( mb, this.ptr) } open fun getCurrentFile(): String { val mb = getMethodBind("FileDialog","get_current_file") return _icall_String( mb, this.ptr) } open fun getCurrentPath(): String { val mb = getMethodBind("FileDialog","get_current_path") return _icall_String( mb, this.ptr) } open fun getFilters(): PoolStringArray { val mb = getMethodBind("FileDialog","get_filters") return _icall_PoolStringArray( mb, this.ptr) } open fun getLineEdit(): LineEdit { val mb = getMethodBind("FileDialog","get_line_edit") return _icall_LineEdit( mb, this.ptr) } open fun getMode(): FileDialog.Mode { val mb = getMethodBind("FileDialog","get_mode") return FileDialog.Mode.from( _icall_Long( mb, this.ptr)) } open fun getVbox(): VBoxContainer { val mb = getMethodBind("FileDialog","get_vbox") return _icall_VBoxContainer( mb, this.ptr) } open fun invalidate() { val mb = getMethodBind("FileDialog","invalidate") _icall_Unit( mb, this.ptr) } open fun isModeOverridingTitle(): Boolean { val mb = getMethodBind("FileDialog","is_mode_overriding_title") return _icall_Boolean( mb, this.ptr) } open fun isShowingHiddenFiles(): Boolean { val mb = getMethodBind("FileDialog","is_showing_hidden_files") return _icall_Boolean( mb, this.ptr) } open fun setAccess(access: Long) { val mb = getMethodBind("FileDialog","set_access") _icall_Unit_Long( mb, this.ptr, access) } open fun setCurrentDir(dir: String) { val mb = getMethodBind("FileDialog","set_current_dir") _icall_Unit_String( mb, this.ptr, dir) } open fun setCurrentFile(file: String) { val mb = getMethodBind("FileDialog","set_current_file") _icall_Unit_String( mb, this.ptr, file) } open fun setCurrentPath(path: String) { val mb = getMethodBind("FileDialog","set_current_path") _icall_Unit_String( mb, this.ptr, path) } open fun setFilters(filters: PoolStringArray) { val mb = getMethodBind("FileDialog","set_filters") _icall_Unit_PoolStringArray( mb, this.ptr, filters) } open fun setMode(mode: Long) { val mb = getMethodBind("FileDialog","set_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setModeOverridesTitle(override: Boolean) { val mb = getMethodBind("FileDialog","set_mode_overrides_title") _icall_Unit_Boolean( mb, this.ptr, override) } open fun setShowHiddenFiles(show: Boolean) { val mb = getMethodBind("FileDialog","set_show_hidden_files") _icall_Unit_Boolean( mb, this.ptr, show) } enum class Mode( id: Long ) { MODE_OPEN_FILE(0), MODE_OPEN_FILES(1), MODE_OPEN_DIR(2), MODE_OPEN_ANY(3), MODE_SAVE_FILE(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Access( id: Long ) { ACCESS_RESOURCES(0), ACCESS_USERDATA(1), ACCESS_FILESYSTEM(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/FileSystemDock.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal2 import godot.core.Variant import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean_Vector2_Variant_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_Vector2_Variant_Object import godot.icalls._icall_Variant_Vector2_Object import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class FileSystemDock internal constructor() : VBoxContainer() { val displayModeChanged: Signal0 by signal() val fileRemoved: Signal1 by signal("file") val filesMoved: Signal2 by signal("old_file", "new_file") val folderMoved: Signal2 by signal("old_folder", "new_file") val folderRemoved: Signal1 by signal("folder") val inherit: Signal1 by signal("file") val instance: Signal1 by signal("files") open fun _bwHistory() { } open fun _duplicateOperationConfirm() { } open fun _featureProfileChanged() { } open fun _fileListActivateFile(arg0: Long) { } open fun _fileListGuiInput(arg0: InputEvent) { } open fun _fileListRmbOption(option: Long) { } open fun _fileListRmbPressed(arg0: Vector2) { } open fun _fileListRmbSelect(arg0: Long, arg1: Vector2) { } open fun _fileListThumbnailDone( arg0: String, arg1: Texture, arg2: Texture, arg3: Variant ) { } open fun _fileMultiSelected(arg0: Long, arg1: Boolean) { } open fun _fileRemoved(arg0: String) { } open fun _folderRemoved(arg0: String) { } open fun _fsChanged() { } open fun _fwHistory() { } open fun _makeDirConfirm() { } open fun _makeSceneConfirm() { } open fun _moveOperationConfirm(toPath: String, overwrite: Boolean = false) { } open fun _moveWithOverwrite() { } open fun _navigateToPath(arg0: String, arg1: Boolean = false) { } open fun _previewInvalidated(arg0: String) { } open fun _renameOperationConfirm() { } open fun _rescan() { } open fun _resourceCreated() { } open fun _searchChanged(arg0: String, arg1: Control) { } open fun _selectFile(arg0: String, arg1: Boolean) { } open fun _toggleFileDisplay() { } open fun _toggleSplitMode(arg0: Boolean) { } open fun _treeActivateFile() { } open fun _treeEmptySelected() { } open fun _treeGuiInput(arg0: InputEvent) { } open fun _treeMultiSelected( arg0: Object, arg1: Long, arg2: Boolean ) { } open fun _treeRmbEmpty(arg0: Vector2) { } open fun _treeRmbOption(option: Long) { } open fun _treeRmbSelect(arg0: Vector2) { } open fun _treeThumbnailDone( arg0: String, arg1: Texture, arg2: Texture, arg3: Variant ) { } open fun _updateImportDock() { } open fun _updateTree( arg0: PoolStringArray, arg1: Boolean, arg2: Boolean, arg3: Boolean ) { } open fun canDropDataFw( arg0: Vector2, arg1: Variant, arg2: Control ): Boolean { val mb = getMethodBind("FileSystemDock","can_drop_data_fw") return _icall_Boolean_Vector2_Variant_Object( mb, this.ptr, arg0, arg1, arg2) } open fun dropDataFw( arg0: Vector2, arg1: Variant, arg2: Control ) { val mb = getMethodBind("FileSystemDock","drop_data_fw") _icall_Unit_Vector2_Variant_Object( mb, this.ptr, arg0, arg1, arg2) } open fun getDragDataFw(arg0: Vector2, arg1: Control): Variant { val mb = getMethodBind("FileSystemDock","get_drag_data_fw") return _icall_Variant_Vector2_Object( mb, this.ptr, arg0, arg1) } open fun navigateToPath(arg0: String) { val mb = getMethodBind("FileSystemDock","navigate_to_path") _icall_Unit_String( mb, this.ptr, arg0) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Font.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.RID import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Double_RID_Vector2_Long_Long_Color_Boolean import godot.icalls._icall_Unit import godot.icalls._icall_Unit_RID_Vector2_String_Color_Long_Color import godot.icalls._icall_Vector2_String import godot.icalls._icall_Vector2_String_Double import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String open class Font internal constructor() : Resource() { open fun draw( canvasItem: RID, position: Vector2, string: String, modulate: Color = Color(1,1,1,1), clipW: Long = -1, outlineModulate: Color = Color(1,1,1,1) ) { val mb = getMethodBind("Font","draw") _icall_Unit_RID_Vector2_String_Color_Long_Color( mb, this.ptr, canvasItem, position, string, modulate, clipW, outlineModulate) } open fun drawChar( canvasItem: RID, position: Vector2, char: Long, next: Long = -1, modulate: Color = Color(1,1,1,1), outline: Boolean = false ): Double { val mb = getMethodBind("Font","draw_char") return _icall_Double_RID_Vector2_Long_Long_Color_Boolean( mb, this.ptr, canvasItem, position, char, next, modulate, outline) } open fun getAscent(): Double { val mb = getMethodBind("Font","get_ascent") return _icall_Double( mb, this.ptr) } open fun getDescent(): Double { val mb = getMethodBind("Font","get_descent") return _icall_Double( mb, this.ptr) } open fun getHeight(): Double { val mb = getMethodBind("Font","get_height") return _icall_Double( mb, this.ptr) } open fun getStringSize(string: String): Vector2 { val mb = getMethodBind("Font","get_string_size") return _icall_Vector2_String( mb, this.ptr, string) } open fun getWordwrapStringSize(string: String, width: Double): Vector2 { val mb = getMethodBind("Font","get_wordwrap_string_size") return _icall_Vector2_String_Double( mb, this.ptr, string, width) } open fun hasOutline(): Boolean { val mb = getMethodBind("Font","has_outline") return _icall_Boolean( mb, this.ptr) } open fun isDistanceFieldHint(): Boolean { val mb = getMethodBind("Font","is_distance_field_hint") return _icall_Boolean( mb, this.ptr) } open fun updateChanges() { val mb = getMethodBind("Font","update_changes") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/FuncRef.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Variant import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_Variant_VariantArray import godot.icalls._icall_varargs import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Any import kotlin.Boolean import kotlin.String import kotlinx.cinterop.COpaquePointer open class FuncRef : Reference() { override fun __new(): COpaquePointer = invokeConstructor("FuncRef", "FuncRef") open fun callFunc(vararg __var_args: Any?): Variant { val mb = getMethodBind("FuncRef","call_func") return _icall_varargs( mb, this.ptr, __var_args) } open fun callFuncv(argArray: VariantArray): Variant { val mb = getMethodBind("FuncRef","call_funcv") return _icall_Variant_VariantArray( mb, this.ptr, argArray) } open fun isValid(): Boolean { val mb = getMethodBind("FuncRef","is_valid") return _icall_Boolean( mb, this.ptr) } open fun setFunction(name: String) { val mb = getMethodBind("FuncRef","set_function") _icall_Unit_String( mb, this.ptr, name) } open fun setInstance(instance: Object) { val mb = getMethodBind("FuncRef","set_instance") _icall_Unit_Object( mb, this.ptr, instance) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GDNative.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Variant import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_GDNativeLibrary import godot.icalls._icall_Unit_Object import godot.icalls._icall_Variant_String_String_VariantArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.String import kotlinx.cinterop.COpaquePointer open class GDNative : Reference() { open var library: GDNativeLibrary get() { val mb = getMethodBind("GDNative","get_library") return _icall_GDNativeLibrary(mb, this.ptr) } set(value) { val mb = getMethodBind("GDNative","set_library") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GDNative", "GDNative") open fun callNative( callingType: String, procedureName: String, arguments: VariantArray ): Variant { val mb = getMethodBind("GDNative","call_native") return _icall_Variant_String_String_VariantArray( mb, this.ptr, callingType, procedureName, arguments) } open fun getLibrary(): GDNativeLibrary { val mb = getMethodBind("GDNative","get_library") return _icall_GDNativeLibrary( mb, this.ptr) } open fun initialize(): Boolean { val mb = getMethodBind("GDNative","initialize") return _icall_Boolean( mb, this.ptr) } open fun setLibrary(library: GDNativeLibrary) { val mb = getMethodBind("GDNative","set_library") _icall_Unit_Object( mb, this.ptr, library) } open fun terminate(): Boolean { val mb = getMethodBind("GDNative","terminate") return _icall_Boolean( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GDNativeLibrary.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.icalls._icall_Boolean import godot.icalls._icall_ConfigFile import godot.icalls._icall_PoolStringArray import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.String import kotlinx.cinterop.COpaquePointer open class GDNativeLibrary : Resource() { open var configFile: ConfigFile get() { val mb = getMethodBind("GDNativeLibrary","get_config_file") return _icall_ConfigFile(mb, this.ptr) } set(value) { val mb = getMethodBind("GDNativeLibrary","set_config_file") _icall_Unit_Object(mb, this.ptr, value) } open var loadOnce: Boolean get() { val mb = getMethodBind("GDNativeLibrary","should_load_once") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GDNativeLibrary","set_load_once") _icall_Unit_Boolean(mb, this.ptr, value) } open var reloadable: Boolean get() { val mb = getMethodBind("GDNativeLibrary","is_reloadable") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GDNativeLibrary","set_reloadable") _icall_Unit_Boolean(mb, this.ptr, value) } open var singleton: Boolean get() { val mb = getMethodBind("GDNativeLibrary","is_singleton") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GDNativeLibrary","set_singleton") _icall_Unit_Boolean(mb, this.ptr, value) } open var symbolPrefix: String get() { val mb = getMethodBind("GDNativeLibrary","get_symbol_prefix") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("GDNativeLibrary","set_symbol_prefix") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GDNativeLibrary", "GDNativeLibrary") open fun getConfigFile(): ConfigFile { val mb = getMethodBind("GDNativeLibrary","get_config_file") return _icall_ConfigFile( mb, this.ptr) } open fun getCurrentDependencies(): PoolStringArray { val mb = getMethodBind("GDNativeLibrary","get_current_dependencies") return _icall_PoolStringArray( mb, this.ptr) } open fun getCurrentLibraryPath(): String { val mb = getMethodBind("GDNativeLibrary","get_current_library_path") return _icall_String( mb, this.ptr) } open fun getSymbolPrefix(): String { val mb = getMethodBind("GDNativeLibrary","get_symbol_prefix") return _icall_String( mb, this.ptr) } open fun isReloadable(): Boolean { val mb = getMethodBind("GDNativeLibrary","is_reloadable") return _icall_Boolean( mb, this.ptr) } open fun isSingleton(): Boolean { val mb = getMethodBind("GDNativeLibrary","is_singleton") return _icall_Boolean( mb, this.ptr) } open fun setConfigFile(configFile: ConfigFile) { val mb = getMethodBind("GDNativeLibrary","set_config_file") _icall_Unit_Object( mb, this.ptr, configFile) } open fun setLoadOnce(loadOnce: Boolean) { val mb = getMethodBind("GDNativeLibrary","set_load_once") _icall_Unit_Boolean( mb, this.ptr, loadOnce) } open fun setReloadable(reloadable: Boolean) { val mb = getMethodBind("GDNativeLibrary","set_reloadable") _icall_Unit_Boolean( mb, this.ptr, reloadable) } open fun setSingleton(singleton: Boolean) { val mb = getMethodBind("GDNativeLibrary","set_singleton") _icall_Unit_Boolean( mb, this.ptr, singleton) } open fun setSymbolPrefix(symbolPrefix: String) { val mb = getMethodBind("GDNativeLibrary","set_symbol_prefix") _icall_Unit_String( mb, this.ptr, symbolPrefix) } open fun shouldLoadOnce(): Boolean { val mb = getMethodBind("GDNativeLibrary","should_load_once") return _icall_Boolean( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GDScript.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolByteArray import godot.core.Variant import godot.icalls._icall_PoolByteArray import godot.icalls._icall_varargs import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Any import kotlinx.cinterop.COpaquePointer open class GDScript : Script() { override fun __new(): COpaquePointer = invokeConstructor("GDScript", "GDScript") open fun getAsByteCode(): PoolByteArray { val mb = getMethodBind("GDScript","get_as_byte_code") return _icall_PoolByteArray( mb, this.ptr) } open fun new(vararg __var_args: Any?): Variant { val mb = getMethodBind("GDScript","new") return _icall_varargs( mb, this.ptr, __var_args) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GDScriptFunctionState.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal1 import godot.core.Variant import godot.core.signal import godot.icalls._icall_Boolean_Boolean import godot.icalls._icall_Variant_nVariant import godot.internal.utils.getMethodBind import kotlin.Any import kotlin.Boolean import kotlin.NotImplementedError open class GDScriptFunctionState internal constructor() : Reference() { val completed: Signal1 by signal("result") open fun _signalCallback(vararg __var_args: Any?): Variant { throw NotImplementedError("_signal_callback is not implemented for GDScriptFunctionState") } open fun isValid(extendedCheck: Boolean = false): Boolean { val mb = getMethodBind("GDScriptFunctionState","is_valid") return _icall_Boolean_Boolean( mb, this.ptr, extendedCheck) } open fun resume(arg: Variant? = null): Variant { val mb = getMethodBind("GDScriptFunctionState","resume") return _icall_Variant_nVariant( mb, this.ptr, arg) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GIProbe.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.GIProbe import godot.core.Vector3 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_GIProbeData import godot.icalls._icall_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Unit_nObject_Boolean import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class GIProbe : VisualInstance() { open var bias: Double get() { val mb = getMethodBind("GIProbe","get_bias") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_bias") _icall_Unit_Double(mb, this.ptr, value) } open var compress: Boolean get() { val mb = getMethodBind("GIProbe","is_compressed") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_compress") _icall_Unit_Boolean(mb, this.ptr, value) } open var data: GIProbeData get() { val mb = getMethodBind("GIProbe","get_probe_data") return _icall_GIProbeData(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_probe_data") _icall_Unit_Object(mb, this.ptr, value) } open var dynamicRange: Long get() { val mb = getMethodBind("GIProbe","get_dynamic_range") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_dynamic_range") _icall_Unit_Long(mb, this.ptr, value) } open var energy: Double get() { val mb = getMethodBind("GIProbe","get_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_energy") _icall_Unit_Double(mb, this.ptr, value) } open var extents: Vector3 get() { val mb = getMethodBind("GIProbe","get_extents") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_extents") _icall_Unit_Vector3(mb, this.ptr, value) } open var interior: Boolean get() { val mb = getMethodBind("GIProbe","is_interior") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_interior") _icall_Unit_Boolean(mb, this.ptr, value) } open var normalBias: Double get() { val mb = getMethodBind("GIProbe","get_normal_bias") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_normal_bias") _icall_Unit_Double(mb, this.ptr, value) } open var propagation: Double get() { val mb = getMethodBind("GIProbe","get_propagation") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_propagation") _icall_Unit_Double(mb, this.ptr, value) } open var subdiv: Long get() { val mb = getMethodBind("GIProbe","get_subdiv") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbe","set_subdiv") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GIProbe", "GIProbe") open fun extents(schedule: Vector3.() -> Unit): Vector3 = extents.apply{ schedule(this) extents = this } open fun bake(fromNode: Node? = null, createVisualDebug: Boolean = false) { val mb = getMethodBind("GIProbe","bake") _icall_Unit_nObject_Boolean( mb, this.ptr, fromNode, createVisualDebug) } open fun debugBake() { val mb = getMethodBind("GIProbe","debug_bake") _icall_Unit( mb, this.ptr) } open fun getBias(): Double { val mb = getMethodBind("GIProbe","get_bias") return _icall_Double( mb, this.ptr) } open fun getDynamicRange(): Long { val mb = getMethodBind("GIProbe","get_dynamic_range") return _icall_Long( mb, this.ptr) } open fun getEnergy(): Double { val mb = getMethodBind("GIProbe","get_energy") return _icall_Double( mb, this.ptr) } open fun getExtents(): Vector3 { val mb = getMethodBind("GIProbe","get_extents") return _icall_Vector3( mb, this.ptr) } open fun getNormalBias(): Double { val mb = getMethodBind("GIProbe","get_normal_bias") return _icall_Double( mb, this.ptr) } open fun getProbeData(): GIProbeData { val mb = getMethodBind("GIProbe","get_probe_data") return _icall_GIProbeData( mb, this.ptr) } open fun getPropagation(): Double { val mb = getMethodBind("GIProbe","get_propagation") return _icall_Double( mb, this.ptr) } open fun getSubdiv(): GIProbe.Subdiv { val mb = getMethodBind("GIProbe","get_subdiv") return GIProbe.Subdiv.from( _icall_Long( mb, this.ptr)) } open fun isCompressed(): Boolean { val mb = getMethodBind("GIProbe","is_compressed") return _icall_Boolean( mb, this.ptr) } open fun isInterior(): Boolean { val mb = getMethodBind("GIProbe","is_interior") return _icall_Boolean( mb, this.ptr) } open fun setBias(max: Double) { val mb = getMethodBind("GIProbe","set_bias") _icall_Unit_Double( mb, this.ptr, max) } open fun setCompress(enable: Boolean) { val mb = getMethodBind("GIProbe","set_compress") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setDynamicRange(max: Long) { val mb = getMethodBind("GIProbe","set_dynamic_range") _icall_Unit_Long( mb, this.ptr, max) } open fun setEnergy(max: Double) { val mb = getMethodBind("GIProbe","set_energy") _icall_Unit_Double( mb, this.ptr, max) } open fun setExtents(extents: Vector3) { val mb = getMethodBind("GIProbe","set_extents") _icall_Unit_Vector3( mb, this.ptr, extents) } open fun setInterior(enable: Boolean) { val mb = getMethodBind("GIProbe","set_interior") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setNormalBias(max: Double) { val mb = getMethodBind("GIProbe","set_normal_bias") _icall_Unit_Double( mb, this.ptr, max) } open fun setProbeData(data: GIProbeData) { val mb = getMethodBind("GIProbe","set_probe_data") _icall_Unit_Object( mb, this.ptr, data) } open fun setPropagation(max: Double) { val mb = getMethodBind("GIProbe","set_propagation") _icall_Unit_Double( mb, this.ptr, max) } open fun setSubdiv(subdiv: Long) { val mb = getMethodBind("GIProbe","set_subdiv") _icall_Unit_Long( mb, this.ptr, subdiv) } enum class Subdiv( id: Long ) { SUBDIV_64(0), SUBDIV_128(1), SUBDIV_256(2), SUBDIV_512(3), SUBDIV_MAX(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GIProbeData.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.AABB import godot.core.PoolIntArray import godot.core.Transform import godot.icalls._icall_AABB import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_PoolIntArray import godot.icalls._icall_Transform import godot.icalls._icall_Unit_AABB import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_PoolIntArray import godot.icalls._icall_Unit_Transform import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class GIProbeData : Resource() { open var bias: Double get() { val mb = getMethodBind("GIProbeData","get_bias") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_bias") _icall_Unit_Double(mb, this.ptr, value) } open var bounds: AABB get() { val mb = getMethodBind("GIProbeData","get_bounds") return _icall_AABB(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_bounds") _icall_Unit_AABB(mb, this.ptr, value) } open var cellSize: Double get() { val mb = getMethodBind("GIProbeData","get_cell_size") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_cell_size") _icall_Unit_Double(mb, this.ptr, value) } open var compress: Boolean get() { val mb = getMethodBind("GIProbeData","is_compressed") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_compress") _icall_Unit_Boolean(mb, this.ptr, value) } open var dynamicData: PoolIntArray get() { val mb = getMethodBind("GIProbeData","get_dynamic_data") return _icall_PoolIntArray(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_dynamic_data") _icall_Unit_PoolIntArray(mb, this.ptr, value) } open var dynamicRange: Long get() { val mb = getMethodBind("GIProbeData","get_dynamic_range") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_dynamic_range") _icall_Unit_Long(mb, this.ptr, value) } open var energy: Double get() { val mb = getMethodBind("GIProbeData","get_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_energy") _icall_Unit_Double(mb, this.ptr, value) } open var interior: Boolean get() { val mb = getMethodBind("GIProbeData","is_interior") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_interior") _icall_Unit_Boolean(mb, this.ptr, value) } open var normalBias: Double get() { val mb = getMethodBind("GIProbeData","get_normal_bias") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_normal_bias") _icall_Unit_Double(mb, this.ptr, value) } open var propagation: Double get() { val mb = getMethodBind("GIProbeData","get_propagation") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_propagation") _icall_Unit_Double(mb, this.ptr, value) } open var toCellXform: Transform get() { val mb = getMethodBind("GIProbeData","get_to_cell_xform") return _icall_Transform(mb, this.ptr) } set(value) { val mb = getMethodBind("GIProbeData","set_to_cell_xform") _icall_Unit_Transform(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GIProbeData", "GIProbeData") open fun bounds(schedule: AABB.() -> Unit): AABB = bounds.apply{ schedule(this) bounds = this } open fun toCellXform(schedule: Transform.() -> Unit): Transform = toCellXform.apply{ schedule(this) toCellXform = this } open fun getBias(): Double { val mb = getMethodBind("GIProbeData","get_bias") return _icall_Double( mb, this.ptr) } open fun getBounds(): AABB { val mb = getMethodBind("GIProbeData","get_bounds") return _icall_AABB( mb, this.ptr) } open fun getCellSize(): Double { val mb = getMethodBind("GIProbeData","get_cell_size") return _icall_Double( mb, this.ptr) } open fun getDynamicData(): PoolIntArray { val mb = getMethodBind("GIProbeData","get_dynamic_data") return _icall_PoolIntArray( mb, this.ptr) } open fun getDynamicRange(): Long { val mb = getMethodBind("GIProbeData","get_dynamic_range") return _icall_Long( mb, this.ptr) } open fun getEnergy(): Double { val mb = getMethodBind("GIProbeData","get_energy") return _icall_Double( mb, this.ptr) } open fun getNormalBias(): Double { val mb = getMethodBind("GIProbeData","get_normal_bias") return _icall_Double( mb, this.ptr) } open fun getPropagation(): Double { val mb = getMethodBind("GIProbeData","get_propagation") return _icall_Double( mb, this.ptr) } open fun getToCellXform(): Transform { val mb = getMethodBind("GIProbeData","get_to_cell_xform") return _icall_Transform( mb, this.ptr) } open fun isCompressed(): Boolean { val mb = getMethodBind("GIProbeData","is_compressed") return _icall_Boolean( mb, this.ptr) } open fun isInterior(): Boolean { val mb = getMethodBind("GIProbeData","is_interior") return _icall_Boolean( mb, this.ptr) } open fun setBias(bias: Double) { val mb = getMethodBind("GIProbeData","set_bias") _icall_Unit_Double( mb, this.ptr, bias) } open fun setBounds(bounds: AABB) { val mb = getMethodBind("GIProbeData","set_bounds") _icall_Unit_AABB( mb, this.ptr, bounds) } open fun setCellSize(cellSize: Double) { val mb = getMethodBind("GIProbeData","set_cell_size") _icall_Unit_Double( mb, this.ptr, cellSize) } open fun setCompress(compress: Boolean) { val mb = getMethodBind("GIProbeData","set_compress") _icall_Unit_Boolean( mb, this.ptr, compress) } open fun setDynamicData(dynamicData: PoolIntArray) { val mb = getMethodBind("GIProbeData","set_dynamic_data") _icall_Unit_PoolIntArray( mb, this.ptr, dynamicData) } open fun setDynamicRange(dynamicRange: Long) { val mb = getMethodBind("GIProbeData","set_dynamic_range") _icall_Unit_Long( mb, this.ptr, dynamicRange) } open fun setEnergy(energy: Double) { val mb = getMethodBind("GIProbeData","set_energy") _icall_Unit_Double( mb, this.ptr, energy) } open fun setInterior(interior: Boolean) { val mb = getMethodBind("GIProbeData","set_interior") _icall_Unit_Boolean( mb, this.ptr, interior) } open fun setNormalBias(bias: Double) { val mb = getMethodBind("GIProbeData","set_normal_bias") _icall_Unit_Double( mb, this.ptr, bias) } open fun setPropagation(propagation: Double) { val mb = getMethodBind("GIProbeData","set_propagation") _icall_Unit_Double( mb, this.ptr, propagation) } open fun setToCellXform(toCellXform: Transform) { val mb = getMethodBind("GIProbeData","set_to_cell_xform") _icall_Unit_Transform( mb, this.ptr, toCellXform) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Generic6DOFJoint.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class Generic6DOFJoint : Joint() { open var angularLimitX_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 13, value) } open var angularLimitX_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_x") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_x") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var angularLimitX_erp: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 16, value) } open var angularLimitX_forceLimit: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 15) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 15, value) } open var angularLimitX_restitution: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 14) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 14, value) } open var angularLimitX_softness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 12) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 12, value) } open var angularLimitY_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 13, value) } open var angularLimitY_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_y") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_y") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var angularLimitY_erp: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 16, value) } open var angularLimitY_forceLimit: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 15) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 15, value) } open var angularLimitY_restitution: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 14) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 14, value) } open var angularLimitY_softness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 12) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 12, value) } open var angularLimitZ_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 13, value) } open var angularLimitZ_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_z") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_z") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var angularLimitZ_erp: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 16, value) } open var angularLimitZ_forceLimit: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 15) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 15, value) } open var angularLimitZ_restitution: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 14) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 14, value) } open var angularLimitZ_softness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 12) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 12, value) } open var angularMotorX_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_x") return _icall_Boolean_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_x") _icall_Unit_Long_Boolean(mb, this.ptr, 4, value) } open var angularMotorX_forceLimit: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 18) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 18, value) } open var angularMotorX_targetVelocity: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 17) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 17, value) } open var angularMotorY_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_y") return _icall_Boolean_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_y") _icall_Unit_Long_Boolean(mb, this.ptr, 4, value) } open var angularMotorY_forceLimit: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 18) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 18, value) } open var angularMotorY_targetVelocity: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 17) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 17, value) } open var angularMotorZ_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_z") return _icall_Boolean_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_z") _icall_Unit_Long_Boolean(mb, this.ptr, 4, value) } open var angularMotorZ_forceLimit: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 18) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 18, value) } open var angularMotorZ_targetVelocity: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 17) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 17, value) } open var angularSpringX_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 20) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 20, value) } open var angularSpringX_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_x") return _icall_Boolean_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_x") _icall_Unit_Long_Boolean(mb, this.ptr, 2, value) } open var angularSpringX_equilibriumPoint: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 21) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 21, value) } open var angularSpringX_stiffness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 19) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 19, value) } open var angularSpringY_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 20) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 20, value) } open var angularSpringY_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_y") return _icall_Boolean_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_y") _icall_Unit_Long_Boolean(mb, this.ptr, 2, value) } open var angularSpringY_equilibriumPoint: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 21) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 21, value) } open var angularSpringY_stiffness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 19) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 19, value) } open var angularSpringZ_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 20) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 20, value) } open var angularSpringZ_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_z") return _icall_Boolean_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_z") _icall_Unit_Long_Boolean(mb, this.ptr, 2, value) } open var angularSpringZ_equilibriumPoint: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 21) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 21, value) } open var angularSpringZ_stiffness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 19) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 19, value) } open var linearLimitX_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var linearLimitX_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_x") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_x") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open var linearLimitX_lowerDistance: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var linearLimitX_restitution: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var linearLimitX_softness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var linearLimitX_upperDistance: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var linearLimitY_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var linearLimitY_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_y") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_y") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open var linearLimitY_lowerDistance: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var linearLimitY_restitution: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var linearLimitY_softness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var linearLimitY_upperDistance: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var linearLimitZ_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var linearLimitZ_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_z") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_z") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open var linearLimitZ_lowerDistance: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var linearLimitZ_restitution: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var linearLimitZ_softness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var linearLimitZ_upperDistance: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var linearMotorX_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_x") return _icall_Boolean_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_x") _icall_Unit_Long_Boolean(mb, this.ptr, 5, value) } open var linearMotorX_forceLimit: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var linearMotorX_targetVelocity: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var linearMotorY_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_y") return _icall_Boolean_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_y") _icall_Unit_Long_Boolean(mb, this.ptr, 5, value) } open var linearMotorY_forceLimit: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var linearMotorY_targetVelocity: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var linearMotorZ_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_z") return _icall_Boolean_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_z") _icall_Unit_Long_Boolean(mb, this.ptr, 5, value) } open var linearMotorZ_forceLimit: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var linearMotorZ_targetVelocity: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var linearSpringX_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var linearSpringX_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_x") return _icall_Boolean_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_x") _icall_Unit_Long_Boolean(mb, this.ptr, 3, value) } open var linearSpringX_equilibriumPoint: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var linearSpringX_stiffness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var linearSpringY_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var linearSpringY_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_y") return _icall_Boolean_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_y") _icall_Unit_Long_Boolean(mb, this.ptr, 3, value) } open var linearSpringY_equilibriumPoint: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var linearSpringY_stiffness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var linearSpringZ_damping: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var linearSpringZ_enabled: Boolean get() { val mb = getMethodBind("Generic6DOFJoint","get_flag_z") return _icall_Boolean_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_flag_z") _icall_Unit_Long_Boolean(mb, this.ptr, 3, value) } open var linearSpringZ_equilibriumPoint: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var linearSpringZ_stiffness: Double get() { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var precision: Long get() { val mb = getMethodBind("Generic6DOFJoint","get_precision") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Generic6DOFJoint","set_precision") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Generic6DOFJoint", "Generic6DOFJoint") open fun _getAngularHiLimitX(): Double { throw NotImplementedError("_get_angular_hi_limit_x is not implemented for Generic6DOFJoint") } open fun _getAngularHiLimitY(): Double { throw NotImplementedError("_get_angular_hi_limit_y is not implemented for Generic6DOFJoint") } open fun _getAngularHiLimitZ(): Double { throw NotImplementedError("_get_angular_hi_limit_z is not implemented for Generic6DOFJoint") } open fun _getAngularLoLimitX(): Double { throw NotImplementedError("_get_angular_lo_limit_x is not implemented for Generic6DOFJoint") } open fun _getAngularLoLimitY(): Double { throw NotImplementedError("_get_angular_lo_limit_y is not implemented for Generic6DOFJoint") } open fun _getAngularLoLimitZ(): Double { throw NotImplementedError("_get_angular_lo_limit_z is not implemented for Generic6DOFJoint") } open fun _setAngularHiLimitX(angle: Double) { } open fun _setAngularHiLimitY(angle: Double) { } open fun _setAngularHiLimitZ(angle: Double) { } open fun _setAngularLoLimitX(angle: Double) { } open fun _setAngularLoLimitY(angle: Double) { } open fun _setAngularLoLimitZ(angle: Double) { } open fun getFlagX(flag: Long): Boolean { val mb = getMethodBind("Generic6DOFJoint","get_flag_x") return _icall_Boolean_Long( mb, this.ptr, flag) } open fun getFlagY(flag: Long): Boolean { val mb = getMethodBind("Generic6DOFJoint","get_flag_y") return _icall_Boolean_Long( mb, this.ptr, flag) } open fun getFlagZ(flag: Long): Boolean { val mb = getMethodBind("Generic6DOFJoint","get_flag_z") return _icall_Boolean_Long( mb, this.ptr, flag) } open fun getParamX(param: Long): Double { val mb = getMethodBind("Generic6DOFJoint","get_param_x") return _icall_Double_Long( mb, this.ptr, param) } open fun getParamY(param: Long): Double { val mb = getMethodBind("Generic6DOFJoint","get_param_y") return _icall_Double_Long( mb, this.ptr, param) } open fun getParamZ(param: Long): Double { val mb = getMethodBind("Generic6DOFJoint","get_param_z") return _icall_Double_Long( mb, this.ptr, param) } open fun getPrecision(): Long { val mb = getMethodBind("Generic6DOFJoint","get_precision") return _icall_Long( mb, this.ptr) } open fun setFlagX(flag: Long, value: Boolean) { val mb = getMethodBind("Generic6DOFJoint","set_flag_x") _icall_Unit_Long_Boolean( mb, this.ptr, flag, value) } open fun setFlagY(flag: Long, value: Boolean) { val mb = getMethodBind("Generic6DOFJoint","set_flag_y") _icall_Unit_Long_Boolean( mb, this.ptr, flag, value) } open fun setFlagZ(flag: Long, value: Boolean) { val mb = getMethodBind("Generic6DOFJoint","set_flag_z") _icall_Unit_Long_Boolean( mb, this.ptr, flag, value) } open fun setParamX(param: Long, value: Double) { val mb = getMethodBind("Generic6DOFJoint","set_param_x") _icall_Unit_Long_Double( mb, this.ptr, param, value) } open fun setParamY(param: Long, value: Double) { val mb = getMethodBind("Generic6DOFJoint","set_param_y") _icall_Unit_Long_Double( mb, this.ptr, param, value) } open fun setParamZ(param: Long, value: Double) { val mb = getMethodBind("Generic6DOFJoint","set_param_z") _icall_Unit_Long_Double( mb, this.ptr, param, value) } open fun setPrecision(precision: Long) { val mb = getMethodBind("Generic6DOFJoint","set_precision") _icall_Unit_Long( mb, this.ptr, precision) } enum class Param( id: Long ) { PARAM_LINEAR_LOWER_LIMIT(0), PARAM_LINEAR_UPPER_LIMIT(1), PARAM_LINEAR_LIMIT_SOFTNESS(2), PARAM_LINEAR_RESTITUTION(3), PARAM_LINEAR_DAMPING(4), PARAM_LINEAR_MOTOR_TARGET_VELOCITY(5), PARAM_LINEAR_MOTOR_FORCE_LIMIT(6), PARAM_LINEAR_SPRING_STIFFNESS(7), PARAM_LINEAR_SPRING_DAMPING(8), PARAM_LINEAR_SPRING_EQUILIBRIUM_POINT(9), PARAM_ANGULAR_LOWER_LIMIT(10), PARAM_ANGULAR_UPPER_LIMIT(11), PARAM_ANGULAR_LIMIT_SOFTNESS(12), PARAM_ANGULAR_DAMPING(13), PARAM_ANGULAR_RESTITUTION(14), PARAM_ANGULAR_FORCE_LIMIT(15), PARAM_ANGULAR_ERP(16), PARAM_ANGULAR_MOTOR_TARGET_VELOCITY(17), PARAM_ANGULAR_MOTOR_FORCE_LIMIT(18), PARAM_ANGULAR_SPRING_STIFFNESS(19), PARAM_ANGULAR_SPRING_DAMPING(20), PARAM_ANGULAR_SPRING_EQUILIBRIUM_POINT(21), PARAM_MAX(22); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Flag( id: Long ) { FLAG_ENABLE_LINEAR_LIMIT(0), FLAG_ENABLE_ANGULAR_LIMIT(1), FLAG_ENABLE_ANGULAR_SPRING(2), FLAG_ENABLE_LINEAR_SPRING(3), FLAG_ENABLE_MOTOR(4), FLAG_ENABLE_LINEAR_MOTOR(5), FLAG_MAX(6); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Geometry.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.Godot import godot.core.Plane import godot.core.PoolIntArray import godot.core.PoolVector2Array import godot.core.PoolVector3Array import godot.core.Variant import godot.core.VariantArray import godot.core.Vector2 import godot.core.Vector3 import godot.icalls._icall_Boolean_PoolVector2Array import godot.icalls._icall_Boolean_Vector2_PoolVector2Array import godot.icalls._icall_Boolean_Vector2_Vector2_Double import godot.icalls._icall_Boolean_Vector2_Vector2_Vector2_Vector2 import godot.icalls._icall_Dictionary_PoolVector2Array import godot.icalls._icall_Double_Vector2_Vector2_Vector2_Double import godot.icalls._icall_Long_Vector3 import godot.icalls._icall_PoolIntArray_PoolVector2Array import godot.icalls._icall_PoolVector2Array_PoolVector2Array import godot.icalls._icall_PoolVector2Array_Vector2_Vector2_Vector2_Vector2 import godot.icalls._icall_PoolVector3Array_PoolVector3Array_Plane import godot.icalls._icall_PoolVector3Array_Vector3_Vector3_Double_Double import godot.icalls._icall_PoolVector3Array_Vector3_Vector3_VariantArray import godot.icalls._icall_PoolVector3Array_Vector3_Vector3_Vector3_Double import godot.icalls._icall_PoolVector3Array_Vector3_Vector3_Vector3_Vector3 import godot.icalls._icall_VariantArray_Double_Double_Long_Long import godot.icalls._icall_VariantArray_Double_Double_Long_Long_Long import godot.icalls._icall_VariantArray_PoolVector2Array_Double_Long import godot.icalls._icall_VariantArray_PoolVector2Array_Double_Long_Long import godot.icalls._icall_VariantArray_PoolVector2Array_PoolVector2Array import godot.icalls._icall_VariantArray_Vector3 import godot.icalls._icall_Variant_Vector2_Vector2_Vector2_Vector2 import godot.icalls._icall_Variant_Vector3_Vector3_Vector3_Vector3_Vector3 import godot.icalls._icall_Vector2_Vector2_Vector2_Vector2 import godot.icalls._icall_Vector3_Vector3_Vector3_Vector3 import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object Geometry : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("Geometry".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton Geometry" } ptr } fun buildBoxPlanes(extents: Vector3): VariantArray { val mb = getMethodBind("_Geometry","build_box_planes") return _icall_VariantArray_Vector3( mb, this.ptr, extents) } fun buildCapsulePlanes( radius: Double, height: Double, sides: Long, lats: Long, axis: Long = 2 ): VariantArray { val mb = getMethodBind("_Geometry","build_capsule_planes") return _icall_VariantArray_Double_Double_Long_Long_Long( mb, this.ptr, radius, height, sides, lats, axis) } fun buildCylinderPlanes( radius: Double, height: Double, sides: Long, axis: Long = 2 ): VariantArray { val mb = getMethodBind("_Geometry","build_cylinder_planes") return _icall_VariantArray_Double_Double_Long_Long( mb, this.ptr, radius, height, sides, axis) } fun clipPolygon(points: PoolVector3Array, plane: Plane): PoolVector3Array { val mb = getMethodBind("_Geometry","clip_polygon") return _icall_PoolVector3Array_PoolVector3Array_Plane( mb, this.ptr, points, plane) } fun clipPolygons2d(polygonA: PoolVector2Array, polygonB: PoolVector2Array): VariantArray { val mb = getMethodBind("_Geometry","clip_polygons_2d") return _icall_VariantArray_PoolVector2Array_PoolVector2Array( mb, this.ptr, polygonA, polygonB) } fun clipPolylineWithPolygon2d(polyline: PoolVector2Array, polygon: PoolVector2Array): VariantArray { val mb = getMethodBind("_Geometry","clip_polyline_with_polygon_2d") return _icall_VariantArray_PoolVector2Array_PoolVector2Array( mb, this.ptr, polyline, polygon) } fun convexHull2d(points: PoolVector2Array): PoolVector2Array { val mb = getMethodBind("_Geometry","convex_hull_2d") return _icall_PoolVector2Array_PoolVector2Array( mb, this.ptr, points) } fun excludePolygons2d(polygonA: PoolVector2Array, polygonB: PoolVector2Array): VariantArray { val mb = getMethodBind("_Geometry","exclude_polygons_2d") return _icall_VariantArray_PoolVector2Array_PoolVector2Array( mb, this.ptr, polygonA, polygonB) } fun getClosestPointToSegment( point: Vector3, s1: Vector3, s2: Vector3 ): Vector3 { val mb = getMethodBind("_Geometry","get_closest_point_to_segment") return _icall_Vector3_Vector3_Vector3_Vector3( mb, this.ptr, point, s1, s2) } fun getClosestPointToSegment2d( point: Vector2, s1: Vector2, s2: Vector2 ): Vector2 { val mb = getMethodBind("_Geometry","get_closest_point_to_segment_2d") return _icall_Vector2_Vector2_Vector2_Vector2( mb, this.ptr, point, s1, s2) } fun getClosestPointToSegmentUncapped( point: Vector3, s1: Vector3, s2: Vector3 ): Vector3 { val mb = getMethodBind("_Geometry","get_closest_point_to_segment_uncapped") return _icall_Vector3_Vector3_Vector3_Vector3( mb, this.ptr, point, s1, s2) } fun getClosestPointToSegmentUncapped2d( point: Vector2, s1: Vector2, s2: Vector2 ): Vector2 { val mb = getMethodBind("_Geometry","get_closest_point_to_segment_uncapped_2d") return _icall_Vector2_Vector2_Vector2_Vector2( mb, this.ptr, point, s1, s2) } fun getClosestPointsBetweenSegments( p1: Vector3, p2: Vector3, q1: Vector3, q2: Vector3 ): PoolVector3Array { val mb = getMethodBind("_Geometry","get_closest_points_between_segments") return _icall_PoolVector3Array_Vector3_Vector3_Vector3_Vector3( mb, this.ptr, p1, p2, q1, q2) } fun getClosestPointsBetweenSegments2d( p1: Vector2, q1: Vector2, p2: Vector2, q2: Vector2 ): PoolVector2Array { val mb = getMethodBind("_Geometry","get_closest_points_between_segments_2d") return _icall_PoolVector2Array_Vector2_Vector2_Vector2_Vector2( mb, this.ptr, p1, q1, p2, q2) } fun getUv84NormalBit(normal: Vector3): Long { val mb = getMethodBind("_Geometry","get_uv84_normal_bit") return _icall_Long_Vector3( mb, this.ptr, normal) } fun intersectPolygons2d(polygonA: PoolVector2Array, polygonB: PoolVector2Array): VariantArray { val mb = getMethodBind("_Geometry","intersect_polygons_2d") return _icall_VariantArray_PoolVector2Array_PoolVector2Array( mb, this.ptr, polygonA, polygonB) } fun intersectPolylineWithPolygon2d(polyline: PoolVector2Array, polygon: PoolVector2Array): VariantArray { val mb = getMethodBind("_Geometry","intersect_polyline_with_polygon_2d") return _icall_VariantArray_PoolVector2Array_PoolVector2Array( mb, this.ptr, polyline, polygon) } fun isPointInCircle( point: Vector2, circlePosition: Vector2, circleRadius: Double ): Boolean { val mb = getMethodBind("_Geometry","is_point_in_circle") return _icall_Boolean_Vector2_Vector2_Double( mb, this.ptr, point, circlePosition, circleRadius) } fun isPointInPolygon(point: Vector2, polygon: PoolVector2Array): Boolean { val mb = getMethodBind("_Geometry","is_point_in_polygon") return _icall_Boolean_Vector2_PoolVector2Array( mb, this.ptr, point, polygon) } fun isPolygonClockwise(polygon: PoolVector2Array): Boolean { val mb = getMethodBind("_Geometry","is_polygon_clockwise") return _icall_Boolean_PoolVector2Array( mb, this.ptr, polygon) } fun lineIntersectsLine2d( fromA: Vector2, dirA: Vector2, fromB: Vector2, dirB: Vector2 ): Variant { val mb = getMethodBind("_Geometry","line_intersects_line_2d") return _icall_Variant_Vector2_Vector2_Vector2_Vector2( mb, this.ptr, fromA, dirA, fromB, dirB) } fun makeAtlas(sizes: PoolVector2Array): Dictionary { val mb = getMethodBind("_Geometry","make_atlas") return _icall_Dictionary_PoolVector2Array( mb, this.ptr, sizes) } fun mergePolygons2d(polygonA: PoolVector2Array, polygonB: PoolVector2Array): VariantArray { val mb = getMethodBind("_Geometry","merge_polygons_2d") return _icall_VariantArray_PoolVector2Array_PoolVector2Array( mb, this.ptr, polygonA, polygonB) } fun offsetPolygon2d( polygon: PoolVector2Array, delta: Double, joinType: Long = 0 ): VariantArray { val mb = getMethodBind("_Geometry","offset_polygon_2d") return _icall_VariantArray_PoolVector2Array_Double_Long( mb, this.ptr, polygon, delta, joinType) } fun offsetPolyline2d( polyline: PoolVector2Array, delta: Double, joinType: Long = 0, endType: Long = 3 ): VariantArray { val mb = getMethodBind("_Geometry","offset_polyline_2d") return _icall_VariantArray_PoolVector2Array_Double_Long_Long( mb, this.ptr, polyline, delta, joinType, endType) } fun pointIsInsideTriangle( point: Vector2, a: Vector2, b: Vector2, c: Vector2 ): Boolean { val mb = getMethodBind("_Geometry","point_is_inside_triangle") return _icall_Boolean_Vector2_Vector2_Vector2_Vector2( mb, this.ptr, point, a, b, c) } fun rayIntersectsTriangle( from: Vector3, dir: Vector3, a: Vector3, b: Vector3, c: Vector3 ): Variant { val mb = getMethodBind("_Geometry","ray_intersects_triangle") return _icall_Variant_Vector3_Vector3_Vector3_Vector3_Vector3( mb, this.ptr, from, dir, a, b, c) } fun segmentIntersectsCircle( segmentFrom: Vector2, segmentTo: Vector2, circlePosition: Vector2, circleRadius: Double ): Double { val mb = getMethodBind("_Geometry","segment_intersects_circle") return _icall_Double_Vector2_Vector2_Vector2_Double( mb, this.ptr, segmentFrom, segmentTo, circlePosition, circleRadius) } fun segmentIntersectsConvex( from: Vector3, to: Vector3, planes: VariantArray ): PoolVector3Array { val mb = getMethodBind("_Geometry","segment_intersects_convex") return _icall_PoolVector3Array_Vector3_Vector3_VariantArray( mb, this.ptr, from, to, planes) } fun segmentIntersectsCylinder( from: Vector3, to: Vector3, height: Double, radius: Double ): PoolVector3Array { val mb = getMethodBind("_Geometry","segment_intersects_cylinder") return _icall_PoolVector3Array_Vector3_Vector3_Double_Double( mb, this.ptr, from, to, height, radius) } fun segmentIntersectsSegment2d( fromA: Vector2, toA: Vector2, fromB: Vector2, toB: Vector2 ): Variant { val mb = getMethodBind("_Geometry","segment_intersects_segment_2d") return _icall_Variant_Vector2_Vector2_Vector2_Vector2( mb, this.ptr, fromA, toA, fromB, toB) } fun segmentIntersectsSphere( from: Vector3, to: Vector3, spherePosition: Vector3, sphereRadius: Double ): PoolVector3Array { val mb = getMethodBind("_Geometry","segment_intersects_sphere") return _icall_PoolVector3Array_Vector3_Vector3_Vector3_Double( mb, this.ptr, from, to, spherePosition, sphereRadius) } fun segmentIntersectsTriangle( from: Vector3, to: Vector3, a: Vector3, b: Vector3, c: Vector3 ): Variant { val mb = getMethodBind("_Geometry","segment_intersects_triangle") return _icall_Variant_Vector3_Vector3_Vector3_Vector3_Vector3( mb, this.ptr, from, to, a, b, c) } fun triangulateDelaunay2d(points: PoolVector2Array): PoolIntArray { val mb = getMethodBind("_Geometry","triangulate_delaunay_2d") return _icall_PoolIntArray_PoolVector2Array( mb, this.ptr, points) } fun triangulatePolygon(polygon: PoolVector2Array): PoolIntArray { val mb = getMethodBind("_Geometry","triangulate_polygon") return _icall_PoolIntArray_PoolVector2Array( mb, this.ptr, polygon) } enum class PolyEndType( id: Long ) { END_POLYGON(0), END_JOINED(1), END_BUTT(2), END_SQUARE(3), END_ROUND(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class PolyBooleanOperation( id: Long ) { OPERATION_UNION(0), OPERATION_DIFFERENCE(1), OPERATION_INTERSECTION(2), OPERATION_XOR(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class PolyJoinType( id: Long ) { JOIN_SQUARE(0), JOIN_ROUND(1), JOIN_MITER(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GeometryInstance.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.GeometryInstance import godot.core.AABB import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Material import godot.icalls._icall_Unit_AABB import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long open class GeometryInstance internal constructor() : VisualInstance() { open var castShadow: Long get() { val mb = getMethodBind("GeometryInstance","get_cast_shadows_setting") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GeometryInstance","set_cast_shadows_setting") _icall_Unit_Long(mb, this.ptr, value) } open var extraCullMargin: Double get() { val mb = getMethodBind("GeometryInstance","get_extra_cull_margin") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GeometryInstance","set_extra_cull_margin") _icall_Unit_Double(mb, this.ptr, value) } open var lodMaxDistance: Double get() { val mb = getMethodBind("GeometryInstance","get_lod_max_distance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GeometryInstance","set_lod_max_distance") _icall_Unit_Double(mb, this.ptr, value) } open var lodMaxHysteresis: Double get() { val mb = getMethodBind("GeometryInstance","get_lod_max_hysteresis") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GeometryInstance","set_lod_max_hysteresis") _icall_Unit_Double(mb, this.ptr, value) } open var lodMinDistance: Double get() { val mb = getMethodBind("GeometryInstance","get_lod_min_distance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GeometryInstance","set_lod_min_distance") _icall_Unit_Double(mb, this.ptr, value) } open var lodMinHysteresis: Double get() { val mb = getMethodBind("GeometryInstance","get_lod_min_hysteresis") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GeometryInstance","set_lod_min_hysteresis") _icall_Unit_Double(mb, this.ptr, value) } open var materialOverride: Material get() { val mb = getMethodBind("GeometryInstance","get_material_override") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("GeometryInstance","set_material_override") _icall_Unit_Object(mb, this.ptr, value) } open var useInBakedLight: Boolean get() { val mb = getMethodBind("GeometryInstance","get_flag") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("GeometryInstance","set_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open fun getCastShadowsSetting(): GeometryInstance.ShadowCastingSetting { val mb = getMethodBind("GeometryInstance","get_cast_shadows_setting") return GeometryInstance.ShadowCastingSetting.from( _icall_Long( mb, this.ptr)) } open fun getExtraCullMargin(): Double { val mb = getMethodBind("GeometryInstance","get_extra_cull_margin") return _icall_Double( mb, this.ptr) } open fun getFlag(flag: Long): Boolean { val mb = getMethodBind("GeometryInstance","get_flag") return _icall_Boolean_Long( mb, this.ptr, flag) } open fun getLodMaxDistance(): Double { val mb = getMethodBind("GeometryInstance","get_lod_max_distance") return _icall_Double( mb, this.ptr) } open fun getLodMaxHysteresis(): Double { val mb = getMethodBind("GeometryInstance","get_lod_max_hysteresis") return _icall_Double( mb, this.ptr) } open fun getLodMinDistance(): Double { val mb = getMethodBind("GeometryInstance","get_lod_min_distance") return _icall_Double( mb, this.ptr) } open fun getLodMinHysteresis(): Double { val mb = getMethodBind("GeometryInstance","get_lod_min_hysteresis") return _icall_Double( mb, this.ptr) } open fun getMaterialOverride(): Material { val mb = getMethodBind("GeometryInstance","get_material_override") return _icall_Material( mb, this.ptr) } open fun setCastShadowsSetting(shadowCastingSetting: Long) { val mb = getMethodBind("GeometryInstance","set_cast_shadows_setting") _icall_Unit_Long( mb, this.ptr, shadowCastingSetting) } open fun setCustomAabb(aabb: AABB) { val mb = getMethodBind("GeometryInstance","set_custom_aabb") _icall_Unit_AABB( mb, this.ptr, aabb) } open fun setExtraCullMargin(margin: Double) { val mb = getMethodBind("GeometryInstance","set_extra_cull_margin") _icall_Unit_Double( mb, this.ptr, margin) } open fun setFlag(flag: Long, value: Boolean) { val mb = getMethodBind("GeometryInstance","set_flag") _icall_Unit_Long_Boolean( mb, this.ptr, flag, value) } open fun setLodMaxDistance(mode: Double) { val mb = getMethodBind("GeometryInstance","set_lod_max_distance") _icall_Unit_Double( mb, this.ptr, mode) } open fun setLodMaxHysteresis(mode: Double) { val mb = getMethodBind("GeometryInstance","set_lod_max_hysteresis") _icall_Unit_Double( mb, this.ptr, mode) } open fun setLodMinDistance(mode: Double) { val mb = getMethodBind("GeometryInstance","set_lod_min_distance") _icall_Unit_Double( mb, this.ptr, mode) } open fun setLodMinHysteresis(mode: Double) { val mb = getMethodBind("GeometryInstance","set_lod_min_hysteresis") _icall_Unit_Double( mb, this.ptr, mode) } open fun setMaterialOverride(material: Material) { val mb = getMethodBind("GeometryInstance","set_material_override") _icall_Unit_Object( mb, this.ptr, material) } enum class Flags( id: Long ) { FLAG_USE_BAKED_LIGHT(0), FLAG_DRAW_NEXT_FRAME_IF_VISIBLE(1), FLAG_MAX(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ShadowCastingSetting( id: Long ) { SHADOW_CASTING_SETTING_OFF(0), SHADOW_CASTING_SETTING_ON(1), SHADOW_CASTING_SETTING_DOUBLE_SIDED(2), SHADOW_CASTING_SETTING_SHADOWS_ONLY(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GlobalConstants.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.internal.type.nullSafe import kotlin.Long import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object GlobalConstants : Object() { final const val BUTTON_LEFT: Long = 1 final const val BUTTON_MASK_LEFT: Long = 1 final const val BUTTON_MASK_MIDDLE: Long = 4 final const val BUTTON_MASK_RIGHT: Long = 2 final const val BUTTON_MASK_XBUTTON1: Long = 128 final const val BUTTON_MASK_XBUTTON2: Long = 256 final const val BUTTON_MIDDLE: Long = 3 final const val BUTTON_RIGHT: Long = 2 final const val BUTTON_WHEEL_DOWN: Long = 5 final const val BUTTON_WHEEL_LEFT: Long = 6 final const val BUTTON_WHEEL_RIGHT: Long = 7 final const val BUTTON_WHEEL_UP: Long = 4 final const val BUTTON_XBUTTON1: Long = 8 final const val BUTTON_XBUTTON2: Long = 9 final const val CORNER_BOTTOM_LEFT: Long = 3 final const val CORNER_BOTTOM_RIGHT: Long = 2 final const val CORNER_TOP_LEFT: Long = 0 final const val CORNER_TOP_RIGHT: Long = 1 final const val ERR_ALREADY_EXISTS: Long = 32 final const val ERR_ALREADY_IN_USE: Long = 22 final const val ERR_BUG: Long = 47 final const val ERR_BUSY: Long = 44 final const val ERR_CANT_ACQUIRE_RESOURCE: Long = 28 final const val ERR_CANT_CONNECT: Long = 25 final const val ERR_CANT_CREATE: Long = 20 final const val ERR_CANT_FORK: Long = 29 final const val ERR_CANT_OPEN: Long = 19 final const val ERR_CANT_RESOLVE: Long = 26 final const val ERR_COMPILATION_FAILED: Long = 36 final const val ERR_CONNECTION_ERROR: Long = 27 final const val ERR_CYCLIC_LINK: Long = 40 final const val ERR_DATABASE_CANT_READ: Long = 34 final const val ERR_DATABASE_CANT_WRITE: Long = 35 final const val ERR_DOES_NOT_EXIST: Long = 33 final const val ERR_DUPLICATE_SYMBOL: Long = 42 final const val ERR_FILE_ALREADY_IN_USE: Long = 11 final const val ERR_FILE_BAD_DRIVE: Long = 8 final const val ERR_FILE_BAD_PATH: Long = 9 final const val ERR_FILE_CANT_OPEN: Long = 12 final const val ERR_FILE_CANT_READ: Long = 14 final const val ERR_FILE_CANT_WRITE: Long = 13 final const val ERR_FILE_CORRUPT: Long = 16 final const val ERR_FILE_EOF: Long = 18 final const val ERR_FILE_MISSING_DEPENDENCIES: Long = 17 final const val ERR_FILE_NOT_FOUND: Long = 7 final const val ERR_FILE_NO_PERMISSION: Long = 10 final const val ERR_FILE_UNRECOGNIZED: Long = 15 final const val ERR_HELP: Long = 46 final const val ERR_INVALID_DATA: Long = 30 final const val ERR_INVALID_DECLARATION: Long = 41 final const val ERR_INVALID_PARAMETER: Long = 31 final const val ERR_LINK_FAILED: Long = 38 final const val ERR_LOCKED: Long = 23 final const val ERR_METHOD_NOT_FOUND: Long = 37 final const val ERR_OUT_OF_MEMORY: Long = 6 final const val ERR_PARAMETER_RANGE_ERROR: Long = 5 final const val ERR_PARSE_ERROR: Long = 43 final const val ERR_PRINTER_ON_FIRE: Long = 48 final const val ERR_QUERY_FAILED: Long = 21 final const val ERR_SCRIPT_FAILED: Long = 39 final const val ERR_SKIP: Long = 45 final const val ERR_TIMEOUT: Long = 24 final const val ERR_UNAUTHORIZED: Long = 4 final const val ERR_UNAVAILABLE: Long = 2 final const val ERR_UNCONFIGURED: Long = 3 final const val FAILED: Long = 1 final const val HALIGN_CENTER: Long = 1 final const val HALIGN_LEFT: Long = 0 final const val HALIGN_RIGHT: Long = 2 final const val HORIZONTAL: Long = 0 final const val JOY_ANALOG_L2: Long = 6 final const val JOY_ANALOG_LX: Long = 0 final const val JOY_ANALOG_LY: Long = 1 final const val JOY_ANALOG_R2: Long = 7 final const val JOY_ANALOG_RX: Long = 2 final const val JOY_ANALOG_RY: Long = 3 final const val JOY_AXIS_0: Long = 0 final const val JOY_AXIS_1: Long = 1 final const val JOY_AXIS_2: Long = 2 final const val JOY_AXIS_3: Long = 3 final const val JOY_AXIS_4: Long = 4 final const val JOY_AXIS_5: Long = 5 final const val JOY_AXIS_6: Long = 6 final const val JOY_AXIS_7: Long = 7 final const val JOY_AXIS_8: Long = 8 final const val JOY_AXIS_9: Long = 9 final const val JOY_AXIS_MAX: Long = 10 final const val JOY_BUTTON_0: Long = 0 final const val JOY_BUTTON_1: Long = 1 final const val JOY_BUTTON_10: Long = 10 final const val JOY_BUTTON_11: Long = 11 final const val JOY_BUTTON_12: Long = 12 final const val JOY_BUTTON_13: Long = 13 final const val JOY_BUTTON_14: Long = 14 final const val JOY_BUTTON_15: Long = 15 final const val JOY_BUTTON_2: Long = 2 final const val JOY_BUTTON_3: Long = 3 final const val JOY_BUTTON_4: Long = 4 final const val JOY_BUTTON_5: Long = 5 final const val JOY_BUTTON_6: Long = 6 final const val JOY_BUTTON_7: Long = 7 final const val JOY_BUTTON_8: Long = 8 final const val JOY_BUTTON_9: Long = 9 final const val JOY_BUTTON_MAX: Long = 16 final const val JOY_DPAD_DOWN: Long = 13 final const val JOY_DPAD_LEFT: Long = 14 final const val JOY_DPAD_RIGHT: Long = 15 final const val JOY_DPAD_UP: Long = 12 final const val JOY_DS_A: Long = 1 final const val JOY_DS_B: Long = 0 final const val JOY_DS_X: Long = 3 final const val JOY_DS_Y: Long = 2 final const val JOY_L: Long = 4 final const val JOY_L2: Long = 6 final const val JOY_L3: Long = 8 final const val JOY_OCULUS_AX: Long = 7 final const val JOY_OCULUS_BY: Long = 1 final const val JOY_OCULUS_MENU: Long = 3 final const val JOY_OPENVR_MENU: Long = 1 final const val JOY_OPENVR_TOUCHPADX: Long = 0 final const val JOY_OPENVR_TOUCHPADY: Long = 1 final const val JOY_R: Long = 5 final const val JOY_R2: Long = 7 final const val JOY_R3: Long = 9 final const val JOY_SELECT: Long = 10 final const val JOY_SONY_CIRCLE: Long = 1 final const val JOY_SONY_SQUARE: Long = 2 final const val JOY_SONY_TRIANGLE: Long = 3 final const val JOY_SONY_X: Long = 0 final const val JOY_START: Long = 11 final const val JOY_VR_ANALOG_GRIP: Long = 4 final const val JOY_VR_ANALOG_TRIGGER: Long = 2 final const val JOY_VR_GRIP: Long = 2 final const val JOY_VR_PAD: Long = 14 final const val JOY_VR_TRIGGER: Long = 15 final const val JOY_XBOX_A: Long = 0 final const val JOY_XBOX_B: Long = 1 final const val JOY_XBOX_X: Long = 2 final const val JOY_XBOX_Y: Long = 3 final const val KEY_0: Long = 48 final const val KEY_1: Long = 49 final const val KEY_2: Long = 50 final const val KEY_3: Long = 51 final const val KEY_4: Long = 52 final const val KEY_5: Long = 53 final const val KEY_6: Long = 54 final const val KEY_7: Long = 55 final const val KEY_8: Long = 56 final const val KEY_9: Long = 57 final const val KEY_A: Long = 65 final const val KEY_AACUTE: Long = 193 final const val KEY_ACIRCUMFLEX: Long = 194 final const val KEY_ACUTE: Long = 180 final const val KEY_ADIAERESIS: Long = 196 final const val KEY_AE: Long = 198 final const val KEY_AGRAVE: Long = 192 final const val KEY_ALT: Long = 16777240 final const val KEY_AMPERSAND: Long = 38 final const val KEY_APOSTROPHE: Long = 39 final const val KEY_ARING: Long = 197 final const val KEY_ASCIICIRCUM: Long = 94 final const val KEY_ASCIITILDE: Long = 126 final const val KEY_ASTERISK: Long = 42 final const val KEY_AT: Long = 64 final const val KEY_ATILDE: Long = 195 final const val KEY_B: Long = 66 final const val KEY_BACK: Long = 16777280 final const val KEY_BACKSLASH: Long = 92 final const val KEY_BACKSPACE: Long = 16777220 final const val KEY_BACKTAB: Long = 16777219 final const val KEY_BAR: Long = 124 final const val KEY_BASSBOOST: Long = 16777287 final const val KEY_BASSDOWN: Long = 16777289 final const val KEY_BASSUP: Long = 16777288 final const val KEY_BRACELEFT: Long = 123 final const val KEY_BRACERIGHT: Long = 125 final const val KEY_BRACKETLEFT: Long = 91 final const val KEY_BRACKETRIGHT: Long = 93 final const val KEY_BROKENBAR: Long = 166 final const val KEY_C: Long = 67 final const val KEY_CAPSLOCK: Long = 16777241 final const val KEY_CCEDILLA: Long = 199 final const val KEY_CEDILLA: Long = 184 final const val KEY_CENT: Long = 162 final const val KEY_CLEAR: Long = 16777228 final const val KEY_CODE_MASK: Long = 33554431 final const val KEY_COLON: Long = 58 final const val KEY_COMMA: Long = 44 final const val KEY_CONTROL: Long = 16777238 final const val KEY_COPYRIGHT: Long = 169 final const val KEY_CURRENCY: Long = 164 final const val KEY_D: Long = 68 final const val KEY_DEGREE: Long = 176 final const val KEY_DELETE: Long = 16777224 final const val KEY_DIAERESIS: Long = 168 final const val KEY_DIRECTION_L: Long = 16777266 final const val KEY_DIRECTION_R: Long = 16777267 final const val KEY_DIVISION: Long = 247 final const val KEY_DOLLAR: Long = 36 final const val KEY_DOWN: Long = 16777234 final const val KEY_E: Long = 69 final const val KEY_EACUTE: Long = 201 final const val KEY_ECIRCUMFLEX: Long = 202 final const val KEY_EDIAERESIS: Long = 203 final const val KEY_EGRAVE: Long = 200 final const val KEY_END: Long = 16777230 final const val KEY_ENTER: Long = 16777221 final const val KEY_EQUAL: Long = 61 final const val KEY_ESCAPE: Long = 16777217 final const val KEY_ETH: Long = 208 final const val KEY_EXCLAM: Long = 33 final const val KEY_EXCLAMDOWN: Long = 161 final const val KEY_F: Long = 70 final const val KEY_F1: Long = 16777244 final const val KEY_F10: Long = 16777253 final const val KEY_F11: Long = 16777254 final const val KEY_F12: Long = 16777255 final const val KEY_F13: Long = 16777256 final const val KEY_F14: Long = 16777257 final const val KEY_F15: Long = 16777258 final const val KEY_F16: Long = 16777259 final const val KEY_F2: Long = 16777245 final const val KEY_F3: Long = 16777246 final const val KEY_F4: Long = 16777247 final const val KEY_F5: Long = 16777248 final const val KEY_F6: Long = 16777249 final const val KEY_F7: Long = 16777250 final const val KEY_F8: Long = 16777251 final const val KEY_F9: Long = 16777252 final const val KEY_FAVORITES: Long = 16777298 final const val KEY_FORWARD: Long = 16777281 final const val KEY_G: Long = 71 final const val KEY_GREATER: Long = 62 final const val KEY_GUILLEMOTLEFT: Long = 171 final const val KEY_GUILLEMOTRIGHT: Long = 187 final const val KEY_H: Long = 72 final const val KEY_HELP: Long = 16777265 final const val KEY_HOME: Long = 16777229 final const val KEY_HOMEPAGE: Long = 16777297 final const val KEY_HYPER_L: Long = 16777263 final const val KEY_HYPER_R: Long = 16777264 final const val KEY_HYPHEN: Long = 173 final const val KEY_I: Long = 73 final const val KEY_IACUTE: Long = 205 final const val KEY_ICIRCUMFLEX: Long = 206 final const val KEY_IDIAERESIS: Long = 207 final const val KEY_IGRAVE: Long = 204 final const val KEY_INSERT: Long = 16777223 final const val KEY_J: Long = 74 final const val KEY_K: Long = 75 final const val KEY_KP_0: Long = 16777350 final const val KEY_KP_1: Long = 16777351 final const val KEY_KP_2: Long = 16777352 final const val KEY_KP_3: Long = 16777353 final const val KEY_KP_4: Long = 16777354 final const val KEY_KP_5: Long = 16777355 final const val KEY_KP_6: Long = 16777356 final const val KEY_KP_7: Long = 16777357 final const val KEY_KP_8: Long = 16777358 final const val KEY_KP_9: Long = 16777359 final const val KEY_KP_ADD: Long = 16777349 final const val KEY_KP_DIVIDE: Long = 16777346 final const val KEY_KP_ENTER: Long = 16777222 final const val KEY_KP_MULTIPLY: Long = 16777345 final const val KEY_KP_PERIOD: Long = 16777348 final const val KEY_KP_SUBTRACT: Long = 16777347 final const val KEY_L: Long = 76 final const val KEY_LAUNCH0: Long = 16777304 final const val KEY_LAUNCH1: Long = 16777305 final const val KEY_LAUNCH2: Long = 16777306 final const val KEY_LAUNCH3: Long = 16777307 final const val KEY_LAUNCH4: Long = 16777308 final const val KEY_LAUNCH5: Long = 16777309 final const val KEY_LAUNCH6: Long = 16777310 final const val KEY_LAUNCH7: Long = 16777311 final const val KEY_LAUNCH8: Long = 16777312 final const val KEY_LAUNCH9: Long = 16777313 final const val KEY_LAUNCHA: Long = 16777314 final const val KEY_LAUNCHB: Long = 16777315 final const val KEY_LAUNCHC: Long = 16777316 final const val KEY_LAUNCHD: Long = 16777317 final const val KEY_LAUNCHE: Long = 16777318 final const val KEY_LAUNCHF: Long = 16777319 final const val KEY_LAUNCHMAIL: Long = 16777302 final const val KEY_LAUNCHMEDIA: Long = 16777303 final const val KEY_LEFT: Long = 16777231 final const val KEY_LESS: Long = 60 final const val KEY_M: Long = 77 final const val KEY_MACRON: Long = 175 final const val KEY_MASCULINE: Long = 186 final const val KEY_MASK_ALT: Long = 67108864 final const val KEY_MASK_CMD: Long = 268435456 final const val KEY_MASK_CTRL: Long = 268435456 final const val KEY_MASK_GROUP_SWITCH: Long = 1073741824 final const val KEY_MASK_KPAD: Long = 536870912 final const val KEY_MASK_META: Long = 134217728 final const val KEY_MASK_SHIFT: Long = 33554432 final const val KEY_MEDIANEXT: Long = 16777295 final const val KEY_MEDIAPLAY: Long = 16777292 final const val KEY_MEDIAPREVIOUS: Long = 16777294 final const val KEY_MEDIARECORD: Long = 16777296 final const val KEY_MEDIASTOP: Long = 16777293 final const val KEY_MENU: Long = 16777262 final const val KEY_META: Long = 16777239 final const val KEY_MINUS: Long = 45 final const val KEY_MODIFIER_MASK: Long = -16777216 final const val KEY_MU: Long = 181 final const val KEY_MULTIPLY: Long = 215 final const val KEY_N: Long = 78 final const val KEY_NOBREAKSPACE: Long = 160 final const val KEY_NOTSIGN: Long = 172 final const val KEY_NTILDE: Long = 209 final const val KEY_NUMBERSIGN: Long = 35 final const val KEY_NUMLOCK: Long = 16777242 final const val KEY_O: Long = 79 final const val KEY_OACUTE: Long = 211 final const val KEY_OCIRCUMFLEX: Long = 212 final const val KEY_ODIAERESIS: Long = 214 final const val KEY_OGRAVE: Long = 210 final const val KEY_ONEHALF: Long = 189 final const val KEY_ONEQUARTER: Long = 188 final const val KEY_ONESUPERIOR: Long = 185 final const val KEY_OOBLIQUE: Long = 216 final const val KEY_OPENURL: Long = 16777301 final const val KEY_ORDFEMININE: Long = 170 final const val KEY_OTILDE: Long = 213 final const val KEY_P: Long = 80 final const val KEY_PAGEDOWN: Long = 16777236 final const val KEY_PAGEUP: Long = 16777235 final const val KEY_PARAGRAPH: Long = 182 final const val KEY_PARENLEFT: Long = 40 final const val KEY_PARENRIGHT: Long = 41 final const val KEY_PAUSE: Long = 16777225 final const val KEY_PERCENT: Long = 37 final const val KEY_PERIOD: Long = 46 final const val KEY_PERIODCENTERED: Long = 183 final const val KEY_PLUS: Long = 43 final const val KEY_PLUSMINUS: Long = 177 final const val KEY_PRINT: Long = 16777226 final const val KEY_Q: Long = 81 final const val KEY_QUESTION: Long = 63 final const val KEY_QUESTIONDOWN: Long = 191 final const val KEY_QUOTEDBL: Long = 34 final const val KEY_QUOTELEFT: Long = 96 final const val KEY_R: Long = 82 final const val KEY_REFRESH: Long = 16777283 final const val KEY_REGISTERED: Long = 174 final const val KEY_RIGHT: Long = 16777233 final const val KEY_S: Long = 83 final const val KEY_SCROLLLOCK: Long = 16777243 final const val KEY_SEARCH: Long = 16777299 final const val KEY_SECTION: Long = 167 final const val KEY_SEMICOLON: Long = 59 final const val KEY_SHIFT: Long = 16777237 final const val KEY_SLASH: Long = 47 final const val KEY_SPACE: Long = 32 final const val KEY_SSHARP: Long = 223 final const val KEY_STANDBY: Long = 16777300 final const val KEY_STERLING: Long = 163 final const val KEY_STOP: Long = 16777282 final const val KEY_SUPER_L: Long = 16777260 final const val KEY_SUPER_R: Long = 16777261 final const val KEY_SYSREQ: Long = 16777227 final const val KEY_T: Long = 84 final const val KEY_TAB: Long = 16777218 final const val KEY_THORN: Long = 222 final const val KEY_THREEQUARTERS: Long = 190 final const val KEY_THREESUPERIOR: Long = 179 final const val KEY_TREBLEDOWN: Long = 16777291 final const val KEY_TREBLEUP: Long = 16777290 final const val KEY_TWOSUPERIOR: Long = 178 final const val KEY_U: Long = 85 final const val KEY_UACUTE: Long = 218 final const val KEY_UCIRCUMFLEX: Long = 219 final const val KEY_UDIAERESIS: Long = 220 final const val KEY_UGRAVE: Long = 217 final const val KEY_UNDERSCORE: Long = 95 final const val KEY_UNKNOWN: Long = 33554431 final const val KEY_UP: Long = 16777232 final const val KEY_V: Long = 86 final const val KEY_VOLUMEDOWN: Long = 16777284 final const val KEY_VOLUMEMUTE: Long = 16777285 final const val KEY_VOLUMEUP: Long = 16777286 final const val KEY_W: Long = 87 final const val KEY_X: Long = 88 final const val KEY_Y: Long = 89 final const val KEY_YACUTE: Long = 221 final const val KEY_YDIAERESIS: Long = 255 final const val KEY_YEN: Long = 165 final const val KEY_Z: Long = 90 final const val MARGIN_BOTTOM: Long = 3 final const val MARGIN_LEFT: Long = 0 final const val MARGIN_RIGHT: Long = 2 final const val MARGIN_TOP: Long = 1 final const val METHOD_FLAGS_DEFAULT: Long = 1 final const val METHOD_FLAG_CONST: Long = 8 final const val METHOD_FLAG_EDITOR: Long = 2 final const val METHOD_FLAG_FROM_SCRIPT: Long = 64 final const val METHOD_FLAG_NORMAL: Long = 1 final const val METHOD_FLAG_NOSCRIPT: Long = 4 final const val METHOD_FLAG_REVERSE: Long = 16 final const val METHOD_FLAG_VIRTUAL: Long = 32 final const val MIDI_MESSAGE_AFTERTOUCH: Long = 10 final const val MIDI_MESSAGE_CHANNEL_PRESSURE: Long = 13 final const val MIDI_MESSAGE_CONTROL_CHANGE: Long = 11 final const val MIDI_MESSAGE_NOTE_OFF: Long = 8 final const val MIDI_MESSAGE_NOTE_ON: Long = 9 final const val MIDI_MESSAGE_PITCH_BEND: Long = 14 final const val MIDI_MESSAGE_PROGRAM_CHANGE: Long = 12 final const val OK: Long = 0 final const val OP_ADD: Long = 6 final const val OP_AND: Long = 20 final const val OP_BIT_AND: Long = 16 final const val OP_BIT_NEGATE: Long = 19 final const val OP_BIT_OR: Long = 17 final const val OP_BIT_XOR: Long = 18 final const val OP_DIVIDE: Long = 9 final const val OP_EQUAL: Long = 0 final const val OP_GREATER: Long = 4 final const val OP_GREATER_EQUAL: Long = 5 final const val OP_IN: Long = 24 final const val OP_LESS: Long = 2 final const val OP_LESS_EQUAL: Long = 3 final const val OP_MAX: Long = 25 final const val OP_MODULE: Long = 12 final const val OP_MULTIPLY: Long = 8 final const val OP_NEGATE: Long = 10 final const val OP_NOT: Long = 23 final const val OP_NOT_EQUAL: Long = 1 final const val OP_OR: Long = 21 final const val OP_POSITIVE: Long = 11 final const val OP_SHIFT_LEFT: Long = 14 final const val OP_SHIFT_RIGHT: Long = 15 final const val OP_STRING_CONCAT: Long = 13 final const val OP_SUBTRACT: Long = 7 final const val OP_XOR: Long = 22 final const val PROPERTY_HINT_COLOR_NO_ALPHA: Long = 20 final const val PROPERTY_HINT_DIR: Long = 14 final const val PROPERTY_HINT_ENUM: Long = 3 final const val PROPERTY_HINT_EXP_EASING: Long = 4 final const val PROPERTY_HINT_EXP_RANGE: Long = 2 final const val PROPERTY_HINT_FILE: Long = 13 final const val PROPERTY_HINT_FLAGS: Long = 8 final const val PROPERTY_HINT_GLOBAL_DIR: Long = 16 final const val PROPERTY_HINT_GLOBAL_FILE: Long = 15 final const val PROPERTY_HINT_IMAGE_COMPRESS_LOSSLESS: Long = 22 final const val PROPERTY_HINT_IMAGE_COMPRESS_LOSSY: Long = 21 final const val PROPERTY_HINT_KEY_ACCEL: Long = 7 final const val PROPERTY_HINT_LAYERS_2D_PHYSICS: Long = 10 final const val PROPERTY_HINT_LAYERS_2D_RENDER: Long = 9 final const val PROPERTY_HINT_LAYERS_3D_PHYSICS: Long = 12 final const val PROPERTY_HINT_LAYERS_3D_RENDER: Long = 11 final const val PROPERTY_HINT_LENGTH: Long = 5 final const val PROPERTY_HINT_MULTILINE_TEXT: Long = 18 final const val PROPERTY_HINT_NONE: Long = 0 final const val PROPERTY_HINT_PLACEHOLDER_TEXT: Long = 19 final const val PROPERTY_HINT_RANGE: Long = 1 final const val PROPERTY_HINT_RESOURCE_TYPE: Long = 17 final const val PROPERTY_USAGE_CATEGORY: Long = 256 final const val PROPERTY_USAGE_CHECKABLE: Long = 16 final const val PROPERTY_USAGE_CHECKED: Long = 32 final const val PROPERTY_USAGE_DEFAULT: Long = 7 final const val PROPERTY_USAGE_DEFAULT_INTL: Long = 71 final const val PROPERTY_USAGE_EDITOR: Long = 2 final const val PROPERTY_USAGE_EDITOR_HELPER: Long = 8 final const val PROPERTY_USAGE_GROUP: Long = 128 final const val PROPERTY_USAGE_INTERNATIONALIZED: Long = 64 final const val PROPERTY_USAGE_NETWORK: Long = 4 final const val PROPERTY_USAGE_NOEDITOR: Long = 5 final const val PROPERTY_USAGE_NO_INSTANCE_STATE: Long = 2048 final const val PROPERTY_USAGE_RESTART_IF_CHANGED: Long = 4096 final const val PROPERTY_USAGE_SCRIPT_VARIABLE: Long = 8192 final const val PROPERTY_USAGE_STORAGE: Long = 1 final const val SPKEY: Long = 16777216 final const val TYPE_AABB: Long = 11 final const val TYPE_ARRAY: Long = 19 final const val TYPE_BASIS: Long = 12 final const val TYPE_BOOL: Long = 1 final const val TYPE_COLOR: Long = 14 final const val TYPE_COLOR_ARRAY: Long = 26 final const val TYPE_DICTIONARY: Long = 18 final const val TYPE_INT: Long = 2 final const val TYPE_INT_ARRAY: Long = 21 final const val TYPE_MAX: Long = 27 final const val TYPE_NIL: Long = 0 final const val TYPE_NODE_PATH: Long = 15 final const val TYPE_OBJECT: Long = 17 final const val TYPE_PLANE: Long = 9 final const val TYPE_QUAT: Long = 10 final const val TYPE_RAW_ARRAY: Long = 20 final const val TYPE_REAL: Long = 3 final const val TYPE_REAL_ARRAY: Long = 22 final const val TYPE_RECT2: Long = 6 final const val TYPE_RID: Long = 16 final const val TYPE_STRING: Long = 4 final const val TYPE_STRING_ARRAY: Long = 23 final const val TYPE_TRANSFORM: Long = 13 final const val TYPE_TRANSFORM2D: Long = 8 final const val TYPE_VECTOR2: Long = 5 final const val TYPE_VECTOR2_ARRAY: Long = 24 final const val TYPE_VECTOR3: Long = 7 final const val TYPE_VECTOR3_ARRAY: Long = 25 final const val VALIGN_BOTTOM: Long = 2 final const val VALIGN_CENTER: Long = 1 final const val VALIGN_TOP: Long = 0 final const val VERTICAL: Long = 1 override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("GlobalConstants".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton GlobalConstants" } ptr } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Gradient.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.PoolColorArray import godot.core.PoolRealArray import godot.icalls._icall_Color_Double import godot.icalls._icall_Color_Long import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_PoolColorArray import godot.icalls._icall_PoolRealArray import godot.icalls._icall_Unit_Double_Color import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Color import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_PoolColorArray import godot.icalls._icall_Unit_PoolRealArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class Gradient : Resource() { open var colors: PoolColorArray get() { val mb = getMethodBind("Gradient","get_colors") return _icall_PoolColorArray(mb, this.ptr) } set(value) { val mb = getMethodBind("Gradient","set_colors") _icall_Unit_PoolColorArray(mb, this.ptr, value) } open var offsets: PoolRealArray get() { val mb = getMethodBind("Gradient","get_offsets") return _icall_PoolRealArray(mb, this.ptr) } set(value) { val mb = getMethodBind("Gradient","set_offsets") _icall_Unit_PoolRealArray(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Gradient", "Gradient") open fun addPoint(offset: Double, color: Color) { val mb = getMethodBind("Gradient","add_point") _icall_Unit_Double_Color( mb, this.ptr, offset, color) } open fun getColor(point: Long): Color { val mb = getMethodBind("Gradient","get_color") return _icall_Color_Long( mb, this.ptr, point) } open fun getColors(): PoolColorArray { val mb = getMethodBind("Gradient","get_colors") return _icall_PoolColorArray( mb, this.ptr) } open fun getOffset(point: Long): Double { val mb = getMethodBind("Gradient","get_offset") return _icall_Double_Long( mb, this.ptr, point) } open fun getOffsets(): PoolRealArray { val mb = getMethodBind("Gradient","get_offsets") return _icall_PoolRealArray( mb, this.ptr) } open fun getPointCount(): Long { val mb = getMethodBind("Gradient","get_point_count") return _icall_Long( mb, this.ptr) } open fun interpolate(offset: Double): Color { val mb = getMethodBind("Gradient","interpolate") return _icall_Color_Double( mb, this.ptr, offset) } open fun removePoint(offset: Long) { val mb = getMethodBind("Gradient","remove_point") _icall_Unit_Long( mb, this.ptr, offset) } open fun setColor(point: Long, color: Color) { val mb = getMethodBind("Gradient","set_color") _icall_Unit_Long_Color( mb, this.ptr, point, color) } open fun setColors(colors: PoolColorArray) { val mb = getMethodBind("Gradient","set_colors") _icall_Unit_PoolColorArray( mb, this.ptr, colors) } open fun setOffset(point: Long, offset: Double) { val mb = getMethodBind("Gradient","set_offset") _icall_Unit_Long_Double( mb, this.ptr, point, offset) } open fun setOffsets(offsets: PoolRealArray) { val mb = getMethodBind("Gradient","set_offsets") _icall_Unit_PoolRealArray( mb, this.ptr, offsets) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GradientTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Gradient import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.UninitializedPropertyAccessException import kotlinx.cinterop.COpaquePointer open class GradientTexture : Texture() { open var gradient: Gradient get() { val mb = getMethodBind("GradientTexture","get_gradient") return _icall_Gradient(mb, this.ptr) } set(value) { val mb = getMethodBind("GradientTexture","set_gradient") _icall_Unit_Object(mb, this.ptr, value) } open var width: Long get() { throw UninitializedPropertyAccessException("Cannot access property width: has no getter") } set(value) { val mb = getMethodBind("GradientTexture","set_width") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GradientTexture", "GradientTexture") open fun _update() { } open fun getGradient(): Gradient { val mb = getMethodBind("GradientTexture","get_gradient") return _icall_Gradient( mb, this.ptr) } open fun setGradient(gradient: Gradient) { val mb = getMethodBind("GradientTexture","set_gradient") _icall_Unit_Object( mb, this.ptr, gradient) } open fun setWidth(width: Long) { val mb = getMethodBind("GradientTexture","set_width") _icall_Unit_Long( mb, this.ptr, width) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GraphEdit.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal3 import godot.core.Signal4 import godot.core.VariantArray import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long_Long import godot.icalls._icall_Boolean_String_Long_String_Long import godot.icalls._icall_Double import godot.icalls._icall_HBoxContainer import godot.icalls._icall_Long import godot.icalls._icall_Long_String_Long_String_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String_Long_String_Long import godot.icalls._icall_Unit_String_Long_String_Long_Double import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class GraphEdit : Control() { val _beginNodeMove: Signal0 by signal() val _endNodeMove: Signal0 by signal() val connectionFromEmpty: Signal3 by signal("to", "to_slot", "release_position") val connectionRequest: Signal4 by signal("from", "from_slot", "to", "to_slot") val connectionToEmpty: Signal3 by signal("from", "from_slot", "release_position") val copyNodesRequest: Signal0 by signal() val deleteNodesRequest: Signal0 by signal() val disconnectionRequest: Signal4 by signal("from", "from_slot", "to", "to_slot") val duplicateNodesRequest: Signal0 by signal() val nodeSelected: Signal1 by signal("node") val nodeUnselected: Signal1 by signal("node") val pasteNodesRequest: Signal0 by signal() val popupRequest: Signal1 by signal("position") val scrollOffsetChanged: Signal1 by signal("ofs") open var rightDisconnects: Boolean get() { val mb = getMethodBind("GraphEdit","is_right_disconnects_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphEdit","set_right_disconnects") _icall_Unit_Boolean(mb, this.ptr, value) } open var scrollOffset: Vector2 get() { val mb = getMethodBind("GraphEdit","get_scroll_ofs") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphEdit","set_scroll_ofs") _icall_Unit_Vector2(mb, this.ptr, value) } open var snapDistance: Long get() { val mb = getMethodBind("GraphEdit","get_snap") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphEdit","set_snap") _icall_Unit_Long(mb, this.ptr, value) } open var useSnap: Boolean get() { val mb = getMethodBind("GraphEdit","is_using_snap") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphEdit","set_use_snap") _icall_Unit_Boolean(mb, this.ptr, value) } open var zoom: Double get() { val mb = getMethodBind("GraphEdit","get_zoom") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphEdit","set_zoom") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GraphEdit", "GraphEdit") open fun scrollOffset(schedule: Vector2.() -> Unit): Vector2 = scrollOffset.apply{ schedule(this) scrollOffset = this } open fun _connectionsLayerDraw() { } open fun _graphNodeMoved(arg0: Node) { } open fun _graphNodeRaised(arg0: Node) { } override fun _guiInput(arg0: InputEvent) { } open fun _scrollMoved(arg0: Double) { } open fun _snapToggled() { } open fun _snapValueChanged(arg0: Double) { } open fun _topLayerDraw() { } open fun _topLayerInput(arg0: InputEvent) { } open fun _updateScrollOffset() { } open fun _zoomMinus() { } open fun _zoomPlus() { } open fun _zoomReset() { } open fun addValidConnectionType(fromType: Long, toType: Long) { val mb = getMethodBind("GraphEdit","add_valid_connection_type") _icall_Unit_Long_Long( mb, this.ptr, fromType, toType) } open fun addValidLeftDisconnectType(type: Long) { val mb = getMethodBind("GraphEdit","add_valid_left_disconnect_type") _icall_Unit_Long( mb, this.ptr, type) } open fun addValidRightDisconnectType(type: Long) { val mb = getMethodBind("GraphEdit","add_valid_right_disconnect_type") _icall_Unit_Long( mb, this.ptr, type) } open fun clearConnections() { val mb = getMethodBind("GraphEdit","clear_connections") _icall_Unit( mb, this.ptr) } open fun connectNode( from: String, fromPort: Long, to: String, toPort: Long ): GodotError { val mb = getMethodBind("GraphEdit","connect_node") return GodotError.byValue( _icall_Long_String_Long_String_Long( mb, this.ptr, from, fromPort, to, toPort).toUInt()) } open fun disconnectNode( from: String, fromPort: Long, to: String, toPort: Long ) { val mb = getMethodBind("GraphEdit","disconnect_node") _icall_Unit_String_Long_String_Long( mb, this.ptr, from, fromPort, to, toPort) } open fun getConnectionList(): VariantArray { val mb = getMethodBind("GraphEdit","get_connection_list") return _icall_VariantArray( mb, this.ptr) } open fun getScrollOfs(): Vector2 { val mb = getMethodBind("GraphEdit","get_scroll_ofs") return _icall_Vector2( mb, this.ptr) } open fun getSnap(): Long { val mb = getMethodBind("GraphEdit","get_snap") return _icall_Long( mb, this.ptr) } open fun getZoom(): Double { val mb = getMethodBind("GraphEdit","get_zoom") return _icall_Double( mb, this.ptr) } open fun getZoomHbox(): HBoxContainer { val mb = getMethodBind("GraphEdit","get_zoom_hbox") return _icall_HBoxContainer( mb, this.ptr) } open fun isNodeConnected( from: String, fromPort: Long, to: String, toPort: Long ): Boolean { val mb = getMethodBind("GraphEdit","is_node_connected") return _icall_Boolean_String_Long_String_Long( mb, this.ptr, from, fromPort, to, toPort) } open fun isRightDisconnectsEnabled(): Boolean { val mb = getMethodBind("GraphEdit","is_right_disconnects_enabled") return _icall_Boolean( mb, this.ptr) } open fun isUsingSnap(): Boolean { val mb = getMethodBind("GraphEdit","is_using_snap") return _icall_Boolean( mb, this.ptr) } open fun isValidConnectionType(fromType: Long, toType: Long): Boolean { val mb = getMethodBind("GraphEdit","is_valid_connection_type") return _icall_Boolean_Long_Long( mb, this.ptr, fromType, toType) } open fun removeValidConnectionType(fromType: Long, toType: Long) { val mb = getMethodBind("GraphEdit","remove_valid_connection_type") _icall_Unit_Long_Long( mb, this.ptr, fromType, toType) } open fun removeValidLeftDisconnectType(type: Long) { val mb = getMethodBind("GraphEdit","remove_valid_left_disconnect_type") _icall_Unit_Long( mb, this.ptr, type) } open fun removeValidRightDisconnectType(type: Long) { val mb = getMethodBind("GraphEdit","remove_valid_right_disconnect_type") _icall_Unit_Long( mb, this.ptr, type) } open fun setConnectionActivity( from: String, fromPort: Long, to: String, toPort: Long, amount: Double ) { val mb = getMethodBind("GraphEdit","set_connection_activity") _icall_Unit_String_Long_String_Long_Double( mb, this.ptr, from, fromPort, to, toPort, amount) } open fun setRightDisconnects(enable: Boolean) { val mb = getMethodBind("GraphEdit","set_right_disconnects") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setScrollOfs(ofs: Vector2) { val mb = getMethodBind("GraphEdit","set_scroll_ofs") _icall_Unit_Vector2( mb, this.ptr, ofs) } open fun setSelected(node: Node) { val mb = getMethodBind("GraphEdit","set_selected") _icall_Unit_Object( mb, this.ptr, node) } open fun setSnap(pixels: Long) { val mb = getMethodBind("GraphEdit","set_snap") _icall_Unit_Long( mb, this.ptr, pixels) } open fun setUseSnap(enable: Boolean) { val mb = getMethodBind("GraphEdit","set_use_snap") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setZoom(pZoom: Double) { val mb = getMethodBind("GraphEdit","set_zoom") _icall_Unit_Double( mb, this.ptr, pZoom) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GraphNode.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.GraphNode import godot.core.Color import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal2 import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Color_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean_Long_Color_Boolean_Long_Color_nObject_nObject import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class GraphNode : Container() { val closeRequest: Signal0 by signal() val dragged: Signal2 by signal("from", "to") val offsetChanged: Signal0 by signal() val raiseRequest: Signal0 by signal() val resizeRequest: Signal1 by signal("new_minsize") open var comment: Boolean get() { val mb = getMethodBind("GraphNode","is_comment") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphNode","set_comment") _icall_Unit_Boolean(mb, this.ptr, value) } open var offset: Vector2 get() { val mb = getMethodBind("GraphNode","get_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphNode","set_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var overlay: Long get() { val mb = getMethodBind("GraphNode","get_overlay") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphNode","set_overlay") _icall_Unit_Long(mb, this.ptr, value) } open var resizable: Boolean get() { val mb = getMethodBind("GraphNode","is_resizable") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphNode","set_resizable") _icall_Unit_Boolean(mb, this.ptr, value) } open var selected: Boolean get() { val mb = getMethodBind("GraphNode","is_selected") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphNode","set_selected") _icall_Unit_Boolean(mb, this.ptr, value) } open var showClose: Boolean get() { val mb = getMethodBind("GraphNode","is_close_button_visible") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphNode","set_show_close_button") _icall_Unit_Boolean(mb, this.ptr, value) } open var title: String get() { val mb = getMethodBind("GraphNode","get_title") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("GraphNode","set_title") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GraphNode", "GraphNode") open fun offset(schedule: Vector2.() -> Unit): Vector2 = offset.apply{ schedule(this) offset = this } override fun _guiInput(arg0: InputEvent) { } open fun clearAllSlots() { val mb = getMethodBind("GraphNode","clear_all_slots") _icall_Unit( mb, this.ptr) } open fun clearSlot(idx: Long) { val mb = getMethodBind("GraphNode","clear_slot") _icall_Unit_Long( mb, this.ptr, idx) } open fun getConnectionInputColor(idx: Long): Color { val mb = getMethodBind("GraphNode","get_connection_input_color") return _icall_Color_Long( mb, this.ptr, idx) } open fun getConnectionInputCount(): Long { val mb = getMethodBind("GraphNode","get_connection_input_count") return _icall_Long( mb, this.ptr) } open fun getConnectionInputPosition(idx: Long): Vector2 { val mb = getMethodBind("GraphNode","get_connection_input_position") return _icall_Vector2_Long( mb, this.ptr, idx) } open fun getConnectionInputType(idx: Long): Long { val mb = getMethodBind("GraphNode","get_connection_input_type") return _icall_Long_Long( mb, this.ptr, idx) } open fun getConnectionOutputColor(idx: Long): Color { val mb = getMethodBind("GraphNode","get_connection_output_color") return _icall_Color_Long( mb, this.ptr, idx) } open fun getConnectionOutputCount(): Long { val mb = getMethodBind("GraphNode","get_connection_output_count") return _icall_Long( mb, this.ptr) } open fun getConnectionOutputPosition(idx: Long): Vector2 { val mb = getMethodBind("GraphNode","get_connection_output_position") return _icall_Vector2_Long( mb, this.ptr, idx) } open fun getConnectionOutputType(idx: Long): Long { val mb = getMethodBind("GraphNode","get_connection_output_type") return _icall_Long_Long( mb, this.ptr, idx) } open fun getOffset(): Vector2 { val mb = getMethodBind("GraphNode","get_offset") return _icall_Vector2( mb, this.ptr) } open fun getOverlay(): GraphNode.Overlay { val mb = getMethodBind("GraphNode","get_overlay") return GraphNode.Overlay.from( _icall_Long( mb, this.ptr)) } open fun getSlotColorLeft(idx: Long): Color { val mb = getMethodBind("GraphNode","get_slot_color_left") return _icall_Color_Long( mb, this.ptr, idx) } open fun getSlotColorRight(idx: Long): Color { val mb = getMethodBind("GraphNode","get_slot_color_right") return _icall_Color_Long( mb, this.ptr, idx) } open fun getSlotTypeLeft(idx: Long): Long { val mb = getMethodBind("GraphNode","get_slot_type_left") return _icall_Long_Long( mb, this.ptr, idx) } open fun getSlotTypeRight(idx: Long): Long { val mb = getMethodBind("GraphNode","get_slot_type_right") return _icall_Long_Long( mb, this.ptr, idx) } open fun getTitle(): String { val mb = getMethodBind("GraphNode","get_title") return _icall_String( mb, this.ptr) } open fun isCloseButtonVisible(): Boolean { val mb = getMethodBind("GraphNode","is_close_button_visible") return _icall_Boolean( mb, this.ptr) } open fun isComment(): Boolean { val mb = getMethodBind("GraphNode","is_comment") return _icall_Boolean( mb, this.ptr) } open fun isResizable(): Boolean { val mb = getMethodBind("GraphNode","is_resizable") return _icall_Boolean( mb, this.ptr) } open fun isSelected(): Boolean { val mb = getMethodBind("GraphNode","is_selected") return _icall_Boolean( mb, this.ptr) } open fun isSlotEnabledLeft(idx: Long): Boolean { val mb = getMethodBind("GraphNode","is_slot_enabled_left") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isSlotEnabledRight(idx: Long): Boolean { val mb = getMethodBind("GraphNode","is_slot_enabled_right") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun setComment(comment: Boolean) { val mb = getMethodBind("GraphNode","set_comment") _icall_Unit_Boolean( mb, this.ptr, comment) } open fun setOffset(offset: Vector2) { val mb = getMethodBind("GraphNode","set_offset") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun setOverlay(overlay: Long) { val mb = getMethodBind("GraphNode","set_overlay") _icall_Unit_Long( mb, this.ptr, overlay) } open fun setResizable(resizable: Boolean) { val mb = getMethodBind("GraphNode","set_resizable") _icall_Unit_Boolean( mb, this.ptr, resizable) } open fun setSelected(selected: Boolean) { val mb = getMethodBind("GraphNode","set_selected") _icall_Unit_Boolean( mb, this.ptr, selected) } open fun setShowCloseButton(show: Boolean) { val mb = getMethodBind("GraphNode","set_show_close_button") _icall_Unit_Boolean( mb, this.ptr, show) } open fun setSlot( idx: Long, enableLeft: Boolean, typeLeft: Long, colorLeft: Color, enableRight: Boolean, typeRight: Long, colorRight: Color, customLeft: Texture? = null, customRight: Texture? = null ) { val mb = getMethodBind("GraphNode","set_slot") _icall_Unit_Long_Boolean_Long_Color_Boolean_Long_Color_nObject_nObject( mb, this.ptr, idx, enableLeft, typeLeft, colorLeft, enableRight, typeRight, colorRight, customLeft, customRight) } open fun setTitle(title: String) { val mb = getMethodBind("GraphNode","set_title") _icall_Unit_String( mb, this.ptr, title) } enum class Overlay( id: Long ) { OVERLAY_DISABLED(0), OVERLAY_BREAKPOINT(1), OVERLAY_POSITION(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GridContainer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class GridContainer : Container() { open var columns: Long get() { val mb = getMethodBind("GridContainer","get_columns") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GridContainer","set_columns") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GridContainer", "GridContainer") open fun getColumns(): Long { val mb = getMethodBind("GridContainer","get_columns") return _icall_Long( mb, this.ptr) } open fun setColumns(columns: Long) { val mb = getMethodBind("GridContainer","set_columns") _icall_Unit_Long( mb, this.ptr, columns) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GridMap.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Signal1 import godot.core.VariantArray import godot.core.Vector3 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Long_Long_Long_Long import godot.icalls._icall_MeshLibrary import godot.icalls._icall_RID_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Boolean_Boolean_Long_Long import godot.icalls._icall_Unit_Boolean_Double import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Long_Long_Long_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector3 import godot.icalls._icall_Vector3_Long_Long_Long import godot.icalls._icall_Vector3_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class GridMap : Spatial() { val cellSizeChanged: Signal1 by signal("cell_size") open var cellCenterX: Boolean get() { val mb = getMethodBind("GridMap","get_center_x") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GridMap","set_center_x") _icall_Unit_Boolean(mb, this.ptr, value) } open var cellCenterY: Boolean get() { val mb = getMethodBind("GridMap","get_center_y") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GridMap","set_center_y") _icall_Unit_Boolean(mb, this.ptr, value) } open var cellCenterZ: Boolean get() { val mb = getMethodBind("GridMap","get_center_z") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("GridMap","set_center_z") _icall_Unit_Boolean(mb, this.ptr, value) } open var cellOctantSize: Long get() { val mb = getMethodBind("GridMap","get_octant_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GridMap","set_octant_size") _icall_Unit_Long(mb, this.ptr, value) } open var cellScale: Double get() { val mb = getMethodBind("GridMap","get_cell_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GridMap","set_cell_scale") _icall_Unit_Double(mb, this.ptr, value) } open var cellSize: Vector3 get() { val mb = getMethodBind("GridMap","get_cell_size") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("GridMap","set_cell_size") _icall_Unit_Vector3(mb, this.ptr, value) } open var collisionLayer: Long get() { val mb = getMethodBind("GridMap","get_collision_layer") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GridMap","set_collision_layer") _icall_Unit_Long(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("GridMap","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("GridMap","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open var meshLibrary: MeshLibrary get() { val mb = getMethodBind("GridMap","get_mesh_library") return _icall_MeshLibrary(mb, this.ptr) } set(value) { val mb = getMethodBind("GridMap","set_mesh_library") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GridMap", "GridMap") open fun cellSize(schedule: Vector3.() -> Unit): Vector3 = cellSize.apply{ schedule(this) cellSize = this } open fun _updateOctantsCallback() { } open fun clear() { val mb = getMethodBind("GridMap","clear") _icall_Unit( mb, this.ptr) } open fun clearBakedMeshes() { val mb = getMethodBind("GridMap","clear_baked_meshes") _icall_Unit( mb, this.ptr) } open fun getBakeMeshInstance(idx: Long): RID { val mb = getMethodBind("GridMap","get_bake_mesh_instance") return _icall_RID_Long( mb, this.ptr, idx) } open fun getBakeMeshes(): VariantArray { val mb = getMethodBind("GridMap","get_bake_meshes") return _icall_VariantArray( mb, this.ptr) } open fun getCellItem( x: Long, y: Long, z: Long ): Long { val mb = getMethodBind("GridMap","get_cell_item") return _icall_Long_Long_Long_Long( mb, this.ptr, x, y, z) } open fun getCellItemOrientation( x: Long, y: Long, z: Long ): Long { val mb = getMethodBind("GridMap","get_cell_item_orientation") return _icall_Long_Long_Long_Long( mb, this.ptr, x, y, z) } open fun getCellScale(): Double { val mb = getMethodBind("GridMap","get_cell_scale") return _icall_Double( mb, this.ptr) } open fun getCellSize(): Vector3 { val mb = getMethodBind("GridMap","get_cell_size") return _icall_Vector3( mb, this.ptr) } open fun getCenterX(): Boolean { val mb = getMethodBind("GridMap","get_center_x") return _icall_Boolean( mb, this.ptr) } open fun getCenterY(): Boolean { val mb = getMethodBind("GridMap","get_center_y") return _icall_Boolean( mb, this.ptr) } open fun getCenterZ(): Boolean { val mb = getMethodBind("GridMap","get_center_z") return _icall_Boolean( mb, this.ptr) } open fun getCollisionLayer(): Long { val mb = getMethodBind("GridMap","get_collision_layer") return _icall_Long( mb, this.ptr) } open fun getCollisionLayerBit(bit: Long): Boolean { val mb = getMethodBind("GridMap","get_collision_layer_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getCollisionMask(): Long { val mb = getMethodBind("GridMap","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("GridMap","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getMeshLibrary(): MeshLibrary { val mb = getMethodBind("GridMap","get_mesh_library") return _icall_MeshLibrary( mb, this.ptr) } open fun getMeshes(): VariantArray { val mb = getMethodBind("GridMap","get_meshes") return _icall_VariantArray( mb, this.ptr) } open fun getOctantSize(): Long { val mb = getMethodBind("GridMap","get_octant_size") return _icall_Long( mb, this.ptr) } open fun getUsedCells(): VariantArray { val mb = getMethodBind("GridMap","get_used_cells") return _icall_VariantArray( mb, this.ptr) } open fun makeBakedMeshes(genLightmapUv: Boolean = false, lightmapUvTexelSize: Double = 0.1) { val mb = getMethodBind("GridMap","make_baked_meshes") _icall_Unit_Boolean_Double( mb, this.ptr, genLightmapUv, lightmapUvTexelSize) } open fun mapToWorld( x: Long, y: Long, z: Long ): Vector3 { val mb = getMethodBind("GridMap","map_to_world") return _icall_Vector3_Long_Long_Long( mb, this.ptr, x, y, z) } open fun resourceChanged(resource: Resource) { val mb = getMethodBind("GridMap","resource_changed") _icall_Unit_Object( mb, this.ptr, resource) } open fun setCellItem( x: Long, y: Long, z: Long, item: Long, orientation: Long = 0 ) { val mb = getMethodBind("GridMap","set_cell_item") _icall_Unit_Long_Long_Long_Long_Long( mb, this.ptr, x, y, z, item, orientation) } open fun setCellScale(scale: Double) { val mb = getMethodBind("GridMap","set_cell_scale") _icall_Unit_Double( mb, this.ptr, scale) } open fun setCellSize(size: Vector3) { val mb = getMethodBind("GridMap","set_cell_size") _icall_Unit_Vector3( mb, this.ptr, size) } open fun setCenterX(enable: Boolean) { val mb = getMethodBind("GridMap","set_center_x") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCenterY(enable: Boolean) { val mb = getMethodBind("GridMap","set_center_y") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCenterZ(enable: Boolean) { val mb = getMethodBind("GridMap","set_center_z") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setClip( enabled: Boolean, clipabove: Boolean = true, floor: Long = 0, axis: Long = 0 ) { val mb = getMethodBind("GridMap","set_clip") _icall_Unit_Boolean_Boolean_Long_Long( mb, this.ptr, enabled, clipabove, floor, axis) } open fun setCollisionLayer(layer: Long) { val mb = getMethodBind("GridMap","set_collision_layer") _icall_Unit_Long( mb, this.ptr, layer) } open fun setCollisionLayerBit(bit: Long, value: Boolean) { val mb = getMethodBind("GridMap","set_collision_layer_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setCollisionMask(mask: Long) { val mb = getMethodBind("GridMap","set_collision_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("GridMap","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setMeshLibrary(meshLibrary: MeshLibrary) { val mb = getMethodBind("GridMap","set_mesh_library") _icall_Unit_Object( mb, this.ptr, meshLibrary) } open fun setOctantSize(size: Long) { val mb = getMethodBind("GridMap","set_octant_size") _icall_Unit_Long( mb, this.ptr, size) } open fun worldToMap(pos: Vector3): Vector3 { val mb = getMethodBind("GridMap","world_to_map") return _icall_Vector3_Vector3( mb, this.ptr, pos) } companion object { final const val INVALID_CELL_ITEM: Long = -1 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/GrooveJoint2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class GrooveJoint2D : Joint2D() { open var initialOffset: Double get() { val mb = getMethodBind("GrooveJoint2D","get_initial_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GrooveJoint2D","set_initial_offset") _icall_Unit_Double(mb, this.ptr, value) } open var length: Double get() { val mb = getMethodBind("GrooveJoint2D","get_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("GrooveJoint2D","set_length") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("GrooveJoint2D", "GrooveJoint2D") open fun getInitialOffset(): Double { val mb = getMethodBind("GrooveJoint2D","get_initial_offset") return _icall_Double( mb, this.ptr) } open fun getLength(): Double { val mb = getMethodBind("GrooveJoint2D","get_length") return _icall_Double( mb, this.ptr) } open fun setInitialOffset(offset: Double) { val mb = getMethodBind("GrooveJoint2D","set_initial_offset") _icall_Unit_Double( mb, this.ptr, offset) } open fun setLength(length: Double) { val mb = getMethodBind("GrooveJoint2D","set_length") _icall_Unit_Double( mb, this.ptr, length) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HBoxContainer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class HBoxContainer : BoxContainer() { override fun __new(): COpaquePointer = invokeConstructor("HBoxContainer", "HBoxContainer") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HScrollBar.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class HScrollBar : ScrollBar() { override fun __new(): COpaquePointer = invokeConstructor("HScrollBar", "HScrollBar") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HSeparator.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class HSeparator : Separator() { override fun __new(): COpaquePointer = invokeConstructor("HSeparator", "HSeparator") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HSlider.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class HSlider : Slider() { override fun __new(): COpaquePointer = invokeConstructor("HSlider", "HSlider") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HSplitContainer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class HSplitContainer : SplitContainer() { override fun __new(): COpaquePointer = invokeConstructor("HSplitContainer", "HSplitContainer") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HTTPClient.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.HTTPClient import godot.core.Dictionary import godot.core.GodotError import godot.core.PoolByteArray import godot.core.PoolStringArray import godot.icalls._icall_Boolean import godot.icalls._icall_Dictionary import godot.icalls._icall_Long import godot.icalls._icall_Long_Long_String_PoolStringArray_PoolByteArray import godot.icalls._icall_Long_Long_String_PoolStringArray_String import godot.icalls._icall_Long_String_Long_Boolean_Boolean import godot.icalls._icall_PoolByteArray import godot.icalls._icall_PoolStringArray import godot.icalls._icall_StreamPeer import godot.icalls._icall_String_Dictionary import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class HTTPClient : Reference() { open var blockingModeEnabled: Boolean get() { val mb = getMethodBind("HTTPClient","is_blocking_mode_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("HTTPClient","set_blocking_mode") _icall_Unit_Boolean(mb, this.ptr, value) } open var connection: StreamPeer get() { val mb = getMethodBind("HTTPClient","get_connection") return _icall_StreamPeer(mb, this.ptr) } set(value) { val mb = getMethodBind("HTTPClient","set_connection") _icall_Unit_Object(mb, this.ptr, value) } open var readChunkSize: Long get() { val mb = getMethodBind("HTTPClient","get_read_chunk_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("HTTPClient","set_read_chunk_size") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("HTTPClient", "HTTPClient") open fun close() { val mb = getMethodBind("HTTPClient","close") _icall_Unit( mb, this.ptr) } open fun connectToHost( host: String, port: Long = -1, useSsl: Boolean = false, verifyHost: Boolean = true ): GodotError { val mb = getMethodBind("HTTPClient","connect_to_host") return GodotError.byValue( _icall_Long_String_Long_Boolean_Boolean( mb, this.ptr, host, port, useSsl, verifyHost).toUInt()) } open fun getConnection(): StreamPeer { val mb = getMethodBind("HTTPClient","get_connection") return _icall_StreamPeer( mb, this.ptr) } open fun getReadChunkSize(): Long { val mb = getMethodBind("HTTPClient","get_read_chunk_size") return _icall_Long( mb, this.ptr) } open fun getResponseBodyLength(): Long { val mb = getMethodBind("HTTPClient","get_response_body_length") return _icall_Long( mb, this.ptr) } open fun getResponseCode(): Long { val mb = getMethodBind("HTTPClient","get_response_code") return _icall_Long( mb, this.ptr) } open fun getResponseHeaders(): PoolStringArray { val mb = getMethodBind("HTTPClient","get_response_headers") return _icall_PoolStringArray( mb, this.ptr) } open fun getResponseHeadersAsDictionary(): Dictionary { val mb = getMethodBind("HTTPClient","get_response_headers_as_dictionary") return _icall_Dictionary( mb, this.ptr) } open fun getStatus(): HTTPClient.Status { val mb = getMethodBind("HTTPClient","get_status") return HTTPClient.Status.from( _icall_Long( mb, this.ptr)) } open fun hasResponse(): Boolean { val mb = getMethodBind("HTTPClient","has_response") return _icall_Boolean( mb, this.ptr) } open fun isBlockingModeEnabled(): Boolean { val mb = getMethodBind("HTTPClient","is_blocking_mode_enabled") return _icall_Boolean( mb, this.ptr) } open fun isResponseChunked(): Boolean { val mb = getMethodBind("HTTPClient","is_response_chunked") return _icall_Boolean( mb, this.ptr) } open fun poll(): GodotError { val mb = getMethodBind("HTTPClient","poll") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } open fun queryStringFromDict(fields: Dictionary): String { val mb = getMethodBind("HTTPClient","query_string_from_dict") return _icall_String_Dictionary( mb, this.ptr, fields) } open fun readResponseBodyChunk(): PoolByteArray { val mb = getMethodBind("HTTPClient","read_response_body_chunk") return _icall_PoolByteArray( mb, this.ptr) } open fun request( method: Long, url: String, headers: PoolStringArray, body: String = "" ): GodotError { val mb = getMethodBind("HTTPClient","request") return GodotError.byValue( _icall_Long_Long_String_PoolStringArray_String( mb, this.ptr, method, url, headers, body).toUInt()) } open fun requestRaw( method: Long, url: String, headers: PoolStringArray, body: PoolByteArray ): GodotError { val mb = getMethodBind("HTTPClient","request_raw") return GodotError.byValue( _icall_Long_Long_String_PoolStringArray_PoolByteArray( mb, this.ptr, method, url, headers, body).toUInt()) } open fun setBlockingMode(enabled: Boolean) { val mb = getMethodBind("HTTPClient","set_blocking_mode") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setConnection(connection: StreamPeer) { val mb = getMethodBind("HTTPClient","set_connection") _icall_Unit_Object( mb, this.ptr, connection) } open fun setReadChunkSize(bytes: Long) { val mb = getMethodBind("HTTPClient","set_read_chunk_size") _icall_Unit_Long( mb, this.ptr, bytes) } enum class Status( id: Long ) { STATUS_DISCONNECTED(0), STATUS_RESOLVING(1), STATUS_CANT_RESOLVE(2), STATUS_CONNECTING(3), STATUS_CANT_CONNECT(4), STATUS_CONNECTED(5), STATUS_REQUESTING(6), STATUS_BODY(7), STATUS_CONNECTION_ERROR(8), STATUS_SSL_HANDSHAKE_ERROR(9); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Method( id: Long ) { METHOD_GET(0), METHOD_HEAD(1), METHOD_POST(2), METHOD_PUT(3), METHOD_DELETE(4), METHOD_OPTIONS(5), METHOD_TRACE(6), METHOD_CONNECT(7), METHOD_PATCH(8), METHOD_MAX(9); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ResponseCode( id: Long ) { RESPONSE_CONTINUE(100), RESPONSE_SWITCHING_PROTOCOLS(101), RESPONSE_PROCESSING(102), RESPONSE_OK(200), RESPONSE_CREATED(201), RESPONSE_ACCEPTED(202), RESPONSE_NON_AUTHORITATIVE_INFORMATION(203), RESPONSE_NO_CONTENT(204), RESPONSE_RESET_CONTENT(205), RESPONSE_PARTIAL_CONTENT(206), RESPONSE_MULTI_STATUS(207), RESPONSE_ALREADY_REPORTED(208), RESPONSE_IM_USED(226), RESPONSE_MULTIPLE_CHOICES(300), RESPONSE_MOVED_PERMANENTLY(301), RESPONSE_FOUND(302), RESPONSE_SEE_OTHER(303), RESPONSE_NOT_MODIFIED(304), RESPONSE_USE_PROXY(305), RESPONSE_SWITCH_PROXY(306), RESPONSE_TEMPORARY_REDIRECT(307), RESPONSE_PERMANENT_REDIRECT(308), RESPONSE_BAD_REQUEST(400), RESPONSE_UNAUTHORIZED(401), RESPONSE_PAYMENT_REQUIRED(402), RESPONSE_FORBIDDEN(403), RESPONSE_NOT_FOUND(404), RESPONSE_METHOD_NOT_ALLOWED(405), RESPONSE_NOT_ACCEPTABLE(406), RESPONSE_PROXY_AUTHENTICATION_REQUIRED(407), RESPONSE_REQUEST_TIMEOUT(408), RESPONSE_CONFLICT(409), RESPONSE_GONE(410), RESPONSE_LENGTH_REQUIRED(411), RESPONSE_PRECONDITION_FAILED(412), RESPONSE_REQUEST_ENTITY_TOO_LARGE(413), RESPONSE_REQUEST_URI_TOO_LONG(414), RESPONSE_UNSUPPORTED_MEDIA_TYPE(415), RESPONSE_REQUESTED_RANGE_NOT_SATISFIABLE(416), RESPONSE_EXPECTATION_FAILED(417), RESPONSE_IM_A_TEAPOT(418), RESPONSE_MISDIRECTED_REQUEST(421), RESPONSE_UNPROCESSABLE_ENTITY(422), RESPONSE_LOCKED(423), RESPONSE_FAILED_DEPENDENCY(424), RESPONSE_UPGRADE_REQUIRED(426), RESPONSE_PRECONDITION_REQUIRED(428), RESPONSE_TOO_MANY_REQUESTS(429), RESPONSE_REQUEST_HEADER_FIELDS_TOO_LARGE(431), RESPONSE_UNAVAILABLE_FOR_LEGAL_REASONS(451), RESPONSE_INTERNAL_SERVER_ERROR(500), RESPONSE_NOT_IMPLEMENTED(501), RESPONSE_BAD_GATEWAY(502), RESPONSE_SERVICE_UNAVAILABLE(503), RESPONSE_GATEWAY_TIMEOUT(504), RESPONSE_HTTP_VERSION_NOT_SUPPORTED(505), RESPONSE_VARIANT_ALSO_NEGOTIATES(506), RESPONSE_INSUFFICIENT_STORAGE(507), RESPONSE_LOOP_DETECTED(508), RESPONSE_NOT_EXTENDED(510), RESPONSE_NETWORK_AUTH_REQUIRED(511); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HTTPRequest.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.HTTPClient import godot.core.GodotError import godot.core.PoolByteArray import godot.core.PoolStringArray import godot.core.Signal4 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_String_PoolStringArray_Boolean_Long_String import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class HTTPRequest : Node() { val requestCompleted: Signal4 by signal("result", "response_code", "headers", "body") open var bodySizeLimit: Long get() { val mb = getMethodBind("HTTPRequest","get_body_size_limit") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("HTTPRequest","set_body_size_limit") _icall_Unit_Long(mb, this.ptr, value) } open var downloadChunkSize: Long get() { val mb = getMethodBind("HTTPRequest","get_download_chunk_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("HTTPRequest","set_download_chunk_size") _icall_Unit_Long(mb, this.ptr, value) } open var downloadFile: String get() { val mb = getMethodBind("HTTPRequest","get_download_file") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("HTTPRequest","set_download_file") _icall_Unit_String(mb, this.ptr, value) } open var maxRedirects: Long get() { val mb = getMethodBind("HTTPRequest","get_max_redirects") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("HTTPRequest","set_max_redirects") _icall_Unit_Long(mb, this.ptr, value) } open var timeout: Long get() { val mb = getMethodBind("HTTPRequest","get_timeout") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("HTTPRequest","set_timeout") _icall_Unit_Long(mb, this.ptr, value) } open var useThreads: Boolean get() { val mb = getMethodBind("HTTPRequest","is_using_threads") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("HTTPRequest","set_use_threads") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("HTTPRequest", "HTTPRequest") open fun _redirectRequest(arg0: String) { } open fun _requestDone( arg0: Long, arg1: Long, arg2: PoolStringArray, arg3: PoolByteArray ) { } open fun _timeout() { } open fun cancelRequest() { val mb = getMethodBind("HTTPRequest","cancel_request") _icall_Unit( mb, this.ptr) } open fun getBodySize(): Long { val mb = getMethodBind("HTTPRequest","get_body_size") return _icall_Long( mb, this.ptr) } open fun getBodySizeLimit(): Long { val mb = getMethodBind("HTTPRequest","get_body_size_limit") return _icall_Long( mb, this.ptr) } open fun getDownloadChunkSize(): Long { val mb = getMethodBind("HTTPRequest","get_download_chunk_size") return _icall_Long( mb, this.ptr) } open fun getDownloadFile(): String { val mb = getMethodBind("HTTPRequest","get_download_file") return _icall_String( mb, this.ptr) } open fun getDownloadedBytes(): Long { val mb = getMethodBind("HTTPRequest","get_downloaded_bytes") return _icall_Long( mb, this.ptr) } open fun getHttpClientStatus(): HTTPClient.Status { val mb = getMethodBind("HTTPRequest","get_http_client_status") return HTTPClient.Status.from( _icall_Long( mb, this.ptr)) } open fun getMaxRedirects(): Long { val mb = getMethodBind("HTTPRequest","get_max_redirects") return _icall_Long( mb, this.ptr) } open fun getTimeout(): Long { val mb = getMethodBind("HTTPRequest","get_timeout") return _icall_Long( mb, this.ptr) } open fun isUsingThreads(): Boolean { val mb = getMethodBind("HTTPRequest","is_using_threads") return _icall_Boolean( mb, this.ptr) } open fun request( url: String, customHeaders: PoolStringArray = PoolStringArray(), sslValidateDomain: Boolean = true, method: Long = 0, requestData: String = "" ): GodotError { val mb = getMethodBind("HTTPRequest","request") return GodotError.byValue( _icall_Long_String_PoolStringArray_Boolean_Long_String( mb, this.ptr, url, customHeaders, sslValidateDomain, method, requestData).toUInt()) } open fun setBodySizeLimit(bytes: Long) { val mb = getMethodBind("HTTPRequest","set_body_size_limit") _icall_Unit_Long( mb, this.ptr, bytes) } open fun setDownloadChunkSize(arg0: Long) { val mb = getMethodBind("HTTPRequest","set_download_chunk_size") _icall_Unit_Long( mb, this.ptr, arg0) } open fun setDownloadFile(path: String) { val mb = getMethodBind("HTTPRequest","set_download_file") _icall_Unit_String( mb, this.ptr, path) } open fun setMaxRedirects(amount: Long) { val mb = getMethodBind("HTTPRequest","set_max_redirects") _icall_Unit_Long( mb, this.ptr, amount) } open fun setTimeout(timeout: Long) { val mb = getMethodBind("HTTPRequest","set_timeout") _icall_Unit_Long( mb, this.ptr, timeout) } open fun setUseThreads(enable: Boolean) { val mb = getMethodBind("HTTPRequest","set_use_threads") _icall_Unit_Boolean( mb, this.ptr, enable) } enum class Result( id: Long ) { RESULT_SUCCESS(0), RESULT_CHUNKED_BODY_SIZE_MISMATCH(1), RESULT_CANT_CONNECT(2), RESULT_CANT_RESOLVE(3), RESULT_CONNECTION_ERROR(4), RESULT_SSL_HANDSHAKE_ERROR(5), RESULT_NO_RESPONSE(6), RESULT_BODY_SIZE_LIMIT_EXCEEDED(7), RESULT_REQUEST_FAILED(8), RESULT_DOWNLOAD_FILE_CANT_OPEN(9), RESULT_DOWNLOAD_FILE_WRITE_ERROR(10), RESULT_REDIRECT_LIMIT_REACHED(11), RESULT_TIMEOUT(12); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HashingContext.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.PoolByteArray import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_PoolByteArray import godot.icalls._icall_PoolByteArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class HashingContext : Reference() { override fun __new(): COpaquePointer = invokeConstructor("HashingContext", "HashingContext") open fun finish(): PoolByteArray { val mb = getMethodBind("HashingContext","finish") return _icall_PoolByteArray( mb, this.ptr) } open fun start(type: Long): GodotError { val mb = getMethodBind("HashingContext","start") return GodotError.byValue( _icall_Long_Long( mb, this.ptr, type).toUInt()) } open fun update(chunk: PoolByteArray): GodotError { val mb = getMethodBind("HashingContext","update") return GodotError.byValue( _icall_Long_PoolByteArray( mb, this.ptr, chunk).toUInt()) } enum class HashType( id: Long ) { HASH_MD5(0), HASH_SHA1(1), HASH_SHA256(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HeightMapShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolRealArray import godot.icalls._icall_Long import godot.icalls._icall_PoolRealArray import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_PoolRealArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class HeightMapShape : Shape() { open var mapData: PoolRealArray get() { val mb = getMethodBind("HeightMapShape","get_map_data") return _icall_PoolRealArray(mb, this.ptr) } set(value) { val mb = getMethodBind("HeightMapShape","set_map_data") _icall_Unit_PoolRealArray(mb, this.ptr, value) } open var mapDepth: Long get() { val mb = getMethodBind("HeightMapShape","get_map_depth") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("HeightMapShape","set_map_depth") _icall_Unit_Long(mb, this.ptr, value) } open var mapWidth: Long get() { val mb = getMethodBind("HeightMapShape","get_map_width") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("HeightMapShape","set_map_width") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("HeightMapShape", "HeightMapShape") open fun getMapData(): PoolRealArray { val mb = getMethodBind("HeightMapShape","get_map_data") return _icall_PoolRealArray( mb, this.ptr) } open fun getMapDepth(): Long { val mb = getMethodBind("HeightMapShape","get_map_depth") return _icall_Long( mb, this.ptr) } open fun getMapWidth(): Long { val mb = getMethodBind("HeightMapShape","get_map_width") return _icall_Long( mb, this.ptr) } open fun setMapData(data: PoolRealArray) { val mb = getMethodBind("HeightMapShape","set_map_data") _icall_Unit_PoolRealArray( mb, this.ptr, data) } open fun setMapDepth(height: Long) { val mb = getMethodBind("HeightMapShape","set_map_depth") _icall_Unit_Long( mb, this.ptr, height) } open fun setMapWidth(width: Long) { val mb = getMethodBind("HeightMapShape","set_map_width") _icall_Unit_Long( mb, this.ptr, width) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/HingeJoint.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class HingeJoint : Joint() { open var angularLimit_bias: Double get() { val mb = getMethodBind("HingeJoint","get_param") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("HingeJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var angularLimit_enable: Boolean get() { val mb = getMethodBind("HingeJoint","get_flag") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("HingeJoint","set_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open var angularLimit_relaxation: Double get() { val mb = getMethodBind("HingeJoint","get_param") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("HingeJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var angularLimit_softness: Double get() { val mb = getMethodBind("HingeJoint","get_param") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("HingeJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var motor_enable: Boolean get() { val mb = getMethodBind("HingeJoint","get_flag") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("HingeJoint","set_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var motor_maxImpulse: Double get() { val mb = getMethodBind("HingeJoint","get_param") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("HingeJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var motor_targetVelocity: Double get() { val mb = getMethodBind("HingeJoint","get_param") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("HingeJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var params_bias: Double get() { val mb = getMethodBind("HingeJoint","get_param") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("HingeJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } override fun __new(): COpaquePointer = invokeConstructor("HingeJoint", "HingeJoint") open fun _getLowerLimit(): Double { throw NotImplementedError("_get_lower_limit is not implemented for HingeJoint") } open fun _getUpperLimit(): Double { throw NotImplementedError("_get_upper_limit is not implemented for HingeJoint") } open fun _setLowerLimit(lowerLimit: Double) { } open fun _setUpperLimit(upperLimit: Double) { } open fun getFlag(flag: Long): Boolean { val mb = getMethodBind("HingeJoint","get_flag") return _icall_Boolean_Long( mb, this.ptr, flag) } open fun getParam(param: Long): Double { val mb = getMethodBind("HingeJoint","get_param") return _icall_Double_Long( mb, this.ptr, param) } open fun setFlag(flag: Long, enabled: Boolean) { val mb = getMethodBind("HingeJoint","set_flag") _icall_Unit_Long_Boolean( mb, this.ptr, flag, enabled) } open fun setParam(param: Long, value: Double) { val mb = getMethodBind("HingeJoint","set_param") _icall_Unit_Long_Double( mb, this.ptr, param, value) } enum class Param( id: Long ) { PARAM_BIAS(0), PARAM_LIMIT_UPPER(1), PARAM_LIMIT_LOWER(2), PARAM_LIMIT_BIAS(3), PARAM_LIMIT_SOFTNESS(4), PARAM_LIMIT_RELAXATION(5), PARAM_MOTOR_TARGET_VELOCITY(6), PARAM_MOTOR_MAX_IMPULSE(7), PARAM_MAX(8); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Flag( id: Long ) { FLAG_USE_LIMIT(0), FLAG_ENABLE_MOTOR(1), FLAG_MAX(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/IP.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.IP import godot.core.Godot import godot.core.VariantArray import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_String_Long import godot.icalls._icall_String_Long import godot.icalls._icall_String_String_Long import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_String import godot.icalls._icall_VariantArray import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object IP : Object() { final const val RESOLVER_INVALID_ID: Long = -1 final const val RESOLVER_MAX_QUERIES: Long = 32 override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("IP".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton IP" } ptr } fun clearCache(hostname: String = "") { val mb = getMethodBind("IP","clear_cache") _icall_Unit_String( mb, this.ptr, hostname) } fun eraseResolveItem(id: Long) { val mb = getMethodBind("IP","erase_resolve_item") _icall_Unit_Long( mb, this.ptr, id) } fun getLocalAddresses(): VariantArray { val mb = getMethodBind("IP","get_local_addresses") return _icall_VariantArray( mb, this.ptr) } fun getLocalInterfaces(): VariantArray { val mb = getMethodBind("IP","get_local_interfaces") return _icall_VariantArray( mb, this.ptr) } fun getResolveItemAddress(id: Long): String { val mb = getMethodBind("IP","get_resolve_item_address") return _icall_String_Long( mb, this.ptr, id) } fun getResolveItemStatus(id: Long): IP.ResolverStatus { val mb = getMethodBind("IP","get_resolve_item_status") return IP.ResolverStatus.from( _icall_Long_Long( mb, this.ptr, id)) } fun resolveHostname(host: String, ipType: Long = 3): String { val mb = getMethodBind("IP","resolve_hostname") return _icall_String_String_Long( mb, this.ptr, host, ipType) } fun resolveHostnameQueueItem(host: String, ipType: Long = 3): Long { val mb = getMethodBind("IP","resolve_hostname_queue_item") return _icall_Long_String_Long( mb, this.ptr, host, ipType) } enum class ResolverStatus( id: Long ) { RESOLVER_STATUS_NONE(0), RESOLVER_STATUS_WAITING(1), RESOLVER_STATUS_DONE(2), RESOLVER_STATUS_ERROR(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Type( id: Long ) { TYPE_NONE(0), TYPE_IPV4(1), TYPE_IPV6(2), TYPE_ANY(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Image.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Image import godot.core.Color import godot.core.Dictionary import godot.core.GodotError import godot.core.PoolByteArray import godot.core.Rect2 import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Color_Long_Long import godot.icalls._icall_Color_Vector2 import godot.icalls._icall_Image import godot.icalls._icall_Image_Rect2 import godot.icalls._icall_Long import godot.icalls._icall_Long_Boolean import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_Long_Long_Double import godot.icalls._icall_Long_PoolByteArray import godot.icalls._icall_Long_String import godot.icalls._icall_Long_String_Boolean import godot.icalls._icall_PoolByteArray import godot.icalls._icall_Rect2 import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Long_Boolean_Long import godot.icalls._icall_Unit_Long_Long_Boolean_Long_PoolByteArray import godot.icalls._icall_Unit_Long_Long_Color import godot.icalls._icall_Unit_Long_Long_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_Object_Rect2_Vector2 import godot.icalls._icall_Unit_Object_Rect2_Vector2 import godot.icalls._icall_Unit_Vector2_Color import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class Image : Resource() { override fun __new(): COpaquePointer = invokeConstructor("Image", "Image") open fun _getData(): Dictionary { throw NotImplementedError("_get_data is not implemented for Image") } open fun _setData(data: Dictionary) { } open fun blendRect( src: Image, srcRect: Rect2, dst: Vector2 ) { val mb = getMethodBind("Image","blend_rect") _icall_Unit_Object_Rect2_Vector2( mb, this.ptr, src, srcRect, dst) } open fun blendRectMask( src: Image, mask: Image, srcRect: Rect2, dst: Vector2 ) { val mb = getMethodBind("Image","blend_rect_mask") _icall_Unit_Object_Object_Rect2_Vector2( mb, this.ptr, src, mask, srcRect, dst) } open fun blitRect( src: Image, srcRect: Rect2, dst: Vector2 ) { val mb = getMethodBind("Image","blit_rect") _icall_Unit_Object_Rect2_Vector2( mb, this.ptr, src, srcRect, dst) } open fun blitRectMask( src: Image, mask: Image, srcRect: Rect2, dst: Vector2 ) { val mb = getMethodBind("Image","blit_rect_mask") _icall_Unit_Object_Object_Rect2_Vector2( mb, this.ptr, src, mask, srcRect, dst) } open fun bumpmapToNormalmap(bumpScale: Double = 1.0) { val mb = getMethodBind("Image","bumpmap_to_normalmap") _icall_Unit_Double( mb, this.ptr, bumpScale) } open fun clearMipmaps() { val mb = getMethodBind("Image","clear_mipmaps") _icall_Unit( mb, this.ptr) } open fun compress( mode: Long, source: Long, lossyQuality: Double ): GodotError { val mb = getMethodBind("Image","compress") return GodotError.byValue( _icall_Long_Long_Long_Double( mb, this.ptr, mode, source, lossyQuality).toUInt()) } open fun convert(format: Long) { val mb = getMethodBind("Image","convert") _icall_Unit_Long( mb, this.ptr, format) } open fun copyFrom(src: Image) { val mb = getMethodBind("Image","copy_from") _icall_Unit_Object( mb, this.ptr, src) } open fun create( width: Long, height: Long, useMipmaps: Boolean, format: Long ) { val mb = getMethodBind("Image","create") _icall_Unit_Long_Long_Boolean_Long( mb, this.ptr, width, height, useMipmaps, format) } open fun createFromData( width: Long, height: Long, useMipmaps: Boolean, format: Long, data: PoolByteArray ) { val mb = getMethodBind("Image","create_from_data") _icall_Unit_Long_Long_Boolean_Long_PoolByteArray( mb, this.ptr, width, height, useMipmaps, format, data) } open fun crop(width: Long, height: Long) { val mb = getMethodBind("Image","crop") _icall_Unit_Long_Long( mb, this.ptr, width, height) } open fun decompress(): GodotError { val mb = getMethodBind("Image","decompress") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } open fun detectAlpha(): Image.AlphaMode { val mb = getMethodBind("Image","detect_alpha") return Image.AlphaMode.from( _icall_Long( mb, this.ptr)) } open fun expandX2Hq2x() { val mb = getMethodBind("Image","expand_x2_hq2x") _icall_Unit( mb, this.ptr) } open fun fill(color: Color) { val mb = getMethodBind("Image","fill") _icall_Unit_Color( mb, this.ptr, color) } open fun fixAlphaEdges() { val mb = getMethodBind("Image","fix_alpha_edges") _icall_Unit( mb, this.ptr) } open fun flipX() { val mb = getMethodBind("Image","flip_x") _icall_Unit( mb, this.ptr) } open fun flipY() { val mb = getMethodBind("Image","flip_y") _icall_Unit( mb, this.ptr) } open fun generateMipmaps(renormalize: Boolean = false): GodotError { val mb = getMethodBind("Image","generate_mipmaps") return GodotError.byValue( _icall_Long_Boolean( mb, this.ptr, renormalize).toUInt()) } open fun getData(): PoolByteArray { val mb = getMethodBind("Image","get_data") return _icall_PoolByteArray( mb, this.ptr) } open fun getFormat(): Image.Format { val mb = getMethodBind("Image","get_format") return Image.Format.from( _icall_Long( mb, this.ptr)) } open fun getHeight(): Long { val mb = getMethodBind("Image","get_height") return _icall_Long( mb, this.ptr) } open fun getMipmapOffset(mipmap: Long): Long { val mb = getMethodBind("Image","get_mipmap_offset") return _icall_Long_Long( mb, this.ptr, mipmap) } open fun getPixel(x: Long, y: Long): Color { val mb = getMethodBind("Image","get_pixel") return _icall_Color_Long_Long( mb, this.ptr, x, y) } open fun getPixelv(src: Vector2): Color { val mb = getMethodBind("Image","get_pixelv") return _icall_Color_Vector2( mb, this.ptr, src) } open fun getRect(rect: Rect2): Image { val mb = getMethodBind("Image","get_rect") return _icall_Image_Rect2( mb, this.ptr, rect) } open fun getSize(): Vector2 { val mb = getMethodBind("Image","get_size") return _icall_Vector2( mb, this.ptr) } open fun getUsedRect(): Rect2 { val mb = getMethodBind("Image","get_used_rect") return _icall_Rect2( mb, this.ptr) } open fun getWidth(): Long { val mb = getMethodBind("Image","get_width") return _icall_Long( mb, this.ptr) } open fun hasMipmaps(): Boolean { val mb = getMethodBind("Image","has_mipmaps") return _icall_Boolean( mb, this.ptr) } open fun isCompressed(): Boolean { val mb = getMethodBind("Image","is_compressed") return _icall_Boolean( mb, this.ptr) } open fun isEmpty(): Boolean { val mb = getMethodBind("Image","is_empty") return _icall_Boolean( mb, this.ptr) } open fun isInvisible(): Boolean { val mb = getMethodBind("Image","is_invisible") return _icall_Boolean( mb, this.ptr) } open fun load(path: String): GodotError { val mb = getMethodBind("Image","load") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun loadJpgFromBuffer(buffer: PoolByteArray): GodotError { val mb = getMethodBind("Image","load_jpg_from_buffer") return GodotError.byValue( _icall_Long_PoolByteArray( mb, this.ptr, buffer).toUInt()) } open fun loadPngFromBuffer(buffer: PoolByteArray): GodotError { val mb = getMethodBind("Image","load_png_from_buffer") return GodotError.byValue( _icall_Long_PoolByteArray( mb, this.ptr, buffer).toUInt()) } open fun loadWebpFromBuffer(buffer: PoolByteArray): GodotError { val mb = getMethodBind("Image","load_webp_from_buffer") return GodotError.byValue( _icall_Long_PoolByteArray( mb, this.ptr, buffer).toUInt()) } open fun lock() { val mb = getMethodBind("Image","lock") _icall_Unit( mb, this.ptr) } open fun normalmapToXy() { val mb = getMethodBind("Image","normalmap_to_xy") _icall_Unit( mb, this.ptr) } open fun premultiplyAlpha() { val mb = getMethodBind("Image","premultiply_alpha") _icall_Unit( mb, this.ptr) } open fun resize( width: Long, height: Long, interpolation: Long = 1 ) { val mb = getMethodBind("Image","resize") _icall_Unit_Long_Long_Long( mb, this.ptr, width, height, interpolation) } open fun resizeToPo2(square: Boolean = false) { val mb = getMethodBind("Image","resize_to_po2") _icall_Unit_Boolean( mb, this.ptr, square) } open fun rgbeToSrgb(): Image { val mb = getMethodBind("Image","rgbe_to_srgb") return _icall_Image( mb, this.ptr) } open fun saveExr(path: String, grayscale: Boolean = false): GodotError { val mb = getMethodBind("Image","save_exr") return GodotError.byValue( _icall_Long_String_Boolean( mb, this.ptr, path, grayscale).toUInt()) } open fun savePng(path: String): GodotError { val mb = getMethodBind("Image","save_png") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun savePngToBuffer(): PoolByteArray { val mb = getMethodBind("Image","save_png_to_buffer") return _icall_PoolByteArray( mb, this.ptr) } open fun setPixel( x: Long, y: Long, color: Color ) { val mb = getMethodBind("Image","set_pixel") _icall_Unit_Long_Long_Color( mb, this.ptr, x, y, color) } open fun setPixelv(dst: Vector2, color: Color) { val mb = getMethodBind("Image","set_pixelv") _icall_Unit_Vector2_Color( mb, this.ptr, dst, color) } open fun shrinkX2() { val mb = getMethodBind("Image","shrink_x2") _icall_Unit( mb, this.ptr) } open fun srgbToLinear() { val mb = getMethodBind("Image","srgb_to_linear") _icall_Unit( mb, this.ptr) } open fun unlock() { val mb = getMethodBind("Image","unlock") _icall_Unit( mb, this.ptr) } enum class AlphaMode( id: Long ) { ALPHA_NONE(0), ALPHA_BIT(1), ALPHA_BLEND(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class CompressSource( id: Long ) { COMPRESS_SOURCE_GENERIC(0), COMPRESS_SOURCE_SRGB(1), COMPRESS_SOURCE_NORMAL(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Interpolation( id: Long ) { INTERPOLATE_NEAREST(0), INTERPOLATE_BILINEAR(1), INTERPOLATE_CUBIC(2), INTERPOLATE_TRILINEAR(3), INTERPOLATE_LANCZOS(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class CompressMode( id: Long ) { COMPRESS_S3TC(0), COMPRESS_PVRTC2(1), COMPRESS_PVRTC4(2), COMPRESS_ETC(3), COMPRESS_ETC2(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Format( id: Long ) { FORMAT_L8(0), FORMAT_LA8(1), FORMAT_R8(2), FORMAT_RG8(3), FORMAT_RGB8(4), FORMAT_RGBA8(5), FORMAT_RGBA4444(6), FORMAT_RGBA5551(7), FORMAT_RF(8), FORMAT_RGF(9), FORMAT_RGBF(10), FORMAT_RGBAF(11), FORMAT_RH(12), FORMAT_RGH(13), FORMAT_RGBH(14), FORMAT_RGBAH(15), FORMAT_RGBE9995(16), FORMAT_DXT1(17), FORMAT_DXT3(18), FORMAT_DXT5(19), FORMAT_RGTC_R(20), FORMAT_RGTC_RG(21), FORMAT_BPTC_RGBA(22), FORMAT_BPTC_RGBF(23), FORMAT_BPTC_RGBFU(24), FORMAT_PVRTC2(25), FORMAT_PVRTC2A(26), FORMAT_PVRTC4(27), FORMAT_PVRTC4A(28), FORMAT_ETC(29), FORMAT_ETC2_R11(30), FORMAT_ETC2_R11S(31), FORMAT_ETC2_RG11(32), FORMAT_ETC2_RG11S(33), FORMAT_ETC2_RGB8(34), FORMAT_ETC2_RGBA8(35), FORMAT_ETC2_RGB8A1(36), FORMAT_MAX(37); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object { final const val MAX_HEIGHT: Long = 16384 final const val MAX_WIDTH: Long = 16384 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ImageTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Image import godot.ImageTexture import godot.core.GodotError import godot.core.RID import godot.core.Vector2 import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Long_Long_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_Long import godot.icalls._icall_Unit_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class ImageTexture : Texture() { open var lossyQuality: Double get() { val mb = getMethodBind("ImageTexture","get_lossy_storage_quality") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ImageTexture","set_lossy_storage_quality") _icall_Unit_Double(mb, this.ptr, value) } open var storage: Long get() { val mb = getMethodBind("ImageTexture","get_storage") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ImageTexture","set_storage") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ImageTexture", "ImageTexture") open fun _reloadHook(rid: RID) { } open fun create( width: Long, height: Long, format: Long, flags: Long = 7 ) { val mb = getMethodBind("ImageTexture","create") _icall_Unit_Long_Long_Long_Long( mb, this.ptr, width, height, format, flags) } open fun createFromImage(image: Image, flags: Long = 7) { val mb = getMethodBind("ImageTexture","create_from_image") _icall_Unit_Object_Long( mb, this.ptr, image, flags) } open fun getFormat(): Image.Format { val mb = getMethodBind("ImageTexture","get_format") return Image.Format.from( _icall_Long( mb, this.ptr)) } open fun getLossyStorageQuality(): Double { val mb = getMethodBind("ImageTexture","get_lossy_storage_quality") return _icall_Double( mb, this.ptr) } open fun getStorage(): ImageTexture.Storage { val mb = getMethodBind("ImageTexture","get_storage") return ImageTexture.Storage.from( _icall_Long( mb, this.ptr)) } open fun load(path: String): GodotError { val mb = getMethodBind("ImageTexture","load") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun setData(image: Image) { val mb = getMethodBind("ImageTexture","set_data") _icall_Unit_Object( mb, this.ptr, image) } open fun setLossyStorageQuality(quality: Double) { val mb = getMethodBind("ImageTexture","set_lossy_storage_quality") _icall_Unit_Double( mb, this.ptr, quality) } open fun setSizeOverride(size: Vector2) { val mb = getMethodBind("ImageTexture","set_size_override") _icall_Unit_Vector2( mb, this.ptr, size) } open fun setStorage(mode: Long) { val mb = getMethodBind("ImageTexture","set_storage") _icall_Unit_Long( mb, this.ptr, mode) } enum class Storage( id: Long ) { STORAGE_RAW(0), STORAGE_COMPRESS_LOSSY(1), STORAGE_COMPRESS_LOSSLESS(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ImmediateGeometry.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.Plane import godot.core.Vector2 import godot.core.Vector3 import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Long_Long_Double_Boolean import godot.icalls._icall_Unit_Long_nObject import godot.icalls._icall_Unit_Plane import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Unit_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class ImmediateGeometry : GeometryInstance() { override fun __new(): COpaquePointer = invokeConstructor("ImmediateGeometry", "ImmediateGeometry") open fun addSphere( lats: Long, lons: Long, radius: Double, addUv: Boolean = true ) { val mb = getMethodBind("ImmediateGeometry","add_sphere") _icall_Unit_Long_Long_Double_Boolean( mb, this.ptr, lats, lons, radius, addUv) } open fun addVertex(position: Vector3) { val mb = getMethodBind("ImmediateGeometry","add_vertex") _icall_Unit_Vector3( mb, this.ptr, position) } open fun begin(primitive: Long, texture: Texture? = null) { val mb = getMethodBind("ImmediateGeometry","begin") _icall_Unit_Long_nObject( mb, this.ptr, primitive, texture) } open fun clear() { val mb = getMethodBind("ImmediateGeometry","clear") _icall_Unit( mb, this.ptr) } open fun end() { val mb = getMethodBind("ImmediateGeometry","end") _icall_Unit( mb, this.ptr) } open fun setColor(color: Color) { val mb = getMethodBind("ImmediateGeometry","set_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setNormal(normal: Vector3) { val mb = getMethodBind("ImmediateGeometry","set_normal") _icall_Unit_Vector3( mb, this.ptr, normal) } open fun setTangent(tangent: Plane) { val mb = getMethodBind("ImmediateGeometry","set_tangent") _icall_Unit_Plane( mb, this.ptr, tangent) } open fun setUv(uv: Vector2) { val mb = getMethodBind("ImmediateGeometry","set_uv") _icall_Unit_Vector2( mb, this.ptr, uv) } open fun setUv2(uv: Vector2) { val mb = getMethodBind("ImmediateGeometry","set_uv2") _icall_Unit_Vector2( mb, this.ptr, uv) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Input.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Input import godot.core.Godot import godot.core.Signal2 import godot.core.VariantArray import godot.core.Vector2 import godot.core.Vector3 import godot.core.signal import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_Long_Long import godot.icalls._icall_Boolean_String import godot.icalls._icall_Double_Long import godot.icalls._icall_Double_Long_Long import godot.icalls._icall_Double_String import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_String_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean_String_String import godot.icalls._icall_Unit_Long_Double_Double_Double import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_Long_Vector2 import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Boolean import godot.icalls._icall_Unit_String_Double import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_Long import godot.icalls._icall_Vector3 import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object Input : Object() { val joyConnectionChanged: Signal2 by signal("device", "connected") override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("Input".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton Input" } ptr } fun actionPress(action: String, strength: Double = 1.0) { val mb = getMethodBind("Input","action_press") _icall_Unit_String_Double( mb, this.ptr, action, strength) } fun actionRelease(action: String) { val mb = getMethodBind("Input","action_release") _icall_Unit_String( mb, this.ptr, action) } fun addJoyMapping(mapping: String, updateExisting: Boolean = false) { val mb = getMethodBind("Input","add_joy_mapping") _icall_Unit_String_Boolean( mb, this.ptr, mapping, updateExisting) } fun getAccelerometer(): Vector3 { val mb = getMethodBind("Input","get_accelerometer") return _icall_Vector3( mb, this.ptr) } fun getActionStrength(action: String): Double { val mb = getMethodBind("Input","get_action_strength") return _icall_Double_String( mb, this.ptr, action) } fun getConnectedJoypads(): VariantArray { val mb = getMethodBind("Input","get_connected_joypads") return _icall_VariantArray( mb, this.ptr) } fun getCurrentCursorShape(): Input.CursorShape { val mb = getMethodBind("Input","get_current_cursor_shape") return Input.CursorShape.from( _icall_Long( mb, this.ptr)) } fun getGravity(): Vector3 { val mb = getMethodBind("Input","get_gravity") return _icall_Vector3( mb, this.ptr) } fun getGyroscope(): Vector3 { val mb = getMethodBind("Input","get_gyroscope") return _icall_Vector3( mb, this.ptr) } fun getJoyAxis(device: Long, axis: Long): Double { val mb = getMethodBind("Input","get_joy_axis") return _icall_Double_Long_Long( mb, this.ptr, device, axis) } fun getJoyAxisIndexFromString(axis: String): Long { val mb = getMethodBind("Input","get_joy_axis_index_from_string") return _icall_Long_String( mb, this.ptr, axis) } fun getJoyAxisString(axisIndex: Long): String { val mb = getMethodBind("Input","get_joy_axis_string") return _icall_String_Long( mb, this.ptr, axisIndex) } fun getJoyButtonIndexFromString(button: String): Long { val mb = getMethodBind("Input","get_joy_button_index_from_string") return _icall_Long_String( mb, this.ptr, button) } fun getJoyButtonString(buttonIndex: Long): String { val mb = getMethodBind("Input","get_joy_button_string") return _icall_String_Long( mb, this.ptr, buttonIndex) } fun getJoyGuid(device: Long): String { val mb = getMethodBind("Input","get_joy_guid") return _icall_String_Long( mb, this.ptr, device) } fun getJoyName(device: Long): String { val mb = getMethodBind("Input","get_joy_name") return _icall_String_Long( mb, this.ptr, device) } fun getJoyVibrationDuration(device: Long): Double { val mb = getMethodBind("Input","get_joy_vibration_duration") return _icall_Double_Long( mb, this.ptr, device) } fun getJoyVibrationStrength(device: Long): Vector2 { val mb = getMethodBind("Input","get_joy_vibration_strength") return _icall_Vector2_Long( mb, this.ptr, device) } fun getLastMouseSpeed(): Vector2 { val mb = getMethodBind("Input","get_last_mouse_speed") return _icall_Vector2( mb, this.ptr) } fun getMagnetometer(): Vector3 { val mb = getMethodBind("Input","get_magnetometer") return _icall_Vector3( mb, this.ptr) } fun getMouseButtonMask(): Long { val mb = getMethodBind("Input","get_mouse_button_mask") return _icall_Long( mb, this.ptr) } fun getMouseMode(): Input.MouseMode { val mb = getMethodBind("Input","get_mouse_mode") return Input.MouseMode.from( _icall_Long( mb, this.ptr)) } fun isActionJustPressed(action: String): Boolean { val mb = getMethodBind("Input","is_action_just_pressed") return _icall_Boolean_String( mb, this.ptr, action) } fun isActionJustReleased(action: String): Boolean { val mb = getMethodBind("Input","is_action_just_released") return _icall_Boolean_String( mb, this.ptr, action) } fun isActionPressed(action: String): Boolean { val mb = getMethodBind("Input","is_action_pressed") return _icall_Boolean_String( mb, this.ptr, action) } fun isJoyButtonPressed(device: Long, button: Long): Boolean { val mb = getMethodBind("Input","is_joy_button_pressed") return _icall_Boolean_Long_Long( mb, this.ptr, device, button) } fun isJoyKnown(device: Long): Boolean { val mb = getMethodBind("Input","is_joy_known") return _icall_Boolean_Long( mb, this.ptr, device) } fun isKeyPressed(scancode: Long): Boolean { val mb = getMethodBind("Input","is_key_pressed") return _icall_Boolean_Long( mb, this.ptr, scancode) } fun isMouseButtonPressed(button: Long): Boolean { val mb = getMethodBind("Input","is_mouse_button_pressed") return _icall_Boolean_Long( mb, this.ptr, button) } fun joyConnectionChanged( device: Long, connected: Boolean, name: String, guid: String ) { val mb = getMethodBind("Input","joy_connection_changed") _icall_Unit_Long_Boolean_String_String( mb, this.ptr, device, connected, name, guid) } fun parseInputEvent(event: InputEvent) { val mb = getMethodBind("Input","parse_input_event") _icall_Unit_Object( mb, this.ptr, event) } fun removeJoyMapping(guid: String) { val mb = getMethodBind("Input","remove_joy_mapping") _icall_Unit_String( mb, this.ptr, guid) } fun setCustomMouseCursor( image: Resource, shape: Long = 0, hotspot: Vector2 = Vector2(0.0, 0.0) ) { val mb = getMethodBind("Input","set_custom_mouse_cursor") _icall_Unit_Object_Long_Vector2( mb, this.ptr, image, shape, hotspot) } fun setDefaultCursorShape(shape: Long = 0) { val mb = getMethodBind("Input","set_default_cursor_shape") _icall_Unit_Long( mb, this.ptr, shape) } fun setMouseMode(mode: Long) { val mb = getMethodBind("Input","set_mouse_mode") _icall_Unit_Long( mb, this.ptr, mode) } fun setUseAccumulatedInput(enable: Boolean) { val mb = getMethodBind("Input","set_use_accumulated_input") _icall_Unit_Boolean( mb, this.ptr, enable) } fun startJoyVibration( device: Long, weakMagnitude: Double, strongMagnitude: Double, duration: Double = 0.0 ) { val mb = getMethodBind("Input","start_joy_vibration") _icall_Unit_Long_Double_Double_Double( mb, this.ptr, device, weakMagnitude, strongMagnitude, duration) } fun stopJoyVibration(device: Long) { val mb = getMethodBind("Input","stop_joy_vibration") _icall_Unit_Long( mb, this.ptr, device) } fun vibrateHandheld(durationMs: Long = 500) { val mb = getMethodBind("Input","vibrate_handheld") _icall_Unit_Long( mb, this.ptr, durationMs) } fun warpMousePosition(to: Vector2) { val mb = getMethodBind("Input","warp_mouse_position") _icall_Unit_Vector2( mb, this.ptr, to) } enum class MouseMode( id: Long ) { MOUSE_MODE_VISIBLE(0), MOUSE_MODE_HIDDEN(1), MOUSE_MODE_CAPTURED(2), MOUSE_MODE_CONFINED(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class CursorShape( id: Long ) { CURSOR_ARROW(0), CURSOR_IBEAM(1), CURSOR_POINTING_HAND(2), CURSOR_CROSS(3), CURSOR_WAIT(4), CURSOR_BUSY(5), CURSOR_DRAG(6), CURSOR_CAN_DROP(7), CURSOR_FORBIDDEN(8), CURSOR_VSIZE(9), CURSOR_HSIZE(10), CURSOR_BDIAGSIZE(11), CURSOR_FDIAGSIZE(12), CURSOR_MOVE(13), CURSOR_VSPLIT(14), CURSOR_HSPLIT(15), CURSOR_HELP(16); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEvent.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Transform2D import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Object import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_Boolean import godot.icalls._icall_Double_String import godot.icalls._icall_InputEvent_Transform2D_Vector2 import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String open class InputEvent internal constructor() : Resource() { open var device: Long get() { val mb = getMethodBind("InputEvent","get_device") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEvent","set_device") _icall_Unit_Long(mb, this.ptr, value) } open fun accumulate(withEvent: InputEvent): Boolean { val mb = getMethodBind("InputEvent","accumulate") return _icall_Boolean_Object( mb, this.ptr, withEvent) } open fun asText(): String { val mb = getMethodBind("InputEvent","as_text") return _icall_String( mb, this.ptr) } open fun getActionStrength(action: String): Double { val mb = getMethodBind("InputEvent","get_action_strength") return _icall_Double_String( mb, this.ptr, action) } open fun getDevice(): Long { val mb = getMethodBind("InputEvent","get_device") return _icall_Long( mb, this.ptr) } open fun isAction(action: String): Boolean { val mb = getMethodBind("InputEvent","is_action") return _icall_Boolean_String( mb, this.ptr, action) } open fun isActionPressed(action: String, allowEcho: Boolean = false): Boolean { val mb = getMethodBind("InputEvent","is_action_pressed") return _icall_Boolean_String_Boolean( mb, this.ptr, action, allowEcho) } open fun isActionReleased(action: String): Boolean { val mb = getMethodBind("InputEvent","is_action_released") return _icall_Boolean_String( mb, this.ptr, action) } open fun isActionType(): Boolean { val mb = getMethodBind("InputEvent","is_action_type") return _icall_Boolean( mb, this.ptr) } open fun isEcho(): Boolean { val mb = getMethodBind("InputEvent","is_echo") return _icall_Boolean( mb, this.ptr) } open fun isPressed(): Boolean { val mb = getMethodBind("InputEvent","is_pressed") return _icall_Boolean( mb, this.ptr) } open fun setDevice(device: Long) { val mb = getMethodBind("InputEvent","set_device") _icall_Unit_Long( mb, this.ptr, device) } open fun shortcutMatch(event: InputEvent): Boolean { val mb = getMethodBind("InputEvent","shortcut_match") return _icall_Boolean_Object( mb, this.ptr, event) } open fun xformedBy(xform: Transform2D, localOfs: Vector2 = Vector2(0.0, 0.0)): InputEvent { val mb = getMethodBind("InputEvent","xformed_by") return _icall_InputEvent_Transform2D_Vector2( mb, this.ptr, xform, localOfs) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventAction.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.String import kotlin.UninitializedPropertyAccessException import kotlinx.cinterop.COpaquePointer open class InputEventAction : InputEvent() { open var action: String get() { val mb = getMethodBind("InputEventAction","get_action") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventAction","set_action") _icall_Unit_String(mb, this.ptr, value) } open var pressed: Boolean get() { throw UninitializedPropertyAccessException("Cannot access property pressed: has no getter") } set(value) { val mb = getMethodBind("InputEventAction","set_pressed") _icall_Unit_Boolean(mb, this.ptr, value) } open var strength: Double get() { val mb = getMethodBind("InputEventAction","get_strength") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventAction","set_strength") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventAction", "InputEventAction") open fun getAction(): String { val mb = getMethodBind("InputEventAction","get_action") return _icall_String( mb, this.ptr) } open fun getStrength(): Double { val mb = getMethodBind("InputEventAction","get_strength") return _icall_Double( mb, this.ptr) } open fun setAction(action: String) { val mb = getMethodBind("InputEventAction","set_action") _icall_Unit_String( mb, this.ptr, action) } open fun setPressed(pressed: Boolean) { val mb = getMethodBind("InputEventAction","set_pressed") _icall_Unit_Boolean( mb, this.ptr, pressed) } open fun setStrength(strength: Double) { val mb = getMethodBind("InputEventAction","set_strength") _icall_Unit_Double( mb, this.ptr, strength) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventGesture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import kotlin.Unit open class InputEventGesture internal constructor() : InputEventWithModifiers() { open var position: Vector2 get() { val mb = getMethodBind("InputEventGesture","get_position") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventGesture","set_position") _icall_Unit_Vector2(mb, this.ptr, value) } open fun position(schedule: Vector2.() -> Unit): Vector2 = position.apply{ schedule(this) position = this } open fun getPosition(): Vector2 { val mb = getMethodBind("InputEventGesture","get_position") return _icall_Vector2( mb, this.ptr) } open fun setPosition(position: Vector2) { val mb = getMethodBind("InputEventGesture","set_position") _icall_Unit_Vector2( mb, this.ptr, position) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventJoypadButton.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.UninitializedPropertyAccessException import kotlinx.cinterop.COpaquePointer open class InputEventJoypadButton : InputEvent() { open var buttonIndex: Long get() { val mb = getMethodBind("InputEventJoypadButton","get_button_index") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventJoypadButton","set_button_index") _icall_Unit_Long(mb, this.ptr, value) } open var pressed: Boolean get() { throw UninitializedPropertyAccessException("Cannot access property pressed: has no getter") } set(value) { val mb = getMethodBind("InputEventJoypadButton","set_pressed") _icall_Unit_Boolean(mb, this.ptr, value) } open var pressure: Double get() { val mb = getMethodBind("InputEventJoypadButton","get_pressure") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventJoypadButton","set_pressure") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventJoypadButton", "InputEventJoypadButton") open fun getButtonIndex(): Long { val mb = getMethodBind("InputEventJoypadButton","get_button_index") return _icall_Long( mb, this.ptr) } open fun getPressure(): Double { val mb = getMethodBind("InputEventJoypadButton","get_pressure") return _icall_Double( mb, this.ptr) } open fun setButtonIndex(buttonIndex: Long) { val mb = getMethodBind("InputEventJoypadButton","set_button_index") _icall_Unit_Long( mb, this.ptr, buttonIndex) } open fun setPressed(pressed: Boolean) { val mb = getMethodBind("InputEventJoypadButton","set_pressed") _icall_Unit_Boolean( mb, this.ptr, pressed) } open fun setPressure(pressure: Double) { val mb = getMethodBind("InputEventJoypadButton","set_pressure") _icall_Unit_Double( mb, this.ptr, pressure) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventJoypadMotion.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class InputEventJoypadMotion : InputEvent() { open var axis: Long get() { val mb = getMethodBind("InputEventJoypadMotion","get_axis") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventJoypadMotion","set_axis") _icall_Unit_Long(mb, this.ptr, value) } open var axisValue: Double get() { val mb = getMethodBind("InputEventJoypadMotion","get_axis_value") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventJoypadMotion","set_axis_value") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventJoypadMotion", "InputEventJoypadMotion") open fun getAxis(): Long { val mb = getMethodBind("InputEventJoypadMotion","get_axis") return _icall_Long( mb, this.ptr) } open fun getAxisValue(): Double { val mb = getMethodBind("InputEventJoypadMotion","get_axis_value") return _icall_Double( mb, this.ptr) } open fun setAxis(axis: Long) { val mb = getMethodBind("InputEventJoypadMotion","set_axis") _icall_Unit_Long( mb, this.ptr, axis) } open fun setAxisValue(axisValue: Double) { val mb = getMethodBind("InputEventJoypadMotion","set_axis_value") _icall_Unit_Double( mb, this.ptr, axisValue) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventKey.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.UninitializedPropertyAccessException import kotlinx.cinterop.COpaquePointer open class InputEventKey : InputEventWithModifiers() { open var echo: Boolean get() { throw UninitializedPropertyAccessException("Cannot access property echo: has no getter") } set(value) { val mb = getMethodBind("InputEventKey","set_echo") _icall_Unit_Boolean(mb, this.ptr, value) } open var pressed: Boolean get() { throw UninitializedPropertyAccessException("Cannot access property pressed: has no getter") } set(value) { val mb = getMethodBind("InputEventKey","set_pressed") _icall_Unit_Boolean(mb, this.ptr, value) } open var scancode: Long get() { val mb = getMethodBind("InputEventKey","get_scancode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventKey","set_scancode") _icall_Unit_Long(mb, this.ptr, value) } open var unicode: Long get() { val mb = getMethodBind("InputEventKey","get_unicode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventKey","set_unicode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventKey", "InputEventKey") open fun getScancode(): Long { val mb = getMethodBind("InputEventKey","get_scancode") return _icall_Long( mb, this.ptr) } open fun getScancodeWithModifiers(): Long { val mb = getMethodBind("InputEventKey","get_scancode_with_modifiers") return _icall_Long( mb, this.ptr) } open fun getUnicode(): Long { val mb = getMethodBind("InputEventKey","get_unicode") return _icall_Long( mb, this.ptr) } open fun setEcho(echo: Boolean) { val mb = getMethodBind("InputEventKey","set_echo") _icall_Unit_Boolean( mb, this.ptr, echo) } open fun setPressed(pressed: Boolean) { val mb = getMethodBind("InputEventKey","set_pressed") _icall_Unit_Boolean( mb, this.ptr, pressed) } open fun setScancode(scancode: Long) { val mb = getMethodBind("InputEventKey","set_scancode") _icall_Unit_Long( mb, this.ptr, scancode) } open fun setUnicode(unicode: Long) { val mb = getMethodBind("InputEventKey","set_unicode") _icall_Unit_Long( mb, this.ptr, unicode) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventMIDI.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class InputEventMIDI : InputEvent() { open var channel: Long get() { val mb = getMethodBind("InputEventMIDI","get_channel") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMIDI","set_channel") _icall_Unit_Long(mb, this.ptr, value) } open var controllerNumber: Long get() { val mb = getMethodBind("InputEventMIDI","get_controller_number") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMIDI","set_controller_number") _icall_Unit_Long(mb, this.ptr, value) } open var controllerValue: Long get() { val mb = getMethodBind("InputEventMIDI","get_controller_value") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMIDI","set_controller_value") _icall_Unit_Long(mb, this.ptr, value) } open var instrument: Long get() { val mb = getMethodBind("InputEventMIDI","get_instrument") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMIDI","set_instrument") _icall_Unit_Long(mb, this.ptr, value) } open var message: Long get() { val mb = getMethodBind("InputEventMIDI","get_message") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMIDI","set_message") _icall_Unit_Long(mb, this.ptr, value) } open var pitch: Long get() { val mb = getMethodBind("InputEventMIDI","get_pitch") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMIDI","set_pitch") _icall_Unit_Long(mb, this.ptr, value) } open var pressure: Long get() { val mb = getMethodBind("InputEventMIDI","get_pressure") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMIDI","set_pressure") _icall_Unit_Long(mb, this.ptr, value) } open var velocity: Long get() { val mb = getMethodBind("InputEventMIDI","get_velocity") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMIDI","set_velocity") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventMIDI", "InputEventMIDI") open fun getChannel(): Long { val mb = getMethodBind("InputEventMIDI","get_channel") return _icall_Long( mb, this.ptr) } open fun getControllerNumber(): Long { val mb = getMethodBind("InputEventMIDI","get_controller_number") return _icall_Long( mb, this.ptr) } open fun getControllerValue(): Long { val mb = getMethodBind("InputEventMIDI","get_controller_value") return _icall_Long( mb, this.ptr) } open fun getInstrument(): Long { val mb = getMethodBind("InputEventMIDI","get_instrument") return _icall_Long( mb, this.ptr) } open fun getMessage(): Long { val mb = getMethodBind("InputEventMIDI","get_message") return _icall_Long( mb, this.ptr) } open fun getPitch(): Long { val mb = getMethodBind("InputEventMIDI","get_pitch") return _icall_Long( mb, this.ptr) } open fun getPressure(): Long { val mb = getMethodBind("InputEventMIDI","get_pressure") return _icall_Long( mb, this.ptr) } open fun getVelocity(): Long { val mb = getMethodBind("InputEventMIDI","get_velocity") return _icall_Long( mb, this.ptr) } open fun setChannel(channel: Long) { val mb = getMethodBind("InputEventMIDI","set_channel") _icall_Unit_Long( mb, this.ptr, channel) } open fun setControllerNumber(controllerNumber: Long) { val mb = getMethodBind("InputEventMIDI","set_controller_number") _icall_Unit_Long( mb, this.ptr, controllerNumber) } open fun setControllerValue(controllerValue: Long) { val mb = getMethodBind("InputEventMIDI","set_controller_value") _icall_Unit_Long( mb, this.ptr, controllerValue) } open fun setInstrument(instrument: Long) { val mb = getMethodBind("InputEventMIDI","set_instrument") _icall_Unit_Long( mb, this.ptr, instrument) } open fun setMessage(message: Long) { val mb = getMethodBind("InputEventMIDI","set_message") _icall_Unit_Long( mb, this.ptr, message) } open fun setPitch(pitch: Long) { val mb = getMethodBind("InputEventMIDI","set_pitch") _icall_Unit_Long( mb, this.ptr, pitch) } open fun setPressure(pressure: Long) { val mb = getMethodBind("InputEventMIDI","set_pressure") _icall_Unit_Long( mb, this.ptr, pressure) } open fun setVelocity(velocity: Long) { val mb = getMethodBind("InputEventMIDI","set_velocity") _icall_Unit_Long( mb, this.ptr, velocity) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventMagnifyGesture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class InputEventMagnifyGesture : InputEventGesture() { open var factor: Double get() { val mb = getMethodBind("InputEventMagnifyGesture","get_factor") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMagnifyGesture","set_factor") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventMagnifyGesture", "InputEventMagnifyGesture") open fun getFactor(): Double { val mb = getMethodBind("InputEventMagnifyGesture","get_factor") return _icall_Double( mb, this.ptr) } open fun setFactor(factor: Double) { val mb = getMethodBind("InputEventMagnifyGesture","set_factor") _icall_Unit_Double( mb, this.ptr, factor) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventMouse.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import kotlin.Long import kotlin.Unit open class InputEventMouse internal constructor() : InputEventWithModifiers() { open var buttonMask: Long get() { val mb = getMethodBind("InputEventMouse","get_button_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouse","set_button_mask") _icall_Unit_Long(mb, this.ptr, value) } open var globalPosition: Vector2 get() { val mb = getMethodBind("InputEventMouse","get_global_position") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouse","set_global_position") _icall_Unit_Vector2(mb, this.ptr, value) } open var position: Vector2 get() { val mb = getMethodBind("InputEventMouse","get_position") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouse","set_position") _icall_Unit_Vector2(mb, this.ptr, value) } open fun globalPosition(schedule: Vector2.() -> Unit): Vector2 = globalPosition.apply{ schedule(this) globalPosition = this } open fun position(schedule: Vector2.() -> Unit): Vector2 = position.apply{ schedule(this) position = this } open fun getButtonMask(): Long { val mb = getMethodBind("InputEventMouse","get_button_mask") return _icall_Long( mb, this.ptr) } open fun getGlobalPosition(): Vector2 { val mb = getMethodBind("InputEventMouse","get_global_position") return _icall_Vector2( mb, this.ptr) } open fun getPosition(): Vector2 { val mb = getMethodBind("InputEventMouse","get_position") return _icall_Vector2( mb, this.ptr) } open fun setButtonMask(buttonMask: Long) { val mb = getMethodBind("InputEventMouse","set_button_mask") _icall_Unit_Long( mb, this.ptr, buttonMask) } open fun setGlobalPosition(globalPosition: Vector2) { val mb = getMethodBind("InputEventMouse","set_global_position") _icall_Unit_Vector2( mb, this.ptr, globalPosition) } open fun setPosition(position: Vector2) { val mb = getMethodBind("InputEventMouse","set_position") _icall_Unit_Vector2( mb, this.ptr, position) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventMouseButton.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.UninitializedPropertyAccessException import kotlinx.cinterop.COpaquePointer open class InputEventMouseButton : InputEventMouse() { open var buttonIndex: Long get() { val mb = getMethodBind("InputEventMouseButton","get_button_index") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouseButton","set_button_index") _icall_Unit_Long(mb, this.ptr, value) } open var doubleclick: Boolean get() { val mb = getMethodBind("InputEventMouseButton","is_doubleclick") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouseButton","set_doubleclick") _icall_Unit_Boolean(mb, this.ptr, value) } open var factor: Double get() { val mb = getMethodBind("InputEventMouseButton","get_factor") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouseButton","set_factor") _icall_Unit_Double(mb, this.ptr, value) } open var pressed: Boolean get() { throw UninitializedPropertyAccessException("Cannot access property pressed: has no getter") } set(value) { val mb = getMethodBind("InputEventMouseButton","set_pressed") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventMouseButton", "InputEventMouseButton") open fun getButtonIndex(): Long { val mb = getMethodBind("InputEventMouseButton","get_button_index") return _icall_Long( mb, this.ptr) } open fun getFactor(): Double { val mb = getMethodBind("InputEventMouseButton","get_factor") return _icall_Double( mb, this.ptr) } open fun isDoubleclick(): Boolean { val mb = getMethodBind("InputEventMouseButton","is_doubleclick") return _icall_Boolean( mb, this.ptr) } open fun setButtonIndex(buttonIndex: Long) { val mb = getMethodBind("InputEventMouseButton","set_button_index") _icall_Unit_Long( mb, this.ptr, buttonIndex) } open fun setDoubleclick(doubleclick: Boolean) { val mb = getMethodBind("InputEventMouseButton","set_doubleclick") _icall_Unit_Boolean( mb, this.ptr, doubleclick) } open fun setFactor(factor: Double) { val mb = getMethodBind("InputEventMouseButton","set_factor") _icall_Unit_Double( mb, this.ptr, factor) } open fun setPressed(pressed: Boolean) { val mb = getMethodBind("InputEventMouseButton","set_pressed") _icall_Unit_Boolean( mb, this.ptr, pressed) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventMouseMotion.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class InputEventMouseMotion : InputEventMouse() { open var pressure: Double get() { val mb = getMethodBind("InputEventMouseMotion","get_pressure") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouseMotion","set_pressure") _icall_Unit_Double(mb, this.ptr, value) } open var relative: Vector2 get() { val mb = getMethodBind("InputEventMouseMotion","get_relative") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouseMotion","set_relative") _icall_Unit_Vector2(mb, this.ptr, value) } open var speed: Vector2 get() { val mb = getMethodBind("InputEventMouseMotion","get_speed") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouseMotion","set_speed") _icall_Unit_Vector2(mb, this.ptr, value) } open var tilt: Vector2 get() { val mb = getMethodBind("InputEventMouseMotion","get_tilt") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventMouseMotion","set_tilt") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventMouseMotion", "InputEventMouseMotion") open fun relative(schedule: Vector2.() -> Unit): Vector2 = relative.apply{ schedule(this) relative = this } open fun speed(schedule: Vector2.() -> Unit): Vector2 = speed.apply{ schedule(this) speed = this } open fun tilt(schedule: Vector2.() -> Unit): Vector2 = tilt.apply{ schedule(this) tilt = this } open fun getPressure(): Double { val mb = getMethodBind("InputEventMouseMotion","get_pressure") return _icall_Double( mb, this.ptr) } open fun getRelative(): Vector2 { val mb = getMethodBind("InputEventMouseMotion","get_relative") return _icall_Vector2( mb, this.ptr) } open fun getSpeed(): Vector2 { val mb = getMethodBind("InputEventMouseMotion","get_speed") return _icall_Vector2( mb, this.ptr) } open fun getTilt(): Vector2 { val mb = getMethodBind("InputEventMouseMotion","get_tilt") return _icall_Vector2( mb, this.ptr) } open fun setPressure(pressure: Double) { val mb = getMethodBind("InputEventMouseMotion","set_pressure") _icall_Unit_Double( mb, this.ptr, pressure) } open fun setRelative(relative: Vector2) { val mb = getMethodBind("InputEventMouseMotion","set_relative") _icall_Unit_Vector2( mb, this.ptr, relative) } open fun setSpeed(speed: Vector2) { val mb = getMethodBind("InputEventMouseMotion","set_speed") _icall_Unit_Vector2( mb, this.ptr, speed) } open fun setTilt(tilt: Vector2) { val mb = getMethodBind("InputEventMouseMotion","set_tilt") _icall_Unit_Vector2( mb, this.ptr, tilt) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventPanGesture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class InputEventPanGesture : InputEventGesture() { open var delta: Vector2 get() { val mb = getMethodBind("InputEventPanGesture","get_delta") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventPanGesture","set_delta") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventPanGesture", "InputEventPanGesture") open fun delta(schedule: Vector2.() -> Unit): Vector2 = delta.apply{ schedule(this) delta = this } open fun getDelta(): Vector2 { val mb = getMethodBind("InputEventPanGesture","get_delta") return _icall_Vector2( mb, this.ptr) } open fun setDelta(delta: Vector2) { val mb = getMethodBind("InputEventPanGesture","set_delta") _icall_Unit_Vector2( mb, this.ptr, delta) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventScreenDrag.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class InputEventScreenDrag : InputEvent() { open var index: Long get() { val mb = getMethodBind("InputEventScreenDrag","get_index") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventScreenDrag","set_index") _icall_Unit_Long(mb, this.ptr, value) } open var position: Vector2 get() { val mb = getMethodBind("InputEventScreenDrag","get_position") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventScreenDrag","set_position") _icall_Unit_Vector2(mb, this.ptr, value) } open var relative: Vector2 get() { val mb = getMethodBind("InputEventScreenDrag","get_relative") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventScreenDrag","set_relative") _icall_Unit_Vector2(mb, this.ptr, value) } open var speed: Vector2 get() { val mb = getMethodBind("InputEventScreenDrag","get_speed") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventScreenDrag","set_speed") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventScreenDrag", "InputEventScreenDrag") open fun position(schedule: Vector2.() -> Unit): Vector2 = position.apply{ schedule(this) position = this } open fun relative(schedule: Vector2.() -> Unit): Vector2 = relative.apply{ schedule(this) relative = this } open fun speed(schedule: Vector2.() -> Unit): Vector2 = speed.apply{ schedule(this) speed = this } open fun getIndex(): Long { val mb = getMethodBind("InputEventScreenDrag","get_index") return _icall_Long( mb, this.ptr) } open fun getPosition(): Vector2 { val mb = getMethodBind("InputEventScreenDrag","get_position") return _icall_Vector2( mb, this.ptr) } open fun getRelative(): Vector2 { val mb = getMethodBind("InputEventScreenDrag","get_relative") return _icall_Vector2( mb, this.ptr) } open fun getSpeed(): Vector2 { val mb = getMethodBind("InputEventScreenDrag","get_speed") return _icall_Vector2( mb, this.ptr) } open fun setIndex(index: Long) { val mb = getMethodBind("InputEventScreenDrag","set_index") _icall_Unit_Long( mb, this.ptr, index) } open fun setPosition(position: Vector2) { val mb = getMethodBind("InputEventScreenDrag","set_position") _icall_Unit_Vector2( mb, this.ptr, position) } open fun setRelative(relative: Vector2) { val mb = getMethodBind("InputEventScreenDrag","set_relative") _icall_Unit_Vector2( mb, this.ptr, relative) } open fun setSpeed(speed: Vector2) { val mb = getMethodBind("InputEventScreenDrag","set_speed") _icall_Unit_Vector2( mb, this.ptr, speed) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventScreenTouch.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.UninitializedPropertyAccessException import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class InputEventScreenTouch : InputEvent() { open var index: Long get() { val mb = getMethodBind("InputEventScreenTouch","get_index") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventScreenTouch","set_index") _icall_Unit_Long(mb, this.ptr, value) } open var position: Vector2 get() { val mb = getMethodBind("InputEventScreenTouch","get_position") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventScreenTouch","set_position") _icall_Unit_Vector2(mb, this.ptr, value) } open var pressed: Boolean get() { throw UninitializedPropertyAccessException("Cannot access property pressed: has no getter") } set(value) { val mb = getMethodBind("InputEventScreenTouch","set_pressed") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InputEventScreenTouch", "InputEventScreenTouch") open fun position(schedule: Vector2.() -> Unit): Vector2 = position.apply{ schedule(this) position = this } open fun getIndex(): Long { val mb = getMethodBind("InputEventScreenTouch","get_index") return _icall_Long( mb, this.ptr) } open fun getPosition(): Vector2 { val mb = getMethodBind("InputEventScreenTouch","get_position") return _icall_Vector2( mb, this.ptr) } open fun setIndex(index: Long) { val mb = getMethodBind("InputEventScreenTouch","set_index") _icall_Unit_Long( mb, this.ptr, index) } open fun setPosition(position: Vector2) { val mb = getMethodBind("InputEventScreenTouch","set_position") _icall_Unit_Vector2( mb, this.ptr, position) } open fun setPressed(pressed: Boolean) { val mb = getMethodBind("InputEventScreenTouch","set_pressed") _icall_Unit_Boolean( mb, this.ptr, pressed) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputEventWithModifiers.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import kotlin.Boolean open class InputEventWithModifiers internal constructor() : InputEvent() { open var alt: Boolean get() { val mb = getMethodBind("InputEventWithModifiers","get_alt") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventWithModifiers","set_alt") _icall_Unit_Boolean(mb, this.ptr, value) } open var command: Boolean get() { val mb = getMethodBind("InputEventWithModifiers","get_command") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventWithModifiers","set_command") _icall_Unit_Boolean(mb, this.ptr, value) } open var control: Boolean get() { val mb = getMethodBind("InputEventWithModifiers","get_control") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventWithModifiers","set_control") _icall_Unit_Boolean(mb, this.ptr, value) } open var meta: Boolean get() { val mb = getMethodBind("InputEventWithModifiers","get_metakey") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventWithModifiers","set_metakey") _icall_Unit_Boolean(mb, this.ptr, value) } open var shift: Boolean get() { val mb = getMethodBind("InputEventWithModifiers","get_shift") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("InputEventWithModifiers","set_shift") _icall_Unit_Boolean(mb, this.ptr, value) } open fun getAlt(): Boolean { val mb = getMethodBind("InputEventWithModifiers","get_alt") return _icall_Boolean( mb, this.ptr) } open fun getCommand(): Boolean { val mb = getMethodBind("InputEventWithModifiers","get_command") return _icall_Boolean( mb, this.ptr) } open fun getControl(): Boolean { val mb = getMethodBind("InputEventWithModifiers","get_control") return _icall_Boolean( mb, this.ptr) } open fun getMetakey(): Boolean { val mb = getMethodBind("InputEventWithModifiers","get_metakey") return _icall_Boolean( mb, this.ptr) } open fun getShift(): Boolean { val mb = getMethodBind("InputEventWithModifiers","get_shift") return _icall_Boolean( mb, this.ptr) } open fun setAlt(enable: Boolean) { val mb = getMethodBind("InputEventWithModifiers","set_alt") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCommand(enable: Boolean) { val mb = getMethodBind("InputEventWithModifiers","set_command") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setControl(enable: Boolean) { val mb = getMethodBind("InputEventWithModifiers","set_control") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setMetakey(enable: Boolean) { val mb = getMethodBind("InputEventWithModifiers","set_metakey") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setShift(enable: Boolean) { val mb = getMethodBind("InputEventWithModifiers","set_shift") _icall_Unit_Boolean( mb, this.ptr, enable) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InputMap.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.core.VariantArray import godot.icalls._icall_Boolean_Object_String import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_Object import godot.icalls._icall_Unit import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Double import godot.icalls._icall_Unit_String_Object import godot.icalls._icall_VariantArray import godot.icalls._icall_VariantArray_String import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object InputMap : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("InputMap".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton InputMap" } ptr } fun actionAddEvent(action: String, event: InputEvent) { val mb = getMethodBind("InputMap","action_add_event") _icall_Unit_String_Object( mb, this.ptr, action, event) } fun actionEraseEvent(action: String, event: InputEvent) { val mb = getMethodBind("InputMap","action_erase_event") _icall_Unit_String_Object( mb, this.ptr, action, event) } fun actionEraseEvents(action: String) { val mb = getMethodBind("InputMap","action_erase_events") _icall_Unit_String( mb, this.ptr, action) } fun actionHasEvent(action: String, event: InputEvent): Boolean { val mb = getMethodBind("InputMap","action_has_event") return _icall_Boolean_String_Object( mb, this.ptr, action, event) } fun actionSetDeadzone(action: String, deadzone: Double) { val mb = getMethodBind("InputMap","action_set_deadzone") _icall_Unit_String_Double( mb, this.ptr, action, deadzone) } fun addAction(action: String, deadzone: Double = 0.5) { val mb = getMethodBind("InputMap","add_action") _icall_Unit_String_Double( mb, this.ptr, action, deadzone) } fun eraseAction(action: String) { val mb = getMethodBind("InputMap","erase_action") _icall_Unit_String( mb, this.ptr, action) } fun eventIsAction(event: InputEvent, action: String): Boolean { val mb = getMethodBind("InputMap","event_is_action") return _icall_Boolean_Object_String( mb, this.ptr, event, action) } fun getActionList(action: String): VariantArray { val mb = getMethodBind("InputMap","get_action_list") return _icall_VariantArray_String( mb, this.ptr, action) } fun getActions(): VariantArray { val mb = getMethodBind("InputMap","get_actions") return _icall_VariantArray( mb, this.ptr) } fun hasAction(action: String): Boolean { val mb = getMethodBind("InputMap","has_action") return _icall_Boolean_String( mb, this.ptr, action) } fun loadFromGlobals() { val mb = getMethodBind("InputMap","load_from_globals") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InstancePlaceholder.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.icalls._icall_Dictionary_Boolean import godot.icalls._icall_Node_Boolean_nObject import godot.icalls._icall_String import godot.icalls._icall_Unit_nObject import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.String open class InstancePlaceholder internal constructor() : Node() { open fun createInstance(replace: Boolean = false, customScene: PackedScene? = null): Node { val mb = getMethodBind("InstancePlaceholder","create_instance") return _icall_Node_Boolean_nObject( mb, this.ptr, replace, customScene) } open fun getInstancePath(): String { val mb = getMethodBind("InstancePlaceholder","get_instance_path") return _icall_String( mb, this.ptr) } open fun getStoredValues(withOrder: Boolean = false): Dictionary { val mb = getMethodBind("InstancePlaceholder","get_stored_values") return _icall_Dictionary_Boolean( mb, this.ptr, withOrder) } open fun replaceByInstance(customScene: PackedScene? = null) { val mb = getMethodBind("InstancePlaceholder","replace_by_instance") _icall_Unit_nObject( mb, this.ptr, customScene) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/InterpolatedCamera.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.NodePath import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_NodePath import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_NodePath import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlinx.cinterop.COpaquePointer open class InterpolatedCamera : Camera() { open var enabled: Boolean get() { val mb = getMethodBind("InterpolatedCamera","is_interpolation_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("InterpolatedCamera","set_interpolation_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var speed: Double get() { val mb = getMethodBind("InterpolatedCamera","get_speed") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("InterpolatedCamera","set_speed") _icall_Unit_Double(mb, this.ptr, value) } open var target: NodePath get() { val mb = getMethodBind("InterpolatedCamera","get_target_path") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("InterpolatedCamera","set_target_path") _icall_Unit_NodePath(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("InterpolatedCamera", "InterpolatedCamera") open fun getSpeed(): Double { val mb = getMethodBind("InterpolatedCamera","get_speed") return _icall_Double( mb, this.ptr) } open fun getTargetPath(): NodePath { val mb = getMethodBind("InterpolatedCamera","get_target_path") return _icall_NodePath( mb, this.ptr) } open fun isInterpolationEnabled(): Boolean { val mb = getMethodBind("InterpolatedCamera","is_interpolation_enabled") return _icall_Boolean( mb, this.ptr) } open fun setInterpolationEnabled(targetPath: Boolean) { val mb = getMethodBind("InterpolatedCamera","set_interpolation_enabled") _icall_Unit_Boolean( mb, this.ptr, targetPath) } open fun setSpeed(speed: Double) { val mb = getMethodBind("InterpolatedCamera","set_speed") _icall_Unit_Double( mb, this.ptr, speed) } open fun setTarget(target: Object) { val mb = getMethodBind("InterpolatedCamera","set_target") _icall_Unit_Object( mb, this.ptr, target) } open fun setTargetPath(targetPath: NodePath) { val mb = getMethodBind("InterpolatedCamera","set_target_path") _icall_Unit_NodePath( mb, this.ptr, targetPath) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ItemList.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.ItemList import godot.core.Color import godot.core.PoolIntArray import godot.core.Rect2 import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal2 import godot.core.Variant import godot.core.VariantArray import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Color_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Long_Vector2_Boolean import godot.icalls._icall_PoolIntArray import godot.icalls._icall_Rect2_Long import godot.icalls._icall_String_Long import godot.icalls._icall_Texture_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Color import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Long_Rect2 import godot.icalls._icall_Unit_Long_String import godot.icalls._icall_Unit_Long_Variant import godot.icalls._icall_Unit_Object_Boolean import godot.icalls._icall_Unit_String_nObject_Boolean import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_VScrollBar import godot.icalls._icall_Variant_Long import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ItemList : Control() { val itemActivated: Signal1 by signal("index") val itemRmbSelected: Signal2 by signal("index", "at_position") val itemSelected: Signal1 by signal("index") val multiSelected: Signal2 by signal("index", "selected") val nothingSelected: Signal0 by signal() val rmbClicked: Signal1 by signal("at_position") open var allowReselect: Boolean get() { val mb = getMethodBind("ItemList","get_allow_reselect") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_allow_reselect") _icall_Unit_Boolean(mb, this.ptr, value) } open var allowRmbSelect: Boolean get() { val mb = getMethodBind("ItemList","get_allow_rmb_select") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_allow_rmb_select") _icall_Unit_Boolean(mb, this.ptr, value) } open var autoHeight: Boolean get() { val mb = getMethodBind("ItemList","has_auto_height") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_auto_height") _icall_Unit_Boolean(mb, this.ptr, value) } open var fixedColumnWidth: Long get() { val mb = getMethodBind("ItemList","get_fixed_column_width") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_fixed_column_width") _icall_Unit_Long(mb, this.ptr, value) } open var fixedIconSize: Vector2 get() { val mb = getMethodBind("ItemList","get_fixed_icon_size") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_fixed_icon_size") _icall_Unit_Vector2(mb, this.ptr, value) } open var iconMode: Long get() { val mb = getMethodBind("ItemList","get_icon_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_icon_mode") _icall_Unit_Long(mb, this.ptr, value) } open var iconScale: Double get() { val mb = getMethodBind("ItemList","get_icon_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_icon_scale") _icall_Unit_Double(mb, this.ptr, value) } open var maxColumns: Long get() { val mb = getMethodBind("ItemList","get_max_columns") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_max_columns") _icall_Unit_Long(mb, this.ptr, value) } open var maxTextLines: Long get() { val mb = getMethodBind("ItemList","get_max_text_lines") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_max_text_lines") _icall_Unit_Long(mb, this.ptr, value) } open var sameColumnWidth: Boolean get() { val mb = getMethodBind("ItemList","is_same_column_width") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_same_column_width") _icall_Unit_Boolean(mb, this.ptr, value) } open var selectMode: Long get() { val mb = getMethodBind("ItemList","get_select_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ItemList","set_select_mode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ItemList", "ItemList") open fun fixedIconSize(schedule: Vector2.() -> Unit): Vector2 = fixedIconSize.apply{ schedule(this) fixedIconSize = this } open fun _getItems(): VariantArray { throw NotImplementedError("_get_items is not implemented for ItemList") } override fun _guiInput(arg0: InputEvent) { } open fun _scrollChanged(arg0: Double) { } open fun _setItems(arg0: VariantArray) { } open fun addIconItem(icon: Texture, selectable: Boolean = true) { val mb = getMethodBind("ItemList","add_icon_item") _icall_Unit_Object_Boolean( mb, this.ptr, icon, selectable) } open fun addItem( text: String, icon: Texture? = null, selectable: Boolean = true ) { val mb = getMethodBind("ItemList","add_item") _icall_Unit_String_nObject_Boolean( mb, this.ptr, text, icon, selectable) } open fun clear() { val mb = getMethodBind("ItemList","clear") _icall_Unit( mb, this.ptr) } open fun ensureCurrentIsVisible() { val mb = getMethodBind("ItemList","ensure_current_is_visible") _icall_Unit( mb, this.ptr) } open fun getAllowReselect(): Boolean { val mb = getMethodBind("ItemList","get_allow_reselect") return _icall_Boolean( mb, this.ptr) } open fun getAllowRmbSelect(): Boolean { val mb = getMethodBind("ItemList","get_allow_rmb_select") return _icall_Boolean( mb, this.ptr) } open fun getFixedColumnWidth(): Long { val mb = getMethodBind("ItemList","get_fixed_column_width") return _icall_Long( mb, this.ptr) } open fun getFixedIconSize(): Vector2 { val mb = getMethodBind("ItemList","get_fixed_icon_size") return _icall_Vector2( mb, this.ptr) } open fun getIconMode(): ItemList.IconMode { val mb = getMethodBind("ItemList","get_icon_mode") return ItemList.IconMode.from( _icall_Long( mb, this.ptr)) } open fun getIconScale(): Double { val mb = getMethodBind("ItemList","get_icon_scale") return _icall_Double( mb, this.ptr) } open fun getItemAtPosition(position: Vector2, exact: Boolean = false): Long { val mb = getMethodBind("ItemList","get_item_at_position") return _icall_Long_Vector2_Boolean( mb, this.ptr, position, exact) } open fun getItemCount(): Long { val mb = getMethodBind("ItemList","get_item_count") return _icall_Long( mb, this.ptr) } open fun getItemCustomBgColor(idx: Long): Color { val mb = getMethodBind("ItemList","get_item_custom_bg_color") return _icall_Color_Long( mb, this.ptr, idx) } open fun getItemCustomFgColor(idx: Long): Color { val mb = getMethodBind("ItemList","get_item_custom_fg_color") return _icall_Color_Long( mb, this.ptr, idx) } open fun getItemIcon(idx: Long): Texture { val mb = getMethodBind("ItemList","get_item_icon") return _icall_Texture_Long( mb, this.ptr, idx) } open fun getItemIconModulate(idx: Long): Color { val mb = getMethodBind("ItemList","get_item_icon_modulate") return _icall_Color_Long( mb, this.ptr, idx) } open fun getItemIconRegion(idx: Long): Rect2 { val mb = getMethodBind("ItemList","get_item_icon_region") return _icall_Rect2_Long( mb, this.ptr, idx) } open fun getItemMetadata(idx: Long): Variant { val mb = getMethodBind("ItemList","get_item_metadata") return _icall_Variant_Long( mb, this.ptr, idx) } open fun getItemText(idx: Long): String { val mb = getMethodBind("ItemList","get_item_text") return _icall_String_Long( mb, this.ptr, idx) } open fun getItemTooltip(idx: Long): String { val mb = getMethodBind("ItemList","get_item_tooltip") return _icall_String_Long( mb, this.ptr, idx) } open fun getMaxColumns(): Long { val mb = getMethodBind("ItemList","get_max_columns") return _icall_Long( mb, this.ptr) } open fun getMaxTextLines(): Long { val mb = getMethodBind("ItemList","get_max_text_lines") return _icall_Long( mb, this.ptr) } open fun getSelectMode(): ItemList.SelectMode { val mb = getMethodBind("ItemList","get_select_mode") return ItemList.SelectMode.from( _icall_Long( mb, this.ptr)) } open fun getSelectedItems(): PoolIntArray { val mb = getMethodBind("ItemList","get_selected_items") return _icall_PoolIntArray( mb, this.ptr) } open fun getVScroll(): VScrollBar { val mb = getMethodBind("ItemList","get_v_scroll") return _icall_VScrollBar( mb, this.ptr) } open fun hasAutoHeight(): Boolean { val mb = getMethodBind("ItemList","has_auto_height") return _icall_Boolean( mb, this.ptr) } open fun isAnythingSelected(): Boolean { val mb = getMethodBind("ItemList","is_anything_selected") return _icall_Boolean( mb, this.ptr) } open fun isItemDisabled(idx: Long): Boolean { val mb = getMethodBind("ItemList","is_item_disabled") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isItemIconTransposed(idx: Long): Boolean { val mb = getMethodBind("ItemList","is_item_icon_transposed") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isItemSelectable(idx: Long): Boolean { val mb = getMethodBind("ItemList","is_item_selectable") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isItemTooltipEnabled(idx: Long): Boolean { val mb = getMethodBind("ItemList","is_item_tooltip_enabled") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isSameColumnWidth(): Boolean { val mb = getMethodBind("ItemList","is_same_column_width") return _icall_Boolean( mb, this.ptr) } open fun isSelected(idx: Long): Boolean { val mb = getMethodBind("ItemList","is_selected") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun moveItem(fromIdx: Long, toIdx: Long) { val mb = getMethodBind("ItemList","move_item") _icall_Unit_Long_Long( mb, this.ptr, fromIdx, toIdx) } open fun removeItem(idx: Long) { val mb = getMethodBind("ItemList","remove_item") _icall_Unit_Long( mb, this.ptr, idx) } open fun select(idx: Long, single: Boolean = true) { val mb = getMethodBind("ItemList","select") _icall_Unit_Long_Boolean( mb, this.ptr, idx, single) } open fun setAllowReselect(allow: Boolean) { val mb = getMethodBind("ItemList","set_allow_reselect") _icall_Unit_Boolean( mb, this.ptr, allow) } open fun setAllowRmbSelect(allow: Boolean) { val mb = getMethodBind("ItemList","set_allow_rmb_select") _icall_Unit_Boolean( mb, this.ptr, allow) } open fun setAutoHeight(enable: Boolean) { val mb = getMethodBind("ItemList","set_auto_height") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setFixedColumnWidth(width: Long) { val mb = getMethodBind("ItemList","set_fixed_column_width") _icall_Unit_Long( mb, this.ptr, width) } open fun setFixedIconSize(size: Vector2) { val mb = getMethodBind("ItemList","set_fixed_icon_size") _icall_Unit_Vector2( mb, this.ptr, size) } open fun setIconMode(mode: Long) { val mb = getMethodBind("ItemList","set_icon_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setIconScale(scale: Double) { val mb = getMethodBind("ItemList","set_icon_scale") _icall_Unit_Double( mb, this.ptr, scale) } open fun setItemCustomBgColor(idx: Long, customBgColor: Color) { val mb = getMethodBind("ItemList","set_item_custom_bg_color") _icall_Unit_Long_Color( mb, this.ptr, idx, customBgColor) } open fun setItemCustomFgColor(idx: Long, customFgColor: Color) { val mb = getMethodBind("ItemList","set_item_custom_fg_color") _icall_Unit_Long_Color( mb, this.ptr, idx, customFgColor) } open fun setItemDisabled(idx: Long, disabled: Boolean) { val mb = getMethodBind("ItemList","set_item_disabled") _icall_Unit_Long_Boolean( mb, this.ptr, idx, disabled) } open fun setItemIcon(idx: Long, icon: Texture) { val mb = getMethodBind("ItemList","set_item_icon") _icall_Unit_Long_Object( mb, this.ptr, idx, icon) } open fun setItemIconModulate(idx: Long, modulate: Color) { val mb = getMethodBind("ItemList","set_item_icon_modulate") _icall_Unit_Long_Color( mb, this.ptr, idx, modulate) } open fun setItemIconRegion(idx: Long, rect: Rect2) { val mb = getMethodBind("ItemList","set_item_icon_region") _icall_Unit_Long_Rect2( mb, this.ptr, idx, rect) } open fun setItemIconTransposed(idx: Long, transposed: Boolean) { val mb = getMethodBind("ItemList","set_item_icon_transposed") _icall_Unit_Long_Boolean( mb, this.ptr, idx, transposed) } open fun setItemMetadata(idx: Long, metadata: Variant) { val mb = getMethodBind("ItemList","set_item_metadata") _icall_Unit_Long_Variant( mb, this.ptr, idx, metadata) } open fun setItemSelectable(idx: Long, selectable: Boolean) { val mb = getMethodBind("ItemList","set_item_selectable") _icall_Unit_Long_Boolean( mb, this.ptr, idx, selectable) } open fun setItemText(idx: Long, text: String) { val mb = getMethodBind("ItemList","set_item_text") _icall_Unit_Long_String( mb, this.ptr, idx, text) } open fun setItemTooltip(idx: Long, tooltip: String) { val mb = getMethodBind("ItemList","set_item_tooltip") _icall_Unit_Long_String( mb, this.ptr, idx, tooltip) } open fun setItemTooltipEnabled(idx: Long, enable: Boolean) { val mb = getMethodBind("ItemList","set_item_tooltip_enabled") _icall_Unit_Long_Boolean( mb, this.ptr, idx, enable) } open fun setMaxColumns(amount: Long) { val mb = getMethodBind("ItemList","set_max_columns") _icall_Unit_Long( mb, this.ptr, amount) } open fun setMaxTextLines(lines: Long) { val mb = getMethodBind("ItemList","set_max_text_lines") _icall_Unit_Long( mb, this.ptr, lines) } open fun setSameColumnWidth(enable: Boolean) { val mb = getMethodBind("ItemList","set_same_column_width") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setSelectMode(mode: Long) { val mb = getMethodBind("ItemList","set_select_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun sortItemsByText() { val mb = getMethodBind("ItemList","sort_items_by_text") _icall_Unit( mb, this.ptr) } open fun unselect(idx: Long) { val mb = getMethodBind("ItemList","unselect") _icall_Unit_Long( mb, this.ptr, idx) } open fun unselectAll() { val mb = getMethodBind("ItemList","unselect_all") _icall_Unit( mb, this.ptr) } enum class SelectMode( id: Long ) { SELECT_SINGLE(0), SELECT_MULTI(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class IconMode( id: Long ) { ICON_MODE_TOP(0), ICON_MODE_LEFT(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/JNISingleton.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class JNISingleton : Object() { override fun __new(): COpaquePointer = invokeConstructor("JNISingleton", "JNISingleton") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/JSON.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.core.Variant import godot.icalls._icall_JSONParseResult_String import godot.icalls._icall_String_Variant_String_Boolean import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object JSON : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("JSON".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton JSON" } ptr } fun parse(json: String): JSONParseResult { val mb = getMethodBind("_JSON","parse") return _icall_JSONParseResult_String( mb, this.ptr, json) } fun print( value: Variant, indent: String = "", sortKeys: Boolean = false ): String { val mb = getMethodBind("_JSON","print") return _icall_String_Variant_String_Boolean( mb, this.ptr, value, indent, sortKeys) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/JSONParseResult.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.Variant import godot.icalls._icall_Long import godot.icalls._icall_Object import godot.icalls._icall_String import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_Variant import godot.icalls._icall_Variant import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class JSONParseResult : Reference() { open var error: Object get() { val mb = getMethodBind("JSONParseResult","get_error") return _icall_Object(mb, this.ptr) } set(value) { val mb = getMethodBind("JSONParseResult","set_error") _icall_Unit_Object(mb, this.ptr, value) } open var errorLine: Long get() { val mb = getMethodBind("JSONParseResult","get_error_line") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("JSONParseResult","set_error_line") _icall_Unit_Long(mb, this.ptr, value) } open var errorString: String get() { val mb = getMethodBind("JSONParseResult","get_error_string") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("JSONParseResult","set_error_string") _icall_Unit_String(mb, this.ptr, value) } open var result: Variant get() { val mb = getMethodBind("JSONParseResult","get_result") return _icall_Variant(mb, this.ptr) } set(value) { val mb = getMethodBind("JSONParseResult","set_result") _icall_Unit_Variant(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("JSONParseResult", "JSONParseResult") open fun getError(): GodotError { val mb = getMethodBind("JSONParseResult","get_error") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } open fun getErrorLine(): Long { val mb = getMethodBind("JSONParseResult","get_error_line") return _icall_Long( mb, this.ptr) } open fun getErrorString(): String { val mb = getMethodBind("JSONParseResult","get_error_string") return _icall_String( mb, this.ptr) } open fun getResult(): Variant { val mb = getMethodBind("JSONParseResult","get_result") return _icall_Variant( mb, this.ptr) } open fun setError(error: Long) { val mb = getMethodBind("JSONParseResult","set_error") _icall_Unit_Long( mb, this.ptr, error) } open fun setErrorLine(errorLine: Long) { val mb = getMethodBind("JSONParseResult","set_error_line") _icall_Unit_Long( mb, this.ptr, errorLine) } open fun setErrorString(errorString: String) { val mb = getMethodBind("JSONParseResult","set_error_string") _icall_Unit_String( mb, this.ptr, errorString) } open fun setResult(result: Variant) { val mb = getMethodBind("JSONParseResult","set_result") _icall_Unit_Variant( mb, this.ptr, result) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/JSONRPC.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.Variant import godot.icalls._icall_Dictionary_Long_String_nVariant import godot.icalls._icall_Dictionary_String_Variant import godot.icalls._icall_Dictionary_String_Variant_Variant import godot.icalls._icall_Dictionary_Variant_Variant import godot.icalls._icall_String_String import godot.icalls._icall_Unit_String_Object import godot.icalls._icall_Variant_Variant_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class JSONRPC : Object() { override fun __new(): COpaquePointer = invokeConstructor("JSONRPC", "JSONRPC") open fun makeNotification(method: String, params: Variant): Dictionary { val mb = getMethodBind("JSONRPC","make_notification") return _icall_Dictionary_String_Variant( mb, this.ptr, method, params) } open fun makeRequest( method: String, params: Variant, id: Variant ): Dictionary { val mb = getMethodBind("JSONRPC","make_request") return _icall_Dictionary_String_Variant_Variant( mb, this.ptr, method, params, id) } open fun makeResponse(result: Variant, id: Variant): Dictionary { val mb = getMethodBind("JSONRPC","make_response") return _icall_Dictionary_Variant_Variant( mb, this.ptr, result, id) } open fun makeResponseError( code: Long, message: String, id: Variant? = null ): Dictionary { val mb = getMethodBind("JSONRPC","make_response_error") return _icall_Dictionary_Long_String_nVariant( mb, this.ptr, code, message, id) } open fun processAction(action: Variant, recurse: Boolean = false): Variant { val mb = getMethodBind("JSONRPC","process_action") return _icall_Variant_Variant_Boolean( mb, this.ptr, action, recurse) } open fun processString(action: String): String { val mb = getMethodBind("JSONRPC","process_string") return _icall_String_String( mb, this.ptr, action) } open fun setScope(scope: String, target: Object) { val mb = getMethodBind("JSONRPC","set_scope") _icall_Unit_String_Object( mb, this.ptr, scope, target) } enum class ErrorCode( id: Long ) { PARSE_ERROR(-32700), INTERNAL_ERROR(-32603), INVALID_PARAMS(-32602), METHOD_NOT_FOUND(-32601), INVALID_REQUEST(-32600); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/JavaClass.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class JavaClass : Reference() { override fun __new(): COpaquePointer = invokeConstructor("JavaClass", "JavaClass") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/JavaClassWrapper.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.icalls._icall_JavaClass_String import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object JavaClassWrapper : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("JavaClassWrapper".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton JavaClassWrapper" } ptr } fun wrap(name: String): JavaClass { val mb = getMethodBind("JavaClassWrapper","wrap") return _icall_JavaClass_String( mb, this.ptr, name) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/JavaScript.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.core.Variant import godot.icalls._icall_Variant_String_Boolean import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object JavaScript : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("JavaScript".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton JavaScript" } ptr } fun eval(code: String, useGlobalExecutionContext: Boolean = false): Variant { val mb = getMethodBind("JavaScript","eval") return _icall_Variant_String_Boolean( mb, this.ptr, code, useGlobalExecutionContext) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Joint.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.NodePath import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_NodePath import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_NodePath import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long open class Joint internal constructor() : Spatial() { open var collision_excludeNodes: Boolean get() { val mb = getMethodBind("Joint","get_exclude_nodes_from_collision") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Joint","set_exclude_nodes_from_collision") _icall_Unit_Boolean(mb, this.ptr, value) } open var nodes_nodeA: NodePath get() { val mb = getMethodBind("Joint","get_node_a") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("Joint","set_node_a") _icall_Unit_NodePath(mb, this.ptr, value) } open var nodes_nodeB: NodePath get() { val mb = getMethodBind("Joint","get_node_b") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("Joint","set_node_b") _icall_Unit_NodePath(mb, this.ptr, value) } open var solver_priority: Long get() { val mb = getMethodBind("Joint","get_solver_priority") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Joint","set_solver_priority") _icall_Unit_Long(mb, this.ptr, value) } open fun getExcludeNodesFromCollision(): Boolean { val mb = getMethodBind("Joint","get_exclude_nodes_from_collision") return _icall_Boolean( mb, this.ptr) } open fun getNodeA(): NodePath { val mb = getMethodBind("Joint","get_node_a") return _icall_NodePath( mb, this.ptr) } open fun getNodeB(): NodePath { val mb = getMethodBind("Joint","get_node_b") return _icall_NodePath( mb, this.ptr) } open fun getSolverPriority(): Long { val mb = getMethodBind("Joint","get_solver_priority") return _icall_Long( mb, this.ptr) } open fun setExcludeNodesFromCollision(enable: Boolean) { val mb = getMethodBind("Joint","set_exclude_nodes_from_collision") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setNodeA(node: NodePath) { val mb = getMethodBind("Joint","set_node_a") _icall_Unit_NodePath( mb, this.ptr, node) } open fun setNodeB(node: NodePath) { val mb = getMethodBind("Joint","set_node_b") _icall_Unit_NodePath( mb, this.ptr, node) } open fun setSolverPriority(priority: Long) { val mb = getMethodBind("Joint","set_solver_priority") _icall_Unit_Long( mb, this.ptr, priority) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Joint2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.NodePath import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_NodePath import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_NodePath import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double open class Joint2D internal constructor() : Node2D() { open var bias: Double get() { val mb = getMethodBind("Joint2D","get_bias") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Joint2D","set_bias") _icall_Unit_Double(mb, this.ptr, value) } open var disableCollision: Boolean get() { val mb = getMethodBind("Joint2D","get_exclude_nodes_from_collision") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Joint2D","set_exclude_nodes_from_collision") _icall_Unit_Boolean(mb, this.ptr, value) } open var nodeA: NodePath get() { val mb = getMethodBind("Joint2D","get_node_a") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("Joint2D","set_node_a") _icall_Unit_NodePath(mb, this.ptr, value) } open var nodeB: NodePath get() { val mb = getMethodBind("Joint2D","get_node_b") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("Joint2D","set_node_b") _icall_Unit_NodePath(mb, this.ptr, value) } open fun getBias(): Double { val mb = getMethodBind("Joint2D","get_bias") return _icall_Double( mb, this.ptr) } open fun getExcludeNodesFromCollision(): Boolean { val mb = getMethodBind("Joint2D","get_exclude_nodes_from_collision") return _icall_Boolean( mb, this.ptr) } open fun getNodeA(): NodePath { val mb = getMethodBind("Joint2D","get_node_a") return _icall_NodePath( mb, this.ptr) } open fun getNodeB(): NodePath { val mb = getMethodBind("Joint2D","get_node_b") return _icall_NodePath( mb, this.ptr) } open fun setBias(bias: Double) { val mb = getMethodBind("Joint2D","set_bias") _icall_Unit_Double( mb, this.ptr, bias) } open fun setExcludeNodesFromCollision(enable: Boolean) { val mb = getMethodBind("Joint2D","set_exclude_nodes_from_collision") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setNodeA(node: NodePath) { val mb = getMethodBind("Joint2D","set_node_a") _icall_Unit_NodePath( mb, this.ptr, node) } open fun setNodeB(node: NodePath) { val mb = getMethodBind("Joint2D","set_node_b") _icall_Unit_NodePath( mb, this.ptr, node) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/KinematicBody.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Transform import godot.core.Vector3 import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_Transform_Vector3_Boolean import godot.icalls._icall_Double import godot.icalls._icall_KinematicCollision_Long import godot.icalls._icall_KinematicCollision_Vector3_Boolean_Boolean_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Vector3 import godot.icalls._icall_Vector3_Vector3_Vector3_Boolean_Long_Double_Boolean import godot.icalls._icall_Vector3_Vector3_Vector3_Vector3_Boolean_Long_Double_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class KinematicBody : PhysicsBody() { open var collision_safeMargin: Double get() { val mb = getMethodBind("KinematicBody","get_safe_margin") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("KinematicBody","set_safe_margin") _icall_Unit_Double(mb, this.ptr, value) } open var moveLockX: Boolean get() { val mb = getMethodBind("KinematicBody","get_axis_lock") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("KinematicBody","set_axis_lock") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var moveLockY: Boolean get() { val mb = getMethodBind("KinematicBody","get_axis_lock") return _icall_Boolean_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("KinematicBody","set_axis_lock") _icall_Unit_Long_Boolean(mb, this.ptr, 2, value) } open var moveLockZ: Boolean get() { val mb = getMethodBind("KinematicBody","get_axis_lock") return _icall_Boolean_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("KinematicBody","set_axis_lock") _icall_Unit_Long_Boolean(mb, this.ptr, 4, value) } override fun __new(): COpaquePointer = invokeConstructor("KinematicBody", "KinematicBody") open fun getAxisLock(axis: Long): Boolean { val mb = getMethodBind("KinematicBody","get_axis_lock") return _icall_Boolean_Long( mb, this.ptr, axis) } open fun getFloorNormal(): Vector3 { val mb = getMethodBind("KinematicBody","get_floor_normal") return _icall_Vector3( mb, this.ptr) } open fun getFloorVelocity(): Vector3 { val mb = getMethodBind("KinematicBody","get_floor_velocity") return _icall_Vector3( mb, this.ptr) } open fun getSafeMargin(): Double { val mb = getMethodBind("KinematicBody","get_safe_margin") return _icall_Double( mb, this.ptr) } open fun getSlideCollision(slideIdx: Long): KinematicCollision { val mb = getMethodBind("KinematicBody","get_slide_collision") return _icall_KinematicCollision_Long( mb, this.ptr, slideIdx) } open fun getSlideCount(): Long { val mb = getMethodBind("KinematicBody","get_slide_count") return _icall_Long( mb, this.ptr) } open fun isOnCeiling(): Boolean { val mb = getMethodBind("KinematicBody","is_on_ceiling") return _icall_Boolean( mb, this.ptr) } open fun isOnFloor(): Boolean { val mb = getMethodBind("KinematicBody","is_on_floor") return _icall_Boolean( mb, this.ptr) } open fun isOnWall(): Boolean { val mb = getMethodBind("KinematicBody","is_on_wall") return _icall_Boolean( mb, this.ptr) } open fun moveAndCollide( relVec: Vector3, infiniteInertia: Boolean = true, excludeRaycastShapes: Boolean = true, testOnly: Boolean = false ): KinematicCollision { val mb = getMethodBind("KinematicBody","move_and_collide") return _icall_KinematicCollision_Vector3_Boolean_Boolean_Boolean( mb, this.ptr, relVec, infiniteInertia, excludeRaycastShapes, testOnly) } open fun moveAndSlide( linearVelocity: Vector3, upDirection: Vector3 = Vector3(0.0, 0.0, 0.0), stopOnSlope: Boolean = false, maxSlides: Long = 4, floorMaxAngle: Double = 0.785398, infiniteInertia: Boolean = true ): Vector3 { val mb = getMethodBind("KinematicBody","move_and_slide") return _icall_Vector3_Vector3_Vector3_Boolean_Long_Double_Boolean( mb, this.ptr, linearVelocity, upDirection, stopOnSlope, maxSlides, floorMaxAngle, infiniteInertia) } open fun moveAndSlideWithSnap( linearVelocity: Vector3, snap: Vector3, upDirection: Vector3 = Vector3(0.0, 0.0, 0.0), stopOnSlope: Boolean = false, maxSlides: Long = 4, floorMaxAngle: Double = 0.785398, infiniteInertia: Boolean = true ): Vector3 { val mb = getMethodBind("KinematicBody","move_and_slide_with_snap") return _icall_Vector3_Vector3_Vector3_Vector3_Boolean_Long_Double_Boolean( mb, this.ptr, linearVelocity, snap, upDirection, stopOnSlope, maxSlides, floorMaxAngle, infiniteInertia) } open fun setAxisLock(axis: Long, lock: Boolean) { val mb = getMethodBind("KinematicBody","set_axis_lock") _icall_Unit_Long_Boolean( mb, this.ptr, axis, lock) } open fun setSafeMargin(pixels: Double) { val mb = getMethodBind("KinematicBody","set_safe_margin") _icall_Unit_Double( mb, this.ptr, pixels) } open fun testMove( from: Transform, relVec: Vector3, infiniteInertia: Boolean = true ): Boolean { val mb = getMethodBind("KinematicBody","test_move") return _icall_Boolean_Transform_Vector3_Boolean( mb, this.ptr, from, relVec, infiniteInertia) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/KinematicBody2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Transform2D import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Transform2D_Vector2_Boolean import godot.icalls._icall_Double import godot.icalls._icall_KinematicCollision2D_Long import godot.icalls._icall_KinematicCollision2D_Vector2_Boolean_Boolean_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_Vector2_Vector2_Boolean_Long_Double_Boolean import godot.icalls._icall_Vector2_Vector2_Vector2_Vector2_Boolean_Long_Double_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class KinematicBody2D : PhysicsBody2D() { open var collision_safeMargin: Double get() { val mb = getMethodBind("KinematicBody2D","get_safe_margin") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("KinematicBody2D","set_safe_margin") _icall_Unit_Double(mb, this.ptr, value) } open var motion_syncToPhysics: Boolean get() { val mb = getMethodBind("KinematicBody2D","is_sync_to_physics_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("KinematicBody2D","set_sync_to_physics") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("KinematicBody2D", "KinematicBody2D") open fun _directStateChanged(arg0: Object) { } open fun getFloorNormal(): Vector2 { val mb = getMethodBind("KinematicBody2D","get_floor_normal") return _icall_Vector2( mb, this.ptr) } open fun getFloorVelocity(): Vector2 { val mb = getMethodBind("KinematicBody2D","get_floor_velocity") return _icall_Vector2( mb, this.ptr) } open fun getSafeMargin(): Double { val mb = getMethodBind("KinematicBody2D","get_safe_margin") return _icall_Double( mb, this.ptr) } open fun getSlideCollision(slideIdx: Long): KinematicCollision2D { val mb = getMethodBind("KinematicBody2D","get_slide_collision") return _icall_KinematicCollision2D_Long( mb, this.ptr, slideIdx) } open fun getSlideCount(): Long { val mb = getMethodBind("KinematicBody2D","get_slide_count") return _icall_Long( mb, this.ptr) } open fun isOnCeiling(): Boolean { val mb = getMethodBind("KinematicBody2D","is_on_ceiling") return _icall_Boolean( mb, this.ptr) } open fun isOnFloor(): Boolean { val mb = getMethodBind("KinematicBody2D","is_on_floor") return _icall_Boolean( mb, this.ptr) } open fun isOnWall(): Boolean { val mb = getMethodBind("KinematicBody2D","is_on_wall") return _icall_Boolean( mb, this.ptr) } open fun isSyncToPhysicsEnabled(): Boolean { val mb = getMethodBind("KinematicBody2D","is_sync_to_physics_enabled") return _icall_Boolean( mb, this.ptr) } open fun moveAndCollide( relVec: Vector2, infiniteInertia: Boolean = true, excludeRaycastShapes: Boolean = true, testOnly: Boolean = false ): KinematicCollision2D { val mb = getMethodBind("KinematicBody2D","move_and_collide") return _icall_KinematicCollision2D_Vector2_Boolean_Boolean_Boolean( mb, this.ptr, relVec, infiniteInertia, excludeRaycastShapes, testOnly) } open fun moveAndSlide( linearVelocity: Vector2, upDirection: Vector2 = Vector2(0.0, 0.0), stopOnSlope: Boolean = false, maxSlides: Long = 4, floorMaxAngle: Double = 0.785398, infiniteInertia: Boolean = true ): Vector2 { val mb = getMethodBind("KinematicBody2D","move_and_slide") return _icall_Vector2_Vector2_Vector2_Boolean_Long_Double_Boolean( mb, this.ptr, linearVelocity, upDirection, stopOnSlope, maxSlides, floorMaxAngle, infiniteInertia) } open fun moveAndSlideWithSnap( linearVelocity: Vector2, snap: Vector2, upDirection: Vector2 = Vector2(0.0, 0.0), stopOnSlope: Boolean = false, maxSlides: Long = 4, floorMaxAngle: Double = 0.785398, infiniteInertia: Boolean = true ): Vector2 { val mb = getMethodBind("KinematicBody2D","move_and_slide_with_snap") return _icall_Vector2_Vector2_Vector2_Vector2_Boolean_Long_Double_Boolean( mb, this.ptr, linearVelocity, snap, upDirection, stopOnSlope, maxSlides, floorMaxAngle, infiniteInertia) } open fun setSafeMargin(pixels: Double) { val mb = getMethodBind("KinematicBody2D","set_safe_margin") _icall_Unit_Double( mb, this.ptr, pixels) } open fun setSyncToPhysics(enable: Boolean) { val mb = getMethodBind("KinematicBody2D","set_sync_to_physics") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun testMove( from: Transform2D, relVec: Vector2, infiniteInertia: Boolean = true ): Boolean { val mb = getMethodBind("KinematicBody2D","test_move") return _icall_Boolean_Transform2D_Vector2_Boolean( mb, this.ptr, from, relVec, infiniteInertia) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/KinematicCollision.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Variant import godot.core.Vector3 import godot.icalls._icall_Long import godot.icalls._icall_Object import godot.icalls._icall_Variant import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class KinematicCollision : Reference() { open val collider: Object get() { val mb = getMethodBind("KinematicCollision","get_collider") return _icall_Object(mb, this.ptr) } open val colliderId: Long get() { val mb = getMethodBind("KinematicCollision","get_collider_id") return _icall_Long(mb, this.ptr) } open val colliderMetadata: Variant get() { val mb = getMethodBind("KinematicCollision","get_collider_metadata") return _icall_Variant(mb, this.ptr) } open val colliderShape: Object get() { val mb = getMethodBind("KinematicCollision","get_collider_shape") return _icall_Object(mb, this.ptr) } open val colliderShapeIndex: Long get() { val mb = getMethodBind("KinematicCollision","get_collider_shape_index") return _icall_Long(mb, this.ptr) } open val colliderVelocity: Vector3 get() { val mb = getMethodBind("KinematicCollision","get_collider_velocity") return _icall_Vector3(mb, this.ptr) } open val localShape: Object get() { val mb = getMethodBind("KinematicCollision","get_local_shape") return _icall_Object(mb, this.ptr) } open val normal: Vector3 get() { val mb = getMethodBind("KinematicCollision","get_normal") return _icall_Vector3(mb, this.ptr) } open val position: Vector3 get() { val mb = getMethodBind("KinematicCollision","get_position") return _icall_Vector3(mb, this.ptr) } open val remainder: Vector3 get() { val mb = getMethodBind("KinematicCollision","get_remainder") return _icall_Vector3(mb, this.ptr) } open val travel: Vector3 get() { val mb = getMethodBind("KinematicCollision","get_travel") return _icall_Vector3(mb, this.ptr) } override fun __new(): COpaquePointer = invokeConstructor("KinematicCollision", "KinematicCollision") open fun getCollider(): Object { val mb = getMethodBind("KinematicCollision","get_collider") return _icall_Object( mb, this.ptr) } open fun getColliderId(): Long { val mb = getMethodBind("KinematicCollision","get_collider_id") return _icall_Long( mb, this.ptr) } open fun getColliderMetadata(): Variant { val mb = getMethodBind("KinematicCollision","get_collider_metadata") return _icall_Variant( mb, this.ptr) } open fun getColliderShape(): Object { val mb = getMethodBind("KinematicCollision","get_collider_shape") return _icall_Object( mb, this.ptr) } open fun getColliderShapeIndex(): Long { val mb = getMethodBind("KinematicCollision","get_collider_shape_index") return _icall_Long( mb, this.ptr) } open fun getColliderVelocity(): Vector3 { val mb = getMethodBind("KinematicCollision","get_collider_velocity") return _icall_Vector3( mb, this.ptr) } open fun getLocalShape(): Object { val mb = getMethodBind("KinematicCollision","get_local_shape") return _icall_Object( mb, this.ptr) } open fun getNormal(): Vector3 { val mb = getMethodBind("KinematicCollision","get_normal") return _icall_Vector3( mb, this.ptr) } open fun getPosition(): Vector3 { val mb = getMethodBind("KinematicCollision","get_position") return _icall_Vector3( mb, this.ptr) } open fun getRemainder(): Vector3 { val mb = getMethodBind("KinematicCollision","get_remainder") return _icall_Vector3( mb, this.ptr) } open fun getTravel(): Vector3 { val mb = getMethodBind("KinematicCollision","get_travel") return _icall_Vector3( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/KinematicCollision2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Variant import godot.core.Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Object import godot.icalls._icall_Variant import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class KinematicCollision2D : Reference() { open val collider: Object get() { val mb = getMethodBind("KinematicCollision2D","get_collider") return _icall_Object(mb, this.ptr) } open val colliderId: Long get() { val mb = getMethodBind("KinematicCollision2D","get_collider_id") return _icall_Long(mb, this.ptr) } open val colliderMetadata: Variant get() { val mb = getMethodBind("KinematicCollision2D","get_collider_metadata") return _icall_Variant(mb, this.ptr) } open val colliderShape: Object get() { val mb = getMethodBind("KinematicCollision2D","get_collider_shape") return _icall_Object(mb, this.ptr) } open val colliderShapeIndex: Long get() { val mb = getMethodBind("KinematicCollision2D","get_collider_shape_index") return _icall_Long(mb, this.ptr) } open val colliderVelocity: Vector2 get() { val mb = getMethodBind("KinematicCollision2D","get_collider_velocity") return _icall_Vector2(mb, this.ptr) } open val localShape: Object get() { val mb = getMethodBind("KinematicCollision2D","get_local_shape") return _icall_Object(mb, this.ptr) } open val normal: Vector2 get() { val mb = getMethodBind("KinematicCollision2D","get_normal") return _icall_Vector2(mb, this.ptr) } open val position: Vector2 get() { val mb = getMethodBind("KinematicCollision2D","get_position") return _icall_Vector2(mb, this.ptr) } open val remainder: Vector2 get() { val mb = getMethodBind("KinematicCollision2D","get_remainder") return _icall_Vector2(mb, this.ptr) } open val travel: Vector2 get() { val mb = getMethodBind("KinematicCollision2D","get_travel") return _icall_Vector2(mb, this.ptr) } override fun __new(): COpaquePointer = invokeConstructor("KinematicCollision2D", "KinematicCollision2D") open fun getCollider(): Object { val mb = getMethodBind("KinematicCollision2D","get_collider") return _icall_Object( mb, this.ptr) } open fun getColliderId(): Long { val mb = getMethodBind("KinematicCollision2D","get_collider_id") return _icall_Long( mb, this.ptr) } open fun getColliderMetadata(): Variant { val mb = getMethodBind("KinematicCollision2D","get_collider_metadata") return _icall_Variant( mb, this.ptr) } open fun getColliderShape(): Object { val mb = getMethodBind("KinematicCollision2D","get_collider_shape") return _icall_Object( mb, this.ptr) } open fun getColliderShapeIndex(): Long { val mb = getMethodBind("KinematicCollision2D","get_collider_shape_index") return _icall_Long( mb, this.ptr) } open fun getColliderVelocity(): Vector2 { val mb = getMethodBind("KinematicCollision2D","get_collider_velocity") return _icall_Vector2( mb, this.ptr) } open fun getLocalShape(): Object { val mb = getMethodBind("KinematicCollision2D","get_local_shape") return _icall_Object( mb, this.ptr) } open fun getNormal(): Vector2 { val mb = getMethodBind("KinematicCollision2D","get_normal") return _icall_Vector2( mb, this.ptr) } open fun getPosition(): Vector2 { val mb = getMethodBind("KinematicCollision2D","get_position") return _icall_Vector2( mb, this.ptr) } open fun getRemainder(): Vector2 { val mb = getMethodBind("KinematicCollision2D","get_remainder") return _icall_Vector2( mb, this.ptr) } open fun getTravel(): Vector2 { val mb = getMethodBind("KinematicCollision2D","get_travel") return _icall_Vector2( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Label.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Label import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class Label : Control() { open var align: Long get() { val mb = getMethodBind("Label","get_align") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_align") _icall_Unit_Long(mb, this.ptr, value) } open var autowrap: Boolean get() { val mb = getMethodBind("Label","has_autowrap") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_autowrap") _icall_Unit_Boolean(mb, this.ptr, value) } open var clipText: Boolean get() { val mb = getMethodBind("Label","is_clipping_text") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_clip_text") _icall_Unit_Boolean(mb, this.ptr, value) } open var linesSkipped: Long get() { val mb = getMethodBind("Label","get_lines_skipped") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_lines_skipped") _icall_Unit_Long(mb, this.ptr, value) } open var maxLinesVisible: Long get() { val mb = getMethodBind("Label","get_max_lines_visible") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_max_lines_visible") _icall_Unit_Long(mb, this.ptr, value) } open var percentVisible: Double get() { val mb = getMethodBind("Label","get_percent_visible") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_percent_visible") _icall_Unit_Double(mb, this.ptr, value) } open var text: String get() { val mb = getMethodBind("Label","get_text") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_text") _icall_Unit_String(mb, this.ptr, value) } open var uppercase: Boolean get() { val mb = getMethodBind("Label","is_uppercase") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_uppercase") _icall_Unit_Boolean(mb, this.ptr, value) } open var valign: Long get() { val mb = getMethodBind("Label","get_valign") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_valign") _icall_Unit_Long(mb, this.ptr, value) } open var visibleCharacters: Long get() { val mb = getMethodBind("Label","get_visible_characters") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Label","set_visible_characters") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Label", "Label") open fun getAlign(): Label.Align { val mb = getMethodBind("Label","get_align") return Label.Align.from( _icall_Long( mb, this.ptr)) } open fun getLineCount(): Long { val mb = getMethodBind("Label","get_line_count") return _icall_Long( mb, this.ptr) } open fun getLineHeight(): Long { val mb = getMethodBind("Label","get_line_height") return _icall_Long( mb, this.ptr) } open fun getLinesSkipped(): Long { val mb = getMethodBind("Label","get_lines_skipped") return _icall_Long( mb, this.ptr) } open fun getMaxLinesVisible(): Long { val mb = getMethodBind("Label","get_max_lines_visible") return _icall_Long( mb, this.ptr) } open fun getPercentVisible(): Double { val mb = getMethodBind("Label","get_percent_visible") return _icall_Double( mb, this.ptr) } open fun getText(): String { val mb = getMethodBind("Label","get_text") return _icall_String( mb, this.ptr) } open fun getTotalCharacterCount(): Long { val mb = getMethodBind("Label","get_total_character_count") return _icall_Long( mb, this.ptr) } open fun getValign(): Label.VAlign { val mb = getMethodBind("Label","get_valign") return Label.VAlign.from( _icall_Long( mb, this.ptr)) } open fun getVisibleCharacters(): Long { val mb = getMethodBind("Label","get_visible_characters") return _icall_Long( mb, this.ptr) } open fun getVisibleLineCount(): Long { val mb = getMethodBind("Label","get_visible_line_count") return _icall_Long( mb, this.ptr) } open fun hasAutowrap(): Boolean { val mb = getMethodBind("Label","has_autowrap") return _icall_Boolean( mb, this.ptr) } open fun isClippingText(): Boolean { val mb = getMethodBind("Label","is_clipping_text") return _icall_Boolean( mb, this.ptr) } open fun isUppercase(): Boolean { val mb = getMethodBind("Label","is_uppercase") return _icall_Boolean( mb, this.ptr) } open fun setAlign(align: Long) { val mb = getMethodBind("Label","set_align") _icall_Unit_Long( mb, this.ptr, align) } open fun setAutowrap(enable: Boolean) { val mb = getMethodBind("Label","set_autowrap") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setClipText(enable: Boolean) { val mb = getMethodBind("Label","set_clip_text") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setLinesSkipped(linesSkipped: Long) { val mb = getMethodBind("Label","set_lines_skipped") _icall_Unit_Long( mb, this.ptr, linesSkipped) } open fun setMaxLinesVisible(linesVisible: Long) { val mb = getMethodBind("Label","set_max_lines_visible") _icall_Unit_Long( mb, this.ptr, linesVisible) } open fun setPercentVisible(percentVisible: Double) { val mb = getMethodBind("Label","set_percent_visible") _icall_Unit_Double( mb, this.ptr, percentVisible) } open fun setText(text: String) { val mb = getMethodBind("Label","set_text") _icall_Unit_String( mb, this.ptr, text) } open fun setUppercase(enable: Boolean) { val mb = getMethodBind("Label","set_uppercase") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setValign(valign: Long) { val mb = getMethodBind("Label","set_valign") _icall_Unit_Long( mb, this.ptr, valign) } open fun setVisibleCharacters(amount: Long) { val mb = getMethodBind("Label","set_visible_characters") _icall_Unit_Long( mb, this.ptr, amount) } enum class Align( id: Long ) { ALIGN_LEFT(0), ALIGN_CENTER(1), ALIGN_RIGHT(2), ALIGN_FILL(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class VAlign( id: Long ) { VALIGN_TOP(0), VALIGN_CENTER(1), VALIGN_BOTTOM(2), VALIGN_FILL(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/LargeTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.VariantArray import godot.core.Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Long_Vector2_Object import godot.icalls._icall_Texture_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Long_Vector2 import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class LargeTexture : Texture() { override fun __new(): COpaquePointer = invokeConstructor("LargeTexture", "LargeTexture") open fun _getData(): VariantArray { throw NotImplementedError("_get_data is not implemented for LargeTexture") } open fun _setData(data: VariantArray) { } open fun addPiece(ofs: Vector2, texture: Texture): Long { val mb = getMethodBind("LargeTexture","add_piece") return _icall_Long_Vector2_Object( mb, this.ptr, ofs, texture) } open fun clear() { val mb = getMethodBind("LargeTexture","clear") _icall_Unit( mb, this.ptr) } open fun getPieceCount(): Long { val mb = getMethodBind("LargeTexture","get_piece_count") return _icall_Long( mb, this.ptr) } open fun getPieceOffset(idx: Long): Vector2 { val mb = getMethodBind("LargeTexture","get_piece_offset") return _icall_Vector2_Long( mb, this.ptr, idx) } open fun getPieceTexture(idx: Long): Texture { val mb = getMethodBind("LargeTexture","get_piece_texture") return _icall_Texture_Long( mb, this.ptr, idx) } open fun setPieceOffset(idx: Long, ofs: Vector2) { val mb = getMethodBind("LargeTexture","set_piece_offset") _icall_Unit_Long_Vector2( mb, this.ptr, idx, ofs) } open fun setPieceTexture(idx: Long, texture: Texture) { val mb = getMethodBind("LargeTexture","set_piece_texture") _icall_Unit_Long_Object( mb, this.ptr, idx, texture) } open fun setSize(size: Vector2) { val mb = getMethodBind("LargeTexture","set_size") _icall_Unit_Vector2( mb, this.ptr, size) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Light.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Light import godot.core.Color import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Double import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit open class Light internal constructor() : VisualInstance() { open var editorOnly: Boolean get() { val mb = getMethodBind("Light","is_editor_only") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Light","set_editor_only") _icall_Unit_Boolean(mb, this.ptr, value) } open var lightBakeMode: Long get() { val mb = getMethodBind("Light","get_bake_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light","set_bake_mode") _icall_Unit_Long(mb, this.ptr, value) } open var lightColor: Color get() { val mb = getMethodBind("Light","get_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Light","set_color") _icall_Unit_Color(mb, this.ptr, value) } open var lightCullMask: Long get() { val mb = getMethodBind("Light","get_cull_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light","set_cull_mask") _icall_Unit_Long(mb, this.ptr, value) } open var lightEnergy: Double get() { val mb = getMethodBind("Light","get_param") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Light","set_param") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var lightIndirectEnergy: Double get() { val mb = getMethodBind("Light","get_param") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Light","set_param") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var lightNegative: Boolean get() { val mb = getMethodBind("Light","is_negative") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Light","set_negative") _icall_Unit_Boolean(mb, this.ptr, value) } open var lightSpecular: Double get() { val mb = getMethodBind("Light","get_param") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Light","set_param") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var shadowBias: Double get() { val mb = getMethodBind("Light","get_param") return _icall_Double_Long(mb, this.ptr, 13) } set(value) { val mb = getMethodBind("Light","set_param") _icall_Unit_Long_Double(mb, this.ptr, 13, value) } open var shadowColor: Color get() { val mb = getMethodBind("Light","get_shadow_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Light","set_shadow_color") _icall_Unit_Color(mb, this.ptr, value) } open var shadowContact: Double get() { val mb = getMethodBind("Light","get_param") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("Light","set_param") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var shadowEnabled: Boolean get() { val mb = getMethodBind("Light","has_shadow") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Light","set_shadow") _icall_Unit_Boolean(mb, this.ptr, value) } open var shadowReverseCullFace: Boolean get() { val mb = getMethodBind("Light","get_shadow_reverse_cull_face") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Light","set_shadow_reverse_cull_face") _icall_Unit_Boolean(mb, this.ptr, value) } open fun lightColor(schedule: Color.() -> Unit): Color = lightColor.apply{ schedule(this) lightColor = this } open fun shadowColor(schedule: Color.() -> Unit): Color = shadowColor.apply{ schedule(this) shadowColor = this } open fun getBakeMode(): Light.BakeMode { val mb = getMethodBind("Light","get_bake_mode") return Light.BakeMode.from( _icall_Long( mb, this.ptr)) } open fun getColor(): Color { val mb = getMethodBind("Light","get_color") return _icall_Color( mb, this.ptr) } open fun getCullMask(): Long { val mb = getMethodBind("Light","get_cull_mask") return _icall_Long( mb, this.ptr) } open fun getParam(param: Long): Double { val mb = getMethodBind("Light","get_param") return _icall_Double_Long( mb, this.ptr, param) } open fun getShadowColor(): Color { val mb = getMethodBind("Light","get_shadow_color") return _icall_Color( mb, this.ptr) } open fun getShadowReverseCullFace(): Boolean { val mb = getMethodBind("Light","get_shadow_reverse_cull_face") return _icall_Boolean( mb, this.ptr) } open fun hasShadow(): Boolean { val mb = getMethodBind("Light","has_shadow") return _icall_Boolean( mb, this.ptr) } open fun isEditorOnly(): Boolean { val mb = getMethodBind("Light","is_editor_only") return _icall_Boolean( mb, this.ptr) } open fun isNegative(): Boolean { val mb = getMethodBind("Light","is_negative") return _icall_Boolean( mb, this.ptr) } open fun setBakeMode(bakeMode: Long) { val mb = getMethodBind("Light","set_bake_mode") _icall_Unit_Long( mb, this.ptr, bakeMode) } open fun setColor(color: Color) { val mb = getMethodBind("Light","set_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setCullMask(cullMask: Long) { val mb = getMethodBind("Light","set_cull_mask") _icall_Unit_Long( mb, this.ptr, cullMask) } open fun setEditorOnly(editorOnly: Boolean) { val mb = getMethodBind("Light","set_editor_only") _icall_Unit_Boolean( mb, this.ptr, editorOnly) } open fun setNegative(enabled: Boolean) { val mb = getMethodBind("Light","set_negative") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setParam(param: Long, value: Double) { val mb = getMethodBind("Light","set_param") _icall_Unit_Long_Double( mb, this.ptr, param, value) } open fun setShadow(enabled: Boolean) { val mb = getMethodBind("Light","set_shadow") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setShadowColor(shadowColor: Color) { val mb = getMethodBind("Light","set_shadow_color") _icall_Unit_Color( mb, this.ptr, shadowColor) } open fun setShadowReverseCullFace(enable: Boolean) { val mb = getMethodBind("Light","set_shadow_reverse_cull_face") _icall_Unit_Boolean( mb, this.ptr, enable) } enum class BakeMode( id: Long ) { BAKE_DISABLED(0), BAKE_INDIRECT(1), BAKE_ALL(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Param( id: Long ) { PARAM_ENERGY(0), PARAM_INDIRECT_ENERGY(1), PARAM_SPECULAR(2), PARAM_RANGE(3), PARAM_ATTENUATION(4), PARAM_SPOT_ANGLE(5), PARAM_SPOT_ATTENUATION(6), PARAM_CONTACT_SHADOW_SIZE(7), PARAM_SHADOW_MAX_DISTANCE(8), PARAM_SHADOW_SPLIT_1_OFFSET(9), PARAM_SHADOW_SPLIT_2_OFFSET(10), PARAM_SHADOW_SPLIT_3_OFFSET(11), PARAM_SHADOW_NORMAL_BIAS(12), PARAM_SHADOW_BIAS(13), PARAM_SHADOW_BIAS_SPLIT_SCALE(14), PARAM_MAX(15); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Light2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Light2D import godot.core.Color import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Light2D : Node2D() { open var color: Color get() { val mb = getMethodBind("Light2D","get_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_color") _icall_Unit_Color(mb, this.ptr, value) } open var editorOnly: Boolean get() { val mb = getMethodBind("Light2D","is_editor_only") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_editor_only") _icall_Unit_Boolean(mb, this.ptr, value) } open var enabled: Boolean get() { val mb = getMethodBind("Light2D","is_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var energy: Double get() { val mb = getMethodBind("Light2D","get_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_energy") _icall_Unit_Double(mb, this.ptr, value) } open var mode: Long get() { val mb = getMethodBind("Light2D","get_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_mode") _icall_Unit_Long(mb, this.ptr, value) } open var offset: Vector2 get() { val mb = getMethodBind("Light2D","get_texture_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_texture_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var rangeHeight: Double get() { val mb = getMethodBind("Light2D","get_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_height") _icall_Unit_Double(mb, this.ptr, value) } open var rangeItemCullMask: Long get() { val mb = getMethodBind("Light2D","get_item_cull_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_item_cull_mask") _icall_Unit_Long(mb, this.ptr, value) } open var rangeLayerMax: Long get() { val mb = getMethodBind("Light2D","get_layer_range_max") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_layer_range_max") _icall_Unit_Long(mb, this.ptr, value) } open var rangeLayerMin: Long get() { val mb = getMethodBind("Light2D","get_layer_range_min") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_layer_range_min") _icall_Unit_Long(mb, this.ptr, value) } open var rangeZMax: Long get() { val mb = getMethodBind("Light2D","get_z_range_max") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_z_range_max") _icall_Unit_Long(mb, this.ptr, value) } open var rangeZMin: Long get() { val mb = getMethodBind("Light2D","get_z_range_min") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_z_range_min") _icall_Unit_Long(mb, this.ptr, value) } open var shadowBufferSize: Long get() { val mb = getMethodBind("Light2D","get_shadow_buffer_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_shadow_buffer_size") _icall_Unit_Long(mb, this.ptr, value) } open var shadowColor: Color get() { val mb = getMethodBind("Light2D","get_shadow_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_shadow_color") _icall_Unit_Color(mb, this.ptr, value) } open var shadowEnabled: Boolean get() { val mb = getMethodBind("Light2D","is_shadow_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_shadow_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var shadowFilter: Long get() { val mb = getMethodBind("Light2D","get_shadow_filter") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_shadow_filter") _icall_Unit_Long(mb, this.ptr, value) } open var shadowFilterSmooth: Double get() { val mb = getMethodBind("Light2D","get_shadow_smooth") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_shadow_smooth") _icall_Unit_Double(mb, this.ptr, value) } open var shadowGradientLength: Double get() { val mb = getMethodBind("Light2D","get_shadow_gradient_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_shadow_gradient_length") _icall_Unit_Double(mb, this.ptr, value) } open var shadowItemCullMask: Long get() { val mb = getMethodBind("Light2D","get_item_shadow_cull_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_item_shadow_cull_mask") _icall_Unit_Long(mb, this.ptr, value) } open var texture: Texture get() { val mb = getMethodBind("Light2D","get_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_texture") _icall_Unit_Object(mb, this.ptr, value) } open var textureScale: Double get() { val mb = getMethodBind("Light2D","get_texture_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Light2D","set_texture_scale") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Light2D", "Light2D") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun offset(schedule: Vector2.() -> Unit): Vector2 = offset.apply{ schedule(this) offset = this } open fun shadowColor(schedule: Color.() -> Unit): Color = shadowColor.apply{ schedule(this) shadowColor = this } open fun getColor(): Color { val mb = getMethodBind("Light2D","get_color") return _icall_Color( mb, this.ptr) } open fun getEnergy(): Double { val mb = getMethodBind("Light2D","get_energy") return _icall_Double( mb, this.ptr) } open fun getHeight(): Double { val mb = getMethodBind("Light2D","get_height") return _icall_Double( mb, this.ptr) } open fun getItemCullMask(): Long { val mb = getMethodBind("Light2D","get_item_cull_mask") return _icall_Long( mb, this.ptr) } open fun getItemShadowCullMask(): Long { val mb = getMethodBind("Light2D","get_item_shadow_cull_mask") return _icall_Long( mb, this.ptr) } open fun getLayerRangeMax(): Long { val mb = getMethodBind("Light2D","get_layer_range_max") return _icall_Long( mb, this.ptr) } open fun getLayerRangeMin(): Long { val mb = getMethodBind("Light2D","get_layer_range_min") return _icall_Long( mb, this.ptr) } open fun getMode(): Light2D.Mode { val mb = getMethodBind("Light2D","get_mode") return Light2D.Mode.from( _icall_Long( mb, this.ptr)) } open fun getShadowBufferSize(): Long { val mb = getMethodBind("Light2D","get_shadow_buffer_size") return _icall_Long( mb, this.ptr) } open fun getShadowColor(): Color { val mb = getMethodBind("Light2D","get_shadow_color") return _icall_Color( mb, this.ptr) } open fun getShadowFilter(): Light2D.ShadowFilter { val mb = getMethodBind("Light2D","get_shadow_filter") return Light2D.ShadowFilter.from( _icall_Long( mb, this.ptr)) } open fun getShadowGradientLength(): Double { val mb = getMethodBind("Light2D","get_shadow_gradient_length") return _icall_Double( mb, this.ptr) } open fun getShadowSmooth(): Double { val mb = getMethodBind("Light2D","get_shadow_smooth") return _icall_Double( mb, this.ptr) } open fun getTexture(): Texture { val mb = getMethodBind("Light2D","get_texture") return _icall_Texture( mb, this.ptr) } open fun getTextureOffset(): Vector2 { val mb = getMethodBind("Light2D","get_texture_offset") return _icall_Vector2( mb, this.ptr) } open fun getTextureScale(): Double { val mb = getMethodBind("Light2D","get_texture_scale") return _icall_Double( mb, this.ptr) } open fun getZRangeMax(): Long { val mb = getMethodBind("Light2D","get_z_range_max") return _icall_Long( mb, this.ptr) } open fun getZRangeMin(): Long { val mb = getMethodBind("Light2D","get_z_range_min") return _icall_Long( mb, this.ptr) } open fun isEditorOnly(): Boolean { val mb = getMethodBind("Light2D","is_editor_only") return _icall_Boolean( mb, this.ptr) } open fun isEnabled(): Boolean { val mb = getMethodBind("Light2D","is_enabled") return _icall_Boolean( mb, this.ptr) } open fun isShadowEnabled(): Boolean { val mb = getMethodBind("Light2D","is_shadow_enabled") return _icall_Boolean( mb, this.ptr) } open fun setColor(color: Color) { val mb = getMethodBind("Light2D","set_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setEditorOnly(editorOnly: Boolean) { val mb = getMethodBind("Light2D","set_editor_only") _icall_Unit_Boolean( mb, this.ptr, editorOnly) } open fun setEnabled(enabled: Boolean) { val mb = getMethodBind("Light2D","set_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setEnergy(energy: Double) { val mb = getMethodBind("Light2D","set_energy") _icall_Unit_Double( mb, this.ptr, energy) } open fun setHeight(height: Double) { val mb = getMethodBind("Light2D","set_height") _icall_Unit_Double( mb, this.ptr, height) } open fun setItemCullMask(itemCullMask: Long) { val mb = getMethodBind("Light2D","set_item_cull_mask") _icall_Unit_Long( mb, this.ptr, itemCullMask) } open fun setItemShadowCullMask(itemShadowCullMask: Long) { val mb = getMethodBind("Light2D","set_item_shadow_cull_mask") _icall_Unit_Long( mb, this.ptr, itemShadowCullMask) } open fun setLayerRangeMax(layer: Long) { val mb = getMethodBind("Light2D","set_layer_range_max") _icall_Unit_Long( mb, this.ptr, layer) } open fun setLayerRangeMin(layer: Long) { val mb = getMethodBind("Light2D","set_layer_range_min") _icall_Unit_Long( mb, this.ptr, layer) } open fun setMode(mode: Long) { val mb = getMethodBind("Light2D","set_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setShadowBufferSize(size: Long) { val mb = getMethodBind("Light2D","set_shadow_buffer_size") _icall_Unit_Long( mb, this.ptr, size) } open fun setShadowColor(shadowColor: Color) { val mb = getMethodBind("Light2D","set_shadow_color") _icall_Unit_Color( mb, this.ptr, shadowColor) } open fun setShadowEnabled(enabled: Boolean) { val mb = getMethodBind("Light2D","set_shadow_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setShadowFilter(filter: Long) { val mb = getMethodBind("Light2D","set_shadow_filter") _icall_Unit_Long( mb, this.ptr, filter) } open fun setShadowGradientLength(multiplier: Double) { val mb = getMethodBind("Light2D","set_shadow_gradient_length") _icall_Unit_Double( mb, this.ptr, multiplier) } open fun setShadowSmooth(smooth: Double) { val mb = getMethodBind("Light2D","set_shadow_smooth") _icall_Unit_Double( mb, this.ptr, smooth) } open fun setTexture(texture: Texture) { val mb = getMethodBind("Light2D","set_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setTextureOffset(textureOffset: Vector2) { val mb = getMethodBind("Light2D","set_texture_offset") _icall_Unit_Vector2( mb, this.ptr, textureOffset) } open fun setTextureScale(textureScale: Double) { val mb = getMethodBind("Light2D","set_texture_scale") _icall_Unit_Double( mb, this.ptr, textureScale) } open fun setZRangeMax(z: Long) { val mb = getMethodBind("Light2D","set_z_range_max") _icall_Unit_Long( mb, this.ptr, z) } open fun setZRangeMin(z: Long) { val mb = getMethodBind("Light2D","set_z_range_min") _icall_Unit_Long( mb, this.ptr, z) } enum class ShadowFilter( id: Long ) { SHADOW_FILTER_NONE(0), SHADOW_FILTER_PCF3(1), SHADOW_FILTER_PCF5(2), SHADOW_FILTER_PCF7(3), SHADOW_FILTER_PCF9(4), SHADOW_FILTER_PCF13(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Mode( id: Long ) { MODE_ADD(0), MODE_SUB(1), MODE_MIX(2), MODE_MASK(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/LightOccluder2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Long import godot.icalls._icall_OccluderPolygon2D import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class LightOccluder2D : Node2D() { override var lightMask: Long get() { val mb = getMethodBind("LightOccluder2D","get_occluder_light_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("LightOccluder2D","set_occluder_light_mask") _icall_Unit_Long(mb, this.ptr, value) } open var occluder: OccluderPolygon2D get() { val mb = getMethodBind("LightOccluder2D","get_occluder_polygon") return _icall_OccluderPolygon2D(mb, this.ptr) } set(value) { val mb = getMethodBind("LightOccluder2D","set_occluder_polygon") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("LightOccluder2D", "LightOccluder2D") open fun _polyChanged() { } open fun getOccluderLightMask(): Long { val mb = getMethodBind("LightOccluder2D","get_occluder_light_mask") return _icall_Long( mb, this.ptr) } open fun getOccluderPolygon(): OccluderPolygon2D { val mb = getMethodBind("LightOccluder2D","get_occluder_polygon") return _icall_OccluderPolygon2D( mb, this.ptr) } open fun setOccluderLightMask(mask: Long) { val mb = getMethodBind("LightOccluder2D","set_occluder_light_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setOccluderPolygon(polygon: OccluderPolygon2D) { val mb = getMethodBind("LightOccluder2D","set_occluder_polygon") _icall_Unit_Object( mb, this.ptr, polygon) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Line2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Line2D import godot.core.Color import godot.core.PoolVector2Array import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_Curve import godot.icalls._icall_Double import godot.icalls._icall_Gradient import godot.icalls._icall_Long import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_Texture import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Vector2 import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_PoolVector2Array import godot.icalls._icall_Unit_Vector2_Long import godot.icalls._icall_Vector2_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Line2D : Node2D() { open var antialiased: Boolean get() { val mb = getMethodBind("Line2D","get_antialiased") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_antialiased") _icall_Unit_Boolean(mb, this.ptr, value) } open var beginCapMode: Long get() { val mb = getMethodBind("Line2D","get_begin_cap_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_begin_cap_mode") _icall_Unit_Long(mb, this.ptr, value) } open var defaultColor: Color get() { val mb = getMethodBind("Line2D","get_default_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_default_color") _icall_Unit_Color(mb, this.ptr, value) } open var endCapMode: Long get() { val mb = getMethodBind("Line2D","get_end_cap_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_end_cap_mode") _icall_Unit_Long(mb, this.ptr, value) } open var gradient: Gradient get() { val mb = getMethodBind("Line2D","get_gradient") return _icall_Gradient(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_gradient") _icall_Unit_Object(mb, this.ptr, value) } open var jointMode: Long get() { val mb = getMethodBind("Line2D","get_joint_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_joint_mode") _icall_Unit_Long(mb, this.ptr, value) } open var points: PoolVector2Array get() { val mb = getMethodBind("Line2D","get_points") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_points") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } open var roundPrecision: Long get() { val mb = getMethodBind("Line2D","get_round_precision") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_round_precision") _icall_Unit_Long(mb, this.ptr, value) } open var sharpLimit: Double get() { val mb = getMethodBind("Line2D","get_sharp_limit") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_sharp_limit") _icall_Unit_Double(mb, this.ptr, value) } open var texture: Texture get() { val mb = getMethodBind("Line2D","get_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_texture") _icall_Unit_Object(mb, this.ptr, value) } open var textureMode: Long get() { val mb = getMethodBind("Line2D","get_texture_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_texture_mode") _icall_Unit_Long(mb, this.ptr, value) } open var width: Double get() { val mb = getMethodBind("Line2D","get_width") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_width") _icall_Unit_Double(mb, this.ptr, value) } open var widthCurve: Curve get() { val mb = getMethodBind("Line2D","get_curve") return _icall_Curve(mb, this.ptr) } set(value) { val mb = getMethodBind("Line2D","set_curve") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Line2D", "Line2D") open fun defaultColor(schedule: Color.() -> Unit): Color = defaultColor.apply{ schedule(this) defaultColor = this } open fun _curveChanged() { } open fun _gradientChanged() { } open fun addPoint(position: Vector2, atPosition: Long = -1) { val mb = getMethodBind("Line2D","add_point") _icall_Unit_Vector2_Long( mb, this.ptr, position, atPosition) } open fun clearPoints() { val mb = getMethodBind("Line2D","clear_points") _icall_Unit( mb, this.ptr) } open fun getAntialiased(): Boolean { val mb = getMethodBind("Line2D","get_antialiased") return _icall_Boolean( mb, this.ptr) } open fun getBeginCapMode(): Line2D.LineCapMode { val mb = getMethodBind("Line2D","get_begin_cap_mode") return Line2D.LineCapMode.from( _icall_Long( mb, this.ptr)) } open fun getCurve(): Curve { val mb = getMethodBind("Line2D","get_curve") return _icall_Curve( mb, this.ptr) } open fun getDefaultColor(): Color { val mb = getMethodBind("Line2D","get_default_color") return _icall_Color( mb, this.ptr) } open fun getEndCapMode(): Line2D.LineCapMode { val mb = getMethodBind("Line2D","get_end_cap_mode") return Line2D.LineCapMode.from( _icall_Long( mb, this.ptr)) } open fun getGradient(): Gradient { val mb = getMethodBind("Line2D","get_gradient") return _icall_Gradient( mb, this.ptr) } open fun getJointMode(): Line2D.LineJointMode { val mb = getMethodBind("Line2D","get_joint_mode") return Line2D.LineJointMode.from( _icall_Long( mb, this.ptr)) } open fun getPointCount(): Long { val mb = getMethodBind("Line2D","get_point_count") return _icall_Long( mb, this.ptr) } open fun getPointPosition(i: Long): Vector2 { val mb = getMethodBind("Line2D","get_point_position") return _icall_Vector2_Long( mb, this.ptr, i) } open fun getPoints(): PoolVector2Array { val mb = getMethodBind("Line2D","get_points") return _icall_PoolVector2Array( mb, this.ptr) } open fun getRoundPrecision(): Long { val mb = getMethodBind("Line2D","get_round_precision") return _icall_Long( mb, this.ptr) } open fun getSharpLimit(): Double { val mb = getMethodBind("Line2D","get_sharp_limit") return _icall_Double( mb, this.ptr) } open fun getTexture(): Texture { val mb = getMethodBind("Line2D","get_texture") return _icall_Texture( mb, this.ptr) } open fun getTextureMode(): Line2D.LineTextureMode { val mb = getMethodBind("Line2D","get_texture_mode") return Line2D.LineTextureMode.from( _icall_Long( mb, this.ptr)) } open fun getWidth(): Double { val mb = getMethodBind("Line2D","get_width") return _icall_Double( mb, this.ptr) } open fun removePoint(i: Long) { val mb = getMethodBind("Line2D","remove_point") _icall_Unit_Long( mb, this.ptr, i) } open fun setAntialiased(antialiased: Boolean) { val mb = getMethodBind("Line2D","set_antialiased") _icall_Unit_Boolean( mb, this.ptr, antialiased) } open fun setBeginCapMode(mode: Long) { val mb = getMethodBind("Line2D","set_begin_cap_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setCurve(curve: Curve) { val mb = getMethodBind("Line2D","set_curve") _icall_Unit_Object( mb, this.ptr, curve) } open fun setDefaultColor(color: Color) { val mb = getMethodBind("Line2D","set_default_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setEndCapMode(mode: Long) { val mb = getMethodBind("Line2D","set_end_cap_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setGradient(color: Gradient) { val mb = getMethodBind("Line2D","set_gradient") _icall_Unit_Object( mb, this.ptr, color) } open fun setJointMode(mode: Long) { val mb = getMethodBind("Line2D","set_joint_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setPointPosition(i: Long, position: Vector2) { val mb = getMethodBind("Line2D","set_point_position") _icall_Unit_Long_Vector2( mb, this.ptr, i, position) } open fun setPoints(points: PoolVector2Array) { val mb = getMethodBind("Line2D","set_points") _icall_Unit_PoolVector2Array( mb, this.ptr, points) } open fun setRoundPrecision(precision: Long) { val mb = getMethodBind("Line2D","set_round_precision") _icall_Unit_Long( mb, this.ptr, precision) } open fun setSharpLimit(limit: Double) { val mb = getMethodBind("Line2D","set_sharp_limit") _icall_Unit_Double( mb, this.ptr, limit) } open fun setTexture(texture: Texture) { val mb = getMethodBind("Line2D","set_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setTextureMode(mode: Long) { val mb = getMethodBind("Line2D","set_texture_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setWidth(width: Double) { val mb = getMethodBind("Line2D","set_width") _icall_Unit_Double( mb, this.ptr, width) } enum class LineTextureMode( id: Long ) { LINE_TEXTURE_NONE(0), LINE_TEXTURE_TILE(1), LINE_TEXTURE_STRETCH(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class LineCapMode( id: Long ) { LINE_CAP_NONE(0), LINE_CAP_BOX(1), LINE_CAP_ROUND(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class LineJointMode( id: Long ) { LINE_JOINT_SHARP(0), LINE_JOINT_BEVEL(1), LINE_JOINT_ROUND(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/LineEdit.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.LineEdit import godot.core.Signal0 import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_PopupMenu import godot.icalls._icall_String import godot.icalls._icall_Texture import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class LineEdit : Control() { val textChangeRejected: Signal0 by signal() val textChanged: Signal1 by signal("new_text") val textEntered: Signal1 by signal("new_text") open var align: Long get() { val mb = getMethodBind("LineEdit","get_align") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_align") _icall_Unit_Long(mb, this.ptr, value) } open var caretBlink: Boolean get() { val mb = getMethodBind("LineEdit","cursor_get_blink_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","cursor_set_blink_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var caretBlinkSpeed: Double get() { val mb = getMethodBind("LineEdit","cursor_get_blink_speed") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","cursor_set_blink_speed") _icall_Unit_Double(mb, this.ptr, value) } open var caretPosition: Long get() { val mb = getMethodBind("LineEdit","get_cursor_position") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_cursor_position") _icall_Unit_Long(mb, this.ptr, value) } open var clearButtonEnabled: Boolean get() { val mb = getMethodBind("LineEdit","is_clear_button_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_clear_button_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var contextMenuEnabled: Boolean get() { val mb = getMethodBind("LineEdit","is_context_menu_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_context_menu_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var editable: Boolean get() { val mb = getMethodBind("LineEdit","is_editable") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_editable") _icall_Unit_Boolean(mb, this.ptr, value) } open var expandToTextLength: Boolean get() { val mb = getMethodBind("LineEdit","get_expand_to_text_length") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_expand_to_text_length") _icall_Unit_Boolean(mb, this.ptr, value) } open var maxLength: Long get() { val mb = getMethodBind("LineEdit","get_max_length") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_max_length") _icall_Unit_Long(mb, this.ptr, value) } open var placeholderAlpha: Double get() { val mb = getMethodBind("LineEdit","get_placeholder_alpha") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_placeholder_alpha") _icall_Unit_Double(mb, this.ptr, value) } open var placeholderText: String get() { val mb = getMethodBind("LineEdit","get_placeholder") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_placeholder") _icall_Unit_String(mb, this.ptr, value) } open var rightIcon: Texture get() { val mb = getMethodBind("LineEdit","get_right_icon") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_right_icon") _icall_Unit_Object(mb, this.ptr, value) } open var secret: Boolean get() { val mb = getMethodBind("LineEdit","is_secret") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_secret") _icall_Unit_Boolean(mb, this.ptr, value) } open var secretCharacter: String get() { val mb = getMethodBind("LineEdit","get_secret_character") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_secret_character") _icall_Unit_String(mb, this.ptr, value) } open var selectingEnabled: Boolean get() { val mb = getMethodBind("LineEdit","is_selecting_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_selecting_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var shortcutKeysEnabled: Boolean get() { val mb = getMethodBind("LineEdit","is_shortcut_keys_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_shortcut_keys_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var text: String get() { val mb = getMethodBind("LineEdit","get_text") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("LineEdit","set_text") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("LineEdit", "LineEdit") open fun _editorSettingsChanged() { } override fun _guiInput(arg0: InputEvent) { } open fun _textChanged() { } open fun _toggleDrawCaret() { } open fun appendAtCursor(text: String) { val mb = getMethodBind("LineEdit","append_at_cursor") _icall_Unit_String( mb, this.ptr, text) } open fun clear() { val mb = getMethodBind("LineEdit","clear") _icall_Unit( mb, this.ptr) } open fun cursorGetBlinkEnabled(): Boolean { val mb = getMethodBind("LineEdit","cursor_get_blink_enabled") return _icall_Boolean( mb, this.ptr) } open fun cursorGetBlinkSpeed(): Double { val mb = getMethodBind("LineEdit","cursor_get_blink_speed") return _icall_Double( mb, this.ptr) } open fun cursorSetBlinkEnabled(enabled: Boolean) { val mb = getMethodBind("LineEdit","cursor_set_blink_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun cursorSetBlinkSpeed(blinkSpeed: Double) { val mb = getMethodBind("LineEdit","cursor_set_blink_speed") _icall_Unit_Double( mb, this.ptr, blinkSpeed) } open fun deselect() { val mb = getMethodBind("LineEdit","deselect") _icall_Unit( mb, this.ptr) } open fun getAlign(): LineEdit.Align { val mb = getMethodBind("LineEdit","get_align") return LineEdit.Align.from( _icall_Long( mb, this.ptr)) } open fun getCursorPosition(): Long { val mb = getMethodBind("LineEdit","get_cursor_position") return _icall_Long( mb, this.ptr) } open fun getExpandToTextLength(): Boolean { val mb = getMethodBind("LineEdit","get_expand_to_text_length") return _icall_Boolean( mb, this.ptr) } open fun getMaxLength(): Long { val mb = getMethodBind("LineEdit","get_max_length") return _icall_Long( mb, this.ptr) } open fun getMenu(): PopupMenu { val mb = getMethodBind("LineEdit","get_menu") return _icall_PopupMenu( mb, this.ptr) } open fun getPlaceholder(): String { val mb = getMethodBind("LineEdit","get_placeholder") return _icall_String( mb, this.ptr) } open fun getPlaceholderAlpha(): Double { val mb = getMethodBind("LineEdit","get_placeholder_alpha") return _icall_Double( mb, this.ptr) } open fun getRightIcon(): Texture { val mb = getMethodBind("LineEdit","get_right_icon") return _icall_Texture( mb, this.ptr) } open fun getSecretCharacter(): String { val mb = getMethodBind("LineEdit","get_secret_character") return _icall_String( mb, this.ptr) } open fun getText(): String { val mb = getMethodBind("LineEdit","get_text") return _icall_String( mb, this.ptr) } open fun isClearButtonEnabled(): Boolean { val mb = getMethodBind("LineEdit","is_clear_button_enabled") return _icall_Boolean( mb, this.ptr) } open fun isContextMenuEnabled(): Boolean { val mb = getMethodBind("LineEdit","is_context_menu_enabled") return _icall_Boolean( mb, this.ptr) } open fun isEditable(): Boolean { val mb = getMethodBind("LineEdit","is_editable") return _icall_Boolean( mb, this.ptr) } open fun isSecret(): Boolean { val mb = getMethodBind("LineEdit","is_secret") return _icall_Boolean( mb, this.ptr) } open fun isSelectingEnabled(): Boolean { val mb = getMethodBind("LineEdit","is_selecting_enabled") return _icall_Boolean( mb, this.ptr) } open fun isShortcutKeysEnabled(): Boolean { val mb = getMethodBind("LineEdit","is_shortcut_keys_enabled") return _icall_Boolean( mb, this.ptr) } open fun menuOption(option: Long) { val mb = getMethodBind("LineEdit","menu_option") _icall_Unit_Long( mb, this.ptr, option) } open fun select(from: Long = 0, to: Long = -1) { val mb = getMethodBind("LineEdit","select") _icall_Unit_Long_Long( mb, this.ptr, from, to) } open fun selectAll() { val mb = getMethodBind("LineEdit","select_all") _icall_Unit( mb, this.ptr) } open fun setAlign(align: Long) { val mb = getMethodBind("LineEdit","set_align") _icall_Unit_Long( mb, this.ptr, align) } open fun setClearButtonEnabled(enable: Boolean) { val mb = getMethodBind("LineEdit","set_clear_button_enabled") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setContextMenuEnabled(enable: Boolean) { val mb = getMethodBind("LineEdit","set_context_menu_enabled") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCursorPosition(position: Long) { val mb = getMethodBind("LineEdit","set_cursor_position") _icall_Unit_Long( mb, this.ptr, position) } open fun setEditable(enabled: Boolean) { val mb = getMethodBind("LineEdit","set_editable") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setExpandToTextLength(enabled: Boolean) { val mb = getMethodBind("LineEdit","set_expand_to_text_length") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setMaxLength(chars: Long) { val mb = getMethodBind("LineEdit","set_max_length") _icall_Unit_Long( mb, this.ptr, chars) } open fun setPlaceholder(text: String) { val mb = getMethodBind("LineEdit","set_placeholder") _icall_Unit_String( mb, this.ptr, text) } open fun setPlaceholderAlpha(alpha: Double) { val mb = getMethodBind("LineEdit","set_placeholder_alpha") _icall_Unit_Double( mb, this.ptr, alpha) } open fun setRightIcon(icon: Texture) { val mb = getMethodBind("LineEdit","set_right_icon") _icall_Unit_Object( mb, this.ptr, icon) } open fun setSecret(enabled: Boolean) { val mb = getMethodBind("LineEdit","set_secret") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setSecretCharacter(character: String) { val mb = getMethodBind("LineEdit","set_secret_character") _icall_Unit_String( mb, this.ptr, character) } open fun setSelectingEnabled(enable: Boolean) { val mb = getMethodBind("LineEdit","set_selecting_enabled") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setShortcutKeysEnabled(enable: Boolean) { val mb = getMethodBind("LineEdit","set_shortcut_keys_enabled") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setText(text: String) { val mb = getMethodBind("LineEdit","set_text") _icall_Unit_String( mb, this.ptr, text) } enum class Align( id: Long ) { ALIGN_LEFT(0), ALIGN_CENTER(1), ALIGN_RIGHT(2), ALIGN_FILL(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class MenuItems( id: Long ) { MENU_CUT(0), MENU_COPY(1), MENU_PASTE(2), MENU_CLEAR(3), MENU_SELECT_ALL(4), MENU_UNDO(5), MENU_REDO(6), MENU_MAX(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/LineShape2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class LineShape2D : Shape2D() { open var d: Double get() { val mb = getMethodBind("LineShape2D","get_d") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("LineShape2D","set_d") _icall_Unit_Double(mb, this.ptr, value) } open var normal: Vector2 get() { val mb = getMethodBind("LineShape2D","get_normal") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("LineShape2D","set_normal") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("LineShape2D", "LineShape2D") open fun normal(schedule: Vector2.() -> Unit): Vector2 = normal.apply{ schedule(this) normal = this } open fun getD(): Double { val mb = getMethodBind("LineShape2D","get_d") return _icall_Double( mb, this.ptr) } open fun getNormal(): Vector2 { val mb = getMethodBind("LineShape2D","get_normal") return _icall_Vector2( mb, this.ptr) } open fun setD(d: Double) { val mb = getMethodBind("LineShape2D","set_d") _icall_Unit_Double( mb, this.ptr, d) } open fun setNormal(normal: Vector2) { val mb = getMethodBind("LineShape2D","set_normal") _icall_Unit_Vector2( mb, this.ptr, normal) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/LinkButton.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.LinkButton import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class LinkButton : BaseButton() { open var text: String get() { val mb = getMethodBind("LinkButton","get_text") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("LinkButton","set_text") _icall_Unit_String(mb, this.ptr, value) } open var underline: Long get() { val mb = getMethodBind("LinkButton","get_underline_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("LinkButton","set_underline_mode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("LinkButton", "LinkButton") open fun getText(): String { val mb = getMethodBind("LinkButton","get_text") return _icall_String( mb, this.ptr) } open fun getUnderlineMode(): LinkButton.UnderlineMode { val mb = getMethodBind("LinkButton","get_underline_mode") return LinkButton.UnderlineMode.from( _icall_Long( mb, this.ptr)) } open fun setText(text: String) { val mb = getMethodBind("LinkButton","set_text") _icall_Unit_String( mb, this.ptr, text) } open fun setUnderlineMode(underlineMode: Long) { val mb = getMethodBind("LinkButton","set_underline_mode") _icall_Unit_Long( mb, this.ptr, underlineMode) } enum class UnderlineMode( id: Long ) { UNDERLINE_MODE_ALWAYS(0), UNDERLINE_MODE_ON_HOVER(1), UNDERLINE_MODE_NEVER(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Listener.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Transform import godot.icalls._icall_Boolean import godot.icalls._icall_Transform import godot.icalls._icall_Unit import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class Listener : Spatial() { override fun __new(): COpaquePointer = invokeConstructor("Listener", "Listener") open fun clearCurrent() { val mb = getMethodBind("Listener","clear_current") _icall_Unit( mb, this.ptr) } open fun getListenerTransform(): Transform { val mb = getMethodBind("Listener","get_listener_transform") return _icall_Transform( mb, this.ptr) } open fun isCurrent(): Boolean { val mb = getMethodBind("Listener","is_current") return _icall_Boolean( mb, this.ptr) } open fun makeCurrent() { val mb = getMethodBind("Listener","make_current") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MainLoop.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.core.Signal2 import godot.core.Variant import godot.core.signal import godot.icalls._icall_Boolean_Double import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class MainLoop : Object() { val onRequestPermissionsResult: Signal2 by signal("permission", "granted") override fun __new(): COpaquePointer = invokeConstructor("MainLoop", "MainLoop") open fun _dropFiles(files: PoolStringArray, fromScreen: Long) { } open fun _finalize() { } open fun _globalMenuAction(id: Variant, meta: Variant) { } open fun _idle(delta: Double): Boolean { throw NotImplementedError("_idle is not implemented for MainLoop") } open fun _initialize() { } open fun _inputEvent(event: InputEvent) { } open fun _inputText(text: String) { } open fun _iteration(delta: Double): Boolean { throw NotImplementedError("_iteration is not implemented for MainLoop") } open fun finish() { val mb = getMethodBind("MainLoop","finish") _icall_Unit( mb, this.ptr) } open fun idle(delta: Double): Boolean { val mb = getMethodBind("MainLoop","idle") return _icall_Boolean_Double( mb, this.ptr, delta) } open fun init() { val mb = getMethodBind("MainLoop","init") _icall_Unit( mb, this.ptr) } open fun inputEvent(event: InputEvent) { val mb = getMethodBind("MainLoop","input_event") _icall_Unit_Object( mb, this.ptr, event) } open fun inputText(text: String) { val mb = getMethodBind("MainLoop","input_text") _icall_Unit_String( mb, this.ptr, text) } open fun iteration(delta: Double): Boolean { val mb = getMethodBind("MainLoop","iteration") return _icall_Boolean_Double( mb, this.ptr, delta) } companion object { final const val NOTIFICATION_APP_PAUSED: Long = 1015 final const val NOTIFICATION_APP_RESUMED: Long = 1014 final const val NOTIFICATION_CRASH: Long = 1012 final const val NOTIFICATION_OS_IME_UPDATE: Long = 1013 final const val NOTIFICATION_OS_MEMORY_WARNING: Long = 1009 final const val NOTIFICATION_TRANSLATION_CHANGED: Long = 1010 final const val NOTIFICATION_WM_ABOUT: Long = 1011 final const val NOTIFICATION_WM_FOCUS_IN: Long = 1004 final const val NOTIFICATION_WM_FOCUS_OUT: Long = 1005 final const val NOTIFICATION_WM_GO_BACK_REQUEST: Long = 1007 final const val NOTIFICATION_WM_MOUSE_ENTER: Long = 1002 final const val NOTIFICATION_WM_MOUSE_EXIT: Long = 1003 final const val NOTIFICATION_WM_QUIT_REQUEST: Long = 1006 final const val NOTIFICATION_WM_UNFOCUS_REQUEST: Long = 1008 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MarginContainer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class MarginContainer : Container() { override fun __new(): COpaquePointer = invokeConstructor("MarginContainer", "MarginContainer") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Marshalls.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.core.PoolByteArray import godot.core.Variant import godot.icalls._icall_PoolByteArray_String import godot.icalls._icall_String_PoolByteArray import godot.icalls._icall_String_String import godot.icalls._icall_String_Variant_Boolean import godot.icalls._icall_Variant_String_Boolean import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object Marshalls : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("Marshalls".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton Marshalls" } ptr } fun base64ToRaw(base64Str: String): PoolByteArray { val mb = getMethodBind("_Marshalls","base64_to_raw") return _icall_PoolByteArray_String( mb, this.ptr, base64Str) } fun base64ToUtf8(base64Str: String): String { val mb = getMethodBind("_Marshalls","base64_to_utf8") return _icall_String_String( mb, this.ptr, base64Str) } fun base64ToVariant(base64Str: String, allowObjects: Boolean = false): Variant { val mb = getMethodBind("_Marshalls","base64_to_variant") return _icall_Variant_String_Boolean( mb, this.ptr, base64Str, allowObjects) } fun rawToBase64(array: PoolByteArray): String { val mb = getMethodBind("_Marshalls","raw_to_base64") return _icall_String_PoolByteArray( mb, this.ptr, array) } fun utf8ToBase64(utf8Str: String): String { val mb = getMethodBind("_Marshalls","utf8_to_base64") return _icall_String_String( mb, this.ptr, utf8Str) } fun variantToBase64(variant: Variant, fullObjects: Boolean = false): String { val mb = getMethodBind("_Marshalls","variant_to_base64") return _icall_String_Variant_Boolean( mb, this.ptr, variant, fullObjects) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Material.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Long import godot.icalls._icall_Material import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import kotlin.Long open class Material internal constructor() : Resource() { open var nextPass: Material get() { val mb = getMethodBind("Material","get_next_pass") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("Material","set_next_pass") _icall_Unit_Object(mb, this.ptr, value) } open var renderPriority: Long get() { val mb = getMethodBind("Material","get_render_priority") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Material","set_render_priority") _icall_Unit_Long(mb, this.ptr, value) } open fun getNextPass(): Material { val mb = getMethodBind("Material","get_next_pass") return _icall_Material( mb, this.ptr) } open fun getRenderPriority(): Long { val mb = getMethodBind("Material","get_render_priority") return _icall_Long( mb, this.ptr) } open fun setNextPass(nextPass: Material) { val mb = getMethodBind("Material","set_next_pass") _icall_Unit_Object( mb, this.ptr, nextPass) } open fun setRenderPriority(priority: Long) { val mb = getMethodBind("Material","set_render_priority") _icall_Unit_Long( mb, this.ptr, priority) } companion object { final const val RENDER_PRIORITY_MAX: Long = 127 final const val RENDER_PRIORITY_MIN: Long = -128 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MenuButton.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_PopupMenu import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class MenuButton : Button() { val aboutToShow: Signal0 by signal() open var switchOnHover: Boolean get() { val mb = getMethodBind("MenuButton","is_switch_on_hover") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("MenuButton","set_switch_on_hover") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("MenuButton", "MenuButton") open fun _getItems(): VariantArray { throw NotImplementedError("_get_items is not implemented for MenuButton") } open fun _setItems(arg0: VariantArray) { } open fun _unhandledKeyInput(arg0: InputEvent) { } open fun getPopup(): PopupMenu { val mb = getMethodBind("MenuButton","get_popup") return _icall_PopupMenu( mb, this.ptr) } open fun isSwitchOnHover(): Boolean { val mb = getMethodBind("MenuButton","is_switch_on_hover") return _icall_Boolean( mb, this.ptr) } open fun setDisableShortcuts(disabled: Boolean) { val mb = getMethodBind("MenuButton","set_disable_shortcuts") _icall_Unit_Boolean( mb, this.ptr, disabled) } open fun setSwitchOnHover(enable: Boolean) { val mb = getMethodBind("MenuButton","set_switch_on_hover") _icall_Unit_Boolean( mb, this.ptr, enable) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Mesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.AABB import godot.core.PoolVector3Array import godot.core.VariantArray import godot.core.Vector2 import godot.icalls._icall_AABB import godot.icalls._icall_Long import godot.icalls._icall_Material_Long import godot.icalls._icall_Mesh_Double import godot.icalls._icall_PoolVector3Array import godot.icalls._icall_Shape import godot.icalls._icall_TriangleMesh import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_VariantArray_Long import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import kotlin.Double import kotlin.Long import kotlin.Unit open class Mesh internal constructor() : Resource() { open var lightmapSizeHint: Vector2 get() { val mb = getMethodBind("Mesh","get_lightmap_size_hint") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Mesh","set_lightmap_size_hint") _icall_Unit_Vector2(mb, this.ptr, value) } open fun lightmapSizeHint(schedule: Vector2.() -> Unit): Vector2 = lightmapSizeHint.apply{ schedule(this) lightmapSizeHint = this } open fun createConvexShape(): Shape { val mb = getMethodBind("Mesh","create_convex_shape") return _icall_Shape( mb, this.ptr) } open fun createOutline(margin: Double): Mesh { val mb = getMethodBind("Mesh","create_outline") return _icall_Mesh_Double( mb, this.ptr, margin) } open fun createTrimeshShape(): Shape { val mb = getMethodBind("Mesh","create_trimesh_shape") return _icall_Shape( mb, this.ptr) } open fun generateTriangleMesh(): TriangleMesh { val mb = getMethodBind("Mesh","generate_triangle_mesh") return _icall_TriangleMesh( mb, this.ptr) } open fun getAabb(): AABB { val mb = getMethodBind("Mesh","get_aabb") return _icall_AABB( mb, this.ptr) } open fun getFaces(): PoolVector3Array { val mb = getMethodBind("Mesh","get_faces") return _icall_PoolVector3Array( mb, this.ptr) } open fun getLightmapSizeHint(): Vector2 { val mb = getMethodBind("Mesh","get_lightmap_size_hint") return _icall_Vector2( mb, this.ptr) } open fun getSurfaceCount(): Long { val mb = getMethodBind("Mesh","get_surface_count") return _icall_Long( mb, this.ptr) } open fun setLightmapSizeHint(size: Vector2) { val mb = getMethodBind("Mesh","set_lightmap_size_hint") _icall_Unit_Vector2( mb, this.ptr, size) } open fun surfaceGetArrays(surfIdx: Long): VariantArray { val mb = getMethodBind("Mesh","surface_get_arrays") return _icall_VariantArray_Long( mb, this.ptr, surfIdx) } open fun surfaceGetBlendShapeArrays(surfIdx: Long): VariantArray { val mb = getMethodBind("Mesh","surface_get_blend_shape_arrays") return _icall_VariantArray_Long( mb, this.ptr, surfIdx) } open fun surfaceGetMaterial(surfIdx: Long): Material { val mb = getMethodBind("Mesh","surface_get_material") return _icall_Material_Long( mb, this.ptr, surfIdx) } open fun surfaceSetMaterial(surfIdx: Long, material: Material) { val mb = getMethodBind("Mesh","surface_set_material") _icall_Unit_Long_Object( mb, this.ptr, surfIdx, material) } enum class BlendShapeMode( id: Long ) { BLEND_SHAPE_MODE_NORMALIZED(0), BLEND_SHAPE_MODE_RELATIVE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class PrimitiveType( id: Long ) { PRIMITIVE_POINTS(0), PRIMITIVE_LINES(1), PRIMITIVE_LINE_STRIP(2), PRIMITIVE_LINE_LOOP(3), PRIMITIVE_TRIANGLES(4), PRIMITIVE_TRIANGLE_STRIP(5), PRIMITIVE_TRIANGLE_FAN(6); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ArrayFormat( id: Long ) { ARRAY_FORMAT_VERTEX(1), ARRAY_FORMAT_NORMAL(2), ARRAY_FORMAT_TANGENT(4), ARRAY_FORMAT_COLOR(8), ARRAY_COMPRESS_BASE(9), ARRAY_FORMAT_TEX_UV(16), ARRAY_FORMAT_TEX_UV2(32), ARRAY_FORMAT_BONES(64), ARRAY_FORMAT_WEIGHTS(128), ARRAY_FORMAT_INDEX(256), ARRAY_COMPRESS_VERTEX(512), ARRAY_COMPRESS_NORMAL(1024), ARRAY_COMPRESS_TANGENT(2048), ARRAY_COMPRESS_COLOR(4096), ARRAY_COMPRESS_TEX_UV(8192), ARRAY_COMPRESS_TEX_UV2(16384), ARRAY_COMPRESS_BONES(32768), ARRAY_COMPRESS_WEIGHTS(65536), ARRAY_COMPRESS_DEFAULT(97280), ARRAY_COMPRESS_INDEX(131072), ARRAY_FLAG_USE_2D_VERTICES(262144), ARRAY_FLAG_USE_16_BIT_BONES(524288); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ArrayType( id: Long ) { ARRAY_VERTEX(0), ARRAY_NORMAL(1), ARRAY_TANGENT(2), ARRAY_COLOR(3), ARRAY_TEX_UV(4), ARRAY_TEX_UV2(5), ARRAY_BONES(6), ARRAY_WEIGHTS(7), ARRAY_INDEX(8), ARRAY_MAX(9); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MeshDataTool.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.GodotError import godot.core.Plane import godot.core.PoolIntArray import godot.core.PoolRealArray import godot.core.Variant import godot.core.Vector2 import godot.core.Vector3 import godot.icalls._icall_Color_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long_Long import godot.icalls._icall_Long_Object import godot.icalls._icall_Long_Object_Long import godot.icalls._icall_Material import godot.icalls._icall_Plane_Long import godot.icalls._icall_PoolIntArray_Long import godot.icalls._icall_PoolRealArray_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long_Color import godot.icalls._icall_Unit_Long_Plane import godot.icalls._icall_Unit_Long_PoolIntArray import godot.icalls._icall_Unit_Long_PoolRealArray import godot.icalls._icall_Unit_Long_Variant import godot.icalls._icall_Unit_Long_Vector2 import godot.icalls._icall_Unit_Long_Vector3 import godot.icalls._icall_Unit_Object import godot.icalls._icall_Variant_Long import godot.icalls._icall_Vector2_Long import godot.icalls._icall_Vector3_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class MeshDataTool : Reference() { override fun __new(): COpaquePointer = invokeConstructor("MeshDataTool", "MeshDataTool") open fun clear() { val mb = getMethodBind("MeshDataTool","clear") _icall_Unit( mb, this.ptr) } open fun commitToSurface(mesh: ArrayMesh): GodotError { val mb = getMethodBind("MeshDataTool","commit_to_surface") return GodotError.byValue( _icall_Long_Object( mb, this.ptr, mesh).toUInt()) } open fun createFromSurface(mesh: ArrayMesh, surface: Long): GodotError { val mb = getMethodBind("MeshDataTool","create_from_surface") return GodotError.byValue( _icall_Long_Object_Long( mb, this.ptr, mesh, surface).toUInt()) } open fun getEdgeCount(): Long { val mb = getMethodBind("MeshDataTool","get_edge_count") return _icall_Long( mb, this.ptr) } open fun getEdgeFaces(idx: Long): PoolIntArray { val mb = getMethodBind("MeshDataTool","get_edge_faces") return _icall_PoolIntArray_Long( mb, this.ptr, idx) } open fun getEdgeMeta(idx: Long): Variant { val mb = getMethodBind("MeshDataTool","get_edge_meta") return _icall_Variant_Long( mb, this.ptr, idx) } open fun getEdgeVertex(idx: Long, vertex: Long): Long { val mb = getMethodBind("MeshDataTool","get_edge_vertex") return _icall_Long_Long_Long( mb, this.ptr, idx, vertex) } open fun getFaceCount(): Long { val mb = getMethodBind("MeshDataTool","get_face_count") return _icall_Long( mb, this.ptr) } open fun getFaceEdge(idx: Long, edge: Long): Long { val mb = getMethodBind("MeshDataTool","get_face_edge") return _icall_Long_Long_Long( mb, this.ptr, idx, edge) } open fun getFaceMeta(idx: Long): Variant { val mb = getMethodBind("MeshDataTool","get_face_meta") return _icall_Variant_Long( mb, this.ptr, idx) } open fun getFaceNormal(idx: Long): Vector3 { val mb = getMethodBind("MeshDataTool","get_face_normal") return _icall_Vector3_Long( mb, this.ptr, idx) } open fun getFaceVertex(idx: Long, vertex: Long): Long { val mb = getMethodBind("MeshDataTool","get_face_vertex") return _icall_Long_Long_Long( mb, this.ptr, idx, vertex) } open fun getFormat(): Long { val mb = getMethodBind("MeshDataTool","get_format") return _icall_Long( mb, this.ptr) } open fun getMaterial(): Material { val mb = getMethodBind("MeshDataTool","get_material") return _icall_Material( mb, this.ptr) } open fun getVertex(idx: Long): Vector3 { val mb = getMethodBind("MeshDataTool","get_vertex") return _icall_Vector3_Long( mb, this.ptr, idx) } open fun getVertexBones(idx: Long): PoolIntArray { val mb = getMethodBind("MeshDataTool","get_vertex_bones") return _icall_PoolIntArray_Long( mb, this.ptr, idx) } open fun getVertexColor(idx: Long): Color { val mb = getMethodBind("MeshDataTool","get_vertex_color") return _icall_Color_Long( mb, this.ptr, idx) } open fun getVertexCount(): Long { val mb = getMethodBind("MeshDataTool","get_vertex_count") return _icall_Long( mb, this.ptr) } open fun getVertexEdges(idx: Long): PoolIntArray { val mb = getMethodBind("MeshDataTool","get_vertex_edges") return _icall_PoolIntArray_Long( mb, this.ptr, idx) } open fun getVertexFaces(idx: Long): PoolIntArray { val mb = getMethodBind("MeshDataTool","get_vertex_faces") return _icall_PoolIntArray_Long( mb, this.ptr, idx) } open fun getVertexMeta(idx: Long): Variant { val mb = getMethodBind("MeshDataTool","get_vertex_meta") return _icall_Variant_Long( mb, this.ptr, idx) } open fun getVertexNormal(idx: Long): Vector3 { val mb = getMethodBind("MeshDataTool","get_vertex_normal") return _icall_Vector3_Long( mb, this.ptr, idx) } open fun getVertexTangent(idx: Long): Plane { val mb = getMethodBind("MeshDataTool","get_vertex_tangent") return _icall_Plane_Long( mb, this.ptr, idx) } open fun getVertexUv(idx: Long): Vector2 { val mb = getMethodBind("MeshDataTool","get_vertex_uv") return _icall_Vector2_Long( mb, this.ptr, idx) } open fun getVertexUv2(idx: Long): Vector2 { val mb = getMethodBind("MeshDataTool","get_vertex_uv2") return _icall_Vector2_Long( mb, this.ptr, idx) } open fun getVertexWeights(idx: Long): PoolRealArray { val mb = getMethodBind("MeshDataTool","get_vertex_weights") return _icall_PoolRealArray_Long( mb, this.ptr, idx) } open fun setEdgeMeta(idx: Long, meta: Variant) { val mb = getMethodBind("MeshDataTool","set_edge_meta") _icall_Unit_Long_Variant( mb, this.ptr, idx, meta) } open fun setFaceMeta(idx: Long, meta: Variant) { val mb = getMethodBind("MeshDataTool","set_face_meta") _icall_Unit_Long_Variant( mb, this.ptr, idx, meta) } open fun setMaterial(material: Material) { val mb = getMethodBind("MeshDataTool","set_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setVertex(idx: Long, vertex: Vector3) { val mb = getMethodBind("MeshDataTool","set_vertex") _icall_Unit_Long_Vector3( mb, this.ptr, idx, vertex) } open fun setVertexBones(idx: Long, bones: PoolIntArray) { val mb = getMethodBind("MeshDataTool","set_vertex_bones") _icall_Unit_Long_PoolIntArray( mb, this.ptr, idx, bones) } open fun setVertexColor(idx: Long, color: Color) { val mb = getMethodBind("MeshDataTool","set_vertex_color") _icall_Unit_Long_Color( mb, this.ptr, idx, color) } open fun setVertexMeta(idx: Long, meta: Variant) { val mb = getMethodBind("MeshDataTool","set_vertex_meta") _icall_Unit_Long_Variant( mb, this.ptr, idx, meta) } open fun setVertexNormal(idx: Long, normal: Vector3) { val mb = getMethodBind("MeshDataTool","set_vertex_normal") _icall_Unit_Long_Vector3( mb, this.ptr, idx, normal) } open fun setVertexTangent(idx: Long, tangent: Plane) { val mb = getMethodBind("MeshDataTool","set_vertex_tangent") _icall_Unit_Long_Plane( mb, this.ptr, idx, tangent) } open fun setVertexUv(idx: Long, uv: Vector2) { val mb = getMethodBind("MeshDataTool","set_vertex_uv") _icall_Unit_Long_Vector2( mb, this.ptr, idx, uv) } open fun setVertexUv2(idx: Long, uv2: Vector2) { val mb = getMethodBind("MeshDataTool","set_vertex_uv2") _icall_Unit_Long_Vector2( mb, this.ptr, idx, uv2) } open fun setVertexWeights(idx: Long, weights: PoolRealArray) { val mb = getMethodBind("MeshDataTool","set_vertex_weights") _icall_Unit_Long_PoolRealArray( mb, this.ptr, idx, weights) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MeshInstance.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.NodePath import godot.icalls._icall_Long import godot.icalls._icall_Material_Long import godot.icalls._icall_Mesh import godot.icalls._icall_NodePath import godot.icalls._icall_Skin import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_NodePath import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class MeshInstance : GeometryInstance() { open var mesh: Mesh get() { val mb = getMethodBind("MeshInstance","get_mesh") return _icall_Mesh(mb, this.ptr) } set(value) { val mb = getMethodBind("MeshInstance","set_mesh") _icall_Unit_Object(mb, this.ptr, value) } open var skeleton: NodePath get() { val mb = getMethodBind("MeshInstance","get_skeleton_path") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("MeshInstance","set_skeleton_path") _icall_Unit_NodePath(mb, this.ptr, value) } open var skin: Skin get() { val mb = getMethodBind("MeshInstance","get_skin") return _icall_Skin(mb, this.ptr) } set(value) { val mb = getMethodBind("MeshInstance","set_skin") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("MeshInstance", "MeshInstance") open fun _meshChanged() { } open fun createConvexCollision() { val mb = getMethodBind("MeshInstance","create_convex_collision") _icall_Unit( mb, this.ptr) } open fun createDebugTangents() { val mb = getMethodBind("MeshInstance","create_debug_tangents") _icall_Unit( mb, this.ptr) } open fun createTrimeshCollision() { val mb = getMethodBind("MeshInstance","create_trimesh_collision") _icall_Unit( mb, this.ptr) } open fun getMesh(): Mesh { val mb = getMethodBind("MeshInstance","get_mesh") return _icall_Mesh( mb, this.ptr) } open fun getSkeletonPath(): NodePath { val mb = getMethodBind("MeshInstance","get_skeleton_path") return _icall_NodePath( mb, this.ptr) } open fun getSkin(): Skin { val mb = getMethodBind("MeshInstance","get_skin") return _icall_Skin( mb, this.ptr) } open fun getSurfaceMaterial(surface: Long): Material { val mb = getMethodBind("MeshInstance","get_surface_material") return _icall_Material_Long( mb, this.ptr, surface) } open fun getSurfaceMaterialCount(): Long { val mb = getMethodBind("MeshInstance","get_surface_material_count") return _icall_Long( mb, this.ptr) } open fun setMesh(mesh: Mesh) { val mb = getMethodBind("MeshInstance","set_mesh") _icall_Unit_Object( mb, this.ptr, mesh) } open fun setSkeletonPath(skeletonPath: NodePath) { val mb = getMethodBind("MeshInstance","set_skeleton_path") _icall_Unit_NodePath( mb, this.ptr, skeletonPath) } open fun setSkin(skin: Skin) { val mb = getMethodBind("MeshInstance","set_skin") _icall_Unit_Object( mb, this.ptr, skin) } open fun setSurfaceMaterial(surface: Long, material: Material) { val mb = getMethodBind("MeshInstance","set_surface_material") _icall_Unit_Long_Object( mb, this.ptr, surface, material) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MeshInstance2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_Mesh import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class MeshInstance2D : Node2D() { val textureChanged: Signal0 by signal() open var mesh: Mesh get() { val mb = getMethodBind("MeshInstance2D","get_mesh") return _icall_Mesh(mb, this.ptr) } set(value) { val mb = getMethodBind("MeshInstance2D","set_mesh") _icall_Unit_Object(mb, this.ptr, value) } open var normalMap: Texture get() { val mb = getMethodBind("MeshInstance2D","get_normal_map") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("MeshInstance2D","set_normal_map") _icall_Unit_Object(mb, this.ptr, value) } open var texture: Texture get() { val mb = getMethodBind("MeshInstance2D","get_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("MeshInstance2D","set_texture") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("MeshInstance2D", "MeshInstance2D") open fun getMesh(): Mesh { val mb = getMethodBind("MeshInstance2D","get_mesh") return _icall_Mesh( mb, this.ptr) } open fun getNormalMap(): Texture { val mb = getMethodBind("MeshInstance2D","get_normal_map") return _icall_Texture( mb, this.ptr) } open fun getTexture(): Texture { val mb = getMethodBind("MeshInstance2D","get_texture") return _icall_Texture( mb, this.ptr) } open fun setMesh(mesh: Mesh) { val mb = getMethodBind("MeshInstance2D","set_mesh") _icall_Unit_Object( mb, this.ptr, mesh) } open fun setNormalMap(normalMap: Texture) { val mb = getMethodBind("MeshInstance2D","set_normal_map") _icall_Unit_Object( mb, this.ptr, normalMap) } open fun setTexture(texture: Texture) { val mb = getMethodBind("MeshInstance2D","set_texture") _icall_Unit_Object( mb, this.ptr, texture) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MeshLibrary.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolIntArray import godot.core.Transform import godot.core.VariantArray import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_Mesh_Long import godot.icalls._icall_NavigationMesh_Long import godot.icalls._icall_PoolIntArray import godot.icalls._icall_String_Long import godot.icalls._icall_Texture_Long import godot.icalls._icall_Transform_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Long_String import godot.icalls._icall_Unit_Long_Transform import godot.icalls._icall_Unit_Long_VariantArray import godot.icalls._icall_VariantArray_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class MeshLibrary : Resource() { override fun __new(): COpaquePointer = invokeConstructor("MeshLibrary", "MeshLibrary") open fun clear() { val mb = getMethodBind("MeshLibrary","clear") _icall_Unit( mb, this.ptr) } open fun createItem(id: Long) { val mb = getMethodBind("MeshLibrary","create_item") _icall_Unit_Long( mb, this.ptr, id) } open fun findItemByName(name: String): Long { val mb = getMethodBind("MeshLibrary","find_item_by_name") return _icall_Long_String( mb, this.ptr, name) } open fun getItemList(): PoolIntArray { val mb = getMethodBind("MeshLibrary","get_item_list") return _icall_PoolIntArray( mb, this.ptr) } open fun getItemMesh(id: Long): Mesh { val mb = getMethodBind("MeshLibrary","get_item_mesh") return _icall_Mesh_Long( mb, this.ptr, id) } open fun getItemName(id: Long): String { val mb = getMethodBind("MeshLibrary","get_item_name") return _icall_String_Long( mb, this.ptr, id) } open fun getItemNavmesh(id: Long): NavigationMesh { val mb = getMethodBind("MeshLibrary","get_item_navmesh") return _icall_NavigationMesh_Long( mb, this.ptr, id) } open fun getItemNavmeshTransform(id: Long): Transform { val mb = getMethodBind("MeshLibrary","get_item_navmesh_transform") return _icall_Transform_Long( mb, this.ptr, id) } open fun getItemPreview(id: Long): Texture { val mb = getMethodBind("MeshLibrary","get_item_preview") return _icall_Texture_Long( mb, this.ptr, id) } open fun getItemShapes(id: Long): VariantArray { val mb = getMethodBind("MeshLibrary","get_item_shapes") return _icall_VariantArray_Long( mb, this.ptr, id) } open fun getLastUnusedItemId(): Long { val mb = getMethodBind("MeshLibrary","get_last_unused_item_id") return _icall_Long( mb, this.ptr) } open fun removeItem(id: Long) { val mb = getMethodBind("MeshLibrary","remove_item") _icall_Unit_Long( mb, this.ptr, id) } open fun setItemMesh(id: Long, mesh: Mesh) { val mb = getMethodBind("MeshLibrary","set_item_mesh") _icall_Unit_Long_Object( mb, this.ptr, id, mesh) } open fun setItemName(id: Long, name: String) { val mb = getMethodBind("MeshLibrary","set_item_name") _icall_Unit_Long_String( mb, this.ptr, id, name) } open fun setItemNavmesh(id: Long, navmesh: NavigationMesh) { val mb = getMethodBind("MeshLibrary","set_item_navmesh") _icall_Unit_Long_Object( mb, this.ptr, id, navmesh) } open fun setItemNavmeshTransform(id: Long, navmesh: Transform) { val mb = getMethodBind("MeshLibrary","set_item_navmesh_transform") _icall_Unit_Long_Transform( mb, this.ptr, id, navmesh) } open fun setItemPreview(id: Long, texture: Texture) { val mb = getMethodBind("MeshLibrary","set_item_preview") _icall_Unit_Long_Object( mb, this.ptr, id, texture) } open fun setItemShapes(id: Long, shapes: VariantArray) { val mb = getMethodBind("MeshLibrary","set_item_shapes") _icall_Unit_Long_VariantArray( mb, this.ptr, id, shapes) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MeshTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Mesh import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class MeshTexture : Texture() { open var baseTexture: Texture get() { val mb = getMethodBind("MeshTexture","get_base_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("MeshTexture","set_base_texture") _icall_Unit_Object(mb, this.ptr, value) } open var imageSize: Vector2 get() { val mb = getMethodBind("MeshTexture","get_image_size") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("MeshTexture","set_image_size") _icall_Unit_Vector2(mb, this.ptr, value) } open var mesh: Mesh get() { val mb = getMethodBind("MeshTexture","get_mesh") return _icall_Mesh(mb, this.ptr) } set(value) { val mb = getMethodBind("MeshTexture","set_mesh") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("MeshTexture", "MeshTexture") open fun imageSize(schedule: Vector2.() -> Unit): Vector2 = imageSize.apply{ schedule(this) imageSize = this } open fun getBaseTexture(): Texture { val mb = getMethodBind("MeshTexture","get_base_texture") return _icall_Texture( mb, this.ptr) } open fun getImageSize(): Vector2 { val mb = getMethodBind("MeshTexture","get_image_size") return _icall_Vector2( mb, this.ptr) } open fun getMesh(): Mesh { val mb = getMethodBind("MeshTexture","get_mesh") return _icall_Mesh( mb, this.ptr) } open fun setBaseTexture(texture: Texture) { val mb = getMethodBind("MeshTexture","set_base_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setImageSize(size: Vector2) { val mb = getMethodBind("MeshTexture","set_image_size") _icall_Unit_Vector2( mb, this.ptr, size) } open fun setMesh(mesh: Mesh) { val mb = getMethodBind("MeshTexture","set_mesh") _icall_Unit_Object( mb, this.ptr, mesh) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MobileVRInterface.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class MobileVRInterface : ARVRInterface() { open var displayToLens: Double get() { val mb = getMethodBind("MobileVRInterface","get_display_to_lens") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("MobileVRInterface","set_display_to_lens") _icall_Unit_Double(mb, this.ptr, value) } open var displayWidth: Double get() { val mb = getMethodBind("MobileVRInterface","get_display_width") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("MobileVRInterface","set_display_width") _icall_Unit_Double(mb, this.ptr, value) } open var eyeHeight: Double get() { val mb = getMethodBind("MobileVRInterface","get_eye_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("MobileVRInterface","set_eye_height") _icall_Unit_Double(mb, this.ptr, value) } open var iod: Double get() { val mb = getMethodBind("MobileVRInterface","get_iod") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("MobileVRInterface","set_iod") _icall_Unit_Double(mb, this.ptr, value) } open var k1: Double get() { val mb = getMethodBind("MobileVRInterface","get_k1") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("MobileVRInterface","set_k1") _icall_Unit_Double(mb, this.ptr, value) } open var k2: Double get() { val mb = getMethodBind("MobileVRInterface","get_k2") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("MobileVRInterface","set_k2") _icall_Unit_Double(mb, this.ptr, value) } open var oversample: Double get() { val mb = getMethodBind("MobileVRInterface","get_oversample") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("MobileVRInterface","set_oversample") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("MobileVRInterface", "MobileVRInterface") open fun getDisplayToLens(): Double { val mb = getMethodBind("MobileVRInterface","get_display_to_lens") return _icall_Double( mb, this.ptr) } open fun getDisplayWidth(): Double { val mb = getMethodBind("MobileVRInterface","get_display_width") return _icall_Double( mb, this.ptr) } open fun getEyeHeight(): Double { val mb = getMethodBind("MobileVRInterface","get_eye_height") return _icall_Double( mb, this.ptr) } open fun getIod(): Double { val mb = getMethodBind("MobileVRInterface","get_iod") return _icall_Double( mb, this.ptr) } open fun getK1(): Double { val mb = getMethodBind("MobileVRInterface","get_k1") return _icall_Double( mb, this.ptr) } open fun getK2(): Double { val mb = getMethodBind("MobileVRInterface","get_k2") return _icall_Double( mb, this.ptr) } open fun getOversample(): Double { val mb = getMethodBind("MobileVRInterface","get_oversample") return _icall_Double( mb, this.ptr) } open fun setDisplayToLens(displayToLens: Double) { val mb = getMethodBind("MobileVRInterface","set_display_to_lens") _icall_Unit_Double( mb, this.ptr, displayToLens) } open fun setDisplayWidth(displayWidth: Double) { val mb = getMethodBind("MobileVRInterface","set_display_width") _icall_Unit_Double( mb, this.ptr, displayWidth) } open fun setEyeHeight(eyeHeight: Double) { val mb = getMethodBind("MobileVRInterface","set_eye_height") _icall_Unit_Double( mb, this.ptr, eyeHeight) } open fun setIod(iod: Double) { val mb = getMethodBind("MobileVRInterface","set_iod") _icall_Unit_Double( mb, this.ptr, iod) } open fun setK1(k: Double) { val mb = getMethodBind("MobileVRInterface","set_k1") _icall_Unit_Double( mb, this.ptr, k) } open fun setK2(k: Double) { val mb = getMethodBind("MobileVRInterface","set_k2") _icall_Unit_Double( mb, this.ptr, k) } open fun setOversample(oversample: Double) { val mb = getMethodBind("MobileVRInterface","set_oversample") _icall_Unit_Double( mb, this.ptr, oversample) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MultiMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.MultiMesh import godot.core.AABB import godot.core.Color import godot.core.PoolColorArray import godot.core.PoolRealArray import godot.core.PoolVector2Array import godot.core.PoolVector3Array import godot.core.Transform import godot.core.Transform2D import godot.icalls._icall_AABB import godot.icalls._icall_Color_Long import godot.icalls._icall_Long import godot.icalls._icall_Mesh import godot.icalls._icall_Transform2D_Long import godot.icalls._icall_Transform_Long import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Color import godot.icalls._icall_Unit_Long_Transform import godot.icalls._icall_Unit_Long_Transform2D import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_PoolRealArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class MultiMesh : Resource() { open var colorFormat: Long get() { val mb = getMethodBind("MultiMesh","get_color_format") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMesh","set_color_format") _icall_Unit_Long(mb, this.ptr, value) } open var customDataFormat: Long get() { val mb = getMethodBind("MultiMesh","get_custom_data_format") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMesh","set_custom_data_format") _icall_Unit_Long(mb, this.ptr, value) } open var instanceCount: Long get() { val mb = getMethodBind("MultiMesh","get_instance_count") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMesh","set_instance_count") _icall_Unit_Long(mb, this.ptr, value) } open var mesh: Mesh get() { val mb = getMethodBind("MultiMesh","get_mesh") return _icall_Mesh(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMesh","set_mesh") _icall_Unit_Object(mb, this.ptr, value) } open var transformFormat: Long get() { val mb = getMethodBind("MultiMesh","get_transform_format") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMesh","set_transform_format") _icall_Unit_Long(mb, this.ptr, value) } open var visibleInstanceCount: Long get() { val mb = getMethodBind("MultiMesh","get_visible_instance_count") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMesh","set_visible_instance_count") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("MultiMesh", "MultiMesh") open fun _getColorArray(): PoolColorArray { throw NotImplementedError("_get_color_array is not implemented for MultiMesh") } open fun _getCustomDataArray(): PoolColorArray { throw NotImplementedError("_get_custom_data_array is not implemented for MultiMesh") } open fun _getTransform2dArray(): PoolVector2Array { throw NotImplementedError("_get_transform_2d_array is not implemented for MultiMesh") } open fun _getTransformArray(): PoolVector3Array { throw NotImplementedError("_get_transform_array is not implemented for MultiMesh") } open fun _setColorArray(arg0: PoolColorArray) { } open fun _setCustomDataArray(arg0: PoolColorArray) { } open fun _setTransform2dArray(arg0: PoolVector2Array) { } open fun _setTransformArray(arg0: PoolVector3Array) { } open fun getAabb(): AABB { val mb = getMethodBind("MultiMesh","get_aabb") return _icall_AABB( mb, this.ptr) } open fun getColorFormat(): MultiMesh.ColorFormat { val mb = getMethodBind("MultiMesh","get_color_format") return MultiMesh.ColorFormat.from( _icall_Long( mb, this.ptr)) } open fun getCustomDataFormat(): MultiMesh.CustomDataFormat { val mb = getMethodBind("MultiMesh","get_custom_data_format") return MultiMesh.CustomDataFormat.from( _icall_Long( mb, this.ptr)) } open fun getInstanceColor(instance: Long): Color { val mb = getMethodBind("MultiMesh","get_instance_color") return _icall_Color_Long( mb, this.ptr, instance) } open fun getInstanceCount(): Long { val mb = getMethodBind("MultiMesh","get_instance_count") return _icall_Long( mb, this.ptr) } open fun getInstanceCustomData(instance: Long): Color { val mb = getMethodBind("MultiMesh","get_instance_custom_data") return _icall_Color_Long( mb, this.ptr, instance) } open fun getInstanceTransform(instance: Long): Transform { val mb = getMethodBind("MultiMesh","get_instance_transform") return _icall_Transform_Long( mb, this.ptr, instance) } open fun getInstanceTransform2d(instance: Long): Transform2D { val mb = getMethodBind("MultiMesh","get_instance_transform_2d") return _icall_Transform2D_Long( mb, this.ptr, instance) } open fun getMesh(): Mesh { val mb = getMethodBind("MultiMesh","get_mesh") return _icall_Mesh( mb, this.ptr) } open fun getTransformFormat(): MultiMesh.TransformFormat { val mb = getMethodBind("MultiMesh","get_transform_format") return MultiMesh.TransformFormat.from( _icall_Long( mb, this.ptr)) } open fun getVisibleInstanceCount(): Long { val mb = getMethodBind("MultiMesh","get_visible_instance_count") return _icall_Long( mb, this.ptr) } open fun setAsBulkArray(array: PoolRealArray) { val mb = getMethodBind("MultiMesh","set_as_bulk_array") _icall_Unit_PoolRealArray( mb, this.ptr, array) } open fun setColorFormat(format: Long) { val mb = getMethodBind("MultiMesh","set_color_format") _icall_Unit_Long( mb, this.ptr, format) } open fun setCustomDataFormat(format: Long) { val mb = getMethodBind("MultiMesh","set_custom_data_format") _icall_Unit_Long( mb, this.ptr, format) } open fun setInstanceColor(instance: Long, color: Color) { val mb = getMethodBind("MultiMesh","set_instance_color") _icall_Unit_Long_Color( mb, this.ptr, instance, color) } open fun setInstanceCount(count: Long) { val mb = getMethodBind("MultiMesh","set_instance_count") _icall_Unit_Long( mb, this.ptr, count) } open fun setInstanceCustomData(instance: Long, customData: Color) { val mb = getMethodBind("MultiMesh","set_instance_custom_data") _icall_Unit_Long_Color( mb, this.ptr, instance, customData) } open fun setInstanceTransform(instance: Long, transform: Transform) { val mb = getMethodBind("MultiMesh","set_instance_transform") _icall_Unit_Long_Transform( mb, this.ptr, instance, transform) } open fun setInstanceTransform2d(instance: Long, transform: Transform2D) { val mb = getMethodBind("MultiMesh","set_instance_transform_2d") _icall_Unit_Long_Transform2D( mb, this.ptr, instance, transform) } open fun setMesh(mesh: Mesh) { val mb = getMethodBind("MultiMesh","set_mesh") _icall_Unit_Object( mb, this.ptr, mesh) } open fun setTransformFormat(format: Long) { val mb = getMethodBind("MultiMesh","set_transform_format") _icall_Unit_Long( mb, this.ptr, format) } open fun setVisibleInstanceCount(count: Long) { val mb = getMethodBind("MultiMesh","set_visible_instance_count") _icall_Unit_Long( mb, this.ptr, count) } enum class TransformFormat( id: Long ) { TRANSFORM_2D(0), TRANSFORM_3D(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class CustomDataFormat( id: Long ) { CUSTOM_DATA_NONE(0), CUSTOM_DATA_8BIT(1), CUSTOM_DATA_FLOAT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ColorFormat( id: Long ) { COLOR_NONE(0), COLOR_8BIT(1), COLOR_FLOAT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MultiMeshInstance.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_MultiMesh import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class MultiMeshInstance : GeometryInstance() { open var multimesh: MultiMesh get() { val mb = getMethodBind("MultiMeshInstance","get_multimesh") return _icall_MultiMesh(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMeshInstance","set_multimesh") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("MultiMeshInstance", "MultiMeshInstance") open fun getMultimesh(): MultiMesh { val mb = getMethodBind("MultiMeshInstance","get_multimesh") return _icall_MultiMesh( mb, this.ptr) } open fun setMultimesh(multimesh: MultiMesh) { val mb = getMethodBind("MultiMeshInstance","set_multimesh") _icall_Unit_Object( mb, this.ptr, multimesh) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MultiMeshInstance2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_MultiMesh import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class MultiMeshInstance2D : Node2D() { val textureChanged: Signal0 by signal() open var multimesh: MultiMesh get() { val mb = getMethodBind("MultiMeshInstance2D","get_multimesh") return _icall_MultiMesh(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMeshInstance2D","set_multimesh") _icall_Unit_Object(mb, this.ptr, value) } open var normalMap: Texture get() { val mb = getMethodBind("MultiMeshInstance2D","get_normal_map") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMeshInstance2D","set_normal_map") _icall_Unit_Object(mb, this.ptr, value) } open var texture: Texture get() { val mb = getMethodBind("MultiMeshInstance2D","get_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiMeshInstance2D","set_texture") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("MultiMeshInstance2D", "MultiMeshInstance2D") open fun getMultimesh(): MultiMesh { val mb = getMethodBind("MultiMeshInstance2D","get_multimesh") return _icall_MultiMesh( mb, this.ptr) } open fun getNormalMap(): Texture { val mb = getMethodBind("MultiMeshInstance2D","get_normal_map") return _icall_Texture( mb, this.ptr) } open fun getTexture(): Texture { val mb = getMethodBind("MultiMeshInstance2D","get_texture") return _icall_Texture( mb, this.ptr) } open fun setMultimesh(multimesh: MultiMesh) { val mb = getMethodBind("MultiMeshInstance2D","set_multimesh") _icall_Unit_Object( mb, this.ptr, multimesh) } open fun setNormalMap(normalMap: Texture) { val mb = getMethodBind("MultiMeshInstance2D","set_normal_map") _icall_Unit_Object( mb, this.ptr, normalMap) } open fun setTexture(texture: Texture) { val mb = getMethodBind("MultiMeshInstance2D","set_texture") _icall_Unit_Object( mb, this.ptr, texture) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MultiplayerAPI.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.PoolByteArray import godot.core.PoolIntArray import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_PoolByteArray_Long_Long import godot.icalls._icall_NetworkedMultiplayerPeer import godot.icalls._icall_PoolIntArray import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlinx.cinterop.COpaquePointer open class MultiplayerAPI : Reference() { val connectedToServer: Signal0 by signal() val connectionFailed: Signal0 by signal() val networkPeerConnected: Signal1 by signal("id") val networkPeerDisconnected: Signal1 by signal("id") val networkPeerPacket: Signal2 by signal("id", "packet") val serverDisconnected: Signal0 by signal() open var allowObjectDecoding: Boolean get() { val mb = getMethodBind("MultiplayerAPI","is_object_decoding_allowed") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiplayerAPI","set_allow_object_decoding") _icall_Unit_Boolean(mb, this.ptr, value) } open var networkPeer: NetworkedMultiplayerPeer get() { val mb = getMethodBind("MultiplayerAPI","get_network_peer") return _icall_NetworkedMultiplayerPeer(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiplayerAPI","set_network_peer") _icall_Unit_Object(mb, this.ptr, value) } open var refuseNewNetworkConnections: Boolean get() { val mb = getMethodBind("MultiplayerAPI","is_refusing_new_network_connections") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("MultiplayerAPI","set_refuse_new_network_connections") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("MultiplayerAPI", "MultiplayerAPI") open fun _addPeer(id: Long) { } open fun _connectedToServer() { } open fun _connectionFailed() { } open fun _delPeer(id: Long) { } open fun _serverDisconnected() { } open fun clear() { val mb = getMethodBind("MultiplayerAPI","clear") _icall_Unit( mb, this.ptr) } open fun getNetworkConnectedPeers(): PoolIntArray { val mb = getMethodBind("MultiplayerAPI","get_network_connected_peers") return _icall_PoolIntArray( mb, this.ptr) } open fun getNetworkPeer(): NetworkedMultiplayerPeer { val mb = getMethodBind("MultiplayerAPI","get_network_peer") return _icall_NetworkedMultiplayerPeer( mb, this.ptr) } open fun getNetworkUniqueId(): Long { val mb = getMethodBind("MultiplayerAPI","get_network_unique_id") return _icall_Long( mb, this.ptr) } open fun getRpcSenderId(): Long { val mb = getMethodBind("MultiplayerAPI","get_rpc_sender_id") return _icall_Long( mb, this.ptr) } open fun hasNetworkPeer(): Boolean { val mb = getMethodBind("MultiplayerAPI","has_network_peer") return _icall_Boolean( mb, this.ptr) } open fun isNetworkServer(): Boolean { val mb = getMethodBind("MultiplayerAPI","is_network_server") return _icall_Boolean( mb, this.ptr) } open fun isObjectDecodingAllowed(): Boolean { val mb = getMethodBind("MultiplayerAPI","is_object_decoding_allowed") return _icall_Boolean( mb, this.ptr) } open fun isRefusingNewNetworkConnections(): Boolean { val mb = getMethodBind("MultiplayerAPI","is_refusing_new_network_connections") return _icall_Boolean( mb, this.ptr) } open fun poll() { val mb = getMethodBind("MultiplayerAPI","poll") _icall_Unit( mb, this.ptr) } open fun sendBytes( bytes: PoolByteArray, id: Long = 0, mode: Long = 2 ): GodotError { val mb = getMethodBind("MultiplayerAPI","send_bytes") return GodotError.byValue( _icall_Long_PoolByteArray_Long_Long( mb, this.ptr, bytes, id, mode).toUInt()) } open fun setAllowObjectDecoding(enable: Boolean) { val mb = getMethodBind("MultiplayerAPI","set_allow_object_decoding") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setNetworkPeer(peer: NetworkedMultiplayerPeer) { val mb = getMethodBind("MultiplayerAPI","set_network_peer") _icall_Unit_Object( mb, this.ptr, peer) } open fun setRefuseNewNetworkConnections(refuse: Boolean) { val mb = getMethodBind("MultiplayerAPI","set_refuse_new_network_connections") _icall_Unit_Boolean( mb, this.ptr, refuse) } open fun setRootNode(node: Node) { val mb = getMethodBind("MultiplayerAPI","set_root_node") _icall_Unit_Object( mb, this.ptr, node) } enum class RPCMode( id: Long ) { DISABLED(0), REMOTE(1), MASTER(2), PUPPET(3), SLAVE(3), REMOTESYNC(4), SYNC(4), MASTERSYNC(5), PUPPETSYNC(6); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/MultiplayerPeerGDNative.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class MultiplayerPeerGDNative : NetworkedMultiplayerPeer() { override fun __new(): COpaquePointer = invokeConstructor("MultiplayerPeerGDNative", "MultiplayerPeerGDNative") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Mutex.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.icalls._icall_Long import godot.icalls._icall_Unit import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class Mutex : Reference() { override fun __new(): COpaquePointer = invokeConstructor("Mutex", "_Mutex") open fun lock() { val mb = getMethodBind("_Mutex","lock") _icall_Unit( mb, this.ptr) } open fun tryLock(): GodotError { val mb = getMethodBind("_Mutex","try_lock") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } open fun unlock() { val mb = getMethodBind("_Mutex","unlock") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/NativeScript.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Variant import godot.icalls._icall_GDNativeLibrary import godot.icalls._icall_String import godot.icalls._icall_String_String import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_varargs import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Any import kotlin.String import kotlinx.cinterop.COpaquePointer open class NativeScript : Script() { open var className: String get() { val mb = getMethodBind("NativeScript","get_class_name") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("NativeScript","set_class_name") _icall_Unit_String(mb, this.ptr, value) } open var library: GDNativeLibrary get() { val mb = getMethodBind("NativeScript","get_library") return _icall_GDNativeLibrary(mb, this.ptr) } set(value) { val mb = getMethodBind("NativeScript","set_library") _icall_Unit_Object(mb, this.ptr, value) } open var scriptClassIconPath: String get() { val mb = getMethodBind("NativeScript","get_script_class_icon_path") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("NativeScript","set_script_class_icon_path") _icall_Unit_String(mb, this.ptr, value) } open var scriptClassName: String get() { val mb = getMethodBind("NativeScript","get_script_class_name") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("NativeScript","set_script_class_name") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("NativeScript", "NativeScript") open fun getClassDocumentation(): String { val mb = getMethodBind("NativeScript","get_class_documentation") return _icall_String( mb, this.ptr) } open fun getClassName(): String { val mb = getMethodBind("NativeScript","get_class_name") return _icall_String( mb, this.ptr) } open fun getLibrary(): GDNativeLibrary { val mb = getMethodBind("NativeScript","get_library") return _icall_GDNativeLibrary( mb, this.ptr) } open fun getMethodDocumentation(method: String): String { val mb = getMethodBind("NativeScript","get_method_documentation") return _icall_String_String( mb, this.ptr, method) } open fun getPropertyDocumentation(path: String): String { val mb = getMethodBind("NativeScript","get_property_documentation") return _icall_String_String( mb, this.ptr, path) } open fun getScriptClassIconPath(): String { val mb = getMethodBind("NativeScript","get_script_class_icon_path") return _icall_String( mb, this.ptr) } open fun getScriptClassName(): String { val mb = getMethodBind("NativeScript","get_script_class_name") return _icall_String( mb, this.ptr) } open fun getSignalDocumentation(signalName: String): String { val mb = getMethodBind("NativeScript","get_signal_documentation") return _icall_String_String( mb, this.ptr, signalName) } open fun new(vararg __var_args: Any?): Variant { val mb = getMethodBind("NativeScript","new") return _icall_varargs( mb, this.ptr, __var_args) } open fun setClassName(className: String) { val mb = getMethodBind("NativeScript","set_class_name") _icall_Unit_String( mb, this.ptr, className) } open fun setLibrary(library: GDNativeLibrary) { val mb = getMethodBind("NativeScript","set_library") _icall_Unit_Object( mb, this.ptr, library) } open fun setScriptClassIconPath(iconPath: String) { val mb = getMethodBind("NativeScript","set_script_class_icon_path") _icall_Unit_String( mb, this.ptr, iconPath) } open fun setScriptClassName(className: String) { val mb = getMethodBind("NativeScript","set_script_class_name") _icall_Unit_String( mb, this.ptr, className) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Navigation.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolVector3Array import godot.core.Transform import godot.core.Vector3 import godot.icalls._icall_Long_Object_Transform_nObject import godot.icalls._icall_Object_Vector3 import godot.icalls._icall_PoolVector3Array_Vector3_Vector3_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Transform import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.icalls._icall_Vector3_Vector3 import godot.icalls._icall_Vector3_Vector3_Vector3_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Navigation : Spatial() { open var upVector: Vector3 get() { val mb = getMethodBind("Navigation","get_up_vector") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("Navigation","set_up_vector") _icall_Unit_Vector3(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Navigation", "Navigation") open fun upVector(schedule: Vector3.() -> Unit): Vector3 = upVector.apply{ schedule(this) upVector = this } open fun getClosestPoint(toPoint: Vector3): Vector3 { val mb = getMethodBind("Navigation","get_closest_point") return _icall_Vector3_Vector3( mb, this.ptr, toPoint) } open fun getClosestPointNormal(toPoint: Vector3): Vector3 { val mb = getMethodBind("Navigation","get_closest_point_normal") return _icall_Vector3_Vector3( mb, this.ptr, toPoint) } open fun getClosestPointOwner(toPoint: Vector3): Object { val mb = getMethodBind("Navigation","get_closest_point_owner") return _icall_Object_Vector3( mb, this.ptr, toPoint) } open fun getClosestPointToSegment( start: Vector3, end: Vector3, useCollision: Boolean = false ): Vector3 { val mb = getMethodBind("Navigation","get_closest_point_to_segment") return _icall_Vector3_Vector3_Vector3_Boolean( mb, this.ptr, start, end, useCollision) } open fun getSimplePath( start: Vector3, end: Vector3, optimize: Boolean = true ): PoolVector3Array { val mb = getMethodBind("Navigation","get_simple_path") return _icall_PoolVector3Array_Vector3_Vector3_Boolean( mb, this.ptr, start, end, optimize) } open fun getUpVector(): Vector3 { val mb = getMethodBind("Navigation","get_up_vector") return _icall_Vector3( mb, this.ptr) } open fun navmeshAdd( mesh: NavigationMesh, xform: Transform, owner: Object? = null ): Long { val mb = getMethodBind("Navigation","navmesh_add") return _icall_Long_Object_Transform_nObject( mb, this.ptr, mesh, xform, owner) } open fun navmeshRemove(id: Long) { val mb = getMethodBind("Navigation","navmesh_remove") _icall_Unit_Long( mb, this.ptr, id) } open fun navmeshSetTransform(id: Long, xform: Transform) { val mb = getMethodBind("Navigation","navmesh_set_transform") _icall_Unit_Long_Transform( mb, this.ptr, id, xform) } open fun setUpVector(up: Vector3) { val mb = getMethodBind("Navigation","set_up_vector") _icall_Unit_Vector3( mb, this.ptr, up) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Navigation2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolVector2Array import godot.core.Transform2D import godot.core.Vector2 import godot.icalls._icall_Long_Object_Transform2D_nObject import godot.icalls._icall_Object_Vector2 import godot.icalls._icall_PoolVector2Array_Vector2_Vector2_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Transform2D import godot.icalls._icall_Vector2_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlinx.cinterop.COpaquePointer open class Navigation2D : Node2D() { override fun __new(): COpaquePointer = invokeConstructor("Navigation2D", "Navigation2D") open fun getClosestPoint(toPoint: Vector2): Vector2 { val mb = getMethodBind("Navigation2D","get_closest_point") return _icall_Vector2_Vector2( mb, this.ptr, toPoint) } open fun getClosestPointOwner(toPoint: Vector2): Object { val mb = getMethodBind("Navigation2D","get_closest_point_owner") return _icall_Object_Vector2( mb, this.ptr, toPoint) } open fun getSimplePath( start: Vector2, end: Vector2, optimize: Boolean = true ): PoolVector2Array { val mb = getMethodBind("Navigation2D","get_simple_path") return _icall_PoolVector2Array_Vector2_Vector2_Boolean( mb, this.ptr, start, end, optimize) } open fun navpolyAdd( mesh: NavigationPolygon, xform: Transform2D, owner: Object? = null ): Long { val mb = getMethodBind("Navigation2D","navpoly_add") return _icall_Long_Object_Transform2D_nObject( mb, this.ptr, mesh, xform, owner) } open fun navpolyRemove(id: Long) { val mb = getMethodBind("Navigation2D","navpoly_remove") _icall_Unit_Long( mb, this.ptr, id) } open fun navpolySetTransform(id: Long, xform: Transform2D) { val mb = getMethodBind("Navigation2D","navpoly_set_transform") _icall_Unit_Long_Transform2D( mb, this.ptr, id, xform) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/NavigationMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolIntArray import godot.core.PoolVector3Array import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_PoolIntArray_Long import godot.icalls._icall_PoolVector3Array import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_PoolIntArray import godot.icalls._icall_Unit_PoolVector3Array import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class NavigationMesh : Resource() { open var agent_height: Double get() { val mb = getMethodBind("NavigationMesh","get_agent_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_agent_height") _icall_Unit_Double(mb, this.ptr, value) } open var agent_maxClimb: Double get() { val mb = getMethodBind("NavigationMesh","get_agent_max_climb") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_agent_max_climb") _icall_Unit_Double(mb, this.ptr, value) } open var agent_maxSlope: Double get() { val mb = getMethodBind("NavigationMesh","get_agent_max_slope") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_agent_max_slope") _icall_Unit_Double(mb, this.ptr, value) } open var agent_radius: Double get() { val mb = getMethodBind("NavigationMesh","get_agent_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_agent_radius") _icall_Unit_Double(mb, this.ptr, value) } open var cell_height: Double get() { val mb = getMethodBind("NavigationMesh","get_cell_height") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_cell_height") _icall_Unit_Double(mb, this.ptr, value) } open var cell_size: Double get() { val mb = getMethodBind("NavigationMesh","get_cell_size") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_cell_size") _icall_Unit_Double(mb, this.ptr, value) } open var detail_sampleDistance: Double get() { val mb = getMethodBind("NavigationMesh","get_detail_sample_distance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_detail_sample_distance") _icall_Unit_Double(mb, this.ptr, value) } open var detail_sampleMaxError: Double get() { val mb = getMethodBind("NavigationMesh","get_detail_sample_max_error") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_detail_sample_max_error") _icall_Unit_Double(mb, this.ptr, value) } open var edge_maxError: Double get() { val mb = getMethodBind("NavigationMesh","get_edge_max_error") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_edge_max_error") _icall_Unit_Double(mb, this.ptr, value) } open var edge_maxLength: Double get() { val mb = getMethodBind("NavigationMesh","get_edge_max_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_edge_max_length") _icall_Unit_Double(mb, this.ptr, value) } open var filter_filterWalkableLowHeightSpans: Boolean get() { val mb = getMethodBind("NavigationMesh","get_filter_walkable_low_height_spans") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_filter_walkable_low_height_spans") _icall_Unit_Boolean(mb, this.ptr, value) } open var filter_ledgeSpans: Boolean get() { val mb = getMethodBind("NavigationMesh","get_filter_ledge_spans") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_filter_ledge_spans") _icall_Unit_Boolean(mb, this.ptr, value) } open var filter_lowHangingObstacles: Boolean get() { val mb = getMethodBind("NavigationMesh","get_filter_low_hanging_obstacles") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_filter_low_hanging_obstacles") _icall_Unit_Boolean(mb, this.ptr, value) } open var geometry_collisionMask: Long get() { val mb = getMethodBind("NavigationMesh","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open var geometry_parsedGeometryType: Long get() { val mb = getMethodBind("NavigationMesh","get_parsed_geometry_type") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_parsed_geometry_type") _icall_Unit_Long(mb, this.ptr, value) } open var geometry_sourceGeometryMode: Long get() { val mb = getMethodBind("NavigationMesh","get_source_geometry_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_source_geometry_mode") _icall_Unit_Long(mb, this.ptr, value) } open var geometry_sourceGroupName: String get() { val mb = getMethodBind("NavigationMesh","get_source_group_name") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_source_group_name") _icall_Unit_String(mb, this.ptr, value) } open var polygon_vertsPerPoly: Double get() { val mb = getMethodBind("NavigationMesh","get_verts_per_poly") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_verts_per_poly") _icall_Unit_Double(mb, this.ptr, value) } open var region_mergeSize: Double get() { val mb = getMethodBind("NavigationMesh","get_region_merge_size") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_region_merge_size") _icall_Unit_Double(mb, this.ptr, value) } open var region_minSize: Double get() { val mb = getMethodBind("NavigationMesh","get_region_min_size") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_region_min_size") _icall_Unit_Double(mb, this.ptr, value) } open var samplePartitionType_samplePartitionType: Long get() { val mb = getMethodBind("NavigationMesh","get_sample_partition_type") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_sample_partition_type") _icall_Unit_Long(mb, this.ptr, value) } open var vertices: PoolVector3Array get() { val mb = getMethodBind("NavigationMesh","get_vertices") return _icall_PoolVector3Array(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMesh","set_vertices") _icall_Unit_PoolVector3Array(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("NavigationMesh", "NavigationMesh") open fun _getPolygons(): VariantArray { throw NotImplementedError("_get_polygons is not implemented for NavigationMesh") } open fun _setPolygons(polygons: VariantArray) { } open fun addPolygon(polygon: PoolIntArray) { val mb = getMethodBind("NavigationMesh","add_polygon") _icall_Unit_PoolIntArray( mb, this.ptr, polygon) } open fun clearPolygons() { val mb = getMethodBind("NavigationMesh","clear_polygons") _icall_Unit( mb, this.ptr) } open fun createFromMesh(mesh: Mesh) { val mb = getMethodBind("NavigationMesh","create_from_mesh") _icall_Unit_Object( mb, this.ptr, mesh) } open fun getAgentHeight(): Double { val mb = getMethodBind("NavigationMesh","get_agent_height") return _icall_Double( mb, this.ptr) } open fun getAgentMaxClimb(): Double { val mb = getMethodBind("NavigationMesh","get_agent_max_climb") return _icall_Double( mb, this.ptr) } open fun getAgentMaxSlope(): Double { val mb = getMethodBind("NavigationMesh","get_agent_max_slope") return _icall_Double( mb, this.ptr) } open fun getAgentRadius(): Double { val mb = getMethodBind("NavigationMesh","get_agent_radius") return _icall_Double( mb, this.ptr) } open fun getCellHeight(): Double { val mb = getMethodBind("NavigationMesh","get_cell_height") return _icall_Double( mb, this.ptr) } open fun getCellSize(): Double { val mb = getMethodBind("NavigationMesh","get_cell_size") return _icall_Double( mb, this.ptr) } open fun getCollisionMask(): Long { val mb = getMethodBind("NavigationMesh","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("NavigationMesh","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getDetailSampleDistance(): Double { val mb = getMethodBind("NavigationMesh","get_detail_sample_distance") return _icall_Double( mb, this.ptr) } open fun getDetailSampleMaxError(): Double { val mb = getMethodBind("NavigationMesh","get_detail_sample_max_error") return _icall_Double( mb, this.ptr) } open fun getEdgeMaxError(): Double { val mb = getMethodBind("NavigationMesh","get_edge_max_error") return _icall_Double( mb, this.ptr) } open fun getEdgeMaxLength(): Double { val mb = getMethodBind("NavigationMesh","get_edge_max_length") return _icall_Double( mb, this.ptr) } open fun getFilterLedgeSpans(): Boolean { val mb = getMethodBind("NavigationMesh","get_filter_ledge_spans") return _icall_Boolean( mb, this.ptr) } open fun getFilterLowHangingObstacles(): Boolean { val mb = getMethodBind("NavigationMesh","get_filter_low_hanging_obstacles") return _icall_Boolean( mb, this.ptr) } open fun getFilterWalkableLowHeightSpans(): Boolean { val mb = getMethodBind("NavigationMesh","get_filter_walkable_low_height_spans") return _icall_Boolean( mb, this.ptr) } open fun getParsedGeometryType(): Long { val mb = getMethodBind("NavigationMesh","get_parsed_geometry_type") return _icall_Long( mb, this.ptr) } open fun getPolygon(idx: Long): PoolIntArray { val mb = getMethodBind("NavigationMesh","get_polygon") return _icall_PoolIntArray_Long( mb, this.ptr, idx) } open fun getPolygonCount(): Long { val mb = getMethodBind("NavigationMesh","get_polygon_count") return _icall_Long( mb, this.ptr) } open fun getRegionMergeSize(): Double { val mb = getMethodBind("NavigationMesh","get_region_merge_size") return _icall_Double( mb, this.ptr) } open fun getRegionMinSize(): Double { val mb = getMethodBind("NavigationMesh","get_region_min_size") return _icall_Double( mb, this.ptr) } open fun getSamplePartitionType(): Long { val mb = getMethodBind("NavigationMesh","get_sample_partition_type") return _icall_Long( mb, this.ptr) } open fun getSourceGeometryMode(): Long { val mb = getMethodBind("NavigationMesh","get_source_geometry_mode") return _icall_Long( mb, this.ptr) } open fun getSourceGroupName(): String { val mb = getMethodBind("NavigationMesh","get_source_group_name") return _icall_String( mb, this.ptr) } open fun getVertices(): PoolVector3Array { val mb = getMethodBind("NavigationMesh","get_vertices") return _icall_PoolVector3Array( mb, this.ptr) } open fun getVertsPerPoly(): Double { val mb = getMethodBind("NavigationMesh","get_verts_per_poly") return _icall_Double( mb, this.ptr) } open fun setAgentHeight(agentHeight: Double) { val mb = getMethodBind("NavigationMesh","set_agent_height") _icall_Unit_Double( mb, this.ptr, agentHeight) } open fun setAgentMaxClimb(agentMaxClimb: Double) { val mb = getMethodBind("NavigationMesh","set_agent_max_climb") _icall_Unit_Double( mb, this.ptr, agentMaxClimb) } open fun setAgentMaxSlope(agentMaxSlope: Double) { val mb = getMethodBind("NavigationMesh","set_agent_max_slope") _icall_Unit_Double( mb, this.ptr, agentMaxSlope) } open fun setAgentRadius(agentRadius: Double) { val mb = getMethodBind("NavigationMesh","set_agent_radius") _icall_Unit_Double( mb, this.ptr, agentRadius) } open fun setCellHeight(cellHeight: Double) { val mb = getMethodBind("NavigationMesh","set_cell_height") _icall_Unit_Double( mb, this.ptr, cellHeight) } open fun setCellSize(cellSize: Double) { val mb = getMethodBind("NavigationMesh","set_cell_size") _icall_Unit_Double( mb, this.ptr, cellSize) } open fun setCollisionMask(mask: Long) { val mb = getMethodBind("NavigationMesh","set_collision_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("NavigationMesh","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setDetailSampleDistance(detailSampleDist: Double) { val mb = getMethodBind("NavigationMesh","set_detail_sample_distance") _icall_Unit_Double( mb, this.ptr, detailSampleDist) } open fun setDetailSampleMaxError(detailSampleMaxError: Double) { val mb = getMethodBind("NavigationMesh","set_detail_sample_max_error") _icall_Unit_Double( mb, this.ptr, detailSampleMaxError) } open fun setEdgeMaxError(edgeMaxError: Double) { val mb = getMethodBind("NavigationMesh","set_edge_max_error") _icall_Unit_Double( mb, this.ptr, edgeMaxError) } open fun setEdgeMaxLength(edgeMaxLength: Double) { val mb = getMethodBind("NavigationMesh","set_edge_max_length") _icall_Unit_Double( mb, this.ptr, edgeMaxLength) } open fun setFilterLedgeSpans(filterLedgeSpans: Boolean) { val mb = getMethodBind("NavigationMesh","set_filter_ledge_spans") _icall_Unit_Boolean( mb, this.ptr, filterLedgeSpans) } open fun setFilterLowHangingObstacles(filterLowHangingObstacles: Boolean) { val mb = getMethodBind("NavigationMesh","set_filter_low_hanging_obstacles") _icall_Unit_Boolean( mb, this.ptr, filterLowHangingObstacles) } open fun setFilterWalkableLowHeightSpans(filterWalkableLowHeightSpans: Boolean) { val mb = getMethodBind("NavigationMesh","set_filter_walkable_low_height_spans") _icall_Unit_Boolean( mb, this.ptr, filterWalkableLowHeightSpans) } open fun setParsedGeometryType(geometryType: Long) { val mb = getMethodBind("NavigationMesh","set_parsed_geometry_type") _icall_Unit_Long( mb, this.ptr, geometryType) } open fun setRegionMergeSize(regionMergeSize: Double) { val mb = getMethodBind("NavigationMesh","set_region_merge_size") _icall_Unit_Double( mb, this.ptr, regionMergeSize) } open fun setRegionMinSize(regionMinSize: Double) { val mb = getMethodBind("NavigationMesh","set_region_min_size") _icall_Unit_Double( mb, this.ptr, regionMinSize) } open fun setSamplePartitionType(samplePartitionType: Long) { val mb = getMethodBind("NavigationMesh","set_sample_partition_type") _icall_Unit_Long( mb, this.ptr, samplePartitionType) } open fun setSourceGeometryMode(mask: Long) { val mb = getMethodBind("NavigationMesh","set_source_geometry_mode") _icall_Unit_Long( mb, this.ptr, mask) } open fun setSourceGroupName(mask: String) { val mb = getMethodBind("NavigationMesh","set_source_group_name") _icall_Unit_String( mb, this.ptr, mask) } open fun setVertices(vertices: PoolVector3Array) { val mb = getMethodBind("NavigationMesh","set_vertices") _icall_Unit_PoolVector3Array( mb, this.ptr, vertices) } open fun setVertsPerPoly(vertsPerPoly: Double) { val mb = getMethodBind("NavigationMesh","set_verts_per_poly") _icall_Unit_Double( mb, this.ptr, vertsPerPoly) } companion object { final const val PARSED_GEOMETRY_BOTH: Long = 2 final const val PARSED_GEOMETRY_MESH_INSTANCES: Long = 0 final const val PARSED_GEOMETRY_STATIC_COLLIDERS: Long = 1 final const val SAMPLE_PARTITION_LAYERS: Long = 2 final const val SAMPLE_PARTITION_MONOTONE: Long = 1 final const val SAMPLE_PARTITION_WATERSHED: Long = 0 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/NavigationMeshInstance.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_NavigationMesh import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class NavigationMeshInstance : Spatial() { open var enabled: Boolean get() { val mb = getMethodBind("NavigationMeshInstance","is_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMeshInstance","set_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var navmesh: NavigationMesh get() { val mb = getMethodBind("NavigationMeshInstance","get_navigation_mesh") return _icall_NavigationMesh(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationMeshInstance","set_navigation_mesh") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("NavigationMeshInstance", "NavigationMeshInstance") open fun getNavigationMesh(): NavigationMesh { val mb = getMethodBind("NavigationMeshInstance","get_navigation_mesh") return _icall_NavigationMesh( mb, this.ptr) } open fun isEnabled(): Boolean { val mb = getMethodBind("NavigationMeshInstance","is_enabled") return _icall_Boolean( mb, this.ptr) } open fun setEnabled(enabled: Boolean) { val mb = getMethodBind("NavigationMeshInstance","set_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setNavigationMesh(navmesh: NavigationMesh) { val mb = getMethodBind("NavigationMeshInstance","set_navigation_mesh") _icall_Unit_Object( mb, this.ptr, navmesh) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/NavigationPolygon.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolIntArray import godot.core.PoolVector2Array import godot.core.VariantArray import godot.icalls._icall_Long import godot.icalls._icall_PoolIntArray_Long import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_PoolVector2Array_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_PoolVector2Array import godot.icalls._icall_Unit_PoolIntArray import godot.icalls._icall_Unit_PoolVector2Array import godot.icalls._icall_Unit_PoolVector2Array_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class NavigationPolygon : Resource() { open var vertices: PoolVector2Array get() { val mb = getMethodBind("NavigationPolygon","get_vertices") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationPolygon","set_vertices") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("NavigationPolygon", "NavigationPolygon") open fun _getOutlines(): VariantArray { throw NotImplementedError("_get_outlines is not implemented for NavigationPolygon") } open fun _getPolygons(): VariantArray { throw NotImplementedError("_get_polygons is not implemented for NavigationPolygon") } open fun _setOutlines(outlines: VariantArray) { } open fun _setPolygons(polygons: VariantArray) { } open fun addOutline(outline: PoolVector2Array) { val mb = getMethodBind("NavigationPolygon","add_outline") _icall_Unit_PoolVector2Array( mb, this.ptr, outline) } open fun addOutlineAtIndex(outline: PoolVector2Array, index: Long) { val mb = getMethodBind("NavigationPolygon","add_outline_at_index") _icall_Unit_PoolVector2Array_Long( mb, this.ptr, outline, index) } open fun addPolygon(polygon: PoolIntArray) { val mb = getMethodBind("NavigationPolygon","add_polygon") _icall_Unit_PoolIntArray( mb, this.ptr, polygon) } open fun clearOutlines() { val mb = getMethodBind("NavigationPolygon","clear_outlines") _icall_Unit( mb, this.ptr) } open fun clearPolygons() { val mb = getMethodBind("NavigationPolygon","clear_polygons") _icall_Unit( mb, this.ptr) } open fun getOutline(idx: Long): PoolVector2Array { val mb = getMethodBind("NavigationPolygon","get_outline") return _icall_PoolVector2Array_Long( mb, this.ptr, idx) } open fun getOutlineCount(): Long { val mb = getMethodBind("NavigationPolygon","get_outline_count") return _icall_Long( mb, this.ptr) } open fun getPolygon(idx: Long): PoolIntArray { val mb = getMethodBind("NavigationPolygon","get_polygon") return _icall_PoolIntArray_Long( mb, this.ptr, idx) } open fun getPolygonCount(): Long { val mb = getMethodBind("NavigationPolygon","get_polygon_count") return _icall_Long( mb, this.ptr) } open fun getVertices(): PoolVector2Array { val mb = getMethodBind("NavigationPolygon","get_vertices") return _icall_PoolVector2Array( mb, this.ptr) } open fun makePolygonsFromOutlines() { val mb = getMethodBind("NavigationPolygon","make_polygons_from_outlines") _icall_Unit( mb, this.ptr) } open fun removeOutline(idx: Long) { val mb = getMethodBind("NavigationPolygon","remove_outline") _icall_Unit_Long( mb, this.ptr, idx) } open fun setOutline(idx: Long, outline: PoolVector2Array) { val mb = getMethodBind("NavigationPolygon","set_outline") _icall_Unit_Long_PoolVector2Array( mb, this.ptr, idx, outline) } open fun setVertices(vertices: PoolVector2Array) { val mb = getMethodBind("NavigationPolygon","set_vertices") _icall_Unit_PoolVector2Array( mb, this.ptr, vertices) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/NavigationPolygonInstance.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_NavigationPolygon import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class NavigationPolygonInstance : Node2D() { open var enabled: Boolean get() { val mb = getMethodBind("NavigationPolygonInstance","is_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationPolygonInstance","set_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var navpoly: NavigationPolygon get() { val mb = getMethodBind("NavigationPolygonInstance","get_navigation_polygon") return _icall_NavigationPolygon(mb, this.ptr) } set(value) { val mb = getMethodBind("NavigationPolygonInstance","set_navigation_polygon") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("NavigationPolygonInstance", "NavigationPolygonInstance") open fun _navpolyChanged() { } open fun getNavigationPolygon(): NavigationPolygon { val mb = getMethodBind("NavigationPolygonInstance","get_navigation_polygon") return _icall_NavigationPolygon( mb, this.ptr) } open fun isEnabled(): Boolean { val mb = getMethodBind("NavigationPolygonInstance","is_enabled") return _icall_Boolean( mb, this.ptr) } open fun setEnabled(enabled: Boolean) { val mb = getMethodBind("NavigationPolygonInstance","set_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setNavigationPolygon(navpoly: NavigationPolygon) { val mb = getMethodBind("NavigationPolygonInstance","set_navigation_polygon") _icall_Unit_Object( mb, this.ptr, navpoly) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/NetworkedMultiplayerENet.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.NetworkedMultiplayerENet import godot.core.GodotError import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_Long_Long_Long_Long import godot.icalls._icall_Long_String_Long_Long_Long_Long import godot.icalls._icall_String_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class NetworkedMultiplayerENet : NetworkedMultiplayerPeer() { open var alwaysOrdered: Boolean get() { val mb = getMethodBind("NetworkedMultiplayerENet","is_always_ordered") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NetworkedMultiplayerENet","set_always_ordered") _icall_Unit_Boolean(mb, this.ptr, value) } open var channelCount: Long get() { val mb = getMethodBind("NetworkedMultiplayerENet","get_channel_count") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NetworkedMultiplayerENet","set_channel_count") _icall_Unit_Long(mb, this.ptr, value) } open var compressionMode: Long get() { val mb = getMethodBind("NetworkedMultiplayerENet","get_compression_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NetworkedMultiplayerENet","set_compression_mode") _icall_Unit_Long(mb, this.ptr, value) } open var dtlsVerify: Boolean get() { val mb = getMethodBind("NetworkedMultiplayerENet","is_dtls_verify_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NetworkedMultiplayerENet","set_dtls_verify_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var serverRelay: Boolean get() { val mb = getMethodBind("NetworkedMultiplayerENet","is_server_relay_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NetworkedMultiplayerENet","set_server_relay_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var transferChannel: Long get() { val mb = getMethodBind("NetworkedMultiplayerENet","get_transfer_channel") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NetworkedMultiplayerENet","set_transfer_channel") _icall_Unit_Long(mb, this.ptr, value) } open var useDtls: Boolean get() { val mb = getMethodBind("NetworkedMultiplayerENet","is_dtls_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NetworkedMultiplayerENet","set_dtls_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("NetworkedMultiplayerENet", "NetworkedMultiplayerENet") open fun closeConnection(waitUsec: Long = 100) { val mb = getMethodBind("NetworkedMultiplayerENet","close_connection") _icall_Unit_Long( mb, this.ptr, waitUsec) } open fun createClient( address: String, port: Long, inBandwidth: Long = 0, outBandwidth: Long = 0, clientPort: Long = 0 ): GodotError { val mb = getMethodBind("NetworkedMultiplayerENet","create_client") return GodotError.byValue( _icall_Long_String_Long_Long_Long_Long( mb, this.ptr, address, port, inBandwidth, outBandwidth, clientPort).toUInt()) } open fun createServer( port: Long, maxClients: Long = 32, inBandwidth: Long = 0, outBandwidth: Long = 0 ): GodotError { val mb = getMethodBind("NetworkedMultiplayerENet","create_server") return GodotError.byValue( _icall_Long_Long_Long_Long_Long( mb, this.ptr, port, maxClients, inBandwidth, outBandwidth).toUInt()) } open fun disconnectPeer(id: Long, now: Boolean = false) { val mb = getMethodBind("NetworkedMultiplayerENet","disconnect_peer") _icall_Unit_Long_Boolean( mb, this.ptr, id, now) } open fun getChannelCount(): Long { val mb = getMethodBind("NetworkedMultiplayerENet","get_channel_count") return _icall_Long( mb, this.ptr) } open fun getCompressionMode(): NetworkedMultiplayerENet.CompressionMode { val mb = getMethodBind("NetworkedMultiplayerENet","get_compression_mode") return NetworkedMultiplayerENet.CompressionMode.from( _icall_Long( mb, this.ptr)) } open fun getLastPacketChannel(): Long { val mb = getMethodBind("NetworkedMultiplayerENet","get_last_packet_channel") return _icall_Long( mb, this.ptr) } open fun getPacketChannel(): Long { val mb = getMethodBind("NetworkedMultiplayerENet","get_packet_channel") return _icall_Long( mb, this.ptr) } open fun getPeerAddress(id: Long): String { val mb = getMethodBind("NetworkedMultiplayerENet","get_peer_address") return _icall_String_Long( mb, this.ptr, id) } open fun getPeerPort(id: Long): Long { val mb = getMethodBind("NetworkedMultiplayerENet","get_peer_port") return _icall_Long_Long( mb, this.ptr, id) } open fun getTransferChannel(): Long { val mb = getMethodBind("NetworkedMultiplayerENet","get_transfer_channel") return _icall_Long( mb, this.ptr) } open fun isAlwaysOrdered(): Boolean { val mb = getMethodBind("NetworkedMultiplayerENet","is_always_ordered") return _icall_Boolean( mb, this.ptr) } open fun isDtlsEnabled(): Boolean { val mb = getMethodBind("NetworkedMultiplayerENet","is_dtls_enabled") return _icall_Boolean( mb, this.ptr) } open fun isDtlsVerifyEnabled(): Boolean { val mb = getMethodBind("NetworkedMultiplayerENet","is_dtls_verify_enabled") return _icall_Boolean( mb, this.ptr) } open fun isServerRelayEnabled(): Boolean { val mb = getMethodBind("NetworkedMultiplayerENet","is_server_relay_enabled") return _icall_Boolean( mb, this.ptr) } open fun setAlwaysOrdered(ordered: Boolean) { val mb = getMethodBind("NetworkedMultiplayerENet","set_always_ordered") _icall_Unit_Boolean( mb, this.ptr, ordered) } open fun setBindIp(ip: String) { val mb = getMethodBind("NetworkedMultiplayerENet","set_bind_ip") _icall_Unit_String( mb, this.ptr, ip) } open fun setChannelCount(channels: Long) { val mb = getMethodBind("NetworkedMultiplayerENet","set_channel_count") _icall_Unit_Long( mb, this.ptr, channels) } open fun setCompressionMode(mode: Long) { val mb = getMethodBind("NetworkedMultiplayerENet","set_compression_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setDtlsCertificate(certificate: X509Certificate) { val mb = getMethodBind("NetworkedMultiplayerENet","set_dtls_certificate") _icall_Unit_Object( mb, this.ptr, certificate) } open fun setDtlsEnabled(enabled: Boolean) { val mb = getMethodBind("NetworkedMultiplayerENet","set_dtls_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setDtlsKey(key: CryptoKey) { val mb = getMethodBind("NetworkedMultiplayerENet","set_dtls_key") _icall_Unit_Object( mb, this.ptr, key) } open fun setDtlsVerifyEnabled(enabled: Boolean) { val mb = getMethodBind("NetworkedMultiplayerENet","set_dtls_verify_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setServerRelayEnabled(enabled: Boolean) { val mb = getMethodBind("NetworkedMultiplayerENet","set_server_relay_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setTransferChannel(channel: Long) { val mb = getMethodBind("NetworkedMultiplayerENet","set_transfer_channel") _icall_Unit_Long( mb, this.ptr, channel) } enum class CompressionMode( id: Long ) { COMPRESS_NONE(0), COMPRESS_RANGE_CODER(1), COMPRESS_FASTLZ(2), COMPRESS_ZLIB(3), COMPRESS_ZSTD(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/NetworkedMultiplayerPeer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.NetworkedMultiplayerPeer import godot.core.Signal0 import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long open class NetworkedMultiplayerPeer internal constructor() : PacketPeer() { val connectionFailed: Signal0 by signal() val connectionSucceeded: Signal0 by signal() val peerConnected: Signal1 by signal("id") val peerDisconnected: Signal1 by signal("id") val serverDisconnected: Signal0 by signal() open var refuseNewConnections: Boolean get() { val mb = getMethodBind("NetworkedMultiplayerPeer","is_refusing_new_connections") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NetworkedMultiplayerPeer","set_refuse_new_connections") _icall_Unit_Boolean(mb, this.ptr, value) } open var transferMode: Long get() { val mb = getMethodBind("NetworkedMultiplayerPeer","get_transfer_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NetworkedMultiplayerPeer","set_transfer_mode") _icall_Unit_Long(mb, this.ptr, value) } open fun getConnectionStatus(): NetworkedMultiplayerPeer.ConnectionStatus { val mb = getMethodBind("NetworkedMultiplayerPeer","get_connection_status") return NetworkedMultiplayerPeer.ConnectionStatus.from( _icall_Long( mb, this.ptr)) } open fun getPacketPeer(): Long { val mb = getMethodBind("NetworkedMultiplayerPeer","get_packet_peer") return _icall_Long( mb, this.ptr) } open fun getTransferMode(): NetworkedMultiplayerPeer.TransferMode { val mb = getMethodBind("NetworkedMultiplayerPeer","get_transfer_mode") return NetworkedMultiplayerPeer.TransferMode.from( _icall_Long( mb, this.ptr)) } open fun getUniqueId(): Long { val mb = getMethodBind("NetworkedMultiplayerPeer","get_unique_id") return _icall_Long( mb, this.ptr) } open fun isRefusingNewConnections(): Boolean { val mb = getMethodBind("NetworkedMultiplayerPeer","is_refusing_new_connections") return _icall_Boolean( mb, this.ptr) } open fun poll() { val mb = getMethodBind("NetworkedMultiplayerPeer","poll") _icall_Unit( mb, this.ptr) } open fun setRefuseNewConnections(enable: Boolean) { val mb = getMethodBind("NetworkedMultiplayerPeer","set_refuse_new_connections") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setTargetPeer(id: Long) { val mb = getMethodBind("NetworkedMultiplayerPeer","set_target_peer") _icall_Unit_Long( mb, this.ptr, id) } open fun setTransferMode(mode: Long) { val mb = getMethodBind("NetworkedMultiplayerPeer","set_transfer_mode") _icall_Unit_Long( mb, this.ptr, mode) } enum class ConnectionStatus( id: Long ) { CONNECTION_DISCONNECTED(0), CONNECTION_CONNECTING(1), CONNECTION_CONNECTED(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class TransferMode( id: Long ) { TRANSFER_MODE_UNRELIABLE(0), TRANSFER_MODE_UNRELIABLE_ORDERED(1), TRANSFER_MODE_RELIABLE(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object { final const val TARGET_PEER_BROADCAST: Long = 0 final const val TARGET_PEER_SERVER: Long = 1 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/NinePatchRect.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.NinePatchRect import godot.core.Rect2 import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Rect2 import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Rect2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class NinePatchRect : Control() { val textureChanged: Signal0 by signal() open var axisStretchHorizontal: Long get() { val mb = getMethodBind("NinePatchRect","get_h_axis_stretch_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NinePatchRect","set_h_axis_stretch_mode") _icall_Unit_Long(mb, this.ptr, value) } open var axisStretchVertical: Long get() { val mb = getMethodBind("NinePatchRect","get_v_axis_stretch_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("NinePatchRect","set_v_axis_stretch_mode") _icall_Unit_Long(mb, this.ptr, value) } open var drawCenter: Boolean get() { val mb = getMethodBind("NinePatchRect","is_draw_center_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NinePatchRect","set_draw_center") _icall_Unit_Boolean(mb, this.ptr, value) } open var patchMarginBottom: Long get() { val mb = getMethodBind("NinePatchRect","get_patch_margin") return _icall_Long_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("NinePatchRect","set_patch_margin") _icall_Unit_Long_Long(mb, this.ptr, 3, value) } open var patchMarginLeft: Long get() { val mb = getMethodBind("NinePatchRect","get_patch_margin") return _icall_Long_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("NinePatchRect","set_patch_margin") _icall_Unit_Long_Long(mb, this.ptr, 0, value) } open var patchMarginRight: Long get() { val mb = getMethodBind("NinePatchRect","get_patch_margin") return _icall_Long_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("NinePatchRect","set_patch_margin") _icall_Unit_Long_Long(mb, this.ptr, 2, value) } open var patchMarginTop: Long get() { val mb = getMethodBind("NinePatchRect","get_patch_margin") return _icall_Long_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("NinePatchRect","set_patch_margin") _icall_Unit_Long_Long(mb, this.ptr, 1, value) } open var regionRect: Rect2 get() { val mb = getMethodBind("NinePatchRect","get_region_rect") return _icall_Rect2(mb, this.ptr) } set(value) { val mb = getMethodBind("NinePatchRect","set_region_rect") _icall_Unit_Rect2(mb, this.ptr, value) } open var texture: Texture get() { val mb = getMethodBind("NinePatchRect","get_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("NinePatchRect","set_texture") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("NinePatchRect", "NinePatchRect") open fun regionRect(schedule: Rect2.() -> Unit): Rect2 = regionRect.apply{ schedule(this) regionRect = this } open fun getHAxisStretchMode(): NinePatchRect.AxisStretchMode { val mb = getMethodBind("NinePatchRect","get_h_axis_stretch_mode") return NinePatchRect.AxisStretchMode.from( _icall_Long( mb, this.ptr)) } open fun getPatchMargin(margin: Long): Long { val mb = getMethodBind("NinePatchRect","get_patch_margin") return _icall_Long_Long( mb, this.ptr, margin) } open fun getRegionRect(): Rect2 { val mb = getMethodBind("NinePatchRect","get_region_rect") return _icall_Rect2( mb, this.ptr) } open fun getTexture(): Texture { val mb = getMethodBind("NinePatchRect","get_texture") return _icall_Texture( mb, this.ptr) } open fun getVAxisStretchMode(): NinePatchRect.AxisStretchMode { val mb = getMethodBind("NinePatchRect","get_v_axis_stretch_mode") return NinePatchRect.AxisStretchMode.from( _icall_Long( mb, this.ptr)) } open fun isDrawCenterEnabled(): Boolean { val mb = getMethodBind("NinePatchRect","is_draw_center_enabled") return _icall_Boolean( mb, this.ptr) } open fun setDrawCenter(drawCenter: Boolean) { val mb = getMethodBind("NinePatchRect","set_draw_center") _icall_Unit_Boolean( mb, this.ptr, drawCenter) } open fun setHAxisStretchMode(mode: Long) { val mb = getMethodBind("NinePatchRect","set_h_axis_stretch_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setPatchMargin(margin: Long, value: Long) { val mb = getMethodBind("NinePatchRect","set_patch_margin") _icall_Unit_Long_Long( mb, this.ptr, margin, value) } open fun setRegionRect(rect: Rect2) { val mb = getMethodBind("NinePatchRect","set_region_rect") _icall_Unit_Rect2( mb, this.ptr, rect) } open fun setTexture(texture: Texture) { val mb = getMethodBind("NinePatchRect","set_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setVAxisStretchMode(mode: Long) { val mb = getMethodBind("NinePatchRect","set_v_axis_stretch_mode") _icall_Unit_Long( mb, this.ptr, mode) } enum class AxisStretchMode( id: Long ) { AXIS_STRETCH_MODE_STRETCH(0), AXIS_STRETCH_MODE_TILE(1), AXIS_STRETCH_MODE_TILE_FIT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Node.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Node import godot.core.NodePath import godot.core.Signal0 import godot.core.Variant import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_NodePath import godot.icalls._icall_Boolean_Object import godot.icalls._icall_Boolean_String import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_MultiplayerAPI import godot.icalls._icall_Node import godot.icalls._icall_NodePath import godot.icalls._icall_NodePath_Object import godot.icalls._icall_Node_Long import godot.icalls._icall_Node_NodePath import godot.icalls._icall_Node_String import godot.icalls._icall_Node_String_Boolean_Boolean import godot.icalls._icall_SceneTree import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_String_Variant import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_Boolean import godot.icalls._icall_Unit_Object_Long import godot.icalls._icall_Unit_Object_Object_Boolean import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Boolean import godot.icalls._icall_Unit_String_Long import godot.icalls._icall_Unit_String_Variant import godot.icalls._icall_Unit_String_VariantArray_Boolean import godot.icalls._icall_VariantArray import godot.icalls._icall_VariantArray_NodePath import godot.icalls._icall_Viewport import godot.icalls._icall_varargs import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Any import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class Node : Object() { val ready: Signal0 by signal() val renamed: Signal0 by signal() val treeEntered: Signal0 by signal() val treeExited: Signal0 by signal() val treeExiting: Signal0 by signal() open var customMultiplayer: MultiplayerAPI get() { val mb = getMethodBind("Node","get_custom_multiplayer") return _icall_MultiplayerAPI(mb, this.ptr) } set(value) { val mb = getMethodBind("Node","set_custom_multiplayer") _icall_Unit_Object(mb, this.ptr, value) } open var filename: String get() { val mb = getMethodBind("Node","get_filename") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Node","set_filename") _icall_Unit_String(mb, this.ptr, value) } open val multiplayer: MultiplayerAPI get() { val mb = getMethodBind("Node","get_multiplayer") return _icall_MultiplayerAPI(mb, this.ptr) } open var name: String get() { val mb = getMethodBind("Node","get_name") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Node","set_name") _icall_Unit_String(mb, this.ptr, value) } open var owner: Node get() { val mb = getMethodBind("Node","get_owner") return _icall_Node(mb, this.ptr) } set(value) { val mb = getMethodBind("Node","set_owner") _icall_Unit_Object(mb, this.ptr, value) } open var pauseMode: Long get() { val mb = getMethodBind("Node","get_pause_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Node","set_pause_mode") _icall_Unit_Long(mb, this.ptr, value) } open var processPriority: Long get() { val mb = getMethodBind("Node","get_process_priority") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Node","set_process_priority") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Node", "Node") open fun _enterTree() { } open fun _exitTree() { } open fun _getConfigurationWarning(): String { throw NotImplementedError("_get_configuration_warning is not implemented for Node") } open fun _getEditorDescription(): String { throw NotImplementedError("_get_editor_description is not implemented for Node") } open fun _getImportPath(): NodePath { throw NotImplementedError("_get_import_path is not implemented for Node") } open fun _input(event: InputEvent) { } open fun _physicsProcess(delta: Double) { } open fun _process(delta: Double) { } open fun _ready() { } open fun _setEditorDescription(editorDescription: String) { } open fun _setImportPath(importPath: NodePath) { } open fun _unhandledInput(event: InputEvent) { } open fun _unhandledKeyInput(event: InputEventKey) { } open fun addChild(node: Node, legibleUniqueName: Boolean = false) { val mb = getMethodBind("Node","add_child") _icall_Unit_Object_Boolean( mb, this.ptr, node, legibleUniqueName) } open fun addChildBelowNode( node: Node, childNode: Node, legibleUniqueName: Boolean = false ) { val mb = getMethodBind("Node","add_child_below_node") _icall_Unit_Object_Object_Boolean( mb, this.ptr, node, childNode, legibleUniqueName) } open fun addToGroup(group: String, persistent: Boolean = false) { val mb = getMethodBind("Node","add_to_group") _icall_Unit_String_Boolean( mb, this.ptr, group, persistent) } open fun canProcess(): Boolean { val mb = getMethodBind("Node","can_process") return _icall_Boolean( mb, this.ptr) } open fun duplicate(flags: Long = 15): Node { val mb = getMethodBind("Node","duplicate") return _icall_Node_Long( mb, this.ptr, flags) } open fun findNode( mask: String, recursive: Boolean = true, owned: Boolean = true ): Node { val mb = getMethodBind("Node","find_node") return _icall_Node_String_Boolean_Boolean( mb, this.ptr, mask, recursive, owned) } open fun findParent(mask: String): Node { val mb = getMethodBind("Node","find_parent") return _icall_Node_String( mb, this.ptr, mask) } open fun getChild(idx: Long): Node { val mb = getMethodBind("Node","get_child") return _icall_Node_Long( mb, this.ptr, idx) } open fun getChildCount(): Long { val mb = getMethodBind("Node","get_child_count") return _icall_Long( mb, this.ptr) } open fun getChildren(): VariantArray { val mb = getMethodBind("Node","get_children") return _icall_VariantArray( mb, this.ptr) } open fun getCustomMultiplayer(): MultiplayerAPI { val mb = getMethodBind("Node","get_custom_multiplayer") return _icall_MultiplayerAPI( mb, this.ptr) } open fun getFilename(): String { val mb = getMethodBind("Node","get_filename") return _icall_String( mb, this.ptr) } open fun getGroups(): VariantArray { val mb = getMethodBind("Node","get_groups") return _icall_VariantArray( mb, this.ptr) } open fun getIndex(): Long { val mb = getMethodBind("Node","get_index") return _icall_Long( mb, this.ptr) } open fun getMultiplayer(): MultiplayerAPI { val mb = getMethodBind("Node","get_multiplayer") return _icall_MultiplayerAPI( mb, this.ptr) } open fun getName(): String { val mb = getMethodBind("Node","get_name") return _icall_String( mb, this.ptr) } open fun getNetworkMaster(): Long { val mb = getMethodBind("Node","get_network_master") return _icall_Long( mb, this.ptr) } open fun getNode(path: NodePath): Node { val mb = getMethodBind("Node","get_node") return _icall_Node_NodePath( mb, this.ptr, path) } open fun getNodeAndResource(path: NodePath): VariantArray { val mb = getMethodBind("Node","get_node_and_resource") return _icall_VariantArray_NodePath( mb, this.ptr, path) } open fun getNodeOrNull(path: NodePath): Node { val mb = getMethodBind("Node","get_node_or_null") return _icall_Node_NodePath( mb, this.ptr, path) } open fun getOwner(): Node { val mb = getMethodBind("Node","get_owner") return _icall_Node( mb, this.ptr) } open fun getParent(): Node { val mb = getMethodBind("Node","get_parent") return _icall_Node( mb, this.ptr) } open fun getPath(): NodePath { val mb = getMethodBind("Node","get_path") return _icall_NodePath( mb, this.ptr) } open fun getPathTo(node: Node): NodePath { val mb = getMethodBind("Node","get_path_to") return _icall_NodePath_Object( mb, this.ptr, node) } open fun getPauseMode(): Node.PauseMode { val mb = getMethodBind("Node","get_pause_mode") return Node.PauseMode.from( _icall_Long( mb, this.ptr)) } open fun getPhysicsProcessDeltaTime(): Double { val mb = getMethodBind("Node","get_physics_process_delta_time") return _icall_Double( mb, this.ptr) } open fun getPositionInParent(): Long { val mb = getMethodBind("Node","get_position_in_parent") return _icall_Long( mb, this.ptr) } open fun getProcessDeltaTime(): Double { val mb = getMethodBind("Node","get_process_delta_time") return _icall_Double( mb, this.ptr) } open fun getProcessPriority(): Long { val mb = getMethodBind("Node","get_process_priority") return _icall_Long( mb, this.ptr) } open fun getSceneInstanceLoadPlaceholder(): Boolean { val mb = getMethodBind("Node","get_scene_instance_load_placeholder") return _icall_Boolean( mb, this.ptr) } open fun getTree(): SceneTree { val mb = getMethodBind("Node","get_tree") return _icall_SceneTree( mb, this.ptr) } open fun getViewport(): Viewport { val mb = getMethodBind("Node","get_viewport") return _icall_Viewport( mb, this.ptr) } open fun hasNode(path: NodePath): Boolean { val mb = getMethodBind("Node","has_node") return _icall_Boolean_NodePath( mb, this.ptr, path) } open fun hasNodeAndResource(path: NodePath): Boolean { val mb = getMethodBind("Node","has_node_and_resource") return _icall_Boolean_NodePath( mb, this.ptr, path) } open fun isAParentOf(node: Node): Boolean { val mb = getMethodBind("Node","is_a_parent_of") return _icall_Boolean_Object( mb, this.ptr, node) } open fun isDisplayedFolded(): Boolean { val mb = getMethodBind("Node","is_displayed_folded") return _icall_Boolean( mb, this.ptr) } open fun isGreaterThan(node: Node): Boolean { val mb = getMethodBind("Node","is_greater_than") return _icall_Boolean_Object( mb, this.ptr, node) } open fun isInGroup(group: String): Boolean { val mb = getMethodBind("Node","is_in_group") return _icall_Boolean_String( mb, this.ptr, group) } open fun isInsideTree(): Boolean { val mb = getMethodBind("Node","is_inside_tree") return _icall_Boolean( mb, this.ptr) } open fun isNetworkMaster(): Boolean { val mb = getMethodBind("Node","is_network_master") return _icall_Boolean( mb, this.ptr) } open fun isPhysicsProcessing(): Boolean { val mb = getMethodBind("Node","is_physics_processing") return _icall_Boolean( mb, this.ptr) } open fun isPhysicsProcessingInternal(): Boolean { val mb = getMethodBind("Node","is_physics_processing_internal") return _icall_Boolean( mb, this.ptr) } open fun isProcessing(): Boolean { val mb = getMethodBind("Node","is_processing") return _icall_Boolean( mb, this.ptr) } open fun isProcessingInput(): Boolean { val mb = getMethodBind("Node","is_processing_input") return _icall_Boolean( mb, this.ptr) } open fun isProcessingInternal(): Boolean { val mb = getMethodBind("Node","is_processing_internal") return _icall_Boolean( mb, this.ptr) } open fun isProcessingUnhandledInput(): Boolean { val mb = getMethodBind("Node","is_processing_unhandled_input") return _icall_Boolean( mb, this.ptr) } open fun isProcessingUnhandledKeyInput(): Boolean { val mb = getMethodBind("Node","is_processing_unhandled_key_input") return _icall_Boolean( mb, this.ptr) } open fun moveChild(childNode: Node, toPosition: Long) { val mb = getMethodBind("Node","move_child") _icall_Unit_Object_Long( mb, this.ptr, childNode, toPosition) } open fun printStrayNodes() { val mb = getMethodBind("Node","print_stray_nodes") _icall_Unit( mb, this.ptr) } open fun printTree() { val mb = getMethodBind("Node","print_tree") _icall_Unit( mb, this.ptr) } open fun printTreePretty() { val mb = getMethodBind("Node","print_tree_pretty") _icall_Unit( mb, this.ptr) } open fun propagateCall( method: String, args: VariantArray = VariantArray(), parentFirst: Boolean = false ) { val mb = getMethodBind("Node","propagate_call") _icall_Unit_String_VariantArray_Boolean( mb, this.ptr, method, args, parentFirst) } open fun propagateNotification(what: Long) { val mb = getMethodBind("Node","propagate_notification") _icall_Unit_Long( mb, this.ptr, what) } open fun queueFree() { val mb = getMethodBind("Node","queue_free") _icall_Unit( mb, this.ptr) } open fun raise() { val mb = getMethodBind("Node","raise") _icall_Unit( mb, this.ptr) } open fun removeAndSkip() { val mb = getMethodBind("Node","remove_and_skip") _icall_Unit( mb, this.ptr) } open fun removeChild(node: Node) { val mb = getMethodBind("Node","remove_child") _icall_Unit_Object( mb, this.ptr, node) } open fun removeFromGroup(group: String) { val mb = getMethodBind("Node","remove_from_group") _icall_Unit_String( mb, this.ptr, group) } open fun replaceBy(node: Node, keepData: Boolean = false) { val mb = getMethodBind("Node","replace_by") _icall_Unit_Object_Boolean( mb, this.ptr, node, keepData) } open fun requestReady() { val mb = getMethodBind("Node","request_ready") _icall_Unit( mb, this.ptr) } open fun rpc(method: String, vararg __var_args: Any?): Variant { val mb = getMethodBind("Node","rpc") return _icall_varargs( mb, this.ptr, arrayOf(method, *__var_args)) } open fun rpcConfig(method: String, mode: Long) { val mb = getMethodBind("Node","rpc_config") _icall_Unit_String_Long( mb, this.ptr, method, mode) } open fun rpcId( peerId: Long, method: String, vararg __var_args: Any? ): Variant { val mb = getMethodBind("Node","rpc_id") return _icall_varargs( mb, this.ptr, arrayOf(peerId, method, *__var_args)) } open fun rpcUnreliable(method: String, vararg __var_args: Any?): Variant { val mb = getMethodBind("Node","rpc_unreliable") return _icall_varargs( mb, this.ptr, arrayOf(method, *__var_args)) } open fun rpcUnreliableId( peerId: Long, method: String, vararg __var_args: Any? ): Variant { val mb = getMethodBind("Node","rpc_unreliable_id") return _icall_varargs( mb, this.ptr, arrayOf(peerId, method, *__var_args)) } open fun rset(property: String, value: Variant) { val mb = getMethodBind("Node","rset") _icall_Unit_String_Variant( mb, this.ptr, property, value) } open fun rsetConfig(property: String, mode: Long) { val mb = getMethodBind("Node","rset_config") _icall_Unit_String_Long( mb, this.ptr, property, mode) } open fun rsetId( peerId: Long, property: String, value: Variant ) { val mb = getMethodBind("Node","rset_id") _icall_Unit_Long_String_Variant( mb, this.ptr, peerId, property, value) } open fun rsetUnreliable(property: String, value: Variant) { val mb = getMethodBind("Node","rset_unreliable") _icall_Unit_String_Variant( mb, this.ptr, property, value) } open fun rsetUnreliableId( peerId: Long, property: String, value: Variant ) { val mb = getMethodBind("Node","rset_unreliable_id") _icall_Unit_Long_String_Variant( mb, this.ptr, peerId, property, value) } open fun setCustomMultiplayer(api: MultiplayerAPI) { val mb = getMethodBind("Node","set_custom_multiplayer") _icall_Unit_Object( mb, this.ptr, api) } open fun setDisplayFolded(fold: Boolean) { val mb = getMethodBind("Node","set_display_folded") _icall_Unit_Boolean( mb, this.ptr, fold) } open fun setFilename(filename: String) { val mb = getMethodBind("Node","set_filename") _icall_Unit_String( mb, this.ptr, filename) } open fun setName(name: String) { val mb = getMethodBind("Node","set_name") _icall_Unit_String( mb, this.ptr, name) } open fun setNetworkMaster(id: Long, recursive: Boolean = true) { val mb = getMethodBind("Node","set_network_master") _icall_Unit_Long_Boolean( mb, this.ptr, id, recursive) } open fun setOwner(owner: Node) { val mb = getMethodBind("Node","set_owner") _icall_Unit_Object( mb, this.ptr, owner) } open fun setPauseMode(mode: Long) { val mb = getMethodBind("Node","set_pause_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setPhysicsProcess(enable: Boolean) { val mb = getMethodBind("Node","set_physics_process") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setPhysicsProcessInternal(enable: Boolean) { val mb = getMethodBind("Node","set_physics_process_internal") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setProcess(enable: Boolean) { val mb = getMethodBind("Node","set_process") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setProcessInput(enable: Boolean) { val mb = getMethodBind("Node","set_process_input") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setProcessInternal(enable: Boolean) { val mb = getMethodBind("Node","set_process_internal") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setProcessPriority(priority: Long) { val mb = getMethodBind("Node","set_process_priority") _icall_Unit_Long( mb, this.ptr, priority) } open fun setProcessUnhandledInput(enable: Boolean) { val mb = getMethodBind("Node","set_process_unhandled_input") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setProcessUnhandledKeyInput(enable: Boolean) { val mb = getMethodBind("Node","set_process_unhandled_key_input") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setSceneInstanceLoadPlaceholder(loadPlaceholder: Boolean) { val mb = getMethodBind("Node","set_scene_instance_load_placeholder") _icall_Unit_Boolean( mb, this.ptr, loadPlaceholder) } open fun updateConfigurationWarning() { val mb = getMethodBind("Node","update_configuration_warning") _icall_Unit( mb, this.ptr) } enum class PauseMode( id: Long ) { PAUSE_MODE_INHERIT(0), PAUSE_MODE_STOP(1), PAUSE_MODE_PROCESS(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class DuplicateFlags( id: Long ) { DUPLICATE_SIGNALS(1), DUPLICATE_GROUPS(2), DUPLICATE_SCRIPTS(4), DUPLICATE_USE_INSTANCING(8); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object { final const val NOTIFICATION_APP_PAUSED: Long = 1015 final const val NOTIFICATION_APP_RESUMED: Long = 1014 final const val NOTIFICATION_CRASH: Long = 1012 final const val NOTIFICATION_DRAG_BEGIN: Long = 21 final const val NOTIFICATION_DRAG_END: Long = 22 final const val NOTIFICATION_ENTER_TREE: Long = 10 final const val NOTIFICATION_EXIT_TREE: Long = 11 final const val NOTIFICATION_INSTANCED: Long = 20 final const val NOTIFICATION_INTERNAL_PHYSICS_PROCESS: Long = 26 final const val NOTIFICATION_INTERNAL_PROCESS: Long = 25 final const val NOTIFICATION_MOVED_IN_PARENT: Long = 12 final const val NOTIFICATION_OS_IME_UPDATE: Long = 1013 final const val NOTIFICATION_OS_MEMORY_WARNING: Long = 1009 final const val NOTIFICATION_PARENTED: Long = 18 final const val NOTIFICATION_PATH_CHANGED: Long = 23 final const val NOTIFICATION_PAUSED: Long = 14 final const val NOTIFICATION_PHYSICS_PROCESS: Long = 16 final const val NOTIFICATION_PROCESS: Long = 17 final const val NOTIFICATION_READY: Long = 13 final const val NOTIFICATION_TRANSLATION_CHANGED: Long = 1010 final const val NOTIFICATION_UNPARENTED: Long = 19 final const val NOTIFICATION_UNPAUSED: Long = 15 final const val NOTIFICATION_WM_ABOUT: Long = 1011 final const val NOTIFICATION_WM_FOCUS_IN: Long = 1004 final const val NOTIFICATION_WM_FOCUS_OUT: Long = 1005 final const val NOTIFICATION_WM_GO_BACK_REQUEST: Long = 1007 final const val NOTIFICATION_WM_MOUSE_ENTER: Long = 1002 final const val NOTIFICATION_WM_MOUSE_EXIT: Long = 1003 final const val NOTIFICATION_WM_QUIT_REQUEST: Long = 1006 final const val NOTIFICATION_WM_UNFOCUS_REQUEST: Long = 1008 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Node2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Transform2D import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Double_Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Transform2D_Object import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Double_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Transform2D import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.UninitializedPropertyAccessException import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Node2D : CanvasItem() { open var globalPosition: Vector2 get() { val mb = getMethodBind("Node2D","get_global_position") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_global_position") _icall_Unit_Vector2(mb, this.ptr, value) } open var globalRotation: Double get() { val mb = getMethodBind("Node2D","get_global_rotation") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_global_rotation") _icall_Unit_Double(mb, this.ptr, value) } open var globalRotationDegrees: Double get() { val mb = getMethodBind("Node2D","get_global_rotation_degrees") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_global_rotation_degrees") _icall_Unit_Double(mb, this.ptr, value) } open var globalScale: Vector2 get() { val mb = getMethodBind("Node2D","get_global_scale") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_global_scale") _icall_Unit_Vector2(mb, this.ptr, value) } open var globalTransform: Transform2D get() { throw UninitializedPropertyAccessException("Cannot access property globalTransform: has no getter") } set(value) { val mb = getMethodBind("Node2D","set_global_transform") _icall_Unit_Transform2D(mb, this.ptr, value) } open var position: Vector2 get() { val mb = getMethodBind("Node2D","get_position") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_position") _icall_Unit_Vector2(mb, this.ptr, value) } open var rotation: Double get() { val mb = getMethodBind("Node2D","get_rotation") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_rotation") _icall_Unit_Double(mb, this.ptr, value) } open var rotationDegrees: Double get() { val mb = getMethodBind("Node2D","get_rotation_degrees") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_rotation_degrees") _icall_Unit_Double(mb, this.ptr, value) } open var scale: Vector2 get() { val mb = getMethodBind("Node2D","get_scale") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_scale") _icall_Unit_Vector2(mb, this.ptr, value) } open var skew: Double get() { val mb = getMethodBind("Node2D","get_skew") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_skew") _icall_Unit_Double(mb, this.ptr, value) } open var skewDegrees: Double get() { val mb = getMethodBind("Node2D","get_skew_degrees") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_skew_degrees") _icall_Unit_Double(mb, this.ptr, value) } open var transform: Transform2D get() { throw UninitializedPropertyAccessException("Cannot access property transform: has no getter") } set(value) { val mb = getMethodBind("Node2D","set_transform") _icall_Unit_Transform2D(mb, this.ptr, value) } open var zAsRelative: Boolean get() { val mb = getMethodBind("Node2D","is_z_relative") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_z_as_relative") _icall_Unit_Boolean(mb, this.ptr, value) } open var zIndex: Long get() { val mb = getMethodBind("Node2D","get_z_index") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Node2D","set_z_index") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Node2D", "Node2D") open fun globalPosition(schedule: Vector2.() -> Unit): Vector2 = globalPosition.apply{ schedule(this) globalPosition = this } open fun globalScale(schedule: Vector2.() -> Unit): Vector2 = globalScale.apply{ schedule(this) globalScale = this } open fun globalTransform(schedule: Transform2D.() -> Unit): Transform2D = globalTransform.apply{ schedule(this) globalTransform = this } open fun position(schedule: Vector2.() -> Unit): Vector2 = position.apply{ schedule(this) position = this } open fun scale(schedule: Vector2.() -> Unit): Vector2 = scale.apply{ schedule(this) scale = this } open fun transform(schedule: Transform2D.() -> Unit): Transform2D = transform.apply{ schedule(this) transform = this } open fun applyScale(ratio: Vector2) { val mb = getMethodBind("Node2D","apply_scale") _icall_Unit_Vector2( mb, this.ptr, ratio) } open fun getAngleTo(point: Vector2): Double { val mb = getMethodBind("Node2D","get_angle_to") return _icall_Double_Vector2( mb, this.ptr, point) } open fun getGlobalPosition(): Vector2 { val mb = getMethodBind("Node2D","get_global_position") return _icall_Vector2( mb, this.ptr) } open fun getGlobalRotation(): Double { val mb = getMethodBind("Node2D","get_global_rotation") return _icall_Double( mb, this.ptr) } open fun getGlobalRotationDegrees(): Double { val mb = getMethodBind("Node2D","get_global_rotation_degrees") return _icall_Double( mb, this.ptr) } open fun getGlobalScale(): Vector2 { val mb = getMethodBind("Node2D","get_global_scale") return _icall_Vector2( mb, this.ptr) } open fun getPosition(): Vector2 { val mb = getMethodBind("Node2D","get_position") return _icall_Vector2( mb, this.ptr) } open fun getRelativeTransformToParent(parent: Node): Transform2D { val mb = getMethodBind("Node2D","get_relative_transform_to_parent") return _icall_Transform2D_Object( mb, this.ptr, parent) } open fun getRotation(): Double { val mb = getMethodBind("Node2D","get_rotation") return _icall_Double( mb, this.ptr) } open fun getRotationDegrees(): Double { val mb = getMethodBind("Node2D","get_rotation_degrees") return _icall_Double( mb, this.ptr) } open fun getScale(): Vector2 { val mb = getMethodBind("Node2D","get_scale") return _icall_Vector2( mb, this.ptr) } open fun getSkew(): Double { val mb = getMethodBind("Node2D","get_skew") return _icall_Double( mb, this.ptr) } open fun getSkewDegrees(): Double { val mb = getMethodBind("Node2D","get_skew_degrees") return _icall_Double( mb, this.ptr) } open fun getZIndex(): Long { val mb = getMethodBind("Node2D","get_z_index") return _icall_Long( mb, this.ptr) } open fun globalTranslate(offset: Vector2) { val mb = getMethodBind("Node2D","global_translate") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun isZRelative(): Boolean { val mb = getMethodBind("Node2D","is_z_relative") return _icall_Boolean( mb, this.ptr) } open fun lookAt(point: Vector2) { val mb = getMethodBind("Node2D","look_at") _icall_Unit_Vector2( mb, this.ptr, point) } open fun moveLocalX(delta: Double, scaled: Boolean = false) { val mb = getMethodBind("Node2D","move_local_x") _icall_Unit_Double_Boolean( mb, this.ptr, delta, scaled) } open fun moveLocalY(delta: Double, scaled: Boolean = false) { val mb = getMethodBind("Node2D","move_local_y") _icall_Unit_Double_Boolean( mb, this.ptr, delta, scaled) } open fun rotate(radians: Double) { val mb = getMethodBind("Node2D","rotate") _icall_Unit_Double( mb, this.ptr, radians) } open fun setGlobalPosition(position: Vector2) { val mb = getMethodBind("Node2D","set_global_position") _icall_Unit_Vector2( mb, this.ptr, position) } open fun setGlobalRotation(radians: Double) { val mb = getMethodBind("Node2D","set_global_rotation") _icall_Unit_Double( mb, this.ptr, radians) } open fun setGlobalRotationDegrees(degrees: Double) { val mb = getMethodBind("Node2D","set_global_rotation_degrees") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setGlobalScale(scale: Vector2) { val mb = getMethodBind("Node2D","set_global_scale") _icall_Unit_Vector2( mb, this.ptr, scale) } open fun setGlobalTransform(xform: Transform2D) { val mb = getMethodBind("Node2D","set_global_transform") _icall_Unit_Transform2D( mb, this.ptr, xform) } open fun setPosition(position: Vector2) { val mb = getMethodBind("Node2D","set_position") _icall_Unit_Vector2( mb, this.ptr, position) } open fun setRotation(radians: Double) { val mb = getMethodBind("Node2D","set_rotation") _icall_Unit_Double( mb, this.ptr, radians) } open fun setRotationDegrees(degrees: Double) { val mb = getMethodBind("Node2D","set_rotation_degrees") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setScale(scale: Vector2) { val mb = getMethodBind("Node2D","set_scale") _icall_Unit_Vector2( mb, this.ptr, scale) } open fun setSkew(radians: Double) { val mb = getMethodBind("Node2D","set_skew") _icall_Unit_Double( mb, this.ptr, radians) } open fun setSkewDegrees(degrees: Double) { val mb = getMethodBind("Node2D","set_skew_degrees") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setTransform(xform: Transform2D) { val mb = getMethodBind("Node2D","set_transform") _icall_Unit_Transform2D( mb, this.ptr, xform) } open fun setZAsRelative(enable: Boolean) { val mb = getMethodBind("Node2D","set_z_as_relative") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setZIndex(zIndex: Long) { val mb = getMethodBind("Node2D","set_z_index") _icall_Unit_Long( mb, this.ptr, zIndex) } open fun toGlobal(localPoint: Vector2): Vector2 { val mb = getMethodBind("Node2D","to_global") return _icall_Vector2_Vector2( mb, this.ptr, localPoint) } open fun toLocal(globalPoint: Vector2): Vector2 { val mb = getMethodBind("Node2D","to_local") return _icall_Vector2_Vector2( mb, this.ptr, globalPoint) } open fun translate(offset: Vector2) { val mb = getMethodBind("Node2D","translate") _icall_Unit_Vector2( mb, this.ptr, offset) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/NoiseTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_OpenSimplexNoise import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.UninitializedPropertyAccessException import kotlinx.cinterop.COpaquePointer open class NoiseTexture : Texture() { open var asNormalmap: Boolean get() { val mb = getMethodBind("NoiseTexture","is_normalmap") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NoiseTexture","set_as_normalmap") _icall_Unit_Boolean(mb, this.ptr, value) } open var bumpStrength: Double get() { val mb = getMethodBind("NoiseTexture","get_bump_strength") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("NoiseTexture","set_bump_strength") _icall_Unit_Double(mb, this.ptr, value) } open var height: Long get() { throw UninitializedPropertyAccessException("Cannot access property height: has no getter") } set(value) { val mb = getMethodBind("NoiseTexture","set_height") _icall_Unit_Long(mb, this.ptr, value) } open var noise: OpenSimplexNoise get() { val mb = getMethodBind("NoiseTexture","get_noise") return _icall_OpenSimplexNoise(mb, this.ptr) } set(value) { val mb = getMethodBind("NoiseTexture","set_noise") _icall_Unit_Object(mb, this.ptr, value) } open var seamless: Boolean get() { val mb = getMethodBind("NoiseTexture","get_seamless") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("NoiseTexture","set_seamless") _icall_Unit_Boolean(mb, this.ptr, value) } open var width: Long get() { throw UninitializedPropertyAccessException("Cannot access property width: has no getter") } set(value) { val mb = getMethodBind("NoiseTexture","set_width") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("NoiseTexture", "NoiseTexture") open fun _generateTexture(): Image { throw NotImplementedError("_generate_texture is not implemented for NoiseTexture") } open fun _queueUpdate() { } open fun _threadDone(image: Image) { } open fun _updateTexture() { } open fun getBumpStrength(): Double { val mb = getMethodBind("NoiseTexture","get_bump_strength") return _icall_Double( mb, this.ptr) } open fun getNoise(): OpenSimplexNoise { val mb = getMethodBind("NoiseTexture","get_noise") return _icall_OpenSimplexNoise( mb, this.ptr) } open fun getSeamless(): Boolean { val mb = getMethodBind("NoiseTexture","get_seamless") return _icall_Boolean( mb, this.ptr) } open fun isNormalmap(): Boolean { val mb = getMethodBind("NoiseTexture","is_normalmap") return _icall_Boolean( mb, this.ptr) } open fun setAsNormalmap(asNormalmap: Boolean) { val mb = getMethodBind("NoiseTexture","set_as_normalmap") _icall_Unit_Boolean( mb, this.ptr, asNormalmap) } open fun setBumpStrength(bumpStrength: Double) { val mb = getMethodBind("NoiseTexture","set_bump_strength") _icall_Unit_Double( mb, this.ptr, bumpStrength) } open fun setHeight(height: Long) { val mb = getMethodBind("NoiseTexture","set_height") _icall_Unit_Long( mb, this.ptr, height) } open fun setNoise(noise: OpenSimplexNoise) { val mb = getMethodBind("NoiseTexture","set_noise") _icall_Unit_Object( mb, this.ptr, noise) } open fun setSeamless(seamless: Boolean) { val mb = getMethodBind("NoiseTexture","set_seamless") _icall_Unit_Boolean( mb, this.ptr, seamless) } open fun setWidth(width: Long) { val mb = getMethodBind("NoiseTexture","set_width") _icall_Unit_Long( mb, this.ptr, width) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/OS.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.OS import godot.core.Dictionary import godot.core.Godot import godot.core.GodotError import godot.core.PoolStringArray import godot.core.Rect2 import godot.core.Variant import godot.core.VariantArray import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Boolean_String import godot.icalls._icall_Dictionary import godot.icalls._icall_Dictionary_Boolean import godot.icalls._icall_Dictionary_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Dictionary import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_String import godot.icalls._icall_Long_String_Double_String_String import godot.icalls._icall_Long_String_PoolStringArray_Boolean_VariantArray_Boolean import godot.icalls._icall_PoolStringArray import godot.icalls._icall_Rect2 import godot.icalls._icall_String import godot.icalls._icall_String_Long import godot.icalls._icall_String_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_PoolStringArray import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Long import godot.icalls._icall_Unit_String_String import godot.icalls._icall_Unit_String_String_Variant_Variant import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_Long import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.Unit import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object OS : Object() { var clipboard: String get() { val mb = getMethodBind("_OS","get_clipboard") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_clipboard") _icall_Unit_String(mb, this.ptr, value) } var currentScreen: Long get() { val mb = getMethodBind("_OS","get_current_screen") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_current_screen") _icall_Unit_Long(mb, this.ptr, value) } var exitCode: Long get() { val mb = getMethodBind("_OS","get_exit_code") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_exit_code") _icall_Unit_Long(mb, this.ptr, value) } var keepScreenOn: Boolean get() { val mb = getMethodBind("_OS","is_keep_screen_on") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_keep_screen_on") _icall_Unit_Boolean(mb, this.ptr, value) } var lowProcessorUsageMode: Boolean get() { val mb = getMethodBind("_OS","is_in_low_processor_usage_mode") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_low_processor_usage_mode") _icall_Unit_Boolean(mb, this.ptr, value) } var lowProcessorUsageModeSleepUsec: Long get() { val mb = getMethodBind("_OS","get_low_processor_usage_mode_sleep_usec") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_low_processor_usage_mode_sleep_usec") _icall_Unit_Long(mb, this.ptr, value) } var maxWindowSize: Vector2 get() { val mb = getMethodBind("_OS","get_max_window_size") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_max_window_size") _icall_Unit_Vector2(mb, this.ptr, value) } var minWindowSize: Vector2 get() { val mb = getMethodBind("_OS","get_min_window_size") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_min_window_size") _icall_Unit_Vector2(mb, this.ptr, value) } var screenOrientation: Long get() { val mb = getMethodBind("_OS","get_screen_orientation") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_screen_orientation") _icall_Unit_Long(mb, this.ptr, value) } var tabletDriver: String get() { val mb = getMethodBind("_OS","get_current_tablet_driver") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_current_tablet_driver") _icall_Unit_String(mb, this.ptr, value) } var vsyncEnabled: Boolean get() { val mb = getMethodBind("_OS","is_vsync_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_use_vsync") _icall_Unit_Boolean(mb, this.ptr, value) } var vsyncViaCompositor: Boolean get() { val mb = getMethodBind("_OS","is_vsync_via_compositor_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_vsync_via_compositor") _icall_Unit_Boolean(mb, this.ptr, value) } var windowBorderless: Boolean get() { val mb = getMethodBind("_OS","get_borderless_window") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_borderless_window") _icall_Unit_Boolean(mb, this.ptr, value) } var windowFullscreen: Boolean get() { val mb = getMethodBind("_OS","is_window_fullscreen") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_window_fullscreen") _icall_Unit_Boolean(mb, this.ptr, value) } var windowMaximized: Boolean get() { val mb = getMethodBind("_OS","is_window_maximized") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_window_maximized") _icall_Unit_Boolean(mb, this.ptr, value) } var windowMinimized: Boolean get() { val mb = getMethodBind("_OS","is_window_minimized") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_window_minimized") _icall_Unit_Boolean(mb, this.ptr, value) } var windowPerPixelTransparencyEnabled: Boolean get() { val mb = getMethodBind("_OS","get_window_per_pixel_transparency_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_window_per_pixel_transparency_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } var windowPosition: Vector2 get() { val mb = getMethodBind("_OS","get_window_position") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_window_position") _icall_Unit_Vector2(mb, this.ptr, value) } var windowResizable: Boolean get() { val mb = getMethodBind("_OS","is_window_resizable") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_window_resizable") _icall_Unit_Boolean(mb, this.ptr, value) } var windowSize: Vector2 get() { val mb = getMethodBind("_OS","get_window_size") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("_OS","set_window_size") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("OS".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton OS" } ptr } fun maxWindowSize(schedule: Vector2.() -> Unit): Vector2 = maxWindowSize.apply{ schedule(this) maxWindowSize = this } fun minWindowSize(schedule: Vector2.() -> Unit): Vector2 = minWindowSize.apply{ schedule(this) minWindowSize = this } fun windowPosition(schedule: Vector2.() -> Unit): Vector2 = windowPosition.apply{ schedule(this) windowPosition = this } fun windowSize(schedule: Vector2.() -> Unit): Vector2 = windowSize.apply{ schedule(this) windowSize = this } fun alert(text: String, title: String = "Alert!") { val mb = getMethodBind("_OS","alert") _icall_Unit_String_String( mb, this.ptr, text, title) } fun canDraw(): Boolean { val mb = getMethodBind("_OS","can_draw") return _icall_Boolean( mb, this.ptr) } fun canUseThreads(): Boolean { val mb = getMethodBind("_OS","can_use_threads") return _icall_Boolean( mb, this.ptr) } fun centerWindow() { val mb = getMethodBind("_OS","center_window") _icall_Unit( mb, this.ptr) } fun closeMidiInputs() { val mb = getMethodBind("_OS","close_midi_inputs") _icall_Unit( mb, this.ptr) } fun delayMsec(msec: Long) { val mb = getMethodBind("_OS","delay_msec") _icall_Unit_Long( mb, this.ptr, msec) } fun delayUsec(usec: Long) { val mb = getMethodBind("_OS","delay_usec") _icall_Unit_Long( mb, this.ptr, usec) } fun dumpMemoryToFile(file: String) { val mb = getMethodBind("_OS","dump_memory_to_file") _icall_Unit_String( mb, this.ptr, file) } fun dumpResourcesToFile(file: String) { val mb = getMethodBind("_OS","dump_resources_to_file") _icall_Unit_String( mb, this.ptr, file) } fun execute( path: String, arguments: PoolStringArray, blocking: Boolean = true, output: VariantArray = VariantArray(), readStderr: Boolean = false ): Long { val mb = getMethodBind("_OS","execute") return _icall_Long_String_PoolStringArray_Boolean_VariantArray_Boolean( mb, this.ptr, path, arguments, blocking, output, readStderr) } fun findScancodeFromString(string: String): Long { val mb = getMethodBind("_OS","find_scancode_from_string") return _icall_Long_String( mb, this.ptr, string) } fun getAudioDriverCount(): Long { val mb = getMethodBind("_OS","get_audio_driver_count") return _icall_Long( mb, this.ptr) } fun getAudioDriverName(driver: Long): String { val mb = getMethodBind("_OS","get_audio_driver_name") return _icall_String_Long( mb, this.ptr, driver) } fun getBorderlessWindow(): Boolean { val mb = getMethodBind("_OS","get_borderless_window") return _icall_Boolean( mb, this.ptr) } fun getClipboard(): String { val mb = getMethodBind("_OS","get_clipboard") return _icall_String( mb, this.ptr) } fun getCmdlineArgs(): PoolStringArray { val mb = getMethodBind("_OS","get_cmdline_args") return _icall_PoolStringArray( mb, this.ptr) } fun getConnectedMidiInputs(): PoolStringArray { val mb = getMethodBind("_OS","get_connected_midi_inputs") return _icall_PoolStringArray( mb, this.ptr) } fun getCurrentScreen(): Long { val mb = getMethodBind("_OS","get_current_screen") return _icall_Long( mb, this.ptr) } fun getCurrentTabletDriver(): String { val mb = getMethodBind("_OS","get_current_tablet_driver") return _icall_String( mb, this.ptr) } fun getCurrentVideoDriver(): OS.VideoDriver { val mb = getMethodBind("_OS","get_current_video_driver") return OS.VideoDriver.from( _icall_Long( mb, this.ptr)) } fun getDate(utc: Boolean = false): Dictionary { val mb = getMethodBind("_OS","get_date") return _icall_Dictionary_Boolean( mb, this.ptr, utc) } fun getDatetime(utc: Boolean = false): Dictionary { val mb = getMethodBind("_OS","get_datetime") return _icall_Dictionary_Boolean( mb, this.ptr, utc) } fun getDatetimeFromUnixTime(unixTimeVal: Long): Dictionary { val mb = getMethodBind("_OS","get_datetime_from_unix_time") return _icall_Dictionary_Long( mb, this.ptr, unixTimeVal) } fun getDynamicMemoryUsage(): Long { val mb = getMethodBind("_OS","get_dynamic_memory_usage") return _icall_Long( mb, this.ptr) } fun getEnvironment(environment: String): String { val mb = getMethodBind("_OS","get_environment") return _icall_String_String( mb, this.ptr, environment) } fun getExecutablePath(): String { val mb = getMethodBind("_OS","get_executable_path") return _icall_String( mb, this.ptr) } fun getExitCode(): Long { val mb = getMethodBind("_OS","get_exit_code") return _icall_Long( mb, this.ptr) } fun getGrantedPermissions(): PoolStringArray { val mb = getMethodBind("_OS","get_granted_permissions") return _icall_PoolStringArray( mb, this.ptr) } fun getImeSelection(): Vector2 { val mb = getMethodBind("_OS","get_ime_selection") return _icall_Vector2( mb, this.ptr) } fun getImeText(): String { val mb = getMethodBind("_OS","get_ime_text") return _icall_String( mb, this.ptr) } fun getLatinKeyboardVariant(): String { val mb = getMethodBind("_OS","get_latin_keyboard_variant") return _icall_String( mb, this.ptr) } fun getLocale(): String { val mb = getMethodBind("_OS","get_locale") return _icall_String( mb, this.ptr) } fun getLowProcessorUsageModeSleepUsec(): Long { val mb = getMethodBind("_OS","get_low_processor_usage_mode_sleep_usec") return _icall_Long( mb, this.ptr) } fun getMaxWindowSize(): Vector2 { val mb = getMethodBind("_OS","get_max_window_size") return _icall_Vector2( mb, this.ptr) } fun getMinWindowSize(): Vector2 { val mb = getMethodBind("_OS","get_min_window_size") return _icall_Vector2( mb, this.ptr) } fun getModelName(): String { val mb = getMethodBind("_OS","get_model_name") return _icall_String( mb, this.ptr) } fun getName(): String { val mb = getMethodBind("_OS","get_name") return _icall_String( mb, this.ptr) } fun getPowerPercentLeft(): Long { val mb = getMethodBind("_OS","get_power_percent_left") return _icall_Long( mb, this.ptr) } fun getPowerSecondsLeft(): Long { val mb = getMethodBind("_OS","get_power_seconds_left") return _icall_Long( mb, this.ptr) } fun getPowerState(): OS.PowerState { val mb = getMethodBind("_OS","get_power_state") return OS.PowerState.from( _icall_Long( mb, this.ptr)) } fun getProcessId(): Long { val mb = getMethodBind("_OS","get_process_id") return _icall_Long( mb, this.ptr) } fun getProcessorCount(): Long { val mb = getMethodBind("_OS","get_processor_count") return _icall_Long( mb, this.ptr) } fun getRealWindowSize(): Vector2 { val mb = getMethodBind("_OS","get_real_window_size") return _icall_Vector2( mb, this.ptr) } fun getScancodeString(code: Long): String { val mb = getMethodBind("_OS","get_scancode_string") return _icall_String_Long( mb, this.ptr, code) } fun getScreenCount(): Long { val mb = getMethodBind("_OS","get_screen_count") return _icall_Long( mb, this.ptr) } fun getScreenDpi(screen: Long = -1): Long { val mb = getMethodBind("_OS","get_screen_dpi") return _icall_Long_Long( mb, this.ptr, screen) } fun getScreenOrientation(): OS.ScreenOrientation { val mb = getMethodBind("_OS","get_screen_orientation") return OS.ScreenOrientation.from( _icall_Long( mb, this.ptr)) } fun getScreenPosition(screen: Long = -1): Vector2 { val mb = getMethodBind("_OS","get_screen_position") return _icall_Vector2_Long( mb, this.ptr, screen) } fun getScreenSize(screen: Long = -1): Vector2 { val mb = getMethodBind("_OS","get_screen_size") return _icall_Vector2_Long( mb, this.ptr, screen) } fun getSplashTickMsec(): Long { val mb = getMethodBind("_OS","get_splash_tick_msec") return _icall_Long( mb, this.ptr) } fun getStaticMemoryPeakUsage(): Long { val mb = getMethodBind("_OS","get_static_memory_peak_usage") return _icall_Long( mb, this.ptr) } fun getStaticMemoryUsage(): Long { val mb = getMethodBind("_OS","get_static_memory_usage") return _icall_Long( mb, this.ptr) } fun getSystemDir(dir: Long): String { val mb = getMethodBind("_OS","get_system_dir") return _icall_String_Long( mb, this.ptr, dir) } fun getSystemTimeMsecs(): Long { val mb = getMethodBind("_OS","get_system_time_msecs") return _icall_Long( mb, this.ptr) } fun getSystemTimeSecs(): Long { val mb = getMethodBind("_OS","get_system_time_secs") return _icall_Long( mb, this.ptr) } fun getTabletDriverCount(): Long { val mb = getMethodBind("_OS","get_tablet_driver_count") return _icall_Long( mb, this.ptr) } fun getTabletDriverName(idx: Long): String { val mb = getMethodBind("_OS","get_tablet_driver_name") return _icall_String_Long( mb, this.ptr, idx) } fun getTicksMsec(): Long { val mb = getMethodBind("_OS","get_ticks_msec") return _icall_Long( mb, this.ptr) } fun getTicksUsec(): Long { val mb = getMethodBind("_OS","get_ticks_usec") return _icall_Long( mb, this.ptr) } fun getTime(utc: Boolean = false): Dictionary { val mb = getMethodBind("_OS","get_time") return _icall_Dictionary_Boolean( mb, this.ptr, utc) } fun getTimeZoneInfo(): Dictionary { val mb = getMethodBind("_OS","get_time_zone_info") return _icall_Dictionary( mb, this.ptr) } fun getUniqueId(): String { val mb = getMethodBind("_OS","get_unique_id") return _icall_String( mb, this.ptr) } fun getUnixTime(): Long { val mb = getMethodBind("_OS","get_unix_time") return _icall_Long( mb, this.ptr) } fun getUnixTimeFromDatetime(datetime: Dictionary): Long { val mb = getMethodBind("_OS","get_unix_time_from_datetime") return _icall_Long_Dictionary( mb, this.ptr, datetime) } fun getUserDataDir(): String { val mb = getMethodBind("_OS","get_user_data_dir") return _icall_String( mb, this.ptr) } fun getVideoDriverCount(): Long { val mb = getMethodBind("_OS","get_video_driver_count") return _icall_Long( mb, this.ptr) } fun getVideoDriverName(driver: Long): String { val mb = getMethodBind("_OS","get_video_driver_name") return _icall_String_Long( mb, this.ptr, driver) } fun getVirtualKeyboardHeight(): Long { val mb = getMethodBind("_OS","get_virtual_keyboard_height") return _icall_Long( mb, this.ptr) } fun getWindowPerPixelTransparencyEnabled(): Boolean { val mb = getMethodBind("_OS","get_window_per_pixel_transparency_enabled") return _icall_Boolean( mb, this.ptr) } fun getWindowPosition(): Vector2 { val mb = getMethodBind("_OS","get_window_position") return _icall_Vector2( mb, this.ptr) } fun getWindowSafeArea(): Rect2 { val mb = getMethodBind("_OS","get_window_safe_area") return _icall_Rect2( mb, this.ptr) } fun getWindowSize(): Vector2 { val mb = getMethodBind("_OS","get_window_size") return _icall_Vector2( mb, this.ptr) } fun globalMenuAddItem( menu: String, label: String, id: Variant, meta: Variant ) { val mb = getMethodBind("_OS","global_menu_add_item") _icall_Unit_String_String_Variant_Variant( mb, this.ptr, menu, label, id, meta) } fun globalMenuAddSeparator(menu: String) { val mb = getMethodBind("_OS","global_menu_add_separator") _icall_Unit_String( mb, this.ptr, menu) } fun globalMenuClear(menu: String) { val mb = getMethodBind("_OS","global_menu_clear") _icall_Unit_String( mb, this.ptr, menu) } fun globalMenuRemoveItem(menu: String, idx: Long) { val mb = getMethodBind("_OS","global_menu_remove_item") _icall_Unit_String_Long( mb, this.ptr, menu, idx) } fun hasEnvironment(environment: String): Boolean { val mb = getMethodBind("_OS","has_environment") return _icall_Boolean_String( mb, this.ptr, environment) } fun hasFeature(tagName: String): Boolean { val mb = getMethodBind("_OS","has_feature") return _icall_Boolean_String( mb, this.ptr, tagName) } fun hasTouchscreenUiHint(): Boolean { val mb = getMethodBind("_OS","has_touchscreen_ui_hint") return _icall_Boolean( mb, this.ptr) } fun hasVirtualKeyboard(): Boolean { val mb = getMethodBind("_OS","has_virtual_keyboard") return _icall_Boolean( mb, this.ptr) } fun hideVirtualKeyboard() { val mb = getMethodBind("_OS","hide_virtual_keyboard") _icall_Unit( mb, this.ptr) } fun isDebugBuild(): Boolean { val mb = getMethodBind("_OS","is_debug_build") return _icall_Boolean( mb, this.ptr) } fun isInLowProcessorUsageMode(): Boolean { val mb = getMethodBind("_OS","is_in_low_processor_usage_mode") return _icall_Boolean( mb, this.ptr) } fun isKeepScreenOn(): Boolean { val mb = getMethodBind("_OS","is_keep_screen_on") return _icall_Boolean( mb, this.ptr) } fun isOkLeftAndCancelRight(): Boolean { val mb = getMethodBind("_OS","is_ok_left_and_cancel_right") return _icall_Boolean( mb, this.ptr) } fun isScancodeUnicode(code: Long): Boolean { val mb = getMethodBind("_OS","is_scancode_unicode") return _icall_Boolean_Long( mb, this.ptr, code) } fun isStdoutVerbose(): Boolean { val mb = getMethodBind("_OS","is_stdout_verbose") return _icall_Boolean( mb, this.ptr) } fun isUserfsPersistent(): Boolean { val mb = getMethodBind("_OS","is_userfs_persistent") return _icall_Boolean( mb, this.ptr) } fun isVsyncEnabled(): Boolean { val mb = getMethodBind("_OS","is_vsync_enabled") return _icall_Boolean( mb, this.ptr) } fun isVsyncViaCompositorEnabled(): Boolean { val mb = getMethodBind("_OS","is_vsync_via_compositor_enabled") return _icall_Boolean( mb, this.ptr) } fun isWindowAlwaysOnTop(): Boolean { val mb = getMethodBind("_OS","is_window_always_on_top") return _icall_Boolean( mb, this.ptr) } fun isWindowFocused(): Boolean { val mb = getMethodBind("_OS","is_window_focused") return _icall_Boolean( mb, this.ptr) } fun isWindowFullscreen(): Boolean { val mb = getMethodBind("_OS","is_window_fullscreen") return _icall_Boolean( mb, this.ptr) } fun isWindowMaximized(): Boolean { val mb = getMethodBind("_OS","is_window_maximized") return _icall_Boolean( mb, this.ptr) } fun isWindowMinimized(): Boolean { val mb = getMethodBind("_OS","is_window_minimized") return _icall_Boolean( mb, this.ptr) } fun isWindowResizable(): Boolean { val mb = getMethodBind("_OS","is_window_resizable") return _icall_Boolean( mb, this.ptr) } fun kill(pid: Long): GodotError { val mb = getMethodBind("_OS","kill") return GodotError.byValue( _icall_Long_Long( mb, this.ptr, pid).toUInt()) } fun moveWindowToForeground() { val mb = getMethodBind("_OS","move_window_to_foreground") _icall_Unit( mb, this.ptr) } fun nativeVideoIsPlaying(): Boolean { val mb = getMethodBind("_OS","native_video_is_playing") return _icall_Boolean( mb, this.ptr) } fun nativeVideoPause() { val mb = getMethodBind("_OS","native_video_pause") _icall_Unit( mb, this.ptr) } fun nativeVideoPlay( path: String, volume: Double, audioTrack: String, subtitleTrack: String ): GodotError { val mb = getMethodBind("_OS","native_video_play") return GodotError.byValue( _icall_Long_String_Double_String_String( mb, this.ptr, path, volume, audioTrack, subtitleTrack).toUInt()) } fun nativeVideoStop() { val mb = getMethodBind("_OS","native_video_stop") _icall_Unit( mb, this.ptr) } fun nativeVideoUnpause() { val mb = getMethodBind("_OS","native_video_unpause") _icall_Unit( mb, this.ptr) } fun openMidiInputs() { val mb = getMethodBind("_OS","open_midi_inputs") _icall_Unit( mb, this.ptr) } fun printAllResources(tofile: String = "") { val mb = getMethodBind("_OS","print_all_resources") _icall_Unit_String( mb, this.ptr, tofile) } fun printAllTexturesBySize() { val mb = getMethodBind("_OS","print_all_textures_by_size") _icall_Unit( mb, this.ptr) } fun printResourcesByType(types: PoolStringArray) { val mb = getMethodBind("_OS","print_resources_by_type") _icall_Unit_PoolStringArray( mb, this.ptr, types) } fun printResourcesInUse(short: Boolean = false) { val mb = getMethodBind("_OS","print_resources_in_use") _icall_Unit_Boolean( mb, this.ptr, short) } fun requestAttention() { val mb = getMethodBind("_OS","request_attention") _icall_Unit( mb, this.ptr) } fun requestPermission(name: String): Boolean { val mb = getMethodBind("_OS","request_permission") return _icall_Boolean_String( mb, this.ptr, name) } fun requestPermissions(): Boolean { val mb = getMethodBind("_OS","request_permissions") return _icall_Boolean( mb, this.ptr) } fun setBorderlessWindow(borderless: Boolean) { val mb = getMethodBind("_OS","set_borderless_window") _icall_Unit_Boolean( mb, this.ptr, borderless) } fun setClipboard(clipboard: String) { val mb = getMethodBind("_OS","set_clipboard") _icall_Unit_String( mb, this.ptr, clipboard) } fun setCurrentScreen(screen: Long) { val mb = getMethodBind("_OS","set_current_screen") _icall_Unit_Long( mb, this.ptr, screen) } fun setCurrentTabletDriver(name: String) { val mb = getMethodBind("_OS","set_current_tablet_driver") _icall_Unit_String( mb, this.ptr, name) } fun setExitCode(code: Long) { val mb = getMethodBind("_OS","set_exit_code") _icall_Unit_Long( mb, this.ptr, code) } fun setIcon(icon: Image) { val mb = getMethodBind("_OS","set_icon") _icall_Unit_Object( mb, this.ptr, icon) } fun setImeActive(active: Boolean) { val mb = getMethodBind("_OS","set_ime_active") _icall_Unit_Boolean( mb, this.ptr, active) } fun setImePosition(position: Vector2) { val mb = getMethodBind("_OS","set_ime_position") _icall_Unit_Vector2( mb, this.ptr, position) } fun setKeepScreenOn(enabled: Boolean) { val mb = getMethodBind("_OS","set_keep_screen_on") _icall_Unit_Boolean( mb, this.ptr, enabled) } fun setLowProcessorUsageMode(enable: Boolean) { val mb = getMethodBind("_OS","set_low_processor_usage_mode") _icall_Unit_Boolean( mb, this.ptr, enable) } fun setLowProcessorUsageModeSleepUsec(usec: Long) { val mb = getMethodBind("_OS","set_low_processor_usage_mode_sleep_usec") _icall_Unit_Long( mb, this.ptr, usec) } fun setMaxWindowSize(size: Vector2) { val mb = getMethodBind("_OS","set_max_window_size") _icall_Unit_Vector2( mb, this.ptr, size) } fun setMinWindowSize(size: Vector2) { val mb = getMethodBind("_OS","set_min_window_size") _icall_Unit_Vector2( mb, this.ptr, size) } fun setNativeIcon(filename: String) { val mb = getMethodBind("_OS","set_native_icon") _icall_Unit_String( mb, this.ptr, filename) } fun setScreenOrientation(orientation: Long) { val mb = getMethodBind("_OS","set_screen_orientation") _icall_Unit_Long( mb, this.ptr, orientation) } fun setThreadName(name: String): GodotError { val mb = getMethodBind("_OS","set_thread_name") return GodotError.byValue( _icall_Long_String( mb, this.ptr, name).toUInt()) } fun setUseFileAccessSaveAndSwap(enabled: Boolean) { val mb = getMethodBind("_OS","set_use_file_access_save_and_swap") _icall_Unit_Boolean( mb, this.ptr, enabled) } fun setUseVsync(enable: Boolean) { val mb = getMethodBind("_OS","set_use_vsync") _icall_Unit_Boolean( mb, this.ptr, enable) } fun setVsyncViaCompositor(enable: Boolean) { val mb = getMethodBind("_OS","set_vsync_via_compositor") _icall_Unit_Boolean( mb, this.ptr, enable) } fun setWindowAlwaysOnTop(enabled: Boolean) { val mb = getMethodBind("_OS","set_window_always_on_top") _icall_Unit_Boolean( mb, this.ptr, enabled) } fun setWindowFullscreen(enabled: Boolean) { val mb = getMethodBind("_OS","set_window_fullscreen") _icall_Unit_Boolean( mb, this.ptr, enabled) } fun setWindowMaximized(enabled: Boolean) { val mb = getMethodBind("_OS","set_window_maximized") _icall_Unit_Boolean( mb, this.ptr, enabled) } fun setWindowMinimized(enabled: Boolean) { val mb = getMethodBind("_OS","set_window_minimized") _icall_Unit_Boolean( mb, this.ptr, enabled) } fun setWindowPerPixelTransparencyEnabled(enabled: Boolean) { val mb = getMethodBind("_OS","set_window_per_pixel_transparency_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } fun setWindowPosition(position: Vector2) { val mb = getMethodBind("_OS","set_window_position") _icall_Unit_Vector2( mb, this.ptr, position) } fun setWindowResizable(enabled: Boolean) { val mb = getMethodBind("_OS","set_window_resizable") _icall_Unit_Boolean( mb, this.ptr, enabled) } fun setWindowSize(size: Vector2) { val mb = getMethodBind("_OS","set_window_size") _icall_Unit_Vector2( mb, this.ptr, size) } fun setWindowTitle(title: String) { val mb = getMethodBind("_OS","set_window_title") _icall_Unit_String( mb, this.ptr, title) } fun shellOpen(uri: String): GodotError { val mb = getMethodBind("_OS","shell_open") return GodotError.byValue( _icall_Long_String( mb, this.ptr, uri).toUInt()) } fun showVirtualKeyboard(existingText: String = "") { val mb = getMethodBind("_OS","show_virtual_keyboard") _icall_Unit_String( mb, this.ptr, existingText) } enum class VideoDriver( id: Long ) { VIDEO_DRIVER_GLES3(0), VIDEO_DRIVER_GLES2(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class SystemDir( id: Long ) { SYSTEM_DIR_DESKTOP(0), SYSTEM_DIR_DCIM(1), SYSTEM_DIR_DOCUMENTS(2), SYSTEM_DIR_DOWNLOADS(3), SYSTEM_DIR_MOVIES(4), SYSTEM_DIR_MUSIC(5), SYSTEM_DIR_PICTURES(6), SYSTEM_DIR_RINGTONES(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ScreenOrientation( id: Long ) { SCREEN_ORIENTATION_LANDSCAPE(0), SCREEN_ORIENTATION_PORTRAIT(1), SCREEN_ORIENTATION_REVERSE_LANDSCAPE(2), SCREEN_ORIENTATION_REVERSE_PORTRAIT(3), SCREEN_ORIENTATION_SENSOR_LANDSCAPE(4), SCREEN_ORIENTATION_SENSOR_PORTRAIT(5), SCREEN_ORIENTATION_SENSOR(6); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class PowerState( id: Long ) { POWERSTATE_UNKNOWN(0), POWERSTATE_ON_BATTERY(1), POWERSTATE_NO_BATTERY(2), POWERSTATE_CHARGING(3), POWERSTATE_CHARGED(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Month( id: Long ) { MONTH_JANUARY(1), MONTH_FEBRUARY(2), MONTH_MARCH(3), MONTH_APRIL(4), MONTH_MAY(5), MONTH_JUNE(6), MONTH_JULY(7), MONTH_AUGUST(8), MONTH_SEPTEMBER(9), MONTH_OCTOBER(10), MONTH_NOVEMBER(11), MONTH_DECEMBER(12); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Weekday( id: Long ) { DAY_SUNDAY(0), DAY_MONDAY(1), DAY_TUESDAY(2), DAY_WEDNESDAY(3), DAY_THURSDAY(4), DAY_FRIDAY(5), DAY_SATURDAY(6); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Object.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.NodePath import godot.core.PoolStringArray import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal10 import godot.core.Signal2 import godot.core.Signal3 import godot.core.Signal4 import godot.core.Signal5 import godot.core.Signal6 import godot.core.Signal7 import godot.core.Signal8 import godot.core.Signal9 import godot.core.Variant import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_Object_String import godot.icalls._icall_Long import godot.icalls._icall_Long_String_Object_String_VariantArray_Long import godot.icalls._icall_PoolStringArray import godot.icalls._icall_Reference import godot.icalls._icall_String import godot.icalls._icall_String_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_NodePath_Variant import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Object_String import godot.icalls._icall_Unit_String_Variant import godot.icalls._icall_Unit_String_VariantArray import godot.icalls._icall_VariantArray import godot.icalls._icall_VariantArray_String import godot.icalls._icall_Variant_NodePath import godot.icalls._icall_Variant_String import godot.icalls._icall_Variant_String_VariantArray import godot.icalls._icall_varargs import godot.internal.KObject import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Any import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlin.Unit import kotlin.reflect.KCallable import kotlinx.cinterop.COpaquePointer open class Object : KObject() { val scriptChanged: Signal0 by signal() fun Signal0.emit() { emit(this@Object) } inline fun Unit> Signal0.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal1.emit(a0: A0) { emit(this@Object, a0) } inline fun Unit> Signal1.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal2.emit(a0: A0, a1: A1) { emit(this@Object, a0, a1) } inline fun Unit> Signal2.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal3.emit( a0: A0, a1: A1, a2: A2 ) { emit(this@Object, a0, a1, a2) } inline fun Unit> Signal3.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal4.emit( a0: A0, a1: A1, a2: A2, a3: A3 ) { emit(this@Object, a0, a1, a2, a3) } inline fun Unit> Signal4.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal5.emit( a0: A0, a1: A1, a2: A2, a3: A3, a4: A4 ) { emit(this@Object, a0, a1, a2, a3, a4) } inline fun Unit> Signal5.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal6.emit( a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5 ) { emit(this@Object, a0, a1, a2, a3, a4, a5) } inline fun Unit> Signal6.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal7.emit( a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6 ) { emit(this@Object, a0, a1, a2, a3, a4, a5, a6) } inline fun Unit> Signal7.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal8.emit( a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7 ) { emit(this@Object, a0, a1, a2, a3, a4, a5, a6, a7) } inline fun Unit> Signal8.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal9.emit( a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8 ) { emit(this@Object, a0, a1, a2, a3, a4, a5, a6, a7, a8) } inline fun Unit> Signal9.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun Signal10.emit( a0: A0, a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9 ) { emit(this@Object, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9) } inline fun Unit> Signal10.connect( target: Object, method: K, binds: VariantArray? = null, flags: Long = 0 ) { val methodName = (method as KCallable).name connect(this@Object, target, methodName, binds, flags) } fun toVariant(): Variant = Variant(this) override fun __new(): COpaquePointer = invokeConstructor("Object", "Object") open fun _get(property: String): Variant { throw NotImplementedError("_get is not implemented for Object") } open fun _getPropertyList(): VariantArray { throw NotImplementedError("_get_property_list is not implemented for Object") } open fun _init() { } open fun _notification(what: Long) { } open fun _set(property: String, value: Variant): Boolean { throw NotImplementedError("_set is not implemented for Object") } open fun _toString(): String { throw NotImplementedError("_to_string is not implemented for Object") } open fun addUserSignal(signal: String, arguments: VariantArray = VariantArray()) { val mb = getMethodBind("Object","add_user_signal") _icall_Unit_String_VariantArray( mb, this.ptr, signal, arguments) } open fun call(method: String, vararg __var_args: Any?): Variant { val mb = getMethodBind("Object","call") return _icall_varargs( mb, this.ptr, arrayOf(method, *__var_args)) } open fun callDeferred(method: String, vararg __var_args: Any?) { val mb = getMethodBind("Object","call_deferred") _icall_varargs( mb, this.ptr, arrayOf(method, *__var_args)) } open fun callv(method: String, argArray: VariantArray): Variant { val mb = getMethodBind("Object","callv") return _icall_Variant_String_VariantArray( mb, this.ptr, method, argArray) } open fun canTranslateMessages(): Boolean { val mb = getMethodBind("Object","can_translate_messages") return _icall_Boolean( mb, this.ptr) } open fun connect( signal: String, target: Object, method: String, binds: VariantArray = VariantArray(), flags: Long = 0 ): GodotError { val mb = getMethodBind("Object","connect") return GodotError.byValue( _icall_Long_String_Object_String_VariantArray_Long( mb, this.ptr, signal, target, method, binds, flags).toUInt()) } open fun disconnect( signal: String, target: Object, method: String ) { val mb = getMethodBind("Object","disconnect") _icall_Unit_String_Object_String( mb, this.ptr, signal, target, method) } open fun emitSignal(signal: String, vararg __var_args: Any?) { val mb = getMethodBind("Object","emit_signal") _icall_varargs( mb, this.ptr, arrayOf(signal, *__var_args)) } open fun free() { val mb = getMethodBind("Object","free") _icall_Unit( mb, this.ptr) } open fun get(property: String): Variant { val mb = getMethodBind("Object","get") return _icall_Variant_String( mb, this.ptr, property) } open fun getClass(): String { val mb = getMethodBind("Object","get_class") return _icall_String( mb, this.ptr) } open fun getIncomingConnections(): VariantArray { val mb = getMethodBind("Object","get_incoming_connections") return _icall_VariantArray( mb, this.ptr) } open fun getIndexed(property: NodePath): Variant { val mb = getMethodBind("Object","get_indexed") return _icall_Variant_NodePath( mb, this.ptr, property) } open fun getInstanceId(): Long { val mb = getMethodBind("Object","get_instance_id") return _icall_Long( mb, this.ptr) } open fun getMeta(name: String): Variant { val mb = getMethodBind("Object","get_meta") return _icall_Variant_String( mb, this.ptr, name) } open fun getMetaList(): PoolStringArray { val mb = getMethodBind("Object","get_meta_list") return _icall_PoolStringArray( mb, this.ptr) } open fun getMethodList(): VariantArray { val mb = getMethodBind("Object","get_method_list") return _icall_VariantArray( mb, this.ptr) } open fun getPropertyList(): VariantArray { val mb = getMethodBind("Object","get_property_list") return _icall_VariantArray( mb, this.ptr) } open fun getScript(): Reference { val mb = getMethodBind("Object","get_script") return _icall_Reference( mb, this.ptr) } open fun getSignalConnectionList(signal: String): VariantArray { val mb = getMethodBind("Object","get_signal_connection_list") return _icall_VariantArray_String( mb, this.ptr, signal) } open fun getSignalList(): VariantArray { val mb = getMethodBind("Object","get_signal_list") return _icall_VariantArray( mb, this.ptr) } open fun hasMeta(name: String): Boolean { val mb = getMethodBind("Object","has_meta") return _icall_Boolean_String( mb, this.ptr, name) } open fun hasMethod(method: String): Boolean { val mb = getMethodBind("Object","has_method") return _icall_Boolean_String( mb, this.ptr, method) } open fun hasSignal(signal: String): Boolean { val mb = getMethodBind("Object","has_signal") return _icall_Boolean_String( mb, this.ptr, signal) } open fun hasUserSignal(signal: String): Boolean { val mb = getMethodBind("Object","has_user_signal") return _icall_Boolean_String( mb, this.ptr, signal) } open fun isBlockingSignals(): Boolean { val mb = getMethodBind("Object","is_blocking_signals") return _icall_Boolean( mb, this.ptr) } open fun isClass(_class: String): Boolean { val mb = getMethodBind("Object","is_class") return _icall_Boolean_String( mb, this.ptr, _class) } open fun isConnected( signal: String, target: Object, method: String ): Boolean { val mb = getMethodBind("Object","is_connected") return _icall_Boolean_String_Object_String( mb, this.ptr, signal, target, method) } open fun isQueuedForDeletion(): Boolean { val mb = getMethodBind("Object","is_queued_for_deletion") return _icall_Boolean( mb, this.ptr) } open fun notification(what: Long, reversed: Boolean = false) { val mb = getMethodBind("Object","notification") _icall_Unit_Long_Boolean( mb, this.ptr, what, reversed) } open fun propertyListChangedNotify() { val mb = getMethodBind("Object","property_list_changed_notify") _icall_Unit( mb, this.ptr) } open fun removeMeta(name: String) { val mb = getMethodBind("Object","remove_meta") _icall_Unit_String( mb, this.ptr, name) } open fun set(property: String, value: Variant) { val mb = getMethodBind("Object","set") _icall_Unit_String_Variant( mb, this.ptr, property, value) } open fun setBlockSignals(enable: Boolean) { val mb = getMethodBind("Object","set_block_signals") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setDeferred(property: String, value: Variant) { val mb = getMethodBind("Object","set_deferred") _icall_Unit_String_Variant( mb, this.ptr, property, value) } open fun setIndexed(property: NodePath, value: Variant) { val mb = getMethodBind("Object","set_indexed") _icall_Unit_NodePath_Variant( mb, this.ptr, property, value) } open fun setMessageTranslation(enable: Boolean) { val mb = getMethodBind("Object","set_message_translation") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setMeta(name: String, value: Variant) { val mb = getMethodBind("Object","set_meta") _icall_Unit_String_Variant( mb, this.ptr, name, value) } open fun setScript(script: Reference) { val mb = getMethodBind("Object","set_script") _icall_Unit_Object( mb, this.ptr, script) } override fun toString(): String { val mb = getMethodBind("Object","to_string") return _icall_String( mb, this.ptr) } open fun tr(message: String): String { val mb = getMethodBind("Object","tr") return _icall_String_String( mb, this.ptr, message) } enum class ConnectFlags( id: Long ) { CONNECT_DEFERRED(1), CONNECT_PERSIST(2), CONNECT_ONESHOT(4), CONNECT_REFERENCE_COUNTED(8); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object { final const val NOTIFICATION_POSTINITIALIZE: Long = 0 final const val NOTIFICATION_PREDELETE: Long = 1 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/OccluderPolygon2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.OccluderPolygon2D import godot.core.PoolVector2Array import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_PoolVector2Array import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlinx.cinterop.COpaquePointer open class OccluderPolygon2D : Resource() { open var closed: Boolean get() { val mb = getMethodBind("OccluderPolygon2D","is_closed") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("OccluderPolygon2D","set_closed") _icall_Unit_Boolean(mb, this.ptr, value) } open var cullMode: Long get() { val mb = getMethodBind("OccluderPolygon2D","get_cull_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("OccluderPolygon2D","set_cull_mode") _icall_Unit_Long(mb, this.ptr, value) } open var polygon: PoolVector2Array get() { val mb = getMethodBind("OccluderPolygon2D","get_polygon") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("OccluderPolygon2D","set_polygon") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("OccluderPolygon2D", "OccluderPolygon2D") open fun getCullMode(): OccluderPolygon2D.CullMode { val mb = getMethodBind("OccluderPolygon2D","get_cull_mode") return OccluderPolygon2D.CullMode.from( _icall_Long( mb, this.ptr)) } open fun getPolygon(): PoolVector2Array { val mb = getMethodBind("OccluderPolygon2D","get_polygon") return _icall_PoolVector2Array( mb, this.ptr) } open fun isClosed(): Boolean { val mb = getMethodBind("OccluderPolygon2D","is_closed") return _icall_Boolean( mb, this.ptr) } open fun setClosed(closed: Boolean) { val mb = getMethodBind("OccluderPolygon2D","set_closed") _icall_Unit_Boolean( mb, this.ptr, closed) } open fun setCullMode(cullMode: Long) { val mb = getMethodBind("OccluderPolygon2D","set_cull_mode") _icall_Unit_Long( mb, this.ptr, cullMode) } open fun setPolygon(polygon: PoolVector2Array) { val mb = getMethodBind("OccluderPolygon2D","set_polygon") _icall_Unit_PoolVector2Array( mb, this.ptr, polygon) } enum class CullMode( id: Long ) { CULL_DISABLED(0), CULL_CLOCKWISE(1), CULL_COUNTER_CLOCKWISE(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/OmniLight.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.OmniLight import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class OmniLight : Light() { open var omniShadowDetail: Long get() { val mb = getMethodBind("OmniLight","get_shadow_detail") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("OmniLight","set_shadow_detail") _icall_Unit_Long(mb, this.ptr, value) } open var omniShadowMode: Long get() { val mb = getMethodBind("OmniLight","get_shadow_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("OmniLight","set_shadow_mode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("OmniLight", "OmniLight") open fun getShadowDetail(): OmniLight.ShadowDetail { val mb = getMethodBind("OmniLight","get_shadow_detail") return OmniLight.ShadowDetail.from( _icall_Long( mb, this.ptr)) } open fun getShadowMode(): OmniLight.ShadowMode { val mb = getMethodBind("OmniLight","get_shadow_mode") return OmniLight.ShadowMode.from( _icall_Long( mb, this.ptr)) } open fun setShadowDetail(detail: Long) { val mb = getMethodBind("OmniLight","set_shadow_detail") _icall_Unit_Long( mb, this.ptr, detail) } open fun setShadowMode(mode: Long) { val mb = getMethodBind("OmniLight","set_shadow_mode") _icall_Unit_Long( mb, this.ptr, mode) } enum class ShadowMode( id: Long ) { SHADOW_DUAL_PARABOLOID(0), SHADOW_CUBE(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ShadowDetail( id: Long ) { SHADOW_DETAIL_VERTICAL(0), SHADOW_DETAIL_HORIZONTAL(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/OpenSimplexNoise.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.core.Vector3 import godot.icalls._icall_Double import godot.icalls._icall_Double_Double import godot.icalls._icall_Double_Double_Double import godot.icalls._icall_Double_Double_Double_Double import godot.icalls._icall_Double_Double_Double_Double_Double import godot.icalls._icall_Double_Vector2 import godot.icalls._icall_Double_Vector3 import godot.icalls._icall_Image_Long import godot.icalls._icall_Image_Long_Long import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class OpenSimplexNoise : Resource() { open var lacunarity: Double get() { val mb = getMethodBind("OpenSimplexNoise","get_lacunarity") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("OpenSimplexNoise","set_lacunarity") _icall_Unit_Double(mb, this.ptr, value) } open var octaves: Long get() { val mb = getMethodBind("OpenSimplexNoise","get_octaves") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("OpenSimplexNoise","set_octaves") _icall_Unit_Long(mb, this.ptr, value) } open var period: Double get() { val mb = getMethodBind("OpenSimplexNoise","get_period") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("OpenSimplexNoise","set_period") _icall_Unit_Double(mb, this.ptr, value) } open var persistence: Double get() { val mb = getMethodBind("OpenSimplexNoise","get_persistence") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("OpenSimplexNoise","set_persistence") _icall_Unit_Double(mb, this.ptr, value) } open var seed: Long get() { val mb = getMethodBind("OpenSimplexNoise","get_seed") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("OpenSimplexNoise","set_seed") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("OpenSimplexNoise", "OpenSimplexNoise") open fun getImage(width: Long, height: Long): Image { val mb = getMethodBind("OpenSimplexNoise","get_image") return _icall_Image_Long_Long( mb, this.ptr, width, height) } open fun getLacunarity(): Double { val mb = getMethodBind("OpenSimplexNoise","get_lacunarity") return _icall_Double( mb, this.ptr) } open fun getNoise1d(x: Double): Double { val mb = getMethodBind("OpenSimplexNoise","get_noise_1d") return _icall_Double_Double( mb, this.ptr, x) } open fun getNoise2d(x: Double, y: Double): Double { val mb = getMethodBind("OpenSimplexNoise","get_noise_2d") return _icall_Double_Double_Double( mb, this.ptr, x, y) } open fun getNoise2dv(pos: Vector2): Double { val mb = getMethodBind("OpenSimplexNoise","get_noise_2dv") return _icall_Double_Vector2( mb, this.ptr, pos) } open fun getNoise3d( x: Double, y: Double, z: Double ): Double { val mb = getMethodBind("OpenSimplexNoise","get_noise_3d") return _icall_Double_Double_Double_Double( mb, this.ptr, x, y, z) } open fun getNoise3dv(pos: Vector3): Double { val mb = getMethodBind("OpenSimplexNoise","get_noise_3dv") return _icall_Double_Vector3( mb, this.ptr, pos) } open fun getNoise4d( x: Double, y: Double, z: Double, w: Double ): Double { val mb = getMethodBind("OpenSimplexNoise","get_noise_4d") return _icall_Double_Double_Double_Double_Double( mb, this.ptr, x, y, z, w) } open fun getOctaves(): Long { val mb = getMethodBind("OpenSimplexNoise","get_octaves") return _icall_Long( mb, this.ptr) } open fun getPeriod(): Double { val mb = getMethodBind("OpenSimplexNoise","get_period") return _icall_Double( mb, this.ptr) } open fun getPersistence(): Double { val mb = getMethodBind("OpenSimplexNoise","get_persistence") return _icall_Double( mb, this.ptr) } open fun getSeamlessImage(size: Long): Image { val mb = getMethodBind("OpenSimplexNoise","get_seamless_image") return _icall_Image_Long( mb, this.ptr, size) } open fun getSeed(): Long { val mb = getMethodBind("OpenSimplexNoise","get_seed") return _icall_Long( mb, this.ptr) } open fun setLacunarity(lacunarity: Double) { val mb = getMethodBind("OpenSimplexNoise","set_lacunarity") _icall_Unit_Double( mb, this.ptr, lacunarity) } open fun setOctaves(octaveCount: Long) { val mb = getMethodBind("OpenSimplexNoise","set_octaves") _icall_Unit_Long( mb, this.ptr, octaveCount) } open fun setPeriod(period: Double) { val mb = getMethodBind("OpenSimplexNoise","set_period") _icall_Unit_Double( mb, this.ptr, period) } open fun setPersistence(persistence: Double) { val mb = getMethodBind("OpenSimplexNoise","set_persistence") _icall_Unit_Double( mb, this.ptr, persistence) } open fun setSeed(seed: Long) { val mb = getMethodBind("OpenSimplexNoise","set_seed") _icall_Unit_Long( mb, this.ptr, seed) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/OptionButton.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal1 import godot.core.Variant import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_PopupMenu import godot.icalls._icall_String_Long import godot.icalls._icall_Texture_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Long_String import godot.icalls._icall_Unit_Long_Variant import godot.icalls._icall_Unit_Object_String_Long import godot.icalls._icall_Unit_String_Long import godot.icalls._icall_Variant import godot.icalls._icall_Variant_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class OptionButton : Button() { val itemFocused: Signal1 by signal("index") val itemSelected: Signal1 by signal("index") open val selected: Long get() { val mb = getMethodBind("OptionButton","get_selected") return _icall_Long(mb, this.ptr) } override fun __new(): COpaquePointer = invokeConstructor("OptionButton", "OptionButton") open fun _focused(arg0: Long) { } open fun _getItems(): VariantArray { throw NotImplementedError("_get_items is not implemented for OptionButton") } open fun _selectInt(arg0: Long) { } open fun _selected(arg0: Long) { } open fun _setItems(arg0: VariantArray) { } open fun addIconItem( texture: Texture, label: String, id: Long = -1 ) { val mb = getMethodBind("OptionButton","add_icon_item") _icall_Unit_Object_String_Long( mb, this.ptr, texture, label, id) } open fun addItem(label: String, id: Long = -1) { val mb = getMethodBind("OptionButton","add_item") _icall_Unit_String_Long( mb, this.ptr, label, id) } open fun addSeparator() { val mb = getMethodBind("OptionButton","add_separator") _icall_Unit( mb, this.ptr) } open fun clear() { val mb = getMethodBind("OptionButton","clear") _icall_Unit( mb, this.ptr) } open fun getItemCount(): Long { val mb = getMethodBind("OptionButton","get_item_count") return _icall_Long( mb, this.ptr) } open fun getItemIcon(idx: Long): Texture { val mb = getMethodBind("OptionButton","get_item_icon") return _icall_Texture_Long( mb, this.ptr, idx) } open fun getItemId(idx: Long): Long { val mb = getMethodBind("OptionButton","get_item_id") return _icall_Long_Long( mb, this.ptr, idx) } open fun getItemIndex(id: Long): Long { val mb = getMethodBind("OptionButton","get_item_index") return _icall_Long_Long( mb, this.ptr, id) } open fun getItemMetadata(idx: Long): Variant { val mb = getMethodBind("OptionButton","get_item_metadata") return _icall_Variant_Long( mb, this.ptr, idx) } open fun getItemText(idx: Long): String { val mb = getMethodBind("OptionButton","get_item_text") return _icall_String_Long( mb, this.ptr, idx) } open fun getPopup(): PopupMenu { val mb = getMethodBind("OptionButton","get_popup") return _icall_PopupMenu( mb, this.ptr) } open fun getSelected(): Long { val mb = getMethodBind("OptionButton","get_selected") return _icall_Long( mb, this.ptr) } open fun getSelectedId(): Long { val mb = getMethodBind("OptionButton","get_selected_id") return _icall_Long( mb, this.ptr) } open fun getSelectedMetadata(): Variant { val mb = getMethodBind("OptionButton","get_selected_metadata") return _icall_Variant( mb, this.ptr) } open fun isItemDisabled(idx: Long): Boolean { val mb = getMethodBind("OptionButton","is_item_disabled") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun removeItem(idx: Long) { val mb = getMethodBind("OptionButton","remove_item") _icall_Unit_Long( mb, this.ptr, idx) } open fun select(idx: Long) { val mb = getMethodBind("OptionButton","select") _icall_Unit_Long( mb, this.ptr, idx) } open fun setItemDisabled(idx: Long, disabled: Boolean) { val mb = getMethodBind("OptionButton","set_item_disabled") _icall_Unit_Long_Boolean( mb, this.ptr, idx, disabled) } open fun setItemIcon(idx: Long, texture: Texture) { val mb = getMethodBind("OptionButton","set_item_icon") _icall_Unit_Long_Object( mb, this.ptr, idx, texture) } open fun setItemId(idx: Long, id: Long) { val mb = getMethodBind("OptionButton","set_item_id") _icall_Unit_Long_Long( mb, this.ptr, idx, id) } open fun setItemMetadata(idx: Long, metadata: Variant) { val mb = getMethodBind("OptionButton","set_item_metadata") _icall_Unit_Long_Variant( mb, this.ptr, idx, metadata) } open fun setItemText(idx: Long, text: String) { val mb = getMethodBind("OptionButton","set_item_text") _icall_Unit_Long_String( mb, this.ptr, idx, text) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PCKPacker.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.icalls._icall_Long_Boolean import godot.icalls._icall_Long_String_Long import godot.icalls._icall_Long_String_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class PCKPacker : Reference() { override fun __new(): COpaquePointer = invokeConstructor("PCKPacker", "PCKPacker") open fun addFile(pckPath: String, sourcePath: String): GodotError { val mb = getMethodBind("PCKPacker","add_file") return GodotError.byValue( _icall_Long_String_String( mb, this.ptr, pckPath, sourcePath).toUInt()) } open fun flush(verbose: Boolean = false): GodotError { val mb = getMethodBind("PCKPacker","flush") return GodotError.byValue( _icall_Long_Boolean( mb, this.ptr, verbose).toUInt()) } open fun pckStart(pckName: String, alignment: Long = 0): GodotError { val mb = getMethodBind("PCKPacker","pck_start") return GodotError.byValue( _icall_Long_String_Long( mb, this.ptr, pckName, alignment).toUInt()) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PHashTranslation.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class PHashTranslation : Translation() { override fun __new(): COpaquePointer = invokeConstructor("PHashTranslation", "PHashTranslation") open fun generate(from: Translation) { val mb = getMethodBind("PHashTranslation","generate") _icall_Unit_Object( mb, this.ptr, from) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PackedDataContainer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.PoolByteArray import godot.core.Variant import godot.core.VariantArray import godot.icalls._icall_Long import godot.icalls._icall_Long_Variant import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class PackedDataContainer : Resource() { override fun __new(): COpaquePointer = invokeConstructor("PackedDataContainer", "PackedDataContainer") open fun _getData(): PoolByteArray { throw NotImplementedError("_get_data is not implemented for PackedDataContainer") } open fun _iterGet(arg0: Variant): Variant { throw NotImplementedError("_iter_get is not implemented for PackedDataContainer") } open fun _iterInit(arg0: VariantArray): Variant { throw NotImplementedError("_iter_init is not implemented for PackedDataContainer") } open fun _iterNext(arg0: VariantArray): Variant { throw NotImplementedError("_iter_next is not implemented for PackedDataContainer") } open fun _setData(arg0: PoolByteArray) { } open fun pack(value: Variant): GodotError { val mb = getMethodBind("PackedDataContainer","pack") return GodotError.byValue( _icall_Long_Variant( mb, this.ptr, value).toUInt()) } open fun size(): Long { val mb = getMethodBind("PackedDataContainer","size") return _icall_Long( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PackedDataContainerRef.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Variant import godot.core.VariantArray import godot.icalls._icall_Long import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError open class PackedDataContainerRef internal constructor() : Reference() { open fun _isDictionary(): Boolean { throw NotImplementedError("_is_dictionary is not implemented for PackedDataContainerRef") } open fun _iterGet(arg0: Variant): Variant { throw NotImplementedError("_iter_get is not implemented for PackedDataContainerRef") } open fun _iterInit(arg0: VariantArray): Variant { throw NotImplementedError("_iter_init is not implemented for PackedDataContainerRef") } open fun _iterNext(arg0: VariantArray): Variant { throw NotImplementedError("_iter_next is not implemented for PackedDataContainerRef") } open fun size(): Long { val mb = getMethodBind("PackedDataContainerRef","size") return _icall_Long( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PackedScene.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.GodotError import godot.icalls._icall_Boolean import godot.icalls._icall_Long_Object import godot.icalls._icall_Node_Long import godot.icalls._icall_SceneState import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class PackedScene : Resource() { override fun __new(): COpaquePointer = invokeConstructor("PackedScene", "PackedScene") open fun _getBundledScene(): Dictionary { throw NotImplementedError("_get_bundled_scene is not implemented for PackedScene") } open fun _setBundledScene(arg0: Dictionary) { } open fun canInstance(): Boolean { val mb = getMethodBind("PackedScene","can_instance") return _icall_Boolean( mb, this.ptr) } open fun getState(): SceneState { val mb = getMethodBind("PackedScene","get_state") return _icall_SceneState( mb, this.ptr) } open fun instance(editState: Long = 0): Node { val mb = getMethodBind("PackedScene","instance") return _icall_Node_Long( mb, this.ptr, editState) } open fun pack(path: Node): GodotError { val mb = getMethodBind("PackedScene","pack") return GodotError.byValue( _icall_Long_Object( mb, this.ptr, path).toUInt()) } enum class GenEditState( id: Long ) { GEN_EDIT_STATE_DISABLED(0), GEN_EDIT_STATE_INSTANCE(1), GEN_EDIT_STATE_MAIN(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PacketPeer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.PoolByteArray import godot.core.Variant import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_PoolByteArray import godot.icalls._icall_Long_Variant_Boolean import godot.icalls._icall_PoolByteArray import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Variant_Boolean import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long open class PacketPeer internal constructor() : Reference() { open var allowObjectDecoding: Boolean get() { val mb = getMethodBind("PacketPeer","is_object_decoding_allowed") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PacketPeer","set_allow_object_decoding") _icall_Unit_Boolean(mb, this.ptr, value) } open var encodeBufferMaxSize: Long get() { val mb = getMethodBind("PacketPeer","get_encode_buffer_max_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PacketPeer","set_encode_buffer_max_size") _icall_Unit_Long(mb, this.ptr, value) } open fun getAvailablePacketCount(): Long { val mb = getMethodBind("PacketPeer","get_available_packet_count") return _icall_Long( mb, this.ptr) } open fun getEncodeBufferMaxSize(): Long { val mb = getMethodBind("PacketPeer","get_encode_buffer_max_size") return _icall_Long( mb, this.ptr) } open fun getPacket(): PoolByteArray { val mb = getMethodBind("PacketPeer","get_packet") return _icall_PoolByteArray( mb, this.ptr) } open fun getPacketError(): GodotError { val mb = getMethodBind("PacketPeer","get_packet_error") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } open fun getVar(allowObjects: Boolean = false): Variant { val mb = getMethodBind("PacketPeer","get_var") return _icall_Variant_Boolean( mb, this.ptr, allowObjects) } open fun isObjectDecodingAllowed(): Boolean { val mb = getMethodBind("PacketPeer","is_object_decoding_allowed") return _icall_Boolean( mb, this.ptr) } open fun putPacket(buffer: PoolByteArray): GodotError { val mb = getMethodBind("PacketPeer","put_packet") return GodotError.byValue( _icall_Long_PoolByteArray( mb, this.ptr, buffer).toUInt()) } open fun putVar(_var: Variant, fullObjects: Boolean = false): GodotError { val mb = getMethodBind("PacketPeer","put_var") return GodotError.byValue( _icall_Long_Variant_Boolean( mb, this.ptr, _var, fullObjects).toUInt()) } open fun setAllowObjectDecoding(enable: Boolean) { val mb = getMethodBind("PacketPeer","set_allow_object_decoding") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setEncodeBufferMaxSize(maxSize: Long) { val mb = getMethodBind("PacketPeer","set_encode_buffer_max_size") _icall_Unit_Long( mb, this.ptr, maxSize) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PacketPeerDTLS.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.PacketPeerDTLS import godot.core.GodotError import godot.icalls._icall_Long import godot.icalls._icall_Long_Object_Boolean_String_nObject import godot.icalls._icall_Unit import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class PacketPeerDTLS : PacketPeer() { override fun __new(): COpaquePointer = invokeConstructor("PacketPeerDTLS", "PacketPeerDTLS") open fun connectToPeer( packetPeer: PacketPeerUDP, validateCerts: Boolean = true, forHostname: String = "", validCertificate: X509Certificate? = null ): GodotError { val mb = getMethodBind("PacketPeerDTLS","connect_to_peer") return GodotError.byValue( _icall_Long_Object_Boolean_String_nObject( mb, this.ptr, packetPeer, validateCerts, forHostname, validCertificate).toUInt()) } open fun disconnectFromPeer() { val mb = getMethodBind("PacketPeerDTLS","disconnect_from_peer") _icall_Unit( mb, this.ptr) } open fun getStatus(): PacketPeerDTLS.Status { val mb = getMethodBind("PacketPeerDTLS","get_status") return PacketPeerDTLS.Status.from( _icall_Long( mb, this.ptr)) } open fun poll() { val mb = getMethodBind("PacketPeerDTLS","poll") _icall_Unit( mb, this.ptr) } enum class Status( id: Long ) { STATUS_DISCONNECTED(0), STATUS_HANDSHAKING(1), STATUS_CONNECTED(2), STATUS_ERROR(3), STATUS_ERROR_HOSTNAME_MISMATCH(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PacketPeerGDNative.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class PacketPeerGDNative : PacketPeer() { override fun __new(): COpaquePointer = invokeConstructor("PacketPeerGDNative", "PacketPeerGDNative") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PacketPeerStream.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Long import godot.icalls._icall_StreamPeer import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class PacketPeerStream : PacketPeer() { open var inputBufferMaxSize: Long get() { val mb = getMethodBind("PacketPeerStream","get_input_buffer_max_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PacketPeerStream","set_input_buffer_max_size") _icall_Unit_Long(mb, this.ptr, value) } open var outputBufferMaxSize: Long get() { val mb = getMethodBind("PacketPeerStream","get_output_buffer_max_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PacketPeerStream","set_output_buffer_max_size") _icall_Unit_Long(mb, this.ptr, value) } open var streamPeer: StreamPeer get() { val mb = getMethodBind("PacketPeerStream","get_stream_peer") return _icall_StreamPeer(mb, this.ptr) } set(value) { val mb = getMethodBind("PacketPeerStream","set_stream_peer") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PacketPeerStream", "PacketPeerStream") open fun getInputBufferMaxSize(): Long { val mb = getMethodBind("PacketPeerStream","get_input_buffer_max_size") return _icall_Long( mb, this.ptr) } open fun getOutputBufferMaxSize(): Long { val mb = getMethodBind("PacketPeerStream","get_output_buffer_max_size") return _icall_Long( mb, this.ptr) } open fun getStreamPeer(): StreamPeer { val mb = getMethodBind("PacketPeerStream","get_stream_peer") return _icall_StreamPeer( mb, this.ptr) } open fun setInputBufferMaxSize(maxSizeBytes: Long) { val mb = getMethodBind("PacketPeerStream","set_input_buffer_max_size") _icall_Unit_Long( mb, this.ptr, maxSizeBytes) } open fun setOutputBufferMaxSize(maxSizeBytes: Long) { val mb = getMethodBind("PacketPeerStream","set_output_buffer_max_size") _icall_Unit_Long( mb, this.ptr, maxSizeBytes) } open fun setStreamPeer(peer: StreamPeer) { val mb = getMethodBind("PacketPeerStream","set_stream_peer") _icall_Unit_Object( mb, this.ptr, peer) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PacketPeerUDP.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_Long_String_Long import godot.icalls._icall_Long_String_Long import godot.icalls._icall_Long_String_String import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class PacketPeerUDP : PacketPeer() { override fun __new(): COpaquePointer = invokeConstructor("PacketPeerUDP", "PacketPeerUDP") open fun close() { val mb = getMethodBind("PacketPeerUDP","close") _icall_Unit( mb, this.ptr) } open fun connectToHost(host: String, port: Long): GodotError { val mb = getMethodBind("PacketPeerUDP","connect_to_host") return GodotError.byValue( _icall_Long_String_Long( mb, this.ptr, host, port).toUInt()) } open fun getPacketIp(): String { val mb = getMethodBind("PacketPeerUDP","get_packet_ip") return _icall_String( mb, this.ptr) } open fun getPacketPort(): Long { val mb = getMethodBind("PacketPeerUDP","get_packet_port") return _icall_Long( mb, this.ptr) } open fun isConnectedToHost(): Boolean { val mb = getMethodBind("PacketPeerUDP","is_connected_to_host") return _icall_Boolean( mb, this.ptr) } open fun isListening(): Boolean { val mb = getMethodBind("PacketPeerUDP","is_listening") return _icall_Boolean( mb, this.ptr) } open fun joinMulticastGroup(multicastAddress: String, interfaceName: String): GodotError { val mb = getMethodBind("PacketPeerUDP","join_multicast_group") return GodotError.byValue( _icall_Long_String_String( mb, this.ptr, multicastAddress, interfaceName).toUInt()) } open fun leaveMulticastGroup(multicastAddress: String, interfaceName: String): GodotError { val mb = getMethodBind("PacketPeerUDP","leave_multicast_group") return GodotError.byValue( _icall_Long_String_String( mb, this.ptr, multicastAddress, interfaceName).toUInt()) } open fun listen( port: Long, bindAddress: String = "*", recvBufSize: Long = 65536 ): GodotError { val mb = getMethodBind("PacketPeerUDP","listen") return GodotError.byValue( _icall_Long_Long_String_Long( mb, this.ptr, port, bindAddress, recvBufSize).toUInt()) } open fun setBroadcastEnabled(enabled: Boolean) { val mb = getMethodBind("PacketPeerUDP","set_broadcast_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setDestAddress(host: String, port: Long): GodotError { val mb = getMethodBind("PacketPeerUDP","set_dest_address") return GodotError.byValue( _icall_Long_String_Long( mb, this.ptr, host, port).toUInt()) } open fun wait(): GodotError { val mb = getMethodBind("PacketPeerUDP","wait") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Panel.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class Panel : Control() { override fun __new(): COpaquePointer = invokeConstructor("Panel", "Panel") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PanelContainer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class PanelContainer : Container() { override fun __new(): COpaquePointer = invokeConstructor("PanelContainer", "PanelContainer") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PanoramaSky.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class PanoramaSky : Sky() { open var panorama: Texture get() { val mb = getMethodBind("PanoramaSky","get_panorama") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("PanoramaSky","set_panorama") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PanoramaSky", "PanoramaSky") open fun getPanorama(): Texture { val mb = getMethodBind("PanoramaSky","get_panorama") return _icall_Texture( mb, this.ptr) } open fun setPanorama(texture: Texture) { val mb = getMethodBind("PanoramaSky","set_panorama") _icall_Unit_Object( mb, this.ptr, texture) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ParallaxBackground.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Transform2D import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ParallaxBackground : CanvasLayer() { open var scrollBaseOffset: Vector2 get() { val mb = getMethodBind("ParallaxBackground","get_scroll_base_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("ParallaxBackground","set_scroll_base_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var scrollBaseScale: Vector2 get() { val mb = getMethodBind("ParallaxBackground","get_scroll_base_scale") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("ParallaxBackground","set_scroll_base_scale") _icall_Unit_Vector2(mb, this.ptr, value) } open var scrollIgnoreCameraZoom: Boolean get() { val mb = getMethodBind("ParallaxBackground","is_ignore_camera_zoom") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ParallaxBackground","set_ignore_camera_zoom") _icall_Unit_Boolean(mb, this.ptr, value) } open var scrollLimitBegin: Vector2 get() { val mb = getMethodBind("ParallaxBackground","get_limit_begin") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("ParallaxBackground","set_limit_begin") _icall_Unit_Vector2(mb, this.ptr, value) } open var scrollLimitEnd: Vector2 get() { val mb = getMethodBind("ParallaxBackground","get_limit_end") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("ParallaxBackground","set_limit_end") _icall_Unit_Vector2(mb, this.ptr, value) } open var scrollOffset: Vector2 get() { val mb = getMethodBind("ParallaxBackground","get_scroll_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("ParallaxBackground","set_scroll_offset") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ParallaxBackground", "ParallaxBackground") open fun scrollBaseOffset(schedule: Vector2.() -> Unit): Vector2 = scrollBaseOffset.apply{ schedule(this) scrollBaseOffset = this } open fun scrollBaseScale(schedule: Vector2.() -> Unit): Vector2 = scrollBaseScale.apply{ schedule(this) scrollBaseScale = this } open fun scrollLimitBegin(schedule: Vector2.() -> Unit): Vector2 = scrollLimitBegin.apply{ schedule(this) scrollLimitBegin = this } open fun scrollLimitEnd(schedule: Vector2.() -> Unit): Vector2 = scrollLimitEnd.apply{ schedule(this) scrollLimitEnd = this } open fun scrollOffset(schedule: Vector2.() -> Unit): Vector2 = scrollOffset.apply{ schedule(this) scrollOffset = this } open fun _cameraMoved(arg0: Transform2D, arg1: Vector2) { } open fun getLimitBegin(): Vector2 { val mb = getMethodBind("ParallaxBackground","get_limit_begin") return _icall_Vector2( mb, this.ptr) } open fun getLimitEnd(): Vector2 { val mb = getMethodBind("ParallaxBackground","get_limit_end") return _icall_Vector2( mb, this.ptr) } open fun getScrollBaseOffset(): Vector2 { val mb = getMethodBind("ParallaxBackground","get_scroll_base_offset") return _icall_Vector2( mb, this.ptr) } open fun getScrollBaseScale(): Vector2 { val mb = getMethodBind("ParallaxBackground","get_scroll_base_scale") return _icall_Vector2( mb, this.ptr) } open fun getScrollOffset(): Vector2 { val mb = getMethodBind("ParallaxBackground","get_scroll_offset") return _icall_Vector2( mb, this.ptr) } open fun isIgnoreCameraZoom(): Boolean { val mb = getMethodBind("ParallaxBackground","is_ignore_camera_zoom") return _icall_Boolean( mb, this.ptr) } open fun setIgnoreCameraZoom(ignore: Boolean) { val mb = getMethodBind("ParallaxBackground","set_ignore_camera_zoom") _icall_Unit_Boolean( mb, this.ptr, ignore) } open fun setLimitBegin(ofs: Vector2) { val mb = getMethodBind("ParallaxBackground","set_limit_begin") _icall_Unit_Vector2( mb, this.ptr, ofs) } open fun setLimitEnd(ofs: Vector2) { val mb = getMethodBind("ParallaxBackground","set_limit_end") _icall_Unit_Vector2( mb, this.ptr, ofs) } open fun setScrollBaseOffset(ofs: Vector2) { val mb = getMethodBind("ParallaxBackground","set_scroll_base_offset") _icall_Unit_Vector2( mb, this.ptr, ofs) } open fun setScrollBaseScale(scale: Vector2) { val mb = getMethodBind("ParallaxBackground","set_scroll_base_scale") _icall_Unit_Vector2( mb, this.ptr, scale) } open fun setScrollOffset(ofs: Vector2) { val mb = getMethodBind("ParallaxBackground","set_scroll_offset") _icall_Unit_Vector2( mb, this.ptr, ofs) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ParallaxLayer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ParallaxLayer : Node2D() { open var motionMirroring: Vector2 get() { val mb = getMethodBind("ParallaxLayer","get_mirroring") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("ParallaxLayer","set_mirroring") _icall_Unit_Vector2(mb, this.ptr, value) } open var motionOffset: Vector2 get() { val mb = getMethodBind("ParallaxLayer","get_motion_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("ParallaxLayer","set_motion_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var motionScale: Vector2 get() { val mb = getMethodBind("ParallaxLayer","get_motion_scale") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("ParallaxLayer","set_motion_scale") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ParallaxLayer", "ParallaxLayer") open fun motionMirroring(schedule: Vector2.() -> Unit): Vector2 = motionMirroring.apply{ schedule(this) motionMirroring = this } open fun motionOffset(schedule: Vector2.() -> Unit): Vector2 = motionOffset.apply{ schedule(this) motionOffset = this } open fun motionScale(schedule: Vector2.() -> Unit): Vector2 = motionScale.apply{ schedule(this) motionScale = this } open fun getMirroring(): Vector2 { val mb = getMethodBind("ParallaxLayer","get_mirroring") return _icall_Vector2( mb, this.ptr) } open fun getMotionOffset(): Vector2 { val mb = getMethodBind("ParallaxLayer","get_motion_offset") return _icall_Vector2( mb, this.ptr) } open fun getMotionScale(): Vector2 { val mb = getMethodBind("ParallaxLayer","get_motion_scale") return _icall_Vector2( mb, this.ptr) } open fun setMirroring(mirror: Vector2) { val mb = getMethodBind("ParallaxLayer","set_mirroring") _icall_Unit_Vector2( mb, this.ptr, mirror) } open fun setMotionOffset(offset: Vector2) { val mb = getMethodBind("ParallaxLayer","set_motion_offset") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun setMotionScale(scale: Vector2) { val mb = getMethodBind("ParallaxLayer","set_motion_scale") _icall_Unit_Vector2( mb, this.ptr, scale) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Particles.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Particles import godot.core.AABB import godot.icalls._icall_AABB import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Material import godot.icalls._icall_Mesh_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_AABB import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Particles : GeometryInstance() { open var amount: Long get() { val mb = getMethodBind("Particles","get_amount") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_amount") _icall_Unit_Long(mb, this.ptr, value) } open var drawOrder: Long get() { val mb = getMethodBind("Particles","get_draw_order") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_draw_order") _icall_Unit_Long(mb, this.ptr, value) } open var drawPass1: Mesh get() { val mb = getMethodBind("Particles","get_draw_pass_mesh") return _icall_Mesh_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("Particles","set_draw_pass_mesh") _icall_Unit_Long_Object(mb, this.ptr, 0, value) } open var drawPass2: Mesh get() { val mb = getMethodBind("Particles","get_draw_pass_mesh") return _icall_Mesh_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("Particles","set_draw_pass_mesh") _icall_Unit_Long_Object(mb, this.ptr, 1, value) } open var drawPass3: Mesh get() { val mb = getMethodBind("Particles","get_draw_pass_mesh") return _icall_Mesh_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("Particles","set_draw_pass_mesh") _icall_Unit_Long_Object(mb, this.ptr, 2, value) } open var drawPass4: Mesh get() { val mb = getMethodBind("Particles","get_draw_pass_mesh") return _icall_Mesh_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("Particles","set_draw_pass_mesh") _icall_Unit_Long_Object(mb, this.ptr, 3, value) } open var drawPasses: Long get() { val mb = getMethodBind("Particles","get_draw_passes") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_draw_passes") _icall_Unit_Long(mb, this.ptr, value) } open var emitting: Boolean get() { val mb = getMethodBind("Particles","is_emitting") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_emitting") _icall_Unit_Boolean(mb, this.ptr, value) } open var explosiveness: Double get() { val mb = getMethodBind("Particles","get_explosiveness_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_explosiveness_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var fixedFps: Long get() { val mb = getMethodBind("Particles","get_fixed_fps") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_fixed_fps") _icall_Unit_Long(mb, this.ptr, value) } open var fractDelta: Boolean get() { val mb = getMethodBind("Particles","get_fractional_delta") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_fractional_delta") _icall_Unit_Boolean(mb, this.ptr, value) } open var lifetime: Double get() { val mb = getMethodBind("Particles","get_lifetime") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_lifetime") _icall_Unit_Double(mb, this.ptr, value) } open var localCoords: Boolean get() { val mb = getMethodBind("Particles","get_use_local_coordinates") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_use_local_coordinates") _icall_Unit_Boolean(mb, this.ptr, value) } open var oneShot: Boolean get() { val mb = getMethodBind("Particles","get_one_shot") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_one_shot") _icall_Unit_Boolean(mb, this.ptr, value) } open var preprocess: Double get() { val mb = getMethodBind("Particles","get_pre_process_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_pre_process_time") _icall_Unit_Double(mb, this.ptr, value) } open var processMaterial: Material get() { val mb = getMethodBind("Particles","get_process_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_process_material") _icall_Unit_Object(mb, this.ptr, value) } open var randomness: Double get() { val mb = getMethodBind("Particles","get_randomness_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_randomness_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var speedScale: Double get() { val mb = getMethodBind("Particles","get_speed_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_speed_scale") _icall_Unit_Double(mb, this.ptr, value) } open var visibilityAabb: AABB get() { val mb = getMethodBind("Particles","get_visibility_aabb") return _icall_AABB(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles","set_visibility_aabb") _icall_Unit_AABB(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Particles", "Particles") open fun visibilityAabb(schedule: AABB.() -> Unit): AABB = visibilityAabb.apply{ schedule(this) visibilityAabb = this } open fun captureAabb(): AABB { val mb = getMethodBind("Particles","capture_aabb") return _icall_AABB( mb, this.ptr) } open fun getAmount(): Long { val mb = getMethodBind("Particles","get_amount") return _icall_Long( mb, this.ptr) } open fun getDrawOrder(): Particles.DrawOrder { val mb = getMethodBind("Particles","get_draw_order") return Particles.DrawOrder.from( _icall_Long( mb, this.ptr)) } open fun getDrawPassMesh(pass: Long): Mesh { val mb = getMethodBind("Particles","get_draw_pass_mesh") return _icall_Mesh_Long( mb, this.ptr, pass) } open fun getDrawPasses(): Long { val mb = getMethodBind("Particles","get_draw_passes") return _icall_Long( mb, this.ptr) } open fun getExplosivenessRatio(): Double { val mb = getMethodBind("Particles","get_explosiveness_ratio") return _icall_Double( mb, this.ptr) } open fun getFixedFps(): Long { val mb = getMethodBind("Particles","get_fixed_fps") return _icall_Long( mb, this.ptr) } open fun getFractionalDelta(): Boolean { val mb = getMethodBind("Particles","get_fractional_delta") return _icall_Boolean( mb, this.ptr) } open fun getLifetime(): Double { val mb = getMethodBind("Particles","get_lifetime") return _icall_Double( mb, this.ptr) } open fun getOneShot(): Boolean { val mb = getMethodBind("Particles","get_one_shot") return _icall_Boolean( mb, this.ptr) } open fun getPreProcessTime(): Double { val mb = getMethodBind("Particles","get_pre_process_time") return _icall_Double( mb, this.ptr) } open fun getProcessMaterial(): Material { val mb = getMethodBind("Particles","get_process_material") return _icall_Material( mb, this.ptr) } open fun getRandomnessRatio(): Double { val mb = getMethodBind("Particles","get_randomness_ratio") return _icall_Double( mb, this.ptr) } open fun getSpeedScale(): Double { val mb = getMethodBind("Particles","get_speed_scale") return _icall_Double( mb, this.ptr) } open fun getUseLocalCoordinates(): Boolean { val mb = getMethodBind("Particles","get_use_local_coordinates") return _icall_Boolean( mb, this.ptr) } open fun getVisibilityAabb(): AABB { val mb = getMethodBind("Particles","get_visibility_aabb") return _icall_AABB( mb, this.ptr) } open fun isEmitting(): Boolean { val mb = getMethodBind("Particles","is_emitting") return _icall_Boolean( mb, this.ptr) } open fun restart() { val mb = getMethodBind("Particles","restart") _icall_Unit( mb, this.ptr) } open fun setAmount(amount: Long) { val mb = getMethodBind("Particles","set_amount") _icall_Unit_Long( mb, this.ptr, amount) } open fun setDrawOrder(order: Long) { val mb = getMethodBind("Particles","set_draw_order") _icall_Unit_Long( mb, this.ptr, order) } open fun setDrawPassMesh(pass: Long, mesh: Mesh) { val mb = getMethodBind("Particles","set_draw_pass_mesh") _icall_Unit_Long_Object( mb, this.ptr, pass, mesh) } open fun setDrawPasses(passes: Long) { val mb = getMethodBind("Particles","set_draw_passes") _icall_Unit_Long( mb, this.ptr, passes) } open fun setEmitting(emitting: Boolean) { val mb = getMethodBind("Particles","set_emitting") _icall_Unit_Boolean( mb, this.ptr, emitting) } open fun setExplosivenessRatio(ratio: Double) { val mb = getMethodBind("Particles","set_explosiveness_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setFixedFps(fps: Long) { val mb = getMethodBind("Particles","set_fixed_fps") _icall_Unit_Long( mb, this.ptr, fps) } open fun setFractionalDelta(enable: Boolean) { val mb = getMethodBind("Particles","set_fractional_delta") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setLifetime(secs: Double) { val mb = getMethodBind("Particles","set_lifetime") _icall_Unit_Double( mb, this.ptr, secs) } open fun setOneShot(enable: Boolean) { val mb = getMethodBind("Particles","set_one_shot") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setPreProcessTime(secs: Double) { val mb = getMethodBind("Particles","set_pre_process_time") _icall_Unit_Double( mb, this.ptr, secs) } open fun setProcessMaterial(material: Material) { val mb = getMethodBind("Particles","set_process_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setRandomnessRatio(ratio: Double) { val mb = getMethodBind("Particles","set_randomness_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setSpeedScale(scale: Double) { val mb = getMethodBind("Particles","set_speed_scale") _icall_Unit_Double( mb, this.ptr, scale) } open fun setUseLocalCoordinates(enable: Boolean) { val mb = getMethodBind("Particles","set_use_local_coordinates") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setVisibilityAabb(aabb: AABB) { val mb = getMethodBind("Particles","set_visibility_aabb") _icall_Unit_AABB( mb, this.ptr, aabb) } enum class DrawOrder( id: Long ) { DRAW_ORDER_INDEX(0), DRAW_ORDER_LIFETIME(1), DRAW_ORDER_VIEW_DEPTH(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object { final const val MAX_DRAW_PASSES: Long = 4 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Particles2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Particles2D import godot.core.Rect2 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Material import godot.icalls._icall_Rect2 import godot.icalls._icall_Texture import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Rect2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Particles2D : Node2D() { open var amount: Long get() { val mb = getMethodBind("Particles2D","get_amount") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_amount") _icall_Unit_Long(mb, this.ptr, value) } open var drawOrder: Long get() { val mb = getMethodBind("Particles2D","get_draw_order") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_draw_order") _icall_Unit_Long(mb, this.ptr, value) } open var emitting: Boolean get() { val mb = getMethodBind("Particles2D","is_emitting") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_emitting") _icall_Unit_Boolean(mb, this.ptr, value) } open var explosiveness: Double get() { val mb = getMethodBind("Particles2D","get_explosiveness_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_explosiveness_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var fixedFps: Long get() { val mb = getMethodBind("Particles2D","get_fixed_fps") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_fixed_fps") _icall_Unit_Long(mb, this.ptr, value) } open var fractDelta: Boolean get() { val mb = getMethodBind("Particles2D","get_fractional_delta") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_fractional_delta") _icall_Unit_Boolean(mb, this.ptr, value) } open var lifetime: Double get() { val mb = getMethodBind("Particles2D","get_lifetime") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_lifetime") _icall_Unit_Double(mb, this.ptr, value) } open var localCoords: Boolean get() { val mb = getMethodBind("Particles2D","get_use_local_coordinates") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_use_local_coordinates") _icall_Unit_Boolean(mb, this.ptr, value) } open var normalMap: Texture get() { val mb = getMethodBind("Particles2D","get_normal_map") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_normal_map") _icall_Unit_Object(mb, this.ptr, value) } open var oneShot: Boolean get() { val mb = getMethodBind("Particles2D","get_one_shot") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_one_shot") _icall_Unit_Boolean(mb, this.ptr, value) } open var preprocess: Double get() { val mb = getMethodBind("Particles2D","get_pre_process_time") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_pre_process_time") _icall_Unit_Double(mb, this.ptr, value) } open var processMaterial: Material get() { val mb = getMethodBind("Particles2D","get_process_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_process_material") _icall_Unit_Object(mb, this.ptr, value) } open var randomness: Double get() { val mb = getMethodBind("Particles2D","get_randomness_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_randomness_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var speedScale: Double get() { val mb = getMethodBind("Particles2D","get_speed_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_speed_scale") _icall_Unit_Double(mb, this.ptr, value) } open var texture: Texture get() { val mb = getMethodBind("Particles2D","get_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_texture") _icall_Unit_Object(mb, this.ptr, value) } open var visibilityRect: Rect2 get() { val mb = getMethodBind("Particles2D","get_visibility_rect") return _icall_Rect2(mb, this.ptr) } set(value) { val mb = getMethodBind("Particles2D","set_visibility_rect") _icall_Unit_Rect2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Particles2D", "Particles2D") open fun visibilityRect(schedule: Rect2.() -> Unit): Rect2 = visibilityRect.apply{ schedule(this) visibilityRect = this } open fun captureRect(): Rect2 { val mb = getMethodBind("Particles2D","capture_rect") return _icall_Rect2( mb, this.ptr) } open fun getAmount(): Long { val mb = getMethodBind("Particles2D","get_amount") return _icall_Long( mb, this.ptr) } open fun getDrawOrder(): Particles2D.DrawOrder { val mb = getMethodBind("Particles2D","get_draw_order") return Particles2D.DrawOrder.from( _icall_Long( mb, this.ptr)) } open fun getExplosivenessRatio(): Double { val mb = getMethodBind("Particles2D","get_explosiveness_ratio") return _icall_Double( mb, this.ptr) } open fun getFixedFps(): Long { val mb = getMethodBind("Particles2D","get_fixed_fps") return _icall_Long( mb, this.ptr) } open fun getFractionalDelta(): Boolean { val mb = getMethodBind("Particles2D","get_fractional_delta") return _icall_Boolean( mb, this.ptr) } open fun getLifetime(): Double { val mb = getMethodBind("Particles2D","get_lifetime") return _icall_Double( mb, this.ptr) } open fun getNormalMap(): Texture { val mb = getMethodBind("Particles2D","get_normal_map") return _icall_Texture( mb, this.ptr) } open fun getOneShot(): Boolean { val mb = getMethodBind("Particles2D","get_one_shot") return _icall_Boolean( mb, this.ptr) } open fun getPreProcessTime(): Double { val mb = getMethodBind("Particles2D","get_pre_process_time") return _icall_Double( mb, this.ptr) } open fun getProcessMaterial(): Material { val mb = getMethodBind("Particles2D","get_process_material") return _icall_Material( mb, this.ptr) } open fun getRandomnessRatio(): Double { val mb = getMethodBind("Particles2D","get_randomness_ratio") return _icall_Double( mb, this.ptr) } open fun getSpeedScale(): Double { val mb = getMethodBind("Particles2D","get_speed_scale") return _icall_Double( mb, this.ptr) } open fun getTexture(): Texture { val mb = getMethodBind("Particles2D","get_texture") return _icall_Texture( mb, this.ptr) } open fun getUseLocalCoordinates(): Boolean { val mb = getMethodBind("Particles2D","get_use_local_coordinates") return _icall_Boolean( mb, this.ptr) } open fun getVisibilityRect(): Rect2 { val mb = getMethodBind("Particles2D","get_visibility_rect") return _icall_Rect2( mb, this.ptr) } open fun isEmitting(): Boolean { val mb = getMethodBind("Particles2D","is_emitting") return _icall_Boolean( mb, this.ptr) } open fun restart() { val mb = getMethodBind("Particles2D","restart") _icall_Unit( mb, this.ptr) } open fun setAmount(amount: Long) { val mb = getMethodBind("Particles2D","set_amount") _icall_Unit_Long( mb, this.ptr, amount) } open fun setDrawOrder(order: Long) { val mb = getMethodBind("Particles2D","set_draw_order") _icall_Unit_Long( mb, this.ptr, order) } open fun setEmitting(emitting: Boolean) { val mb = getMethodBind("Particles2D","set_emitting") _icall_Unit_Boolean( mb, this.ptr, emitting) } open fun setExplosivenessRatio(ratio: Double) { val mb = getMethodBind("Particles2D","set_explosiveness_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setFixedFps(fps: Long) { val mb = getMethodBind("Particles2D","set_fixed_fps") _icall_Unit_Long( mb, this.ptr, fps) } open fun setFractionalDelta(enable: Boolean) { val mb = getMethodBind("Particles2D","set_fractional_delta") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setLifetime(secs: Double) { val mb = getMethodBind("Particles2D","set_lifetime") _icall_Unit_Double( mb, this.ptr, secs) } open fun setNormalMap(texture: Texture) { val mb = getMethodBind("Particles2D","set_normal_map") _icall_Unit_Object( mb, this.ptr, texture) } open fun setOneShot(secs: Boolean) { val mb = getMethodBind("Particles2D","set_one_shot") _icall_Unit_Boolean( mb, this.ptr, secs) } open fun setPreProcessTime(secs: Double) { val mb = getMethodBind("Particles2D","set_pre_process_time") _icall_Unit_Double( mb, this.ptr, secs) } open fun setProcessMaterial(material: Material) { val mb = getMethodBind("Particles2D","set_process_material") _icall_Unit_Object( mb, this.ptr, material) } open fun setRandomnessRatio(ratio: Double) { val mb = getMethodBind("Particles2D","set_randomness_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setSpeedScale(scale: Double) { val mb = getMethodBind("Particles2D","set_speed_scale") _icall_Unit_Double( mb, this.ptr, scale) } open fun setTexture(texture: Texture) { val mb = getMethodBind("Particles2D","set_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setUseLocalCoordinates(enable: Boolean) { val mb = getMethodBind("Particles2D","set_use_local_coordinates") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setVisibilityRect(visibilityRect: Rect2) { val mb = getMethodBind("Particles2D","set_visibility_rect") _icall_Unit_Rect2( mb, this.ptr, visibilityRect) } enum class DrawOrder( id: Long ) { DRAW_ORDER_INDEX(0), DRAW_ORDER_LIFETIME(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ParticlesMaterial.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.ParticlesMaterial import godot.core.Color import godot.core.Vector3 import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Color import godot.icalls._icall_CurveTexture import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_GradientTexture import godot.icalls._icall_Long import godot.icalls._icall_Texture import godot.icalls._icall_Texture_Long import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ParticlesMaterial : Material() { open var angle: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var angleCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 7, value) } open var angleRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 7) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 7, value) } open var angularVelocity: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var angularVelocityCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 1, value) } open var angularVelocityRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var animOffset: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 11, value) } open var animOffsetCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 11, value) } open var animOffsetRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 11) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 11, value) } open var animSpeed: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 10, value) } open var animSpeedCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 10, value) } open var animSpeedRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 10) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 10, value) } open var color: Color get() { val mb = getMethodBind("ParticlesMaterial","get_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_color") _icall_Unit_Color(mb, this.ptr, value) } open var colorRamp: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_color_ramp") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_color_ramp") _icall_Unit_Object(mb, this.ptr, value) } open var damping: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var dampingCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 6, value) } open var dampingRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 6) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 6, value) } open var direction: Vector3 get() { val mb = getMethodBind("ParticlesMaterial","get_direction") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_direction") _icall_Unit_Vector3(mb, this.ptr, value) } open var emissionBoxExtents: Vector3 get() { val mb = getMethodBind("ParticlesMaterial","get_emission_box_extents") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_emission_box_extents") _icall_Unit_Vector3(mb, this.ptr, value) } open var emissionColorTexture: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_emission_color_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_emission_color_texture") _icall_Unit_Object(mb, this.ptr, value) } open var emissionNormalTexture: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_emission_normal_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_emission_normal_texture") _icall_Unit_Object(mb, this.ptr, value) } open var emissionPointCount: Long get() { val mb = getMethodBind("ParticlesMaterial","get_emission_point_count") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_emission_point_count") _icall_Unit_Long(mb, this.ptr, value) } open var emissionPointTexture: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_emission_point_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_emission_point_texture") _icall_Unit_Object(mb, this.ptr, value) } open var emissionShape: Long get() { val mb = getMethodBind("ParticlesMaterial","get_emission_shape") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_emission_shape") _icall_Unit_Long(mb, this.ptr, value) } open var emissionSphereRadius: Double get() { val mb = getMethodBind("ParticlesMaterial","get_emission_sphere_radius") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_emission_sphere_radius") _icall_Unit_Double(mb, this.ptr, value) } open var flagAlignY: Boolean get() { val mb = getMethodBind("ParticlesMaterial","get_flag") return _icall_Boolean_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 0, value) } open var flagDisableZ: Boolean get() { val mb = getMethodBind("ParticlesMaterial","get_flag") return _icall_Boolean_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 2, value) } open var flagRotateY: Boolean get() { val mb = getMethodBind("ParticlesMaterial","get_flag") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_flag") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var flatness: Double get() { val mb = getMethodBind("ParticlesMaterial","get_flatness") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_flatness") _icall_Unit_Double(mb, this.ptr, value) } open var gravity: Vector3 get() { val mb = getMethodBind("ParticlesMaterial","get_gravity") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_gravity") _icall_Unit_Vector3(mb, this.ptr, value) } open var hueVariation: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var hueVariationCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 9, value) } open var hueVariationRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 9) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 9, value) } open var initialVelocity: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var initialVelocityRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var lifetimeRandomness: Double get() { val mb = getMethodBind("ParticlesMaterial","get_lifetime_randomness") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_lifetime_randomness") _icall_Unit_Double(mb, this.ptr, value) } open var linearAccel: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var linearAccelCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 3, value) } open var linearAccelRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 3) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 3, value) } open var orbitVelocity: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var orbitVelocityCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 2, value) } open var orbitVelocityRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } open var radialAccel: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var radialAccelCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 4, value) } open var radialAccelRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 4, value) } open var scale: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var scaleCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 8, value) } open var scaleRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 8, value) } open var spread: Double get() { val mb = getMethodBind("ParticlesMaterial","get_spread") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_spread") _icall_Unit_Double(mb, this.ptr, value) } open var tangentialAccel: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var tangentialAccelCurve: Texture get() { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object(mb, this.ptr, 5, value) } open var tangentialAccelRandom: Double get() { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long(mb, this.ptr, 5) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double(mb, this.ptr, 5, value) } open var trailColorModifier: GradientTexture get() { val mb = getMethodBind("ParticlesMaterial","get_trail_color_modifier") return _icall_GradientTexture(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_trail_color_modifier") _icall_Unit_Object(mb, this.ptr, value) } open var trailDivisor: Long get() { val mb = getMethodBind("ParticlesMaterial","get_trail_divisor") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_trail_divisor") _icall_Unit_Long(mb, this.ptr, value) } open var trailSizeModifier: CurveTexture get() { val mb = getMethodBind("ParticlesMaterial","get_trail_size_modifier") return _icall_CurveTexture(mb, this.ptr) } set(value) { val mb = getMethodBind("ParticlesMaterial","set_trail_size_modifier") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ParticlesMaterial", "ParticlesMaterial") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun direction(schedule: Vector3.() -> Unit): Vector3 = direction.apply{ schedule(this) direction = this } open fun emissionBoxExtents(schedule: Vector3.() -> Unit): Vector3 = emissionBoxExtents.apply{ schedule(this) emissionBoxExtents = this } open fun gravity(schedule: Vector3.() -> Unit): Vector3 = gravity.apply{ schedule(this) gravity = this } open fun getColor(): Color { val mb = getMethodBind("ParticlesMaterial","get_color") return _icall_Color( mb, this.ptr) } open fun getColorRamp(): Texture { val mb = getMethodBind("ParticlesMaterial","get_color_ramp") return _icall_Texture( mb, this.ptr) } open fun getDirection(): Vector3 { val mb = getMethodBind("ParticlesMaterial","get_direction") return _icall_Vector3( mb, this.ptr) } open fun getEmissionBoxExtents(): Vector3 { val mb = getMethodBind("ParticlesMaterial","get_emission_box_extents") return _icall_Vector3( mb, this.ptr) } open fun getEmissionColorTexture(): Texture { val mb = getMethodBind("ParticlesMaterial","get_emission_color_texture") return _icall_Texture( mb, this.ptr) } open fun getEmissionNormalTexture(): Texture { val mb = getMethodBind("ParticlesMaterial","get_emission_normal_texture") return _icall_Texture( mb, this.ptr) } open fun getEmissionPointCount(): Long { val mb = getMethodBind("ParticlesMaterial","get_emission_point_count") return _icall_Long( mb, this.ptr) } open fun getEmissionPointTexture(): Texture { val mb = getMethodBind("ParticlesMaterial","get_emission_point_texture") return _icall_Texture( mb, this.ptr) } open fun getEmissionShape(): ParticlesMaterial.EmissionShape { val mb = getMethodBind("ParticlesMaterial","get_emission_shape") return ParticlesMaterial.EmissionShape.from( _icall_Long( mb, this.ptr)) } open fun getEmissionSphereRadius(): Double { val mb = getMethodBind("ParticlesMaterial","get_emission_sphere_radius") return _icall_Double( mb, this.ptr) } open fun getFlag(flag: Long): Boolean { val mb = getMethodBind("ParticlesMaterial","get_flag") return _icall_Boolean_Long( mb, this.ptr, flag) } open fun getFlatness(): Double { val mb = getMethodBind("ParticlesMaterial","get_flatness") return _icall_Double( mb, this.ptr) } open fun getGravity(): Vector3 { val mb = getMethodBind("ParticlesMaterial","get_gravity") return _icall_Vector3( mb, this.ptr) } open fun getLifetimeRandomness(): Double { val mb = getMethodBind("ParticlesMaterial","get_lifetime_randomness") return _icall_Double( mb, this.ptr) } open fun getParam(param: Long): Double { val mb = getMethodBind("ParticlesMaterial","get_param") return _icall_Double_Long( mb, this.ptr, param) } open fun getParamRandomness(param: Long): Double { val mb = getMethodBind("ParticlesMaterial","get_param_randomness") return _icall_Double_Long( mb, this.ptr, param) } open fun getParamTexture(param: Long): Texture { val mb = getMethodBind("ParticlesMaterial","get_param_texture") return _icall_Texture_Long( mb, this.ptr, param) } open fun getSpread(): Double { val mb = getMethodBind("ParticlesMaterial","get_spread") return _icall_Double( mb, this.ptr) } open fun getTrailColorModifier(): GradientTexture { val mb = getMethodBind("ParticlesMaterial","get_trail_color_modifier") return _icall_GradientTexture( mb, this.ptr) } open fun getTrailDivisor(): Long { val mb = getMethodBind("ParticlesMaterial","get_trail_divisor") return _icall_Long( mb, this.ptr) } open fun getTrailSizeModifier(): CurveTexture { val mb = getMethodBind("ParticlesMaterial","get_trail_size_modifier") return _icall_CurveTexture( mb, this.ptr) } open fun setColor(color: Color) { val mb = getMethodBind("ParticlesMaterial","set_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setColorRamp(ramp: Texture) { val mb = getMethodBind("ParticlesMaterial","set_color_ramp") _icall_Unit_Object( mb, this.ptr, ramp) } open fun setDirection(degrees: Vector3) { val mb = getMethodBind("ParticlesMaterial","set_direction") _icall_Unit_Vector3( mb, this.ptr, degrees) } open fun setEmissionBoxExtents(extents: Vector3) { val mb = getMethodBind("ParticlesMaterial","set_emission_box_extents") _icall_Unit_Vector3( mb, this.ptr, extents) } open fun setEmissionColorTexture(texture: Texture) { val mb = getMethodBind("ParticlesMaterial","set_emission_color_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setEmissionNormalTexture(texture: Texture) { val mb = getMethodBind("ParticlesMaterial","set_emission_normal_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setEmissionPointCount(pointCount: Long) { val mb = getMethodBind("ParticlesMaterial","set_emission_point_count") _icall_Unit_Long( mb, this.ptr, pointCount) } open fun setEmissionPointTexture(texture: Texture) { val mb = getMethodBind("ParticlesMaterial","set_emission_point_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setEmissionShape(shape: Long) { val mb = getMethodBind("ParticlesMaterial","set_emission_shape") _icall_Unit_Long( mb, this.ptr, shape) } open fun setEmissionSphereRadius(radius: Double) { val mb = getMethodBind("ParticlesMaterial","set_emission_sphere_radius") _icall_Unit_Double( mb, this.ptr, radius) } open fun setFlag(flag: Long, enable: Boolean) { val mb = getMethodBind("ParticlesMaterial","set_flag") _icall_Unit_Long_Boolean( mb, this.ptr, flag, enable) } open fun setFlatness(amount: Double) { val mb = getMethodBind("ParticlesMaterial","set_flatness") _icall_Unit_Double( mb, this.ptr, amount) } open fun setGravity(accelVec: Vector3) { val mb = getMethodBind("ParticlesMaterial","set_gravity") _icall_Unit_Vector3( mb, this.ptr, accelVec) } open fun setLifetimeRandomness(randomness: Double) { val mb = getMethodBind("ParticlesMaterial","set_lifetime_randomness") _icall_Unit_Double( mb, this.ptr, randomness) } open fun setParam(param: Long, value: Double) { val mb = getMethodBind("ParticlesMaterial","set_param") _icall_Unit_Long_Double( mb, this.ptr, param, value) } open fun setParamRandomness(param: Long, randomness: Double) { val mb = getMethodBind("ParticlesMaterial","set_param_randomness") _icall_Unit_Long_Double( mb, this.ptr, param, randomness) } open fun setParamTexture(param: Long, texture: Texture) { val mb = getMethodBind("ParticlesMaterial","set_param_texture") _icall_Unit_Long_Object( mb, this.ptr, param, texture) } open fun setSpread(degrees: Double) { val mb = getMethodBind("ParticlesMaterial","set_spread") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setTrailColorModifier(texture: GradientTexture) { val mb = getMethodBind("ParticlesMaterial","set_trail_color_modifier") _icall_Unit_Object( mb, this.ptr, texture) } open fun setTrailDivisor(divisor: Long) { val mb = getMethodBind("ParticlesMaterial","set_trail_divisor") _icall_Unit_Long( mb, this.ptr, divisor) } open fun setTrailSizeModifier(texture: CurveTexture) { val mb = getMethodBind("ParticlesMaterial","set_trail_size_modifier") _icall_Unit_Object( mb, this.ptr, texture) } enum class Flags( id: Long ) { FLAG_ALIGN_Y_TO_VELOCITY(0), FLAG_ROTATE_Y(1), FLAG_DISABLE_Z(2), FLAG_MAX(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class EmissionShape( id: Long ) { EMISSION_SHAPE_POINT(0), EMISSION_SHAPE_SPHERE(1), EMISSION_SHAPE_BOX(2), EMISSION_SHAPE_POINTS(3), EMISSION_SHAPE_DIRECTED_POINTS(4), EMISSION_SHAPE_MAX(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class Parameter( id: Long ) { PARAM_INITIAL_LINEAR_VELOCITY(0), PARAM_ANGULAR_VELOCITY(1), PARAM_ORBIT_VELOCITY(2), PARAM_LINEAR_ACCEL(3), PARAM_RADIAL_ACCEL(4), PARAM_TANGENTIAL_ACCEL(5), PARAM_DAMPING(6), PARAM_ANGLE(7), PARAM_SCALE(8), PARAM_HUE_VARIATION(9), PARAM_ANIM_SPEED(10), PARAM_ANIM_OFFSET(11), PARAM_MAX(12); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Path.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_Curve3D import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class Path : Spatial() { val curveChanged: Signal0 by signal() open var curve: Curve3D get() { val mb = getMethodBind("Path","get_curve") return _icall_Curve3D(mb, this.ptr) } set(value) { val mb = getMethodBind("Path","set_curve") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Path", "Path") open fun _curveChanged() { } open fun getCurve(): Curve3D { val mb = getMethodBind("Path","get_curve") return _icall_Curve3D( mb, this.ptr) } open fun setCurve(curve: Curve3D) { val mb = getMethodBind("Path","set_curve") _icall_Unit_Object( mb, this.ptr, curve) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Path2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Curve2D import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class Path2D : Node2D() { open var curve: Curve2D get() { val mb = getMethodBind("Path2D","get_curve") return _icall_Curve2D(mb, this.ptr) } set(value) { val mb = getMethodBind("Path2D","set_curve") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Path2D", "Path2D") open fun _curveChanged() { } open fun getCurve(): Curve2D { val mb = getMethodBind("Path2D","get_curve") return _icall_Curve2D( mb, this.ptr) } open fun setCurve(curve: Curve2D) { val mb = getMethodBind("Path2D","set_curve") _icall_Unit_Object( mb, this.ptr, curve) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PathFollow.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.PathFollow import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class PathFollow : Spatial() { open var cubicInterp: Boolean get() { val mb = getMethodBind("PathFollow","get_cubic_interpolation") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow","set_cubic_interpolation") _icall_Unit_Boolean(mb, this.ptr, value) } open var hOffset: Double get() { val mb = getMethodBind("PathFollow","get_h_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow","set_h_offset") _icall_Unit_Double(mb, this.ptr, value) } open var loop: Boolean get() { val mb = getMethodBind("PathFollow","has_loop") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow","set_loop") _icall_Unit_Boolean(mb, this.ptr, value) } open var offset: Double get() { val mb = getMethodBind("PathFollow","get_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow","set_offset") _icall_Unit_Double(mb, this.ptr, value) } open var rotationMode: Long get() { val mb = getMethodBind("PathFollow","get_rotation_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow","set_rotation_mode") _icall_Unit_Long(mb, this.ptr, value) } open var unitOffset: Double get() { val mb = getMethodBind("PathFollow","get_unit_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow","set_unit_offset") _icall_Unit_Double(mb, this.ptr, value) } open var vOffset: Double get() { val mb = getMethodBind("PathFollow","get_v_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow","set_v_offset") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PathFollow", "PathFollow") open fun getCubicInterpolation(): Boolean { val mb = getMethodBind("PathFollow","get_cubic_interpolation") return _icall_Boolean( mb, this.ptr) } open fun getHOffset(): Double { val mb = getMethodBind("PathFollow","get_h_offset") return _icall_Double( mb, this.ptr) } open fun getOffset(): Double { val mb = getMethodBind("PathFollow","get_offset") return _icall_Double( mb, this.ptr) } open fun getRotationMode(): PathFollow.RotationMode { val mb = getMethodBind("PathFollow","get_rotation_mode") return PathFollow.RotationMode.from( _icall_Long( mb, this.ptr)) } open fun getUnitOffset(): Double { val mb = getMethodBind("PathFollow","get_unit_offset") return _icall_Double( mb, this.ptr) } open fun getVOffset(): Double { val mb = getMethodBind("PathFollow","get_v_offset") return _icall_Double( mb, this.ptr) } open fun hasLoop(): Boolean { val mb = getMethodBind("PathFollow","has_loop") return _icall_Boolean( mb, this.ptr) } open fun setCubicInterpolation(enable: Boolean) { val mb = getMethodBind("PathFollow","set_cubic_interpolation") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setHOffset(hOffset: Double) { val mb = getMethodBind("PathFollow","set_h_offset") _icall_Unit_Double( mb, this.ptr, hOffset) } open fun setLoop(loop: Boolean) { val mb = getMethodBind("PathFollow","set_loop") _icall_Unit_Boolean( mb, this.ptr, loop) } open fun setOffset(offset: Double) { val mb = getMethodBind("PathFollow","set_offset") _icall_Unit_Double( mb, this.ptr, offset) } open fun setRotationMode(rotationMode: Long) { val mb = getMethodBind("PathFollow","set_rotation_mode") _icall_Unit_Long( mb, this.ptr, rotationMode) } open fun setUnitOffset(unitOffset: Double) { val mb = getMethodBind("PathFollow","set_unit_offset") _icall_Unit_Double( mb, this.ptr, unitOffset) } open fun setVOffset(vOffset: Double) { val mb = getMethodBind("PathFollow","set_v_offset") _icall_Unit_Double( mb, this.ptr, vOffset) } enum class RotationMode( id: Long ) { ROTATION_NONE(0), ROTATION_Y(1), ROTATION_XY(2), ROTATION_XYZ(3), ROTATION_ORIENTED(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PathFollow2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlinx.cinterop.COpaquePointer open class PathFollow2D : Node2D() { open var cubicInterp: Boolean get() { val mb = getMethodBind("PathFollow2D","get_cubic_interpolation") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow2D","set_cubic_interpolation") _icall_Unit_Boolean(mb, this.ptr, value) } open var hOffset: Double get() { val mb = getMethodBind("PathFollow2D","get_h_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow2D","set_h_offset") _icall_Unit_Double(mb, this.ptr, value) } open var lookahead: Double get() { val mb = getMethodBind("PathFollow2D","get_lookahead") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow2D","set_lookahead") _icall_Unit_Double(mb, this.ptr, value) } open var loop: Boolean get() { val mb = getMethodBind("PathFollow2D","has_loop") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow2D","set_loop") _icall_Unit_Boolean(mb, this.ptr, value) } open var offset: Double get() { val mb = getMethodBind("PathFollow2D","get_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow2D","set_offset") _icall_Unit_Double(mb, this.ptr, value) } open var rotate: Boolean get() { val mb = getMethodBind("PathFollow2D","is_rotating") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow2D","set_rotate") _icall_Unit_Boolean(mb, this.ptr, value) } open var unitOffset: Double get() { val mb = getMethodBind("PathFollow2D","get_unit_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow2D","set_unit_offset") _icall_Unit_Double(mb, this.ptr, value) } open var vOffset: Double get() { val mb = getMethodBind("PathFollow2D","get_v_offset") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PathFollow2D","set_v_offset") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PathFollow2D", "PathFollow2D") open fun getCubicInterpolation(): Boolean { val mb = getMethodBind("PathFollow2D","get_cubic_interpolation") return _icall_Boolean( mb, this.ptr) } open fun getHOffset(): Double { val mb = getMethodBind("PathFollow2D","get_h_offset") return _icall_Double( mb, this.ptr) } open fun getLookahead(): Double { val mb = getMethodBind("PathFollow2D","get_lookahead") return _icall_Double( mb, this.ptr) } open fun getOffset(): Double { val mb = getMethodBind("PathFollow2D","get_offset") return _icall_Double( mb, this.ptr) } open fun getUnitOffset(): Double { val mb = getMethodBind("PathFollow2D","get_unit_offset") return _icall_Double( mb, this.ptr) } open fun getVOffset(): Double { val mb = getMethodBind("PathFollow2D","get_v_offset") return _icall_Double( mb, this.ptr) } open fun hasLoop(): Boolean { val mb = getMethodBind("PathFollow2D","has_loop") return _icall_Boolean( mb, this.ptr) } open fun isRotating(): Boolean { val mb = getMethodBind("PathFollow2D","is_rotating") return _icall_Boolean( mb, this.ptr) } open fun setCubicInterpolation(enable: Boolean) { val mb = getMethodBind("PathFollow2D","set_cubic_interpolation") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setHOffset(hOffset: Double) { val mb = getMethodBind("PathFollow2D","set_h_offset") _icall_Unit_Double( mb, this.ptr, hOffset) } open fun setLookahead(lookahead: Double) { val mb = getMethodBind("PathFollow2D","set_lookahead") _icall_Unit_Double( mb, this.ptr, lookahead) } open fun setLoop(loop: Boolean) { val mb = getMethodBind("PathFollow2D","set_loop") _icall_Unit_Boolean( mb, this.ptr, loop) } open fun setOffset(offset: Double) { val mb = getMethodBind("PathFollow2D","set_offset") _icall_Unit_Double( mb, this.ptr, offset) } open fun setRotate(enable: Boolean) { val mb = getMethodBind("PathFollow2D","set_rotate") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setUnitOffset(unitOffset: Double) { val mb = getMethodBind("PathFollow2D","set_unit_offset") _icall_Unit_Double( mb, this.ptr, unitOffset) } open fun setVOffset(vOffset: Double) { val mb = getMethodBind("PathFollow2D","set_v_offset") _icall_Unit_Double( mb, this.ptr, vOffset) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Performance.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.icalls._icall_Double_Long import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Double import kotlin.Long import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object Performance : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("Performance".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton Performance" } ptr } fun getMonitor(monitor: Long): Double { val mb = getMethodBind("Performance","get_monitor") return _icall_Double_Long( mb, this.ptr, monitor) } enum class Monitor( id: Long ) { TIME_FPS(0), TIME_PROCESS(1), TIME_PHYSICS_PROCESS(2), MEMORY_STATIC(3), MEMORY_DYNAMIC(4), MEMORY_STATIC_MAX(5), MEMORY_DYNAMIC_MAX(6), MEMORY_MESSAGE_BUFFER_MAX(7), OBJECT_COUNT(8), OBJECT_RESOURCE_COUNT(9), OBJECT_NODE_COUNT(10), OBJECT_ORPHAN_NODE_COUNT(11), RENDER_OBJECTS_IN_FRAME(12), RENDER_VERTICES_IN_FRAME(13), RENDER_MATERIAL_CHANGES_IN_FRAME(14), RENDER_SHADER_CHANGES_IN_FRAME(15), RENDER_SURFACE_CHANGES_IN_FRAME(16), RENDER_DRAW_CALLS_IN_FRAME(17), RENDER_2D_ITEMS_IN_FRAME(18), RENDER_2D_DRAW_CALLS_IN_FRAME(19), RENDER_VIDEO_MEM_USED(20), RENDER_TEXTURE_MEM_USED(21), RENDER_VERTEX_MEM_USED(22), RENDER_USAGE_VIDEO_MEM_TOTAL(23), PHYSICS_2D_ACTIVE_OBJECTS(24), PHYSICS_2D_COLLISION_PAIRS(25), PHYSICS_2D_ISLAND_COUNT(26), PHYSICS_3D_ACTIVE_OBJECTS(27), PHYSICS_3D_COLLISION_PAIRS(28), PHYSICS_3D_ISLAND_COUNT(29), AUDIO_OUTPUT_LATENCY(30), MONITOR_MAX(31); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PhysicalBone.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.PhysicalBone import godot.core.Transform import godot.core.Vector3 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Transform import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Transform import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Unit_Vector3_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class PhysicalBone : PhysicsBody() { open var bodyOffset: Transform get() { val mb = getMethodBind("PhysicalBone","get_body_offset") return _icall_Transform(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicalBone","set_body_offset") _icall_Unit_Transform(mb, this.ptr, value) } open var bounce: Double get() { val mb = getMethodBind("PhysicalBone","get_bounce") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicalBone","set_bounce") _icall_Unit_Double(mb, this.ptr, value) } open var friction: Double get() { val mb = getMethodBind("PhysicalBone","get_friction") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicalBone","set_friction") _icall_Unit_Double(mb, this.ptr, value) } open var gravityScale: Double get() { val mb = getMethodBind("PhysicalBone","get_gravity_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicalBone","set_gravity_scale") _icall_Unit_Double(mb, this.ptr, value) } open var jointOffset: Transform get() { val mb = getMethodBind("PhysicalBone","get_joint_offset") return _icall_Transform(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicalBone","set_joint_offset") _icall_Unit_Transform(mb, this.ptr, value) } open var jointType: Long get() { val mb = getMethodBind("PhysicalBone","get_joint_type") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicalBone","set_joint_type") _icall_Unit_Long(mb, this.ptr, value) } open var mass: Double get() { val mb = getMethodBind("PhysicalBone","get_mass") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicalBone","set_mass") _icall_Unit_Double(mb, this.ptr, value) } open var weight: Double get() { val mb = getMethodBind("PhysicalBone","get_weight") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicalBone","set_weight") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PhysicalBone", "PhysicalBone") open fun bodyOffset(schedule: Transform.() -> Unit): Transform = bodyOffset.apply{ schedule(this) bodyOffset = this } open fun jointOffset(schedule: Transform.() -> Unit): Transform = jointOffset.apply{ schedule(this) jointOffset = this } open fun _directStateChanged(arg0: Object) { } open fun applyCentralImpulse(impulse: Vector3) { val mb = getMethodBind("PhysicalBone","apply_central_impulse") _icall_Unit_Vector3( mb, this.ptr, impulse) } open fun applyImpulse(position: Vector3, impulse: Vector3) { val mb = getMethodBind("PhysicalBone","apply_impulse") _icall_Unit_Vector3_Vector3( mb, this.ptr, position, impulse) } open fun getBodyOffset(): Transform { val mb = getMethodBind("PhysicalBone","get_body_offset") return _icall_Transform( mb, this.ptr) } open fun getBoneId(): Long { val mb = getMethodBind("PhysicalBone","get_bone_id") return _icall_Long( mb, this.ptr) } open fun getBounce(): Double { val mb = getMethodBind("PhysicalBone","get_bounce") return _icall_Double( mb, this.ptr) } open fun getFriction(): Double { val mb = getMethodBind("PhysicalBone","get_friction") return _icall_Double( mb, this.ptr) } open fun getGravityScale(): Double { val mb = getMethodBind("PhysicalBone","get_gravity_scale") return _icall_Double( mb, this.ptr) } open fun getJointOffset(): Transform { val mb = getMethodBind("PhysicalBone","get_joint_offset") return _icall_Transform( mb, this.ptr) } open fun getJointType(): PhysicalBone.JointType { val mb = getMethodBind("PhysicalBone","get_joint_type") return PhysicalBone.JointType.from( _icall_Long( mb, this.ptr)) } open fun getMass(): Double { val mb = getMethodBind("PhysicalBone","get_mass") return _icall_Double( mb, this.ptr) } open fun getSimulatePhysics(): Boolean { val mb = getMethodBind("PhysicalBone","get_simulate_physics") return _icall_Boolean( mb, this.ptr) } open fun getWeight(): Double { val mb = getMethodBind("PhysicalBone","get_weight") return _icall_Double( mb, this.ptr) } open fun isSimulatingPhysics(): Boolean { val mb = getMethodBind("PhysicalBone","is_simulating_physics") return _icall_Boolean( mb, this.ptr) } open fun isStaticBody(): Boolean { val mb = getMethodBind("PhysicalBone","is_static_body") return _icall_Boolean( mb, this.ptr) } open fun setBodyOffset(offset: Transform) { val mb = getMethodBind("PhysicalBone","set_body_offset") _icall_Unit_Transform( mb, this.ptr, offset) } open fun setBounce(bounce: Double) { val mb = getMethodBind("PhysicalBone","set_bounce") _icall_Unit_Double( mb, this.ptr, bounce) } open fun setFriction(friction: Double) { val mb = getMethodBind("PhysicalBone","set_friction") _icall_Unit_Double( mb, this.ptr, friction) } open fun setGravityScale(gravityScale: Double) { val mb = getMethodBind("PhysicalBone","set_gravity_scale") _icall_Unit_Double( mb, this.ptr, gravityScale) } open fun setJointOffset(offset: Transform) { val mb = getMethodBind("PhysicalBone","set_joint_offset") _icall_Unit_Transform( mb, this.ptr, offset) } open fun setJointType(jointType: Long) { val mb = getMethodBind("PhysicalBone","set_joint_type") _icall_Unit_Long( mb, this.ptr, jointType) } open fun setMass(mass: Double) { val mb = getMethodBind("PhysicalBone","set_mass") _icall_Unit_Double( mb, this.ptr, mass) } open fun setWeight(weight: Double) { val mb = getMethodBind("PhysicalBone","set_weight") _icall_Unit_Double( mb, this.ptr, weight) } enum class JointType( id: Long ) { JOINT_TYPE_NONE(0), JOINT_TYPE_PIN(1), JOINT_TYPE_CONE(2), JOINT_TYPE_HINGE(3), JOINT_TYPE_SLIDER(4), JOINT_TYPE_6DOF(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Physics2DDirectBodyState.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Transform2D import godot.core.Variant import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Object_Long import godot.icalls._icall_Physics2DDirectSpaceState import godot.icalls._icall_RID_Long import godot.icalls._icall_Transform2D import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Transform2D import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Unit_Vector2_Vector2 import godot.icalls._icall_Variant_Long import godot.icalls._icall_Vector2 import godot.icalls._icall_Vector2_Long import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit open class Physics2DDirectBodyState internal constructor() : Object() { open var angularVelocity: Double get() { val mb = getMethodBind("Physics2DDirectBodyState","get_angular_velocity") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DDirectBodyState","set_angular_velocity") _icall_Unit_Double(mb, this.ptr, value) } open val inverseInertia: Double get() { val mb = getMethodBind("Physics2DDirectBodyState","get_inverse_inertia") return _icall_Double(mb, this.ptr) } open val inverseMass: Double get() { val mb = getMethodBind("Physics2DDirectBodyState","get_inverse_mass") return _icall_Double(mb, this.ptr) } open var linearVelocity: Vector2 get() { val mb = getMethodBind("Physics2DDirectBodyState","get_linear_velocity") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DDirectBodyState","set_linear_velocity") _icall_Unit_Vector2(mb, this.ptr, value) } open var sleeping: Boolean get() { val mb = getMethodBind("Physics2DDirectBodyState","is_sleeping") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DDirectBodyState","set_sleep_state") _icall_Unit_Boolean(mb, this.ptr, value) } open val step: Double get() { val mb = getMethodBind("Physics2DDirectBodyState","get_step") return _icall_Double(mb, this.ptr) } open val totalAngularDamp: Double get() { val mb = getMethodBind("Physics2DDirectBodyState","get_total_angular_damp") return _icall_Double(mb, this.ptr) } open val totalGravity: Vector2 get() { val mb = getMethodBind("Physics2DDirectBodyState","get_total_gravity") return _icall_Vector2(mb, this.ptr) } open val totalLinearDamp: Double get() { val mb = getMethodBind("Physics2DDirectBodyState","get_total_linear_damp") return _icall_Double(mb, this.ptr) } open var transform: Transform2D get() { val mb = getMethodBind("Physics2DDirectBodyState","get_transform") return _icall_Transform2D(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DDirectBodyState","set_transform") _icall_Unit_Transform2D(mb, this.ptr, value) } open fun linearVelocity(schedule: Vector2.() -> Unit): Vector2 = linearVelocity.apply{ schedule(this) linearVelocity = this } open fun transform(schedule: Transform2D.() -> Unit): Transform2D = transform.apply{ schedule(this) transform = this } open fun addCentralForce(force: Vector2) { val mb = getMethodBind("Physics2DDirectBodyState","add_central_force") _icall_Unit_Vector2( mb, this.ptr, force) } open fun addForce(offset: Vector2, force: Vector2) { val mb = getMethodBind("Physics2DDirectBodyState","add_force") _icall_Unit_Vector2_Vector2( mb, this.ptr, offset, force) } open fun addTorque(torque: Double) { val mb = getMethodBind("Physics2DDirectBodyState","add_torque") _icall_Unit_Double( mb, this.ptr, torque) } open fun applyCentralImpulse(impulse: Vector2) { val mb = getMethodBind("Physics2DDirectBodyState","apply_central_impulse") _icall_Unit_Vector2( mb, this.ptr, impulse) } open fun applyImpulse(offset: Vector2, impulse: Vector2) { val mb = getMethodBind("Physics2DDirectBodyState","apply_impulse") _icall_Unit_Vector2_Vector2( mb, this.ptr, offset, impulse) } open fun applyTorqueImpulse(impulse: Double) { val mb = getMethodBind("Physics2DDirectBodyState","apply_torque_impulse") _icall_Unit_Double( mb, this.ptr, impulse) } open fun getAngularVelocity(): Double { val mb = getMethodBind("Physics2DDirectBodyState","get_angular_velocity") return _icall_Double( mb, this.ptr) } open fun getContactCollider(contactIdx: Long): RID { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_collider") return _icall_RID_Long( mb, this.ptr, contactIdx) } open fun getContactColliderId(contactIdx: Long): Long { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_collider_id") return _icall_Long_Long( mb, this.ptr, contactIdx) } open fun getContactColliderObject(contactIdx: Long): Object { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_collider_object") return _icall_Object_Long( mb, this.ptr, contactIdx) } open fun getContactColliderPosition(contactIdx: Long): Vector2 { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_collider_position") return _icall_Vector2_Long( mb, this.ptr, contactIdx) } open fun getContactColliderShape(contactIdx: Long): Long { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_collider_shape") return _icall_Long_Long( mb, this.ptr, contactIdx) } open fun getContactColliderShapeMetadata(contactIdx: Long): Variant { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_collider_shape_metadata") return _icall_Variant_Long( mb, this.ptr, contactIdx) } open fun getContactColliderVelocityAtPosition(contactIdx: Long): Vector2 { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_collider_velocity_at_position") return _icall_Vector2_Long( mb, this.ptr, contactIdx) } open fun getContactCount(): Long { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_count") return _icall_Long( mb, this.ptr) } open fun getContactLocalNormal(contactIdx: Long): Vector2 { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_local_normal") return _icall_Vector2_Long( mb, this.ptr, contactIdx) } open fun getContactLocalPosition(contactIdx: Long): Vector2 { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_local_position") return _icall_Vector2_Long( mb, this.ptr, contactIdx) } open fun getContactLocalShape(contactIdx: Long): Long { val mb = getMethodBind("Physics2DDirectBodyState","get_contact_local_shape") return _icall_Long_Long( mb, this.ptr, contactIdx) } open fun getInverseInertia(): Double { val mb = getMethodBind("Physics2DDirectBodyState","get_inverse_inertia") return _icall_Double( mb, this.ptr) } open fun getInverseMass(): Double { val mb = getMethodBind("Physics2DDirectBodyState","get_inverse_mass") return _icall_Double( mb, this.ptr) } open fun getLinearVelocity(): Vector2 { val mb = getMethodBind("Physics2DDirectBodyState","get_linear_velocity") return _icall_Vector2( mb, this.ptr) } open fun getSpaceState(): Physics2DDirectSpaceState { val mb = getMethodBind("Physics2DDirectBodyState","get_space_state") return _icall_Physics2DDirectSpaceState( mb, this.ptr) } open fun getStep(): Double { val mb = getMethodBind("Physics2DDirectBodyState","get_step") return _icall_Double( mb, this.ptr) } open fun getTotalAngularDamp(): Double { val mb = getMethodBind("Physics2DDirectBodyState","get_total_angular_damp") return _icall_Double( mb, this.ptr) } open fun getTotalGravity(): Vector2 { val mb = getMethodBind("Physics2DDirectBodyState","get_total_gravity") return _icall_Vector2( mb, this.ptr) } open fun getTotalLinearDamp(): Double { val mb = getMethodBind("Physics2DDirectBodyState","get_total_linear_damp") return _icall_Double( mb, this.ptr) } open fun getTransform(): Transform2D { val mb = getMethodBind("Physics2DDirectBodyState","get_transform") return _icall_Transform2D( mb, this.ptr) } open fun integrateForces() { val mb = getMethodBind("Physics2DDirectBodyState","integrate_forces") _icall_Unit( mb, this.ptr) } open fun isSleeping(): Boolean { val mb = getMethodBind("Physics2DDirectBodyState","is_sleeping") return _icall_Boolean( mb, this.ptr) } open fun setAngularVelocity(velocity: Double) { val mb = getMethodBind("Physics2DDirectBodyState","set_angular_velocity") _icall_Unit_Double( mb, this.ptr, velocity) } open fun setLinearVelocity(velocity: Vector2) { val mb = getMethodBind("Physics2DDirectBodyState","set_linear_velocity") _icall_Unit_Vector2( mb, this.ptr, velocity) } open fun setSleepState(enabled: Boolean) { val mb = getMethodBind("Physics2DDirectBodyState","set_sleep_state") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setTransform(transform: Transform2D) { val mb = getMethodBind("Physics2DDirectBodyState","set_transform") _icall_Unit_Transform2D( mb, this.ptr, transform) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Physics2DDirectBodyStateSW.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class Physics2DDirectBodyStateSW internal constructor() : Physics2DDirectBodyState() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Physics2DDirectSpaceState.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.VariantArray import godot.core.Vector2 import godot.icalls._icall_Dictionary_Object import godot.icalls._icall_Dictionary_Vector2_Vector2_VariantArray_Long_Boolean_Boolean import godot.icalls._icall_VariantArray_Object import godot.icalls._icall_VariantArray_Object_Long import godot.icalls._icall_VariantArray_Vector2_Long_Long_VariantArray_Long_Boolean_Boolean import godot.icalls._icall_VariantArray_Vector2_Long_VariantArray_Long_Boolean_Boolean import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long open class Physics2DDirectSpaceState internal constructor() : Object() { open fun castMotion(shape: Physics2DShapeQueryParameters): VariantArray { val mb = getMethodBind("Physics2DDirectSpaceState","cast_motion") return _icall_VariantArray_Object( mb, this.ptr, shape) } open fun collideShape(shape: Physics2DShapeQueryParameters, maxResults: Long = 32): VariantArray { val mb = getMethodBind("Physics2DDirectSpaceState","collide_shape") return _icall_VariantArray_Object_Long( mb, this.ptr, shape, maxResults) } open fun getRestInfo(shape: Physics2DShapeQueryParameters): Dictionary { val mb = getMethodBind("Physics2DDirectSpaceState","get_rest_info") return _icall_Dictionary_Object( mb, this.ptr, shape) } open fun intersectPoint( point: Vector2, maxResults: Long = 32, exclude: VariantArray = VariantArray(), collisionLayer: Long = 2147483647, collideWithBodies: Boolean = true, collideWithAreas: Boolean = false ): VariantArray { val mb = getMethodBind("Physics2DDirectSpaceState","intersect_point") return _icall_VariantArray_Vector2_Long_VariantArray_Long_Boolean_Boolean( mb, this.ptr, point, maxResults, exclude, collisionLayer, collideWithBodies, collideWithAreas) } open fun intersectPointOnCanvas( point: Vector2, canvasInstanceId: Long, maxResults: Long = 32, exclude: VariantArray = VariantArray(), collisionLayer: Long = 2147483647, collideWithBodies: Boolean = true, collideWithAreas: Boolean = false ): VariantArray { val mb = getMethodBind("Physics2DDirectSpaceState","intersect_point_on_canvas") return _icall_VariantArray_Vector2_Long_Long_VariantArray_Long_Boolean_Boolean( mb, this.ptr, point, canvasInstanceId, maxResults, exclude, collisionLayer, collideWithBodies, collideWithAreas) } open fun intersectRay( from: Vector2, to: Vector2, exclude: VariantArray = VariantArray(), collisionLayer: Long = 2147483647, collideWithBodies: Boolean = true, collideWithAreas: Boolean = false ): Dictionary { val mb = getMethodBind("Physics2DDirectSpaceState","intersect_ray") return _icall_Dictionary_Vector2_Vector2_VariantArray_Long_Boolean_Boolean( mb, this.ptr, from, to, exclude, collisionLayer, collideWithBodies, collideWithAreas) } open fun intersectShape(shape: Physics2DShapeQueryParameters, maxResults: Long = 32): VariantArray { val mb = getMethodBind("Physics2DDirectSpaceState","intersect_shape") return _icall_VariantArray_Object_Long( mb, this.ptr, shape, maxResults) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Physics2DServer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.Physics2DServer import godot.core.Godot import godot.core.RID import godot.core.Transform2D import godot.core.Variant import godot.core.Vector2 import godot.icalls._icall_Boolean_RID import godot.icalls._icall_Boolean_RID_Transform2D_Vector2_Boolean_Double_nObject import godot.icalls._icall_Double_RID_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_RID import godot.icalls._icall_Physics2DDirectBodyState_RID import godot.icalls._icall_Physics2DDirectSpaceState_RID import godot.icalls._icall_RID import godot.icalls._icall_RID_RID import godot.icalls._icall_RID_RID_Long import godot.icalls._icall_RID_Vector2_RID_RID import godot.icalls._icall_RID_Vector2_Vector2_RID_RID import godot.icalls._icall_RID_Vector2_Vector2_Vector2_RID_RID import godot.icalls._icall_Transform2D_RID import godot.icalls._icall_Transform2D_RID_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_RID import godot.icalls._icall_Unit_RID_Boolean import godot.icalls._icall_Unit_RID_Double import godot.icalls._icall_Unit_RID_Long import godot.icalls._icall_Unit_RID_Long_Boolean import godot.icalls._icall_Unit_RID_Long_Boolean_Double import godot.icalls._icall_Unit_RID_Long_Double import godot.icalls._icall_Unit_RID_Long_RID import godot.icalls._icall_Unit_RID_Long_Transform2D import godot.icalls._icall_Unit_RID_Long_Variant import godot.icalls._icall_Unit_RID_Object_String import godot.icalls._icall_Unit_RID_Object_String_nVariant import godot.icalls._icall_Unit_RID_RID import godot.icalls._icall_Unit_RID_RID_Transform2D_Boolean import godot.icalls._icall_Unit_RID_Transform2D import godot.icalls._icall_Unit_RID_Variant import godot.icalls._icall_Unit_RID_Vector2 import godot.icalls._icall_Unit_RID_Vector2_Vector2 import godot.icalls._icall_Variant_RID import godot.icalls._icall_Variant_RID_Long import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object Physics2DServer : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("Physics2DServer".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton Physics2DServer" } ptr } fun areaAddShape( area: RID, shape: RID, transform: Transform2D = Transform2D(), disabled: Boolean = false ) { val mb = getMethodBind("Physics2DServer","area_add_shape") _icall_Unit_RID_RID_Transform2D_Boolean( mb, this.ptr, area, shape, transform, disabled) } fun areaAttachCanvasInstanceId(area: RID, id: Long) { val mb = getMethodBind("Physics2DServer","area_attach_canvas_instance_id") _icall_Unit_RID_Long( mb, this.ptr, area, id) } fun areaAttachObjectInstanceId(area: RID, id: Long) { val mb = getMethodBind("Physics2DServer","area_attach_object_instance_id") _icall_Unit_RID_Long( mb, this.ptr, area, id) } fun areaClearShapes(area: RID) { val mb = getMethodBind("Physics2DServer","area_clear_shapes") _icall_Unit_RID( mb, this.ptr, area) } fun areaCreate(): RID { val mb = getMethodBind("Physics2DServer","area_create") return _icall_RID( mb, this.ptr) } fun areaGetCanvasInstanceId(area: RID): Long { val mb = getMethodBind("Physics2DServer","area_get_canvas_instance_id") return _icall_Long_RID( mb, this.ptr, area) } fun areaGetObjectInstanceId(area: RID): Long { val mb = getMethodBind("Physics2DServer","area_get_object_instance_id") return _icall_Long_RID( mb, this.ptr, area) } fun areaGetParam(area: RID, param: Long): Variant { val mb = getMethodBind("Physics2DServer","area_get_param") return _icall_Variant_RID_Long( mb, this.ptr, area, param) } fun areaGetShape(area: RID, shapeIdx: Long): RID { val mb = getMethodBind("Physics2DServer","area_get_shape") return _icall_RID_RID_Long( mb, this.ptr, area, shapeIdx) } fun areaGetShapeCount(area: RID): Long { val mb = getMethodBind("Physics2DServer","area_get_shape_count") return _icall_Long_RID( mb, this.ptr, area) } fun areaGetShapeTransform(area: RID, shapeIdx: Long): Transform2D { val mb = getMethodBind("Physics2DServer","area_get_shape_transform") return _icall_Transform2D_RID_Long( mb, this.ptr, area, shapeIdx) } fun areaGetSpace(area: RID): RID { val mb = getMethodBind("Physics2DServer","area_get_space") return _icall_RID_RID( mb, this.ptr, area) } fun areaGetSpaceOverrideMode(area: RID): Physics2DServer.AreaSpaceOverrideMode { val mb = getMethodBind("Physics2DServer","area_get_space_override_mode") return Physics2DServer.AreaSpaceOverrideMode.from( _icall_Long_RID( mb, this.ptr, area)) } fun areaGetTransform(area: RID): Transform2D { val mb = getMethodBind("Physics2DServer","area_get_transform") return _icall_Transform2D_RID( mb, this.ptr, area) } fun areaRemoveShape(area: RID, shapeIdx: Long) { val mb = getMethodBind("Physics2DServer","area_remove_shape") _icall_Unit_RID_Long( mb, this.ptr, area, shapeIdx) } fun areaSetAreaMonitorCallback( area: RID, receiver: Object, method: String ) { val mb = getMethodBind("Physics2DServer","area_set_area_monitor_callback") _icall_Unit_RID_Object_String( mb, this.ptr, area, receiver, method) } fun areaSetCollisionLayer(area: RID, layer: Long) { val mb = getMethodBind("Physics2DServer","area_set_collision_layer") _icall_Unit_RID_Long( mb, this.ptr, area, layer) } fun areaSetCollisionMask(area: RID, mask: Long) { val mb = getMethodBind("Physics2DServer","area_set_collision_mask") _icall_Unit_RID_Long( mb, this.ptr, area, mask) } fun areaSetMonitorCallback( area: RID, receiver: Object, method: String ) { val mb = getMethodBind("Physics2DServer","area_set_monitor_callback") _icall_Unit_RID_Object_String( mb, this.ptr, area, receiver, method) } fun areaSetMonitorable(area: RID, monitorable: Boolean) { val mb = getMethodBind("Physics2DServer","area_set_monitorable") _icall_Unit_RID_Boolean( mb, this.ptr, area, monitorable) } fun areaSetParam( area: RID, param: Long, value: Variant ) { val mb = getMethodBind("Physics2DServer","area_set_param") _icall_Unit_RID_Long_Variant( mb, this.ptr, area, param, value) } fun areaSetShape( area: RID, shapeIdx: Long, shape: RID ) { val mb = getMethodBind("Physics2DServer","area_set_shape") _icall_Unit_RID_Long_RID( mb, this.ptr, area, shapeIdx, shape) } fun areaSetShapeDisabled( area: RID, shapeIdx: Long, disabled: Boolean ) { val mb = getMethodBind("Physics2DServer","area_set_shape_disabled") _icall_Unit_RID_Long_Boolean( mb, this.ptr, area, shapeIdx, disabled) } fun areaSetShapeTransform( area: RID, shapeIdx: Long, transform: Transform2D ) { val mb = getMethodBind("Physics2DServer","area_set_shape_transform") _icall_Unit_RID_Long_Transform2D( mb, this.ptr, area, shapeIdx, transform) } fun areaSetSpace(area: RID, space: RID) { val mb = getMethodBind("Physics2DServer","area_set_space") _icall_Unit_RID_RID( mb, this.ptr, area, space) } fun areaSetSpaceOverrideMode(area: RID, mode: Long) { val mb = getMethodBind("Physics2DServer","area_set_space_override_mode") _icall_Unit_RID_Long( mb, this.ptr, area, mode) } fun areaSetTransform(area: RID, transform: Transform2D) { val mb = getMethodBind("Physics2DServer","area_set_transform") _icall_Unit_RID_Transform2D( mb, this.ptr, area, transform) } fun bodyAddCentralForce(body: RID, force: Vector2) { val mb = getMethodBind("Physics2DServer","body_add_central_force") _icall_Unit_RID_Vector2( mb, this.ptr, body, force) } fun bodyAddCollisionException(body: RID, exceptedBody: RID) { val mb = getMethodBind("Physics2DServer","body_add_collision_exception") _icall_Unit_RID_RID( mb, this.ptr, body, exceptedBody) } fun bodyAddForce( body: RID, offset: Vector2, force: Vector2 ) { val mb = getMethodBind("Physics2DServer","body_add_force") _icall_Unit_RID_Vector2_Vector2( mb, this.ptr, body, offset, force) } fun bodyAddShape( body: RID, shape: RID, transform: Transform2D = Transform2D(), disabled: Boolean = false ) { val mb = getMethodBind("Physics2DServer","body_add_shape") _icall_Unit_RID_RID_Transform2D_Boolean( mb, this.ptr, body, shape, transform, disabled) } fun bodyAddTorque(body: RID, torque: Double) { val mb = getMethodBind("Physics2DServer","body_add_torque") _icall_Unit_RID_Double( mb, this.ptr, body, torque) } fun bodyApplyCentralImpulse(body: RID, impulse: Vector2) { val mb = getMethodBind("Physics2DServer","body_apply_central_impulse") _icall_Unit_RID_Vector2( mb, this.ptr, body, impulse) } fun bodyApplyImpulse( body: RID, position: Vector2, impulse: Vector2 ) { val mb = getMethodBind("Physics2DServer","body_apply_impulse") _icall_Unit_RID_Vector2_Vector2( mb, this.ptr, body, position, impulse) } fun bodyApplyTorqueImpulse(body: RID, impulse: Double) { val mb = getMethodBind("Physics2DServer","body_apply_torque_impulse") _icall_Unit_RID_Double( mb, this.ptr, body, impulse) } fun bodyAttachCanvasInstanceId(body: RID, id: Long) { val mb = getMethodBind("Physics2DServer","body_attach_canvas_instance_id") _icall_Unit_RID_Long( mb, this.ptr, body, id) } fun bodyAttachObjectInstanceId(body: RID, id: Long) { val mb = getMethodBind("Physics2DServer","body_attach_object_instance_id") _icall_Unit_RID_Long( mb, this.ptr, body, id) } fun bodyClearShapes(body: RID) { val mb = getMethodBind("Physics2DServer","body_clear_shapes") _icall_Unit_RID( mb, this.ptr, body) } fun bodyCreate(): RID { val mb = getMethodBind("Physics2DServer","body_create") return _icall_RID( mb, this.ptr) } fun bodyGetCanvasInstanceId(body: RID): Long { val mb = getMethodBind("Physics2DServer","body_get_canvas_instance_id") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetCollisionLayer(body: RID): Long { val mb = getMethodBind("Physics2DServer","body_get_collision_layer") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetCollisionMask(body: RID): Long { val mb = getMethodBind("Physics2DServer","body_get_collision_mask") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetContinuousCollisionDetectionMode(body: RID): Physics2DServer.CCDMode { val mb = getMethodBind("Physics2DServer","body_get_continuous_collision_detection_mode") return Physics2DServer.CCDMode.from( _icall_Long_RID( mb, this.ptr, body)) } fun bodyGetDirectState(body: RID): Physics2DDirectBodyState { val mb = getMethodBind("Physics2DServer","body_get_direct_state") return _icall_Physics2DDirectBodyState_RID( mb, this.ptr, body) } fun bodyGetMaxContactsReported(body: RID): Long { val mb = getMethodBind("Physics2DServer","body_get_max_contacts_reported") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetMode(body: RID): Physics2DServer.BodyMode { val mb = getMethodBind("Physics2DServer","body_get_mode") return Physics2DServer.BodyMode.from( _icall_Long_RID( mb, this.ptr, body)) } fun bodyGetObjectInstanceId(body: RID): Long { val mb = getMethodBind("Physics2DServer","body_get_object_instance_id") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetParam(body: RID, param: Long): Double { val mb = getMethodBind("Physics2DServer","body_get_param") return _icall_Double_RID_Long( mb, this.ptr, body, param) } fun bodyGetShape(body: RID, shapeIdx: Long): RID { val mb = getMethodBind("Physics2DServer","body_get_shape") return _icall_RID_RID_Long( mb, this.ptr, body, shapeIdx) } fun bodyGetShapeCount(body: RID): Long { val mb = getMethodBind("Physics2DServer","body_get_shape_count") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetShapeMetadata(body: RID, shapeIdx: Long): Variant { val mb = getMethodBind("Physics2DServer","body_get_shape_metadata") return _icall_Variant_RID_Long( mb, this.ptr, body, shapeIdx) } fun bodyGetShapeTransform(body: RID, shapeIdx: Long): Transform2D { val mb = getMethodBind("Physics2DServer","body_get_shape_transform") return _icall_Transform2D_RID_Long( mb, this.ptr, body, shapeIdx) } fun bodyGetSpace(body: RID): RID { val mb = getMethodBind("Physics2DServer","body_get_space") return _icall_RID_RID( mb, this.ptr, body) } fun bodyGetState(body: RID, state: Long): Variant { val mb = getMethodBind("Physics2DServer","body_get_state") return _icall_Variant_RID_Long( mb, this.ptr, body, state) } fun bodyIsOmittingForceIntegration(body: RID): Boolean { val mb = getMethodBind("Physics2DServer","body_is_omitting_force_integration") return _icall_Boolean_RID( mb, this.ptr, body) } fun bodyRemoveCollisionException(body: RID, exceptedBody: RID) { val mb = getMethodBind("Physics2DServer","body_remove_collision_exception") _icall_Unit_RID_RID( mb, this.ptr, body, exceptedBody) } fun bodyRemoveShape(body: RID, shapeIdx: Long) { val mb = getMethodBind("Physics2DServer","body_remove_shape") _icall_Unit_RID_Long( mb, this.ptr, body, shapeIdx) } fun bodySetAxisVelocity(body: RID, axisVelocity: Vector2) { val mb = getMethodBind("Physics2DServer","body_set_axis_velocity") _icall_Unit_RID_Vector2( mb, this.ptr, body, axisVelocity) } fun bodySetCollisionLayer(body: RID, layer: Long) { val mb = getMethodBind("Physics2DServer","body_set_collision_layer") _icall_Unit_RID_Long( mb, this.ptr, body, layer) } fun bodySetCollisionMask(body: RID, mask: Long) { val mb = getMethodBind("Physics2DServer","body_set_collision_mask") _icall_Unit_RID_Long( mb, this.ptr, body, mask) } fun bodySetContinuousCollisionDetectionMode(body: RID, mode: Long) { val mb = getMethodBind("Physics2DServer","body_set_continuous_collision_detection_mode") _icall_Unit_RID_Long( mb, this.ptr, body, mode) } fun bodySetForceIntegrationCallback( body: RID, receiver: Object, method: String, userdata: Variant? = null ) { val mb = getMethodBind("Physics2DServer","body_set_force_integration_callback") _icall_Unit_RID_Object_String_nVariant( mb, this.ptr, body, receiver, method, userdata) } fun bodySetMaxContactsReported(body: RID, amount: Long) { val mb = getMethodBind("Physics2DServer","body_set_max_contacts_reported") _icall_Unit_RID_Long( mb, this.ptr, body, amount) } fun bodySetMode(body: RID, mode: Long) { val mb = getMethodBind("Physics2DServer","body_set_mode") _icall_Unit_RID_Long( mb, this.ptr, body, mode) } fun bodySetOmitForceIntegration(body: RID, enable: Boolean) { val mb = getMethodBind("Physics2DServer","body_set_omit_force_integration") _icall_Unit_RID_Boolean( mb, this.ptr, body, enable) } fun bodySetParam( body: RID, param: Long, value: Double ) { val mb = getMethodBind("Physics2DServer","body_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, body, param, value) } fun bodySetShape( body: RID, shapeIdx: Long, shape: RID ) { val mb = getMethodBind("Physics2DServer","body_set_shape") _icall_Unit_RID_Long_RID( mb, this.ptr, body, shapeIdx, shape) } fun bodySetShapeAsOneWayCollision( body: RID, shapeIdx: Long, enable: Boolean, margin: Double ) { val mb = getMethodBind("Physics2DServer","body_set_shape_as_one_way_collision") _icall_Unit_RID_Long_Boolean_Double( mb, this.ptr, body, shapeIdx, enable, margin) } fun bodySetShapeDisabled( body: RID, shapeIdx: Long, disabled: Boolean ) { val mb = getMethodBind("Physics2DServer","body_set_shape_disabled") _icall_Unit_RID_Long_Boolean( mb, this.ptr, body, shapeIdx, disabled) } fun bodySetShapeMetadata( body: RID, shapeIdx: Long, metadata: Variant ) { val mb = getMethodBind("Physics2DServer","body_set_shape_metadata") _icall_Unit_RID_Long_Variant( mb, this.ptr, body, shapeIdx, metadata) } fun bodySetShapeTransform( body: RID, shapeIdx: Long, transform: Transform2D ) { val mb = getMethodBind("Physics2DServer","body_set_shape_transform") _icall_Unit_RID_Long_Transform2D( mb, this.ptr, body, shapeIdx, transform) } fun bodySetSpace(body: RID, space: RID) { val mb = getMethodBind("Physics2DServer","body_set_space") _icall_Unit_RID_RID( mb, this.ptr, body, space) } fun bodySetState( body: RID, state: Long, value: Variant ) { val mb = getMethodBind("Physics2DServer","body_set_state") _icall_Unit_RID_Long_Variant( mb, this.ptr, body, state, value) } fun bodyTestMotion( body: RID, from: Transform2D, motion: Vector2, infiniteInertia: Boolean, margin: Double = 0.08, result: Physics2DTestMotionResult? = null ): Boolean { val mb = getMethodBind("Physics2DServer","body_test_motion") return _icall_Boolean_RID_Transform2D_Vector2_Boolean_Double_nObject( mb, this.ptr, body, from, motion, infiniteInertia, margin, result) } fun capsuleShapeCreate(): RID { val mb = getMethodBind("Physics2DServer","capsule_shape_create") return _icall_RID( mb, this.ptr) } fun circleShapeCreate(): RID { val mb = getMethodBind("Physics2DServer","circle_shape_create") return _icall_RID( mb, this.ptr) } fun concavePolygonShapeCreate(): RID { val mb = getMethodBind("Physics2DServer","concave_polygon_shape_create") return _icall_RID( mb, this.ptr) } fun convexPolygonShapeCreate(): RID { val mb = getMethodBind("Physics2DServer","convex_polygon_shape_create") return _icall_RID( mb, this.ptr) } fun dampedSpringJointCreate( anchorA: Vector2, anchorB: Vector2, bodyA: RID, bodyB: RID = RID() ): RID { val mb = getMethodBind("Physics2DServer","damped_spring_joint_create") return _icall_RID_Vector2_Vector2_RID_RID( mb, this.ptr, anchorA, anchorB, bodyA, bodyB) } fun dampedStringJointGetParam(joint: RID, param: Long): Double { val mb = getMethodBind("Physics2DServer","damped_string_joint_get_param") return _icall_Double_RID_Long( mb, this.ptr, joint, param) } fun dampedStringJointSetParam( joint: RID, param: Long, value: Double ) { val mb = getMethodBind("Physics2DServer","damped_string_joint_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, joint, param, value) } fun freeRid(rid: RID) { val mb = getMethodBind("Physics2DServer","free_rid") _icall_Unit_RID( mb, this.ptr, rid) } fun getProcessInfo(processInfo: Long): Long { val mb = getMethodBind("Physics2DServer","get_process_info") return _icall_Long_Long( mb, this.ptr, processInfo) } fun grooveJointCreate( groove1A: Vector2, groove2A: Vector2, anchorB: Vector2, bodyA: RID = RID(), bodyB: RID = RID() ): RID { val mb = getMethodBind("Physics2DServer","groove_joint_create") return _icall_RID_Vector2_Vector2_Vector2_RID_RID( mb, this.ptr, groove1A, groove2A, anchorB, bodyA, bodyB) } fun jointGetParam(joint: RID, param: Long): Double { val mb = getMethodBind("Physics2DServer","joint_get_param") return _icall_Double_RID_Long( mb, this.ptr, joint, param) } fun jointGetType(joint: RID): Physics2DServer.JointType { val mb = getMethodBind("Physics2DServer","joint_get_type") return Physics2DServer.JointType.from( _icall_Long_RID( mb, this.ptr, joint)) } fun jointSetParam( joint: RID, param: Long, value: Double ) { val mb = getMethodBind("Physics2DServer","joint_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, joint, param, value) } fun lineShapeCreate(): RID { val mb = getMethodBind("Physics2DServer","line_shape_create") return _icall_RID( mb, this.ptr) } fun pinJointCreate( anchor: Vector2, bodyA: RID, bodyB: RID = RID() ): RID { val mb = getMethodBind("Physics2DServer","pin_joint_create") return _icall_RID_Vector2_RID_RID( mb, this.ptr, anchor, bodyA, bodyB) } fun rayShapeCreate(): RID { val mb = getMethodBind("Physics2DServer","ray_shape_create") return _icall_RID( mb, this.ptr) } fun rectangleShapeCreate(): RID { val mb = getMethodBind("Physics2DServer","rectangle_shape_create") return _icall_RID( mb, this.ptr) } fun segmentShapeCreate(): RID { val mb = getMethodBind("Physics2DServer","segment_shape_create") return _icall_RID( mb, this.ptr) } fun setActive(active: Boolean) { val mb = getMethodBind("Physics2DServer","set_active") _icall_Unit_Boolean( mb, this.ptr, active) } fun shapeGetData(shape: RID): Variant { val mb = getMethodBind("Physics2DServer","shape_get_data") return _icall_Variant_RID( mb, this.ptr, shape) } fun shapeGetType(shape: RID): Physics2DServer.ShapeType { val mb = getMethodBind("Physics2DServer","shape_get_type") return Physics2DServer.ShapeType.from( _icall_Long_RID( mb, this.ptr, shape)) } fun shapeSetData(shape: RID, data: Variant) { val mb = getMethodBind("Physics2DServer","shape_set_data") _icall_Unit_RID_Variant( mb, this.ptr, shape, data) } fun spaceCreate(): RID { val mb = getMethodBind("Physics2DServer","space_create") return _icall_RID( mb, this.ptr) } fun spaceGetDirectState(space: RID): Physics2DDirectSpaceState { val mb = getMethodBind("Physics2DServer","space_get_direct_state") return _icall_Physics2DDirectSpaceState_RID( mb, this.ptr, space) } fun spaceGetParam(space: RID, param: Long): Double { val mb = getMethodBind("Physics2DServer","space_get_param") return _icall_Double_RID_Long( mb, this.ptr, space, param) } fun spaceIsActive(space: RID): Boolean { val mb = getMethodBind("Physics2DServer","space_is_active") return _icall_Boolean_RID( mb, this.ptr, space) } fun spaceSetActive(space: RID, active: Boolean) { val mb = getMethodBind("Physics2DServer","space_set_active") _icall_Unit_RID_Boolean( mb, this.ptr, space, active) } fun spaceSetParam( space: RID, param: Long, value: Double ) { val mb = getMethodBind("Physics2DServer","space_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, space, param, value) } enum class ProcessInfo( id: Long ) { INFO_ACTIVE_OBJECTS(0), INFO_COLLISION_PAIRS(1), INFO_ISLAND_COUNT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class AreaBodyStatus( id: Long ) { AREA_BODY_ADDED(0), AREA_BODY_REMOVED(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class DampedStringParam( id: Long ) { DAMPED_STRING_REST_LENGTH(0), DAMPED_STRING_STIFFNESS(1), DAMPED_STRING_DAMPING(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BodyMode( id: Long ) { BODY_MODE_STATIC(0), BODY_MODE_KINEMATIC(1), BODY_MODE_RIGID(2), BODY_MODE_CHARACTER(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ShapeType( id: Long ) { SHAPE_LINE(0), SHAPE_RAY(1), SHAPE_SEGMENT(2), SHAPE_CIRCLE(3), SHAPE_RECTANGLE(4), SHAPE_CAPSULE(5), SHAPE_CONVEX_POLYGON(6), SHAPE_CONCAVE_POLYGON(7), SHAPE_CUSTOM(8); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class JointParam( id: Long ) { JOINT_PARAM_BIAS(0), JOINT_PARAM_MAX_BIAS(1), JOINT_PARAM_MAX_FORCE(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class SpaceParameter( id: Long ) { SPACE_PARAM_CONTACT_RECYCLE_RADIUS(0), SPACE_PARAM_CONTACT_MAX_SEPARATION(1), SPACE_PARAM_BODY_MAX_ALLOWED_PENETRATION(2), SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD(3), SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD(4), SPACE_PARAM_BODY_TIME_TO_SLEEP(5), SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS(6), SPACE_PARAM_TEST_MOTION_MIN_CONTACT_DEPTH(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class JointType( id: Long ) { JOINT_PIN(0), JOINT_GROOVE(1), JOINT_DAMPED_SPRING(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class CCDMode( id: Long ) { CCD_MODE_DISABLED(0), CCD_MODE_CAST_RAY(1), CCD_MODE_CAST_SHAPE(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BodyState( id: Long ) { BODY_STATE_TRANSFORM(0), BODY_STATE_LINEAR_VELOCITY(1), BODY_STATE_ANGULAR_VELOCITY(2), BODY_STATE_SLEEPING(3), BODY_STATE_CAN_SLEEP(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BodyParameter( id: Long ) { BODY_PARAM_BOUNCE(0), BODY_PARAM_FRICTION(1), BODY_PARAM_MASS(2), BODY_PARAM_INERTIA(3), BODY_PARAM_GRAVITY_SCALE(4), BODY_PARAM_LINEAR_DAMP(5), BODY_PARAM_ANGULAR_DAMP(6), BODY_PARAM_MAX(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class AreaSpaceOverrideMode( id: Long ) { AREA_SPACE_OVERRIDE_DISABLED(0), AREA_SPACE_OVERRIDE_COMBINE(1), AREA_SPACE_OVERRIDE_COMBINE_REPLACE(2), AREA_SPACE_OVERRIDE_REPLACE(3), AREA_SPACE_OVERRIDE_REPLACE_COMBINE(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class AreaParameter( id: Long ) { AREA_PARAM_GRAVITY(0), AREA_PARAM_GRAVITY_VECTOR(1), AREA_PARAM_GRAVITY_IS_POINT(2), AREA_PARAM_GRAVITY_DISTANCE_SCALE(3), AREA_PARAM_GRAVITY_POINT_ATTENUATION(4), AREA_PARAM_LINEAR_DAMP(5), AREA_PARAM_ANGULAR_DAMP(6), AREA_PARAM_PRIORITY(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Physics2DShapeQueryParameters.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Transform2D import godot.core.VariantArray import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_RID import godot.icalls._icall_Transform2D import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_RID import godot.icalls._icall_Unit_Transform2D import godot.icalls._icall_Unit_VariantArray import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Physics2DShapeQueryParameters : Reference() { open var collideWithAreas: Boolean get() { val mb = getMethodBind("Physics2DShapeQueryParameters","is_collide_with_areas_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_collide_with_areas") _icall_Unit_Boolean(mb, this.ptr, value) } open var collideWithBodies: Boolean get() { val mb = getMethodBind("Physics2DShapeQueryParameters","is_collide_with_bodies_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_collide_with_bodies") _icall_Unit_Boolean(mb, this.ptr, value) } open var collisionLayer: Long get() { val mb = getMethodBind("Physics2DShapeQueryParameters","get_collision_layer") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_collision_layer") _icall_Unit_Long(mb, this.ptr, value) } open var exclude: VariantArray get() { val mb = getMethodBind("Physics2DShapeQueryParameters","get_exclude") return _icall_VariantArray(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_exclude") _icall_Unit_VariantArray(mb, this.ptr, value) } open var margin: Double get() { val mb = getMethodBind("Physics2DShapeQueryParameters","get_margin") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_margin") _icall_Unit_Double(mb, this.ptr, value) } open var motion: Vector2 get() { val mb = getMethodBind("Physics2DShapeQueryParameters","get_motion") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_motion") _icall_Unit_Vector2(mb, this.ptr, value) } open var shapeRid: RID get() { val mb = getMethodBind("Physics2DShapeQueryParameters","get_shape_rid") return _icall_RID(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_shape_rid") _icall_Unit_RID(mb, this.ptr, value) } open var transform: Transform2D get() { val mb = getMethodBind("Physics2DShapeQueryParameters","get_transform") return _icall_Transform2D(mb, this.ptr) } set(value) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_transform") _icall_Unit_Transform2D(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Physics2DShapeQueryParameters", "Physics2DShapeQueryParameters") open fun motion(schedule: Vector2.() -> Unit): Vector2 = motion.apply{ schedule(this) motion = this } open fun transform(schedule: Transform2D.() -> Unit): Transform2D = transform.apply{ schedule(this) transform = this } open fun getCollisionLayer(): Long { val mb = getMethodBind("Physics2DShapeQueryParameters","get_collision_layer") return _icall_Long( mb, this.ptr) } open fun getExclude(): VariantArray { val mb = getMethodBind("Physics2DShapeQueryParameters","get_exclude") return _icall_VariantArray( mb, this.ptr) } open fun getMargin(): Double { val mb = getMethodBind("Physics2DShapeQueryParameters","get_margin") return _icall_Double( mb, this.ptr) } open fun getMotion(): Vector2 { val mb = getMethodBind("Physics2DShapeQueryParameters","get_motion") return _icall_Vector2( mb, this.ptr) } open fun getShapeRid(): RID { val mb = getMethodBind("Physics2DShapeQueryParameters","get_shape_rid") return _icall_RID( mb, this.ptr) } open fun getTransform(): Transform2D { val mb = getMethodBind("Physics2DShapeQueryParameters","get_transform") return _icall_Transform2D( mb, this.ptr) } open fun isCollideWithAreasEnabled(): Boolean { val mb = getMethodBind("Physics2DShapeQueryParameters","is_collide_with_areas_enabled") return _icall_Boolean( mb, this.ptr) } open fun isCollideWithBodiesEnabled(): Boolean { val mb = getMethodBind("Physics2DShapeQueryParameters","is_collide_with_bodies_enabled") return _icall_Boolean( mb, this.ptr) } open fun setCollideWithAreas(enable: Boolean) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_collide_with_areas") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollideWithBodies(enable: Boolean) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_collide_with_bodies") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollisionLayer(collisionLayer: Long) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_collision_layer") _icall_Unit_Long( mb, this.ptr, collisionLayer) } open fun setExclude(exclude: VariantArray) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_exclude") _icall_Unit_VariantArray( mb, this.ptr, exclude) } open fun setMargin(margin: Double) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_margin") _icall_Unit_Double( mb, this.ptr, margin) } open fun setMotion(motion: Vector2) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_motion") _icall_Unit_Vector2( mb, this.ptr, motion) } open fun setShape(shape: Resource) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_shape") _icall_Unit_Object( mb, this.ptr, shape) } open fun setShapeRid(shape: RID) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_shape_rid") _icall_Unit_RID( mb, this.ptr, shape) } open fun setTransform(transform: Transform2D) { val mb = getMethodBind("Physics2DShapeQueryParameters","set_transform") _icall_Unit_Transform2D( mb, this.ptr, transform) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Physics2DShapeQueryResult.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Object_Long import godot.icalls._icall_RID_Long import godot.internal.utils.getMethodBind import kotlin.Long open class Physics2DShapeQueryResult internal constructor() : Reference() { open fun getResultCount(): Long { val mb = getMethodBind("Physics2DShapeQueryResult","get_result_count") return _icall_Long( mb, this.ptr) } open fun getResultObject(idx: Long): Object { val mb = getMethodBind("Physics2DShapeQueryResult","get_result_object") return _icall_Object_Long( mb, this.ptr, idx) } open fun getResultObjectId(idx: Long): Long { val mb = getMethodBind("Physics2DShapeQueryResult","get_result_object_id") return _icall_Long_Long( mb, this.ptr, idx) } open fun getResultObjectShape(idx: Long): Long { val mb = getMethodBind("Physics2DShapeQueryResult","get_result_object_shape") return _icall_Long_Long( mb, this.ptr, idx) } open fun getResultRid(idx: Long): RID { val mb = getMethodBind("Physics2DShapeQueryResult","get_result_rid") return _icall_RID_Long( mb, this.ptr, idx) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Physics2DTestMotionResult.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Object import godot.icalls._icall_RID import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlinx.cinterop.COpaquePointer open class Physics2DTestMotionResult : Reference() { open val collider: Object get() { val mb = getMethodBind("Physics2DTestMotionResult","get_collider") return _icall_Object(mb, this.ptr) } open val colliderId: Long get() { val mb = getMethodBind("Physics2DTestMotionResult","get_collider_id") return _icall_Long(mb, this.ptr) } open val colliderRid: RID get() { val mb = getMethodBind("Physics2DTestMotionResult","get_collider_rid") return _icall_RID(mb, this.ptr) } open val colliderShape: Long get() { val mb = getMethodBind("Physics2DTestMotionResult","get_collider_shape") return _icall_Long(mb, this.ptr) } open val colliderVelocity: Vector2 get() { val mb = getMethodBind("Physics2DTestMotionResult","get_collider_velocity") return _icall_Vector2(mb, this.ptr) } open val collisionNormal: Vector2 get() { val mb = getMethodBind("Physics2DTestMotionResult","get_collision_normal") return _icall_Vector2(mb, this.ptr) } open val collisionPoint: Vector2 get() { val mb = getMethodBind("Physics2DTestMotionResult","get_collision_point") return _icall_Vector2(mb, this.ptr) } open val motion: Vector2 get() { val mb = getMethodBind("Physics2DTestMotionResult","get_motion") return _icall_Vector2(mb, this.ptr) } open val motionRemainder: Vector2 get() { val mb = getMethodBind("Physics2DTestMotionResult","get_motion_remainder") return _icall_Vector2(mb, this.ptr) } override fun __new(): COpaquePointer = invokeConstructor("Physics2DTestMotionResult", "Physics2DTestMotionResult") open fun getCollider(): Object { val mb = getMethodBind("Physics2DTestMotionResult","get_collider") return _icall_Object( mb, this.ptr) } open fun getColliderId(): Long { val mb = getMethodBind("Physics2DTestMotionResult","get_collider_id") return _icall_Long( mb, this.ptr) } open fun getColliderRid(): RID { val mb = getMethodBind("Physics2DTestMotionResult","get_collider_rid") return _icall_RID( mb, this.ptr) } open fun getColliderShape(): Long { val mb = getMethodBind("Physics2DTestMotionResult","get_collider_shape") return _icall_Long( mb, this.ptr) } open fun getColliderVelocity(): Vector2 { val mb = getMethodBind("Physics2DTestMotionResult","get_collider_velocity") return _icall_Vector2( mb, this.ptr) } open fun getCollisionNormal(): Vector2 { val mb = getMethodBind("Physics2DTestMotionResult","get_collision_normal") return _icall_Vector2( mb, this.ptr) } open fun getCollisionPoint(): Vector2 { val mb = getMethodBind("Physics2DTestMotionResult","get_collision_point") return _icall_Vector2( mb, this.ptr) } open fun getMotion(): Vector2 { val mb = getMethodBind("Physics2DTestMotionResult","get_motion") return _icall_Vector2( mb, this.ptr) } open fun getMotionRemainder(): Vector2 { val mb = getMethodBind("Physics2DTestMotionResult","get_motion_remainder") return _icall_Vector2( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PhysicsBody.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.VariantArray import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError open class PhysicsBody internal constructor() : CollisionObject() { open var collisionLayer: Long get() { val mb = getMethodBind("PhysicsBody","get_collision_layer") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsBody","set_collision_layer") _icall_Unit_Long(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("PhysicsBody","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsBody","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open fun _getLayers(): Long { throw NotImplementedError("_get_layers is not implemented for PhysicsBody") } open fun _setLayers(mask: Long) { } open fun addCollisionExceptionWith(body: Node) { val mb = getMethodBind("PhysicsBody","add_collision_exception_with") _icall_Unit_Object( mb, this.ptr, body) } open fun getCollisionExceptions(): VariantArray { val mb = getMethodBind("PhysicsBody","get_collision_exceptions") return _icall_VariantArray( mb, this.ptr) } open fun getCollisionLayer(): Long { val mb = getMethodBind("PhysicsBody","get_collision_layer") return _icall_Long( mb, this.ptr) } open fun getCollisionLayerBit(bit: Long): Boolean { val mb = getMethodBind("PhysicsBody","get_collision_layer_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getCollisionMask(): Long { val mb = getMethodBind("PhysicsBody","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("PhysicsBody","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun removeCollisionExceptionWith(body: Node) { val mb = getMethodBind("PhysicsBody","remove_collision_exception_with") _icall_Unit_Object( mb, this.ptr, body) } open fun setCollisionLayer(layer: Long) { val mb = getMethodBind("PhysicsBody","set_collision_layer") _icall_Unit_Long( mb, this.ptr, layer) } open fun setCollisionLayerBit(bit: Long, value: Boolean) { val mb = getMethodBind("PhysicsBody","set_collision_layer_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setCollisionMask(mask: Long) { val mb = getMethodBind("PhysicsBody","set_collision_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("PhysicsBody","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PhysicsBody2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.VariantArray import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError open class PhysicsBody2D internal constructor() : CollisionObject2D() { open var collisionLayer: Long get() { val mb = getMethodBind("PhysicsBody2D","get_collision_layer") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsBody2D","set_collision_layer") _icall_Unit_Long(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("PhysicsBody2D","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsBody2D","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open fun _getLayers(): Long { throw NotImplementedError("_get_layers is not implemented for PhysicsBody2D") } open fun _setLayers(mask: Long) { } open fun addCollisionExceptionWith(body: Node) { val mb = getMethodBind("PhysicsBody2D","add_collision_exception_with") _icall_Unit_Object( mb, this.ptr, body) } open fun getCollisionExceptions(): VariantArray { val mb = getMethodBind("PhysicsBody2D","get_collision_exceptions") return _icall_VariantArray( mb, this.ptr) } open fun getCollisionLayer(): Long { val mb = getMethodBind("PhysicsBody2D","get_collision_layer") return _icall_Long( mb, this.ptr) } open fun getCollisionLayerBit(bit: Long): Boolean { val mb = getMethodBind("PhysicsBody2D","get_collision_layer_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getCollisionMask(): Long { val mb = getMethodBind("PhysicsBody2D","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("PhysicsBody2D","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun removeCollisionExceptionWith(body: Node) { val mb = getMethodBind("PhysicsBody2D","remove_collision_exception_with") _icall_Unit_Object( mb, this.ptr, body) } open fun setCollisionLayer(layer: Long) { val mb = getMethodBind("PhysicsBody2D","set_collision_layer") _icall_Unit_Long( mb, this.ptr, layer) } open fun setCollisionLayerBit(bit: Long, value: Boolean) { val mb = getMethodBind("PhysicsBody2D","set_collision_layer_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setCollisionMask(mask: Long) { val mb = getMethodBind("PhysicsBody2D","set_collision_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("PhysicsBody2D","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PhysicsDirectBodyState.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Basis import godot.core.RID import godot.core.Transform import godot.core.Vector3 import godot.icalls._icall_Basis import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Double_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Object_Long import godot.icalls._icall_PhysicsDirectSpaceState import godot.icalls._icall_RID_Long import godot.icalls._icall_Transform import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Transform import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Unit_Vector3_Vector3 import godot.icalls._icall_Vector3 import godot.icalls._icall_Vector3_Long import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit open class PhysicsDirectBodyState internal constructor() : Object() { open var angularVelocity: Vector3 get() { val mb = getMethodBind("PhysicsDirectBodyState","get_angular_velocity") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsDirectBodyState","set_angular_velocity") _icall_Unit_Vector3(mb, this.ptr, value) } open val centerOfMass: Vector3 get() { val mb = getMethodBind("PhysicsDirectBodyState","get_center_of_mass") return _icall_Vector3(mb, this.ptr) } open val inverseInertia: Vector3 get() { val mb = getMethodBind("PhysicsDirectBodyState","get_inverse_inertia") return _icall_Vector3(mb, this.ptr) } open val inverseMass: Double get() { val mb = getMethodBind("PhysicsDirectBodyState","get_inverse_mass") return _icall_Double(mb, this.ptr) } open var linearVelocity: Vector3 get() { val mb = getMethodBind("PhysicsDirectBodyState","get_linear_velocity") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsDirectBodyState","set_linear_velocity") _icall_Unit_Vector3(mb, this.ptr, value) } open val principalInertiaAxes: Basis get() { val mb = getMethodBind("PhysicsDirectBodyState","get_principal_inertia_axes") return _icall_Basis(mb, this.ptr) } open var sleeping: Boolean get() { val mb = getMethodBind("PhysicsDirectBodyState","is_sleeping") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsDirectBodyState","set_sleep_state") _icall_Unit_Boolean(mb, this.ptr, value) } open val step: Double get() { val mb = getMethodBind("PhysicsDirectBodyState","get_step") return _icall_Double(mb, this.ptr) } open val totalAngularDamp: Double get() { val mb = getMethodBind("PhysicsDirectBodyState","get_total_angular_damp") return _icall_Double(mb, this.ptr) } open val totalGravity: Vector3 get() { val mb = getMethodBind("PhysicsDirectBodyState","get_total_gravity") return _icall_Vector3(mb, this.ptr) } open val totalLinearDamp: Double get() { val mb = getMethodBind("PhysicsDirectBodyState","get_total_linear_damp") return _icall_Double(mb, this.ptr) } open var transform: Transform get() { val mb = getMethodBind("PhysicsDirectBodyState","get_transform") return _icall_Transform(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsDirectBodyState","set_transform") _icall_Unit_Transform(mb, this.ptr, value) } open fun angularVelocity(schedule: Vector3.() -> Unit): Vector3 = angularVelocity.apply{ schedule(this) angularVelocity = this } open fun linearVelocity(schedule: Vector3.() -> Unit): Vector3 = linearVelocity.apply{ schedule(this) linearVelocity = this } open fun transform(schedule: Transform.() -> Unit): Transform = transform.apply{ schedule(this) transform = this } open fun addCentralForce(force: Vector3) { val mb = getMethodBind("PhysicsDirectBodyState","add_central_force") _icall_Unit_Vector3( mb, this.ptr, force) } open fun addForce(force: Vector3, position: Vector3) { val mb = getMethodBind("PhysicsDirectBodyState","add_force") _icall_Unit_Vector3_Vector3( mb, this.ptr, force, position) } open fun addTorque(torque: Vector3) { val mb = getMethodBind("PhysicsDirectBodyState","add_torque") _icall_Unit_Vector3( mb, this.ptr, torque) } open fun applyCentralImpulse(j: Vector3) { val mb = getMethodBind("PhysicsDirectBodyState","apply_central_impulse") _icall_Unit_Vector3( mb, this.ptr, j) } open fun applyImpulse(position: Vector3, j: Vector3) { val mb = getMethodBind("PhysicsDirectBodyState","apply_impulse") _icall_Unit_Vector3_Vector3( mb, this.ptr, position, j) } open fun applyTorqueImpulse(j: Vector3) { val mb = getMethodBind("PhysicsDirectBodyState","apply_torque_impulse") _icall_Unit_Vector3( mb, this.ptr, j) } open fun getAngularVelocity(): Vector3 { val mb = getMethodBind("PhysicsDirectBodyState","get_angular_velocity") return _icall_Vector3( mb, this.ptr) } open fun getCenterOfMass(): Vector3 { val mb = getMethodBind("PhysicsDirectBodyState","get_center_of_mass") return _icall_Vector3( mb, this.ptr) } open fun getContactCollider(contactIdx: Long): RID { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_collider") return _icall_RID_Long( mb, this.ptr, contactIdx) } open fun getContactColliderId(contactIdx: Long): Long { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_collider_id") return _icall_Long_Long( mb, this.ptr, contactIdx) } open fun getContactColliderObject(contactIdx: Long): Object { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_collider_object") return _icall_Object_Long( mb, this.ptr, contactIdx) } open fun getContactColliderPosition(contactIdx: Long): Vector3 { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_collider_position") return _icall_Vector3_Long( mb, this.ptr, contactIdx) } open fun getContactColliderShape(contactIdx: Long): Long { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_collider_shape") return _icall_Long_Long( mb, this.ptr, contactIdx) } open fun getContactColliderVelocityAtPosition(contactIdx: Long): Vector3 { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_collider_velocity_at_position") return _icall_Vector3_Long( mb, this.ptr, contactIdx) } open fun getContactCount(): Long { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_count") return _icall_Long( mb, this.ptr) } open fun getContactImpulse(contactIdx: Long): Double { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_impulse") return _icall_Double_Long( mb, this.ptr, contactIdx) } open fun getContactLocalNormal(contactIdx: Long): Vector3 { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_local_normal") return _icall_Vector3_Long( mb, this.ptr, contactIdx) } open fun getContactLocalPosition(contactIdx: Long): Vector3 { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_local_position") return _icall_Vector3_Long( mb, this.ptr, contactIdx) } open fun getContactLocalShape(contactIdx: Long): Long { val mb = getMethodBind("PhysicsDirectBodyState","get_contact_local_shape") return _icall_Long_Long( mb, this.ptr, contactIdx) } open fun getInverseInertia(): Vector3 { val mb = getMethodBind("PhysicsDirectBodyState","get_inverse_inertia") return _icall_Vector3( mb, this.ptr) } open fun getInverseMass(): Double { val mb = getMethodBind("PhysicsDirectBodyState","get_inverse_mass") return _icall_Double( mb, this.ptr) } open fun getLinearVelocity(): Vector3 { val mb = getMethodBind("PhysicsDirectBodyState","get_linear_velocity") return _icall_Vector3( mb, this.ptr) } open fun getPrincipalInertiaAxes(): Basis { val mb = getMethodBind("PhysicsDirectBodyState","get_principal_inertia_axes") return _icall_Basis( mb, this.ptr) } open fun getSpaceState(): PhysicsDirectSpaceState { val mb = getMethodBind("PhysicsDirectBodyState","get_space_state") return _icall_PhysicsDirectSpaceState( mb, this.ptr) } open fun getStep(): Double { val mb = getMethodBind("PhysicsDirectBodyState","get_step") return _icall_Double( mb, this.ptr) } open fun getTotalAngularDamp(): Double { val mb = getMethodBind("PhysicsDirectBodyState","get_total_angular_damp") return _icall_Double( mb, this.ptr) } open fun getTotalGravity(): Vector3 { val mb = getMethodBind("PhysicsDirectBodyState","get_total_gravity") return _icall_Vector3( mb, this.ptr) } open fun getTotalLinearDamp(): Double { val mb = getMethodBind("PhysicsDirectBodyState","get_total_linear_damp") return _icall_Double( mb, this.ptr) } open fun getTransform(): Transform { val mb = getMethodBind("PhysicsDirectBodyState","get_transform") return _icall_Transform( mb, this.ptr) } open fun integrateForces() { val mb = getMethodBind("PhysicsDirectBodyState","integrate_forces") _icall_Unit( mb, this.ptr) } open fun isSleeping(): Boolean { val mb = getMethodBind("PhysicsDirectBodyState","is_sleeping") return _icall_Boolean( mb, this.ptr) } open fun setAngularVelocity(velocity: Vector3) { val mb = getMethodBind("PhysicsDirectBodyState","set_angular_velocity") _icall_Unit_Vector3( mb, this.ptr, velocity) } open fun setLinearVelocity(velocity: Vector3) { val mb = getMethodBind("PhysicsDirectBodyState","set_linear_velocity") _icall_Unit_Vector3( mb, this.ptr, velocity) } open fun setSleepState(enabled: Boolean) { val mb = getMethodBind("PhysicsDirectBodyState","set_sleep_state") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setTransform(transform: Transform) { val mb = getMethodBind("PhysicsDirectBodyState","set_transform") _icall_Unit_Transform( mb, this.ptr, transform) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PhysicsDirectSpaceState.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.VariantArray import godot.core.Vector3 import godot.icalls._icall_Dictionary_Object import godot.icalls._icall_Dictionary_Vector3_Vector3_VariantArray_Long_Boolean_Boolean import godot.icalls._icall_VariantArray_Object_Long import godot.icalls._icall_VariantArray_Object_Vector3 import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long open class PhysicsDirectSpaceState internal constructor() : Object() { open fun castMotion(shape: PhysicsShapeQueryParameters, motion: Vector3): VariantArray { val mb = getMethodBind("PhysicsDirectSpaceState","cast_motion") return _icall_VariantArray_Object_Vector3( mb, this.ptr, shape, motion) } open fun collideShape(shape: PhysicsShapeQueryParameters, maxResults: Long = 32): VariantArray { val mb = getMethodBind("PhysicsDirectSpaceState","collide_shape") return _icall_VariantArray_Object_Long( mb, this.ptr, shape, maxResults) } open fun getRestInfo(shape: PhysicsShapeQueryParameters): Dictionary { val mb = getMethodBind("PhysicsDirectSpaceState","get_rest_info") return _icall_Dictionary_Object( mb, this.ptr, shape) } open fun intersectRay( from: Vector3, to: Vector3, exclude: VariantArray = VariantArray(), collisionMask: Long = 2147483647, collideWithBodies: Boolean = true, collideWithAreas: Boolean = false ): Dictionary { val mb = getMethodBind("PhysicsDirectSpaceState","intersect_ray") return _icall_Dictionary_Vector3_Vector3_VariantArray_Long_Boolean_Boolean( mb, this.ptr, from, to, exclude, collisionMask, collideWithBodies, collideWithAreas) } open fun intersectShape(shape: PhysicsShapeQueryParameters, maxResults: Long = 32): VariantArray { val mb = getMethodBind("PhysicsDirectSpaceState","intersect_shape") return _icall_VariantArray_Object_Long( mb, this.ptr, shape, maxResults) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PhysicsMaterial.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlinx.cinterop.COpaquePointer open class PhysicsMaterial : Resource() { open var absorbent: Boolean get() { val mb = getMethodBind("PhysicsMaterial","is_absorbent") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsMaterial","set_absorbent") _icall_Unit_Boolean(mb, this.ptr, value) } open var bounce: Double get() { val mb = getMethodBind("PhysicsMaterial","get_bounce") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsMaterial","set_bounce") _icall_Unit_Double(mb, this.ptr, value) } open var friction: Double get() { val mb = getMethodBind("PhysicsMaterial","get_friction") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsMaterial","set_friction") _icall_Unit_Double(mb, this.ptr, value) } open var rough: Boolean get() { val mb = getMethodBind("PhysicsMaterial","is_rough") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsMaterial","set_rough") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PhysicsMaterial", "PhysicsMaterial") open fun getBounce(): Double { val mb = getMethodBind("PhysicsMaterial","get_bounce") return _icall_Double( mb, this.ptr) } open fun getFriction(): Double { val mb = getMethodBind("PhysicsMaterial","get_friction") return _icall_Double( mb, this.ptr) } open fun isAbsorbent(): Boolean { val mb = getMethodBind("PhysicsMaterial","is_absorbent") return _icall_Boolean( mb, this.ptr) } open fun isRough(): Boolean { val mb = getMethodBind("PhysicsMaterial","is_rough") return _icall_Boolean( mb, this.ptr) } open fun setAbsorbent(absorbent: Boolean) { val mb = getMethodBind("PhysicsMaterial","set_absorbent") _icall_Unit_Boolean( mb, this.ptr, absorbent) } open fun setBounce(bounce: Double) { val mb = getMethodBind("PhysicsMaterial","set_bounce") _icall_Unit_Double( mb, this.ptr, bounce) } open fun setFriction(friction: Double) { val mb = getMethodBind("PhysicsMaterial","set_friction") _icall_Unit_Double( mb, this.ptr, friction) } open fun setRough(rough: Boolean) { val mb = getMethodBind("PhysicsMaterial","set_rough") _icall_Unit_Boolean( mb, this.ptr, rough) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PhysicsServer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.PhysicsServer import godot.core.Godot import godot.core.RID import godot.core.Transform import godot.core.Variant import godot.core.Vector3 import godot.icalls._icall_Boolean_RID import godot.icalls._icall_Boolean_RID_Long import godot.icalls._icall_Boolean_RID_Long_Long import godot.icalls._icall_Double_RID import godot.icalls._icall_Double_RID_Long import godot.icalls._icall_Double_RID_Long_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Long_RID import godot.icalls._icall_PhysicsDirectBodyState_RID import godot.icalls._icall_PhysicsDirectSpaceState_RID import godot.icalls._icall_RID import godot.icalls._icall_RID_Long import godot.icalls._icall_RID_Long_Boolean import godot.icalls._icall_RID_RID import godot.icalls._icall_RID_RID_Long import godot.icalls._icall_RID_RID_Transform_RID_Transform import godot.icalls._icall_RID_RID_Vector3_RID_Vector3 import godot.icalls._icall_Transform_RID import godot.icalls._icall_Transform_RID_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_RID import godot.icalls._icall_Unit_RID_Boolean import godot.icalls._icall_Unit_RID_Double import godot.icalls._icall_Unit_RID_Long import godot.icalls._icall_Unit_RID_Long_Boolean import godot.icalls._icall_Unit_RID_Long_Double import godot.icalls._icall_Unit_RID_Long_Long_Boolean import godot.icalls._icall_Unit_RID_Long_Long_Double import godot.icalls._icall_Unit_RID_Long_RID import godot.icalls._icall_Unit_RID_Long_Transform import godot.icalls._icall_Unit_RID_Long_Variant import godot.icalls._icall_Unit_RID_Object_String import godot.icalls._icall_Unit_RID_Object_String_nVariant import godot.icalls._icall_Unit_RID_RID import godot.icalls._icall_Unit_RID_RID_Transform_Boolean import godot.icalls._icall_Unit_RID_Transform import godot.icalls._icall_Unit_RID_Variant import godot.icalls._icall_Unit_RID_Vector3 import godot.icalls._icall_Unit_RID_Vector3_Vector3 import godot.icalls._icall_Variant_RID import godot.icalls._icall_Variant_RID_Long import godot.icalls._icall_Vector3_RID import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object PhysicsServer : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("PhysicsServer".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton PhysicsServer" } ptr } fun areaAddShape( area: RID, shape: RID, transform: Transform = Transform(), disabled: Boolean = false ) { val mb = getMethodBind("PhysicsServer","area_add_shape") _icall_Unit_RID_RID_Transform_Boolean( mb, this.ptr, area, shape, transform, disabled) } fun areaAttachObjectInstanceId(area: RID, id: Long) { val mb = getMethodBind("PhysicsServer","area_attach_object_instance_id") _icall_Unit_RID_Long( mb, this.ptr, area, id) } fun areaClearShapes(area: RID) { val mb = getMethodBind("PhysicsServer","area_clear_shapes") _icall_Unit_RID( mb, this.ptr, area) } fun areaCreate(): RID { val mb = getMethodBind("PhysicsServer","area_create") return _icall_RID( mb, this.ptr) } fun areaGetObjectInstanceId(area: RID): Long { val mb = getMethodBind("PhysicsServer","area_get_object_instance_id") return _icall_Long_RID( mb, this.ptr, area) } fun areaGetParam(area: RID, param: Long): Variant { val mb = getMethodBind("PhysicsServer","area_get_param") return _icall_Variant_RID_Long( mb, this.ptr, area, param) } fun areaGetShape(area: RID, shapeIdx: Long): RID { val mb = getMethodBind("PhysicsServer","area_get_shape") return _icall_RID_RID_Long( mb, this.ptr, area, shapeIdx) } fun areaGetShapeCount(area: RID): Long { val mb = getMethodBind("PhysicsServer","area_get_shape_count") return _icall_Long_RID( mb, this.ptr, area) } fun areaGetShapeTransform(area: RID, shapeIdx: Long): Transform { val mb = getMethodBind("PhysicsServer","area_get_shape_transform") return _icall_Transform_RID_Long( mb, this.ptr, area, shapeIdx) } fun areaGetSpace(area: RID): RID { val mb = getMethodBind("PhysicsServer","area_get_space") return _icall_RID_RID( mb, this.ptr, area) } fun areaGetSpaceOverrideMode(area: RID): PhysicsServer.AreaSpaceOverrideMode { val mb = getMethodBind("PhysicsServer","area_get_space_override_mode") return PhysicsServer.AreaSpaceOverrideMode.from( _icall_Long_RID( mb, this.ptr, area)) } fun areaGetTransform(area: RID): Transform { val mb = getMethodBind("PhysicsServer","area_get_transform") return _icall_Transform_RID( mb, this.ptr, area) } fun areaIsRayPickable(area: RID): Boolean { val mb = getMethodBind("PhysicsServer","area_is_ray_pickable") return _icall_Boolean_RID( mb, this.ptr, area) } fun areaRemoveShape(area: RID, shapeIdx: Long) { val mb = getMethodBind("PhysicsServer","area_remove_shape") _icall_Unit_RID_Long( mb, this.ptr, area, shapeIdx) } fun areaSetAreaMonitorCallback( area: RID, receiver: Object, method: String ) { val mb = getMethodBind("PhysicsServer","area_set_area_monitor_callback") _icall_Unit_RID_Object_String( mb, this.ptr, area, receiver, method) } fun areaSetCollisionLayer(area: RID, layer: Long) { val mb = getMethodBind("PhysicsServer","area_set_collision_layer") _icall_Unit_RID_Long( mb, this.ptr, area, layer) } fun areaSetCollisionMask(area: RID, mask: Long) { val mb = getMethodBind("PhysicsServer","area_set_collision_mask") _icall_Unit_RID_Long( mb, this.ptr, area, mask) } fun areaSetMonitorCallback( area: RID, receiver: Object, method: String ) { val mb = getMethodBind("PhysicsServer","area_set_monitor_callback") _icall_Unit_RID_Object_String( mb, this.ptr, area, receiver, method) } fun areaSetMonitorable(area: RID, monitorable: Boolean) { val mb = getMethodBind("PhysicsServer","area_set_monitorable") _icall_Unit_RID_Boolean( mb, this.ptr, area, monitorable) } fun areaSetParam( area: RID, param: Long, value: Variant ) { val mb = getMethodBind("PhysicsServer","area_set_param") _icall_Unit_RID_Long_Variant( mb, this.ptr, area, param, value) } fun areaSetRayPickable(area: RID, enable: Boolean) { val mb = getMethodBind("PhysicsServer","area_set_ray_pickable") _icall_Unit_RID_Boolean( mb, this.ptr, area, enable) } fun areaSetShape( area: RID, shapeIdx: Long, shape: RID ) { val mb = getMethodBind("PhysicsServer","area_set_shape") _icall_Unit_RID_Long_RID( mb, this.ptr, area, shapeIdx, shape) } fun areaSetShapeDisabled( area: RID, shapeIdx: Long, disabled: Boolean ) { val mb = getMethodBind("PhysicsServer","area_set_shape_disabled") _icall_Unit_RID_Long_Boolean( mb, this.ptr, area, shapeIdx, disabled) } fun areaSetShapeTransform( area: RID, shapeIdx: Long, transform: Transform ) { val mb = getMethodBind("PhysicsServer","area_set_shape_transform") _icall_Unit_RID_Long_Transform( mb, this.ptr, area, shapeIdx, transform) } fun areaSetSpace(area: RID, space: RID) { val mb = getMethodBind("PhysicsServer","area_set_space") _icall_Unit_RID_RID( mb, this.ptr, area, space) } fun areaSetSpaceOverrideMode(area: RID, mode: Long) { val mb = getMethodBind("PhysicsServer","area_set_space_override_mode") _icall_Unit_RID_Long( mb, this.ptr, area, mode) } fun areaSetTransform(area: RID, transform: Transform) { val mb = getMethodBind("PhysicsServer","area_set_transform") _icall_Unit_RID_Transform( mb, this.ptr, area, transform) } fun bodyAddCentralForce(body: RID, force: Vector3) { val mb = getMethodBind("PhysicsServer","body_add_central_force") _icall_Unit_RID_Vector3( mb, this.ptr, body, force) } fun bodyAddCollisionException(body: RID, exceptedBody: RID) { val mb = getMethodBind("PhysicsServer","body_add_collision_exception") _icall_Unit_RID_RID( mb, this.ptr, body, exceptedBody) } fun bodyAddForce( body: RID, force: Vector3, position: Vector3 ) { val mb = getMethodBind("PhysicsServer","body_add_force") _icall_Unit_RID_Vector3_Vector3( mb, this.ptr, body, force, position) } fun bodyAddShape( body: RID, shape: RID, transform: Transform = Transform(), disabled: Boolean = false ) { val mb = getMethodBind("PhysicsServer","body_add_shape") _icall_Unit_RID_RID_Transform_Boolean( mb, this.ptr, body, shape, transform, disabled) } fun bodyAddTorque(body: RID, torque: Vector3) { val mb = getMethodBind("PhysicsServer","body_add_torque") _icall_Unit_RID_Vector3( mb, this.ptr, body, torque) } fun bodyApplyCentralImpulse(body: RID, impulse: Vector3) { val mb = getMethodBind("PhysicsServer","body_apply_central_impulse") _icall_Unit_RID_Vector3( mb, this.ptr, body, impulse) } fun bodyApplyImpulse( body: RID, position: Vector3, impulse: Vector3 ) { val mb = getMethodBind("PhysicsServer","body_apply_impulse") _icall_Unit_RID_Vector3_Vector3( mb, this.ptr, body, position, impulse) } fun bodyApplyTorqueImpulse(body: RID, impulse: Vector3) { val mb = getMethodBind("PhysicsServer","body_apply_torque_impulse") _icall_Unit_RID_Vector3( mb, this.ptr, body, impulse) } fun bodyAttachObjectInstanceId(body: RID, id: Long) { val mb = getMethodBind("PhysicsServer","body_attach_object_instance_id") _icall_Unit_RID_Long( mb, this.ptr, body, id) } fun bodyClearShapes(body: RID) { val mb = getMethodBind("PhysicsServer","body_clear_shapes") _icall_Unit_RID( mb, this.ptr, body) } fun bodyCreate(mode: Long = 2, initSleeping: Boolean = false): RID { val mb = getMethodBind("PhysicsServer","body_create") return _icall_RID_Long_Boolean( mb, this.ptr, mode, initSleeping) } fun bodyGetCollisionLayer(body: RID): Long { val mb = getMethodBind("PhysicsServer","body_get_collision_layer") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetCollisionMask(body: RID): Long { val mb = getMethodBind("PhysicsServer","body_get_collision_mask") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetDirectState(body: RID): PhysicsDirectBodyState { val mb = getMethodBind("PhysicsServer","body_get_direct_state") return _icall_PhysicsDirectBodyState_RID( mb, this.ptr, body) } fun bodyGetKinematicSafeMargin(body: RID): Double { val mb = getMethodBind("PhysicsServer","body_get_kinematic_safe_margin") return _icall_Double_RID( mb, this.ptr, body) } fun bodyGetMaxContactsReported(body: RID): Long { val mb = getMethodBind("PhysicsServer","body_get_max_contacts_reported") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetMode(body: RID): PhysicsServer.BodyMode { val mb = getMethodBind("PhysicsServer","body_get_mode") return PhysicsServer.BodyMode.from( _icall_Long_RID( mb, this.ptr, body)) } fun bodyGetObjectInstanceId(body: RID): Long { val mb = getMethodBind("PhysicsServer","body_get_object_instance_id") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetParam(body: RID, param: Long): Double { val mb = getMethodBind("PhysicsServer","body_get_param") return _icall_Double_RID_Long( mb, this.ptr, body, param) } fun bodyGetShape(body: RID, shapeIdx: Long): RID { val mb = getMethodBind("PhysicsServer","body_get_shape") return _icall_RID_RID_Long( mb, this.ptr, body, shapeIdx) } fun bodyGetShapeCount(body: RID): Long { val mb = getMethodBind("PhysicsServer","body_get_shape_count") return _icall_Long_RID( mb, this.ptr, body) } fun bodyGetShapeTransform(body: RID, shapeIdx: Long): Transform { val mb = getMethodBind("PhysicsServer","body_get_shape_transform") return _icall_Transform_RID_Long( mb, this.ptr, body, shapeIdx) } fun bodyGetSpace(body: RID): RID { val mb = getMethodBind("PhysicsServer","body_get_space") return _icall_RID_RID( mb, this.ptr, body) } fun bodyGetState(body: RID, state: Long): Variant { val mb = getMethodBind("PhysicsServer","body_get_state") return _icall_Variant_RID_Long( mb, this.ptr, body, state) } fun bodyIsAxisLocked(body: RID, axis: Long): Boolean { val mb = getMethodBind("PhysicsServer","body_is_axis_locked") return _icall_Boolean_RID_Long( mb, this.ptr, body, axis) } fun bodyIsContinuousCollisionDetectionEnabled(body: RID): Boolean { val mb = getMethodBind("PhysicsServer","body_is_continuous_collision_detection_enabled") return _icall_Boolean_RID( mb, this.ptr, body) } fun bodyIsOmittingForceIntegration(body: RID): Boolean { val mb = getMethodBind("PhysicsServer","body_is_omitting_force_integration") return _icall_Boolean_RID( mb, this.ptr, body) } fun bodyIsRayPickable(body: RID): Boolean { val mb = getMethodBind("PhysicsServer","body_is_ray_pickable") return _icall_Boolean_RID( mb, this.ptr, body) } fun bodyRemoveCollisionException(body: RID, exceptedBody: RID) { val mb = getMethodBind("PhysicsServer","body_remove_collision_exception") _icall_Unit_RID_RID( mb, this.ptr, body, exceptedBody) } fun bodyRemoveShape(body: RID, shapeIdx: Long) { val mb = getMethodBind("PhysicsServer","body_remove_shape") _icall_Unit_RID_Long( mb, this.ptr, body, shapeIdx) } fun bodySetAxisLock( body: RID, axis: Long, lock: Boolean ) { val mb = getMethodBind("PhysicsServer","body_set_axis_lock") _icall_Unit_RID_Long_Boolean( mb, this.ptr, body, axis, lock) } fun bodySetAxisVelocity(body: RID, axisVelocity: Vector3) { val mb = getMethodBind("PhysicsServer","body_set_axis_velocity") _icall_Unit_RID_Vector3( mb, this.ptr, body, axisVelocity) } fun bodySetCollisionLayer(body: RID, layer: Long) { val mb = getMethodBind("PhysicsServer","body_set_collision_layer") _icall_Unit_RID_Long( mb, this.ptr, body, layer) } fun bodySetCollisionMask(body: RID, mask: Long) { val mb = getMethodBind("PhysicsServer","body_set_collision_mask") _icall_Unit_RID_Long( mb, this.ptr, body, mask) } fun bodySetEnableContinuousCollisionDetection(body: RID, enable: Boolean) { val mb = getMethodBind("PhysicsServer","body_set_enable_continuous_collision_detection") _icall_Unit_RID_Boolean( mb, this.ptr, body, enable) } fun bodySetForceIntegrationCallback( body: RID, receiver: Object, method: String, userdata: Variant? = null ) { val mb = getMethodBind("PhysicsServer","body_set_force_integration_callback") _icall_Unit_RID_Object_String_nVariant( mb, this.ptr, body, receiver, method, userdata) } fun bodySetKinematicSafeMargin(body: RID, margin: Double) { val mb = getMethodBind("PhysicsServer","body_set_kinematic_safe_margin") _icall_Unit_RID_Double( mb, this.ptr, body, margin) } fun bodySetMaxContactsReported(body: RID, amount: Long) { val mb = getMethodBind("PhysicsServer","body_set_max_contacts_reported") _icall_Unit_RID_Long( mb, this.ptr, body, amount) } fun bodySetMode(body: RID, mode: Long) { val mb = getMethodBind("PhysicsServer","body_set_mode") _icall_Unit_RID_Long( mb, this.ptr, body, mode) } fun bodySetOmitForceIntegration(body: RID, enable: Boolean) { val mb = getMethodBind("PhysicsServer","body_set_omit_force_integration") _icall_Unit_RID_Boolean( mb, this.ptr, body, enable) } fun bodySetParam( body: RID, param: Long, value: Double ) { val mb = getMethodBind("PhysicsServer","body_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, body, param, value) } fun bodySetRayPickable(body: RID, enable: Boolean) { val mb = getMethodBind("PhysicsServer","body_set_ray_pickable") _icall_Unit_RID_Boolean( mb, this.ptr, body, enable) } fun bodySetShape( body: RID, shapeIdx: Long, shape: RID ) { val mb = getMethodBind("PhysicsServer","body_set_shape") _icall_Unit_RID_Long_RID( mb, this.ptr, body, shapeIdx, shape) } fun bodySetShapeDisabled( body: RID, shapeIdx: Long, disabled: Boolean ) { val mb = getMethodBind("PhysicsServer","body_set_shape_disabled") _icall_Unit_RID_Long_Boolean( mb, this.ptr, body, shapeIdx, disabled) } fun bodySetShapeTransform( body: RID, shapeIdx: Long, transform: Transform ) { val mb = getMethodBind("PhysicsServer","body_set_shape_transform") _icall_Unit_RID_Long_Transform( mb, this.ptr, body, shapeIdx, transform) } fun bodySetSpace(body: RID, space: RID) { val mb = getMethodBind("PhysicsServer","body_set_space") _icall_Unit_RID_RID( mb, this.ptr, body, space) } fun bodySetState( body: RID, state: Long, value: Variant ) { val mb = getMethodBind("PhysicsServer","body_set_state") _icall_Unit_RID_Long_Variant( mb, this.ptr, body, state, value) } fun coneTwistJointGetParam(joint: RID, param: Long): Double { val mb = getMethodBind("PhysicsServer","cone_twist_joint_get_param") return _icall_Double_RID_Long( mb, this.ptr, joint, param) } fun coneTwistJointSetParam( joint: RID, param: Long, value: Double ) { val mb = getMethodBind("PhysicsServer","cone_twist_joint_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, joint, param, value) } fun freeRid(rid: RID) { val mb = getMethodBind("PhysicsServer","free_rid") _icall_Unit_RID( mb, this.ptr, rid) } fun generic6dofJointGetFlag( joint: RID, axis: Long, flag: Long ): Boolean { val mb = getMethodBind("PhysicsServer","generic_6dof_joint_get_flag") return _icall_Boolean_RID_Long_Long( mb, this.ptr, joint, axis, flag) } fun generic6dofJointGetParam( joint: RID, axis: Long, param: Long ): Double { val mb = getMethodBind("PhysicsServer","generic_6dof_joint_get_param") return _icall_Double_RID_Long_Long( mb, this.ptr, joint, axis, param) } fun generic6dofJointSetFlag( joint: RID, axis: Long, flag: Long, enable: Boolean ) { val mb = getMethodBind("PhysicsServer","generic_6dof_joint_set_flag") _icall_Unit_RID_Long_Long_Boolean( mb, this.ptr, joint, axis, flag, enable) } fun generic6dofJointSetParam( joint: RID, axis: Long, param: Long, value: Double ) { val mb = getMethodBind("PhysicsServer","generic_6dof_joint_set_param") _icall_Unit_RID_Long_Long_Double( mb, this.ptr, joint, axis, param, value) } fun getProcessInfo(processInfo: Long): Long { val mb = getMethodBind("PhysicsServer","get_process_info") return _icall_Long_Long( mb, this.ptr, processInfo) } fun hingeJointGetFlag(joint: RID, flag: Long): Boolean { val mb = getMethodBind("PhysicsServer","hinge_joint_get_flag") return _icall_Boolean_RID_Long( mb, this.ptr, joint, flag) } fun hingeJointGetParam(joint: RID, param: Long): Double { val mb = getMethodBind("PhysicsServer","hinge_joint_get_param") return _icall_Double_RID_Long( mb, this.ptr, joint, param) } fun hingeJointSetFlag( joint: RID, flag: Long, enabled: Boolean ) { val mb = getMethodBind("PhysicsServer","hinge_joint_set_flag") _icall_Unit_RID_Long_Boolean( mb, this.ptr, joint, flag, enabled) } fun hingeJointSetParam( joint: RID, param: Long, value: Double ) { val mb = getMethodBind("PhysicsServer","hinge_joint_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, joint, param, value) } fun jointCreateConeTwist( bodyA: RID, localRefA: Transform, bodyB: RID, localRefB: Transform ): RID { val mb = getMethodBind("PhysicsServer","joint_create_cone_twist") return _icall_RID_RID_Transform_RID_Transform( mb, this.ptr, bodyA, localRefA, bodyB, localRefB) } fun jointCreateGeneric6dof( bodyA: RID, localRefA: Transform, bodyB: RID, localRefB: Transform ): RID { val mb = getMethodBind("PhysicsServer","joint_create_generic_6dof") return _icall_RID_RID_Transform_RID_Transform( mb, this.ptr, bodyA, localRefA, bodyB, localRefB) } fun jointCreateHinge( bodyA: RID, hingeA: Transform, bodyB: RID, hingeB: Transform ): RID { val mb = getMethodBind("PhysicsServer","joint_create_hinge") return _icall_RID_RID_Transform_RID_Transform( mb, this.ptr, bodyA, hingeA, bodyB, hingeB) } fun jointCreatePin( bodyA: RID, localA: Vector3, bodyB: RID, localB: Vector3 ): RID { val mb = getMethodBind("PhysicsServer","joint_create_pin") return _icall_RID_RID_Vector3_RID_Vector3( mb, this.ptr, bodyA, localA, bodyB, localB) } fun jointCreateSlider( bodyA: RID, localRefA: Transform, bodyB: RID, localRefB: Transform ): RID { val mb = getMethodBind("PhysicsServer","joint_create_slider") return _icall_RID_RID_Transform_RID_Transform( mb, this.ptr, bodyA, localRefA, bodyB, localRefB) } fun jointGetSolverPriority(joint: RID): Long { val mb = getMethodBind("PhysicsServer","joint_get_solver_priority") return _icall_Long_RID( mb, this.ptr, joint) } fun jointGetType(joint: RID): PhysicsServer.JointType { val mb = getMethodBind("PhysicsServer","joint_get_type") return PhysicsServer.JointType.from( _icall_Long_RID( mb, this.ptr, joint)) } fun jointSetSolverPriority(joint: RID, priority: Long) { val mb = getMethodBind("PhysicsServer","joint_set_solver_priority") _icall_Unit_RID_Long( mb, this.ptr, joint, priority) } fun pinJointGetLocalA(joint: RID): Vector3 { val mb = getMethodBind("PhysicsServer","pin_joint_get_local_a") return _icall_Vector3_RID( mb, this.ptr, joint) } fun pinJointGetLocalB(joint: RID): Vector3 { val mb = getMethodBind("PhysicsServer","pin_joint_get_local_b") return _icall_Vector3_RID( mb, this.ptr, joint) } fun pinJointGetParam(joint: RID, param: Long): Double { val mb = getMethodBind("PhysicsServer","pin_joint_get_param") return _icall_Double_RID_Long( mb, this.ptr, joint, param) } fun pinJointSetLocalA(joint: RID, localA: Vector3) { val mb = getMethodBind("PhysicsServer","pin_joint_set_local_a") _icall_Unit_RID_Vector3( mb, this.ptr, joint, localA) } fun pinJointSetLocalB(joint: RID, localB: Vector3) { val mb = getMethodBind("PhysicsServer","pin_joint_set_local_b") _icall_Unit_RID_Vector3( mb, this.ptr, joint, localB) } fun pinJointSetParam( joint: RID, param: Long, value: Double ) { val mb = getMethodBind("PhysicsServer","pin_joint_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, joint, param, value) } fun setActive(active: Boolean) { val mb = getMethodBind("PhysicsServer","set_active") _icall_Unit_Boolean( mb, this.ptr, active) } fun shapeCreate(type: Long): RID { val mb = getMethodBind("PhysicsServer","shape_create") return _icall_RID_Long( mb, this.ptr, type) } fun shapeGetData(shape: RID): Variant { val mb = getMethodBind("PhysicsServer","shape_get_data") return _icall_Variant_RID( mb, this.ptr, shape) } fun shapeGetType(shape: RID): PhysicsServer.ShapeType { val mb = getMethodBind("PhysicsServer","shape_get_type") return PhysicsServer.ShapeType.from( _icall_Long_RID( mb, this.ptr, shape)) } fun shapeSetData(shape: RID, data: Variant) { val mb = getMethodBind("PhysicsServer","shape_set_data") _icall_Unit_RID_Variant( mb, this.ptr, shape, data) } fun sliderJointGetParam(joint: RID, param: Long): Double { val mb = getMethodBind("PhysicsServer","slider_joint_get_param") return _icall_Double_RID_Long( mb, this.ptr, joint, param) } fun sliderJointSetParam( joint: RID, param: Long, value: Double ) { val mb = getMethodBind("PhysicsServer","slider_joint_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, joint, param, value) } fun spaceCreate(): RID { val mb = getMethodBind("PhysicsServer","space_create") return _icall_RID( mb, this.ptr) } fun spaceGetDirectState(space: RID): PhysicsDirectSpaceState { val mb = getMethodBind("PhysicsServer","space_get_direct_state") return _icall_PhysicsDirectSpaceState_RID( mb, this.ptr, space) } fun spaceGetParam(space: RID, param: Long): Double { val mb = getMethodBind("PhysicsServer","space_get_param") return _icall_Double_RID_Long( mb, this.ptr, space, param) } fun spaceIsActive(space: RID): Boolean { val mb = getMethodBind("PhysicsServer","space_is_active") return _icall_Boolean_RID( mb, this.ptr, space) } fun spaceSetActive(space: RID, active: Boolean) { val mb = getMethodBind("PhysicsServer","space_set_active") _icall_Unit_RID_Boolean( mb, this.ptr, space, active) } fun spaceSetParam( space: RID, param: Long, value: Double ) { val mb = getMethodBind("PhysicsServer","space_set_param") _icall_Unit_RID_Long_Double( mb, this.ptr, space, param, value) } enum class BodyAxis( id: Long ) { BODY_AXIS_LINEAR_X(1), BODY_AXIS_LINEAR_Y(2), BODY_AXIS_LINEAR_Z(4), BODY_AXIS_ANGULAR_X(8), BODY_AXIS_ANGULAR_Y(16), BODY_AXIS_ANGULAR_Z(32); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ProcessInfo( id: Long ) { INFO_ACTIVE_OBJECTS(0), INFO_COLLISION_PAIRS(1), INFO_ISLAND_COUNT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class AreaBodyStatus( id: Long ) { AREA_BODY_ADDED(0), AREA_BODY_REMOVED(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BodyMode( id: Long ) { BODY_MODE_STATIC(0), BODY_MODE_KINEMATIC(1), BODY_MODE_RIGID(2), BODY_MODE_CHARACTER(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ShapeType( id: Long ) { SHAPE_PLANE(0), SHAPE_RAY(1), SHAPE_SPHERE(2), SHAPE_BOX(3), SHAPE_CAPSULE(4), SHAPE_CYLINDER(5), SHAPE_CONVEX_POLYGON(6), SHAPE_CONCAVE_POLYGON(7), SHAPE_HEIGHTMAP(8), SHAPE_CUSTOM(9); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class PinJointParam( id: Long ) { PIN_JOINT_BIAS(0), PIN_JOINT_DAMPING(1), PIN_JOINT_IMPULSE_CLAMP(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class SpaceParameter( id: Long ) { SPACE_PARAM_CONTACT_RECYCLE_RADIUS(0), SPACE_PARAM_CONTACT_MAX_SEPARATION(1), SPACE_PARAM_BODY_MAX_ALLOWED_PENETRATION(2), SPACE_PARAM_BODY_LINEAR_VELOCITY_SLEEP_THRESHOLD(3), SPACE_PARAM_BODY_ANGULAR_VELOCITY_SLEEP_THRESHOLD(4), SPACE_PARAM_BODY_TIME_TO_SLEEP(5), SPACE_PARAM_BODY_ANGULAR_VELOCITY_DAMP_RATIO(6), SPACE_PARAM_CONSTRAINT_DEFAULT_BIAS(7), SPACE_PARAM_TEST_MOTION_MIN_CONTACT_DEPTH(8); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ConeTwistJointParam( id: Long ) { CONE_TWIST_JOINT_SWING_SPAN(0), CONE_TWIST_JOINT_TWIST_SPAN(1), CONE_TWIST_JOINT_BIAS(2), CONE_TWIST_JOINT_SOFTNESS(3), CONE_TWIST_JOINT_RELAXATION(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class JointType( id: Long ) { JOINT_PIN(0), JOINT_HINGE(1), JOINT_SLIDER(2), JOINT_CONE_TWIST(3), JOINT_6DOF(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BodyState( id: Long ) { BODY_STATE_TRANSFORM(0), BODY_STATE_LINEAR_VELOCITY(1), BODY_STATE_ANGULAR_VELOCITY(2), BODY_STATE_SLEEPING(3), BODY_STATE_CAN_SLEEP(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class BodyParameter( id: Long ) { BODY_PARAM_BOUNCE(0), BODY_PARAM_FRICTION(1), BODY_PARAM_MASS(2), BODY_PARAM_GRAVITY_SCALE(3), BODY_PARAM_LINEAR_DAMP(4), BODY_PARAM_ANGULAR_DAMP(5), BODY_PARAM_MAX(6); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class G6DOFJointAxisParam( id: Long ) { G6DOF_JOINT_LINEAR_LOWER_LIMIT(0), G6DOF_JOINT_LINEAR_UPPER_LIMIT(1), G6DOF_JOINT_LINEAR_LIMIT_SOFTNESS(2), G6DOF_JOINT_LINEAR_RESTITUTION(3), G6DOF_JOINT_LINEAR_DAMPING(4), G6DOF_JOINT_LINEAR_MOTOR_TARGET_VELOCITY(5), G6DOF_JOINT_LINEAR_MOTOR_FORCE_LIMIT(6), G6DOF_JOINT_ANGULAR_LOWER_LIMIT(10), G6DOF_JOINT_ANGULAR_UPPER_LIMIT(11), G6DOF_JOINT_ANGULAR_LIMIT_SOFTNESS(12), G6DOF_JOINT_ANGULAR_DAMPING(13), G6DOF_JOINT_ANGULAR_RESTITUTION(14), G6DOF_JOINT_ANGULAR_FORCE_LIMIT(15), G6DOF_JOINT_ANGULAR_ERP(16), G6DOF_JOINT_ANGULAR_MOTOR_TARGET_VELOCITY(17), G6DOF_JOINT_ANGULAR_MOTOR_FORCE_LIMIT(18); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class SliderJointParam( id: Long ) { SLIDER_JOINT_LINEAR_LIMIT_UPPER(0), SLIDER_JOINT_LINEAR_LIMIT_LOWER(1), SLIDER_JOINT_LINEAR_LIMIT_SOFTNESS(2), SLIDER_JOINT_LINEAR_LIMIT_RESTITUTION(3), SLIDER_JOINT_LINEAR_LIMIT_DAMPING(4), SLIDER_JOINT_LINEAR_MOTION_SOFTNESS(5), SLIDER_JOINT_LINEAR_MOTION_RESTITUTION(6), SLIDER_JOINT_LINEAR_MOTION_DAMPING(7), SLIDER_JOINT_LINEAR_ORTHOGONAL_SOFTNESS(8), SLIDER_JOINT_LINEAR_ORTHOGONAL_RESTITUTION(9), SLIDER_JOINT_LINEAR_ORTHOGONAL_DAMPING(10), SLIDER_JOINT_ANGULAR_LIMIT_UPPER(11), SLIDER_JOINT_ANGULAR_LIMIT_LOWER(12), SLIDER_JOINT_ANGULAR_LIMIT_SOFTNESS(13), SLIDER_JOINT_ANGULAR_LIMIT_RESTITUTION(14), SLIDER_JOINT_ANGULAR_LIMIT_DAMPING(15), SLIDER_JOINT_ANGULAR_MOTION_SOFTNESS(16), SLIDER_JOINT_ANGULAR_MOTION_RESTITUTION(17), SLIDER_JOINT_ANGULAR_MOTION_DAMPING(18), SLIDER_JOINT_ANGULAR_ORTHOGONAL_SOFTNESS(19), SLIDER_JOINT_ANGULAR_ORTHOGONAL_RESTITUTION(20), SLIDER_JOINT_ANGULAR_ORTHOGONAL_DAMPING(21), SLIDER_JOINT_MAX(22); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class HingeJointParam( id: Long ) { HINGE_JOINT_BIAS(0), HINGE_JOINT_LIMIT_UPPER(1), HINGE_JOINT_LIMIT_LOWER(2), HINGE_JOINT_LIMIT_BIAS(3), HINGE_JOINT_LIMIT_SOFTNESS(4), HINGE_JOINT_LIMIT_RELAXATION(5), HINGE_JOINT_MOTOR_TARGET_VELOCITY(6), HINGE_JOINT_MOTOR_MAX_IMPULSE(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class G6DOFJointAxisFlag( id: Long ) { G6DOF_JOINT_FLAG_ENABLE_LINEAR_LIMIT(0), G6DOF_JOINT_FLAG_ENABLE_ANGULAR_LIMIT(1), G6DOF_JOINT_FLAG_ENABLE_MOTOR(4), G6DOF_JOINT_FLAG_ENABLE_LINEAR_MOTOR(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class HingeJointFlag( id: Long ) { HINGE_JOINT_FLAG_USE_LIMIT(0), HINGE_JOINT_FLAG_ENABLE_MOTOR(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class AreaSpaceOverrideMode( id: Long ) { AREA_SPACE_OVERRIDE_DISABLED(0), AREA_SPACE_OVERRIDE_COMBINE(1), AREA_SPACE_OVERRIDE_COMBINE_REPLACE(2), AREA_SPACE_OVERRIDE_REPLACE(3), AREA_SPACE_OVERRIDE_REPLACE_COMBINE(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class AreaParameter( id: Long ) { AREA_PARAM_GRAVITY(0), AREA_PARAM_GRAVITY_VECTOR(1), AREA_PARAM_GRAVITY_IS_POINT(2), AREA_PARAM_GRAVITY_DISTANCE_SCALE(3), AREA_PARAM_GRAVITY_POINT_ATTENUATION(4), AREA_PARAM_LINEAR_DAMP(5), AREA_PARAM_ANGULAR_DAMP(6), AREA_PARAM_PRIORITY(7); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PhysicsShapeQueryParameters.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Transform import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_RID import godot.icalls._icall_Transform import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_RID import godot.icalls._icall_Unit_Transform import godot.icalls._icall_Unit_VariantArray import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class PhysicsShapeQueryParameters : Reference() { open var collideWithAreas: Boolean get() { val mb = getMethodBind("PhysicsShapeQueryParameters","is_collide_with_areas_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_collide_with_areas") _icall_Unit_Boolean(mb, this.ptr, value) } open var collideWithBodies: Boolean get() { val mb = getMethodBind("PhysicsShapeQueryParameters","is_collide_with_bodies_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_collide_with_bodies") _icall_Unit_Boolean(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("PhysicsShapeQueryParameters","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open var exclude: VariantArray get() { val mb = getMethodBind("PhysicsShapeQueryParameters","get_exclude") return _icall_VariantArray(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_exclude") _icall_Unit_VariantArray(mb, this.ptr, value) } open var margin: Double get() { val mb = getMethodBind("PhysicsShapeQueryParameters","get_margin") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_margin") _icall_Unit_Double(mb, this.ptr, value) } open var shapeRid: RID get() { val mb = getMethodBind("PhysicsShapeQueryParameters","get_shape_rid") return _icall_RID(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_shape_rid") _icall_Unit_RID(mb, this.ptr, value) } open var transform: Transform get() { val mb = getMethodBind("PhysicsShapeQueryParameters","get_transform") return _icall_Transform(mb, this.ptr) } set(value) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_transform") _icall_Unit_Transform(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PhysicsShapeQueryParameters", "PhysicsShapeQueryParameters") open fun transform(schedule: Transform.() -> Unit): Transform = transform.apply{ schedule(this) transform = this } open fun getCollisionMask(): Long { val mb = getMethodBind("PhysicsShapeQueryParameters","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getExclude(): VariantArray { val mb = getMethodBind("PhysicsShapeQueryParameters","get_exclude") return _icall_VariantArray( mb, this.ptr) } open fun getMargin(): Double { val mb = getMethodBind("PhysicsShapeQueryParameters","get_margin") return _icall_Double( mb, this.ptr) } open fun getShapeRid(): RID { val mb = getMethodBind("PhysicsShapeQueryParameters","get_shape_rid") return _icall_RID( mb, this.ptr) } open fun getTransform(): Transform { val mb = getMethodBind("PhysicsShapeQueryParameters","get_transform") return _icall_Transform( mb, this.ptr) } open fun isCollideWithAreasEnabled(): Boolean { val mb = getMethodBind("PhysicsShapeQueryParameters","is_collide_with_areas_enabled") return _icall_Boolean( mb, this.ptr) } open fun isCollideWithBodiesEnabled(): Boolean { val mb = getMethodBind("PhysicsShapeQueryParameters","is_collide_with_bodies_enabled") return _icall_Boolean( mb, this.ptr) } open fun setCollideWithAreas(enable: Boolean) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_collide_with_areas") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollideWithBodies(enable: Boolean) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_collide_with_bodies") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollisionMask(collisionMask: Long) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_collision_mask") _icall_Unit_Long( mb, this.ptr, collisionMask) } open fun setExclude(exclude: VariantArray) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_exclude") _icall_Unit_VariantArray( mb, this.ptr, exclude) } open fun setMargin(margin: Double) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_margin") _icall_Unit_Double( mb, this.ptr, margin) } open fun setShape(shape: Resource) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_shape") _icall_Unit_Object( mb, this.ptr, shape) } open fun setShapeRid(shape: RID) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_shape_rid") _icall_Unit_RID( mb, this.ptr, shape) } open fun setTransform(transform: Transform) { val mb = getMethodBind("PhysicsShapeQueryParameters","set_transform") _icall_Unit_Transform( mb, this.ptr, transform) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PhysicsShapeQueryResult.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_Object_Long import godot.icalls._icall_RID_Long import godot.internal.utils.getMethodBind import kotlin.Long open class PhysicsShapeQueryResult internal constructor() : Reference() { open fun getResultCount(): Long { val mb = getMethodBind("PhysicsShapeQueryResult","get_result_count") return _icall_Long( mb, this.ptr) } open fun getResultObject(idx: Long): Object { val mb = getMethodBind("PhysicsShapeQueryResult","get_result_object") return _icall_Object_Long( mb, this.ptr, idx) } open fun getResultObjectId(idx: Long): Long { val mb = getMethodBind("PhysicsShapeQueryResult","get_result_object_id") return _icall_Long_Long( mb, this.ptr, idx) } open fun getResultObjectShape(idx: Long): Long { val mb = getMethodBind("PhysicsShapeQueryResult","get_result_object_shape") return _icall_Long_Long( mb, this.ptr, idx) } open fun getResultRid(idx: Long): RID { val mb = getMethodBind("PhysicsShapeQueryResult","get_result_rid") return _icall_RID_Long( mb, this.ptr, idx) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PinJoint.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double_Long import godot.icalls._icall_Unit_Long_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class PinJoint : Joint() { open var params_bias: Double get() { val mb = getMethodBind("PinJoint","get_param") return _icall_Double_Long(mb, this.ptr, 0) } set(value) { val mb = getMethodBind("PinJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 0, value) } open var params_damping: Double get() { val mb = getMethodBind("PinJoint","get_param") return _icall_Double_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("PinJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 1, value) } open var params_impulseClamp: Double get() { val mb = getMethodBind("PinJoint","get_param") return _icall_Double_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("PinJoint","set_param") _icall_Unit_Long_Double(mb, this.ptr, 2, value) } override fun __new(): COpaquePointer = invokeConstructor("PinJoint", "PinJoint") open fun getParam(param: Long): Double { val mb = getMethodBind("PinJoint","get_param") return _icall_Double_Long( mb, this.ptr, param) } open fun setParam(param: Long, value: Double) { val mb = getMethodBind("PinJoint","set_param") _icall_Unit_Long_Double( mb, this.ptr, param, value) } enum class Param( id: Long ) { PARAM_BIAS(0), PARAM_DAMPING(1), PARAM_IMPULSE_CLAMP(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PinJoint2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlinx.cinterop.COpaquePointer open class PinJoint2D : Joint2D() { open var softness: Double get() { val mb = getMethodBind("PinJoint2D","get_softness") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PinJoint2D","set_softness") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PinJoint2D", "PinJoint2D") open fun getSoftness(): Double { val mb = getMethodBind("PinJoint2D","get_softness") return _icall_Double( mb, this.ptr) } open fun setSoftness(softness: Double) { val mb = getMethodBind("PinJoint2D","set_softness") _icall_Unit_Double( mb, this.ptr, softness) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PlaneMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Long import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class PlaneMesh : PrimitiveMesh() { open var size: Vector2 get() { val mb = getMethodBind("PlaneMesh","get_size") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("PlaneMesh","set_size") _icall_Unit_Vector2(mb, this.ptr, value) } open var subdivideDepth: Long get() { val mb = getMethodBind("PlaneMesh","get_subdivide_depth") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PlaneMesh","set_subdivide_depth") _icall_Unit_Long(mb, this.ptr, value) } open var subdivideWidth: Long get() { val mb = getMethodBind("PlaneMesh","get_subdivide_width") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PlaneMesh","set_subdivide_width") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PlaneMesh", "PlaneMesh") open fun size(schedule: Vector2.() -> Unit): Vector2 = size.apply{ schedule(this) size = this } open fun getSize(): Vector2 { val mb = getMethodBind("PlaneMesh","get_size") return _icall_Vector2( mb, this.ptr) } open fun getSubdivideDepth(): Long { val mb = getMethodBind("PlaneMesh","get_subdivide_depth") return _icall_Long( mb, this.ptr) } open fun getSubdivideWidth(): Long { val mb = getMethodBind("PlaneMesh","get_subdivide_width") return _icall_Long( mb, this.ptr) } open fun setSize(size: Vector2) { val mb = getMethodBind("PlaneMesh","set_size") _icall_Unit_Vector2( mb, this.ptr, size) } open fun setSubdivideDepth(subdivide: Long) { val mb = getMethodBind("PlaneMesh","set_subdivide_depth") _icall_Unit_Long( mb, this.ptr, subdivide) } open fun setSubdivideWidth(subdivide: Long) { val mb = getMethodBind("PlaneMesh","set_subdivide_width") _icall_Unit_Long( mb, this.ptr, subdivide) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PlaneShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Plane import godot.icalls._icall_Plane import godot.icalls._icall_Unit_Plane import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class PlaneShape : Shape() { open var plane: Plane get() { val mb = getMethodBind("PlaneShape","get_plane") return _icall_Plane(mb, this.ptr) } set(value) { val mb = getMethodBind("PlaneShape","set_plane") _icall_Unit_Plane(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PlaneShape", "PlaneShape") open fun plane(schedule: Plane.() -> Unit): Plane = plane.apply{ schedule(this) plane = this } open fun getPlane(): Plane { val mb = getMethodBind("PlaneShape","get_plane") return _icall_Plane( mb, this.ptr) } open fun setPlane(plane: Plane) { val mb = getMethodBind("PlaneShape","set_plane") _icall_Unit_Plane( mb, this.ptr, plane) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PluginScript.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Variant import godot.icalls._icall_varargs import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Any import kotlinx.cinterop.COpaquePointer open class PluginScript : Script() { override fun __new(): COpaquePointer = invokeConstructor("PluginScript", "PluginScript") open fun new(vararg __var_args: Any?): Variant { val mb = getMethodBind("PluginScript","new") return _icall_varargs( mb, this.ptr, __var_args) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PointMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class PointMesh : PrimitiveMesh() { override fun __new(): COpaquePointer = invokeConstructor("PointMesh", "PointMesh") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Polygon2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.NodePath import godot.core.PoolColorArray import godot.core.PoolRealArray import godot.core.PoolVector2Array import godot.core.VariantArray import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_NodePath import godot.icalls._icall_NodePath_Long import godot.icalls._icall_PoolColorArray import godot.icalls._icall_PoolRealArray_Long import godot.icalls._icall_PoolVector2Array import godot.icalls._icall_Texture import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_NodePath import godot.icalls._icall_Unit_Long_PoolRealArray import godot.icalls._icall_Unit_NodePath import godot.icalls._icall_Unit_NodePath_PoolRealArray import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_PoolColorArray import godot.icalls._icall_Unit_PoolVector2Array import godot.icalls._icall_Unit_VariantArray import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class Polygon2D : Node2D() { open var antialiased: Boolean get() { val mb = getMethodBind("Polygon2D","get_antialiased") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_antialiased") _icall_Unit_Boolean(mb, this.ptr, value) } open var color: Color get() { val mb = getMethodBind("Polygon2D","get_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_color") _icall_Unit_Color(mb, this.ptr, value) } open var internalVertexCount: Long get() { val mb = getMethodBind("Polygon2D","get_internal_vertex_count") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_internal_vertex_count") _icall_Unit_Long(mb, this.ptr, value) } open var invertBorder: Double get() { val mb = getMethodBind("Polygon2D","get_invert_border") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_invert_border") _icall_Unit_Double(mb, this.ptr, value) } open var invertEnable: Boolean get() { val mb = getMethodBind("Polygon2D","get_invert") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_invert") _icall_Unit_Boolean(mb, this.ptr, value) } open var offset: Vector2 get() { val mb = getMethodBind("Polygon2D","get_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var polygon: PoolVector2Array get() { val mb = getMethodBind("Polygon2D","get_polygon") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_polygon") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } open var polygons: VariantArray get() { val mb = getMethodBind("Polygon2D","get_polygons") return _icall_VariantArray(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_polygons") _icall_Unit_VariantArray(mb, this.ptr, value) } open var skeleton: NodePath get() { val mb = getMethodBind("Polygon2D","get_skeleton") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_skeleton") _icall_Unit_NodePath(mb, this.ptr, value) } open var texture: Texture get() { val mb = getMethodBind("Polygon2D","get_texture") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_texture") _icall_Unit_Object(mb, this.ptr, value) } open var textureOffset: Vector2 get() { val mb = getMethodBind("Polygon2D","get_texture_offset") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_texture_offset") _icall_Unit_Vector2(mb, this.ptr, value) } open var textureRotation: Double get() { val mb = getMethodBind("Polygon2D","get_texture_rotation") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_texture_rotation") _icall_Unit_Double(mb, this.ptr, value) } open var textureRotationDegrees: Double get() { val mb = getMethodBind("Polygon2D","get_texture_rotation_degrees") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_texture_rotation_degrees") _icall_Unit_Double(mb, this.ptr, value) } open var textureScale: Vector2 get() { val mb = getMethodBind("Polygon2D","get_texture_scale") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_texture_scale") _icall_Unit_Vector2(mb, this.ptr, value) } open var uv: PoolVector2Array get() { val mb = getMethodBind("Polygon2D","get_uv") return _icall_PoolVector2Array(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_uv") _icall_Unit_PoolVector2Array(mb, this.ptr, value) } open var vertexColors: PoolColorArray get() { val mb = getMethodBind("Polygon2D","get_vertex_colors") return _icall_PoolColorArray(mb, this.ptr) } set(value) { val mb = getMethodBind("Polygon2D","set_vertex_colors") _icall_Unit_PoolColorArray(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Polygon2D", "Polygon2D") open fun color(schedule: Color.() -> Unit): Color = color.apply{ schedule(this) color = this } open fun offset(schedule: Vector2.() -> Unit): Vector2 = offset.apply{ schedule(this) offset = this } open fun textureOffset(schedule: Vector2.() -> Unit): Vector2 = textureOffset.apply{ schedule(this) textureOffset = this } open fun textureScale(schedule: Vector2.() -> Unit): Vector2 = textureScale.apply{ schedule(this) textureScale = this } open fun _getBones(): VariantArray { throw NotImplementedError("_get_bones is not implemented for Polygon2D") } open fun _setBones(bones: VariantArray) { } open fun _skeletonBoneSetupChanged() { } open fun addBone(path: NodePath, weights: PoolRealArray) { val mb = getMethodBind("Polygon2D","add_bone") _icall_Unit_NodePath_PoolRealArray( mb, this.ptr, path, weights) } open fun clearBones() { val mb = getMethodBind("Polygon2D","clear_bones") _icall_Unit( mb, this.ptr) } open fun eraseBone(index: Long) { val mb = getMethodBind("Polygon2D","erase_bone") _icall_Unit_Long( mb, this.ptr, index) } open fun getAntialiased(): Boolean { val mb = getMethodBind("Polygon2D","get_antialiased") return _icall_Boolean( mb, this.ptr) } open fun getBoneCount(): Long { val mb = getMethodBind("Polygon2D","get_bone_count") return _icall_Long( mb, this.ptr) } open fun getBonePath(index: Long): NodePath { val mb = getMethodBind("Polygon2D","get_bone_path") return _icall_NodePath_Long( mb, this.ptr, index) } open fun getBoneWeights(index: Long): PoolRealArray { val mb = getMethodBind("Polygon2D","get_bone_weights") return _icall_PoolRealArray_Long( mb, this.ptr, index) } open fun getColor(): Color { val mb = getMethodBind("Polygon2D","get_color") return _icall_Color( mb, this.ptr) } open fun getInternalVertexCount(): Long { val mb = getMethodBind("Polygon2D","get_internal_vertex_count") return _icall_Long( mb, this.ptr) } open fun getInvert(): Boolean { val mb = getMethodBind("Polygon2D","get_invert") return _icall_Boolean( mb, this.ptr) } open fun getInvertBorder(): Double { val mb = getMethodBind("Polygon2D","get_invert_border") return _icall_Double( mb, this.ptr) } open fun getOffset(): Vector2 { val mb = getMethodBind("Polygon2D","get_offset") return _icall_Vector2( mb, this.ptr) } open fun getPolygon(): PoolVector2Array { val mb = getMethodBind("Polygon2D","get_polygon") return _icall_PoolVector2Array( mb, this.ptr) } open fun getPolygons(): VariantArray { val mb = getMethodBind("Polygon2D","get_polygons") return _icall_VariantArray( mb, this.ptr) } open fun getSkeleton(): NodePath { val mb = getMethodBind("Polygon2D","get_skeleton") return _icall_NodePath( mb, this.ptr) } open fun getTexture(): Texture { val mb = getMethodBind("Polygon2D","get_texture") return _icall_Texture( mb, this.ptr) } open fun getTextureOffset(): Vector2 { val mb = getMethodBind("Polygon2D","get_texture_offset") return _icall_Vector2( mb, this.ptr) } open fun getTextureRotation(): Double { val mb = getMethodBind("Polygon2D","get_texture_rotation") return _icall_Double( mb, this.ptr) } open fun getTextureRotationDegrees(): Double { val mb = getMethodBind("Polygon2D","get_texture_rotation_degrees") return _icall_Double( mb, this.ptr) } open fun getTextureScale(): Vector2 { val mb = getMethodBind("Polygon2D","get_texture_scale") return _icall_Vector2( mb, this.ptr) } open fun getUv(): PoolVector2Array { val mb = getMethodBind("Polygon2D","get_uv") return _icall_PoolVector2Array( mb, this.ptr) } open fun getVertexColors(): PoolColorArray { val mb = getMethodBind("Polygon2D","get_vertex_colors") return _icall_PoolColorArray( mb, this.ptr) } open fun setAntialiased(antialiased: Boolean) { val mb = getMethodBind("Polygon2D","set_antialiased") _icall_Unit_Boolean( mb, this.ptr, antialiased) } open fun setBonePath(index: Long, path: NodePath) { val mb = getMethodBind("Polygon2D","set_bone_path") _icall_Unit_Long_NodePath( mb, this.ptr, index, path) } open fun setBoneWeights(index: Long, weights: PoolRealArray) { val mb = getMethodBind("Polygon2D","set_bone_weights") _icall_Unit_Long_PoolRealArray( mb, this.ptr, index, weights) } open fun setColor(color: Color) { val mb = getMethodBind("Polygon2D","set_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setInternalVertexCount(internalVertexCount: Long) { val mb = getMethodBind("Polygon2D","set_internal_vertex_count") _icall_Unit_Long( mb, this.ptr, internalVertexCount) } open fun setInvert(invert: Boolean) { val mb = getMethodBind("Polygon2D","set_invert") _icall_Unit_Boolean( mb, this.ptr, invert) } open fun setInvertBorder(invertBorder: Double) { val mb = getMethodBind("Polygon2D","set_invert_border") _icall_Unit_Double( mb, this.ptr, invertBorder) } open fun setOffset(offset: Vector2) { val mb = getMethodBind("Polygon2D","set_offset") _icall_Unit_Vector2( mb, this.ptr, offset) } open fun setPolygon(polygon: PoolVector2Array) { val mb = getMethodBind("Polygon2D","set_polygon") _icall_Unit_PoolVector2Array( mb, this.ptr, polygon) } open fun setPolygons(polygons: VariantArray) { val mb = getMethodBind("Polygon2D","set_polygons") _icall_Unit_VariantArray( mb, this.ptr, polygons) } open fun setSkeleton(skeleton: NodePath) { val mb = getMethodBind("Polygon2D","set_skeleton") _icall_Unit_NodePath( mb, this.ptr, skeleton) } open fun setTexture(texture: Texture) { val mb = getMethodBind("Polygon2D","set_texture") _icall_Unit_Object( mb, this.ptr, texture) } open fun setTextureOffset(textureOffset: Vector2) { val mb = getMethodBind("Polygon2D","set_texture_offset") _icall_Unit_Vector2( mb, this.ptr, textureOffset) } open fun setTextureRotation(textureRotation: Double) { val mb = getMethodBind("Polygon2D","set_texture_rotation") _icall_Unit_Double( mb, this.ptr, textureRotation) } open fun setTextureRotationDegrees(textureRotation: Double) { val mb = getMethodBind("Polygon2D","set_texture_rotation_degrees") _icall_Unit_Double( mb, this.ptr, textureRotation) } open fun setTextureScale(textureScale: Vector2) { val mb = getMethodBind("Polygon2D","set_texture_scale") _icall_Unit_Vector2( mb, this.ptr, textureScale) } open fun setUv(uv: PoolVector2Array) { val mb = getMethodBind("Polygon2D","set_uv") _icall_Unit_PoolVector2Array( mb, this.ptr, uv) } open fun setVertexColors(vertexColors: PoolColorArray) { val mb = getMethodBind("Polygon2D","set_vertex_colors") _icall_Unit_PoolColorArray( mb, this.ptr, vertexColors) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PolygonPathFinder.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.PoolIntArray import godot.core.PoolVector2Array import godot.core.Rect2 import godot.core.Vector2 import godot.icalls._icall_Boolean_Vector2 import godot.icalls._icall_Double_Long import godot.icalls._icall_PoolVector2Array_Vector2_Vector2 import godot.icalls._icall_Rect2 import godot.icalls._icall_Unit_Long_Double import godot.icalls._icall_Unit_PoolVector2Array_PoolIntArray import godot.icalls._icall_Vector2_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class PolygonPathFinder : Resource() { override fun __new(): COpaquePointer = invokeConstructor("PolygonPathFinder", "PolygonPathFinder") open fun _getData(): Dictionary { throw NotImplementedError("_get_data is not implemented for PolygonPathFinder") } open fun _setData(arg0: Dictionary) { } open fun findPath(from: Vector2, to: Vector2): PoolVector2Array { val mb = getMethodBind("PolygonPathFinder","find_path") return _icall_PoolVector2Array_Vector2_Vector2( mb, this.ptr, from, to) } open fun getBounds(): Rect2 { val mb = getMethodBind("PolygonPathFinder","get_bounds") return _icall_Rect2( mb, this.ptr) } open fun getClosestPoint(point: Vector2): Vector2 { val mb = getMethodBind("PolygonPathFinder","get_closest_point") return _icall_Vector2_Vector2( mb, this.ptr, point) } open fun getIntersections(from: Vector2, to: Vector2): PoolVector2Array { val mb = getMethodBind("PolygonPathFinder","get_intersections") return _icall_PoolVector2Array_Vector2_Vector2( mb, this.ptr, from, to) } open fun getPointPenalty(idx: Long): Double { val mb = getMethodBind("PolygonPathFinder","get_point_penalty") return _icall_Double_Long( mb, this.ptr, idx) } open fun isPointInside(point: Vector2): Boolean { val mb = getMethodBind("PolygonPathFinder","is_point_inside") return _icall_Boolean_Vector2( mb, this.ptr, point) } open fun setPointPenalty(idx: Long, penalty: Double) { val mb = getMethodBind("PolygonPathFinder","set_point_penalty") _icall_Unit_Long_Double( mb, this.ptr, idx, penalty) } open fun setup(points: PoolVector2Array, connections: PoolIntArray) { val mb = getMethodBind("PolygonPathFinder","setup") _icall_Unit_PoolVector2Array_PoolIntArray( mb, this.ptr, points, connections) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Popup.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Rect2 import godot.core.Signal0 import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Rect2 import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Unit_Vector2_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class Popup : Control() { val aboutToShow: Signal0 by signal() val popupHide: Signal0 by signal() open var popupExclusive: Boolean get() { val mb = getMethodBind("Popup","is_exclusive") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Popup","set_exclusive") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Popup", "Popup") open fun isExclusive(): Boolean { val mb = getMethodBind("Popup","is_exclusive") return _icall_Boolean( mb, this.ptr) } open fun popup(bounds: Rect2 = Rect2(0.0, 0.0, 0.0, 0.0)) { val mb = getMethodBind("Popup","popup") _icall_Unit_Rect2( mb, this.ptr, bounds) } open fun popupCentered(size: Vector2 = Vector2(0.0, 0.0)) { val mb = getMethodBind("Popup","popup_centered") _icall_Unit_Vector2( mb, this.ptr, size) } open fun popupCenteredClamped(size: Vector2 = Vector2(0.0, 0.0), fallbackRatio: Double = 0.75) { val mb = getMethodBind("Popup","popup_centered_clamped") _icall_Unit_Vector2_Double( mb, this.ptr, size, fallbackRatio) } open fun popupCenteredMinsize(minsize: Vector2 = Vector2(0.0, 0.0)) { val mb = getMethodBind("Popup","popup_centered_minsize") _icall_Unit_Vector2( mb, this.ptr, minsize) } open fun popupCenteredRatio(ratio: Double = 0.75) { val mb = getMethodBind("Popup","popup_centered_ratio") _icall_Unit_Double( mb, this.ptr, ratio) } open fun setAsMinsize() { val mb = getMethodBind("Popup","set_as_minsize") _icall_Unit( mb, this.ptr) } open fun setExclusive(enable: Boolean) { val mb = getMethodBind("Popup","set_exclusive") _icall_Unit_Boolean( mb, this.ptr, enable) } companion object { final const val NOTIFICATION_POPUP_HIDE: Long = 81 final const val NOTIFICATION_POST_POPUP: Long = 80 } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PopupDialog.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class PopupDialog : Popup() { override fun __new(): COpaquePointer = invokeConstructor("PopupDialog", "PopupDialog") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PopupMenu.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal1 import godot.core.Variant import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_ShortCut_Long import godot.icalls._icall_String_Long import godot.icalls._icall_Texture_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Long_Long import godot.icalls._icall_Unit_Long_Object import godot.icalls._icall_Unit_Long_Object_Boolean import godot.icalls._icall_Unit_Long_String import godot.icalls._icall_Unit_Long_Variant import godot.icalls._icall_Unit_Object_Long_Boolean import godot.icalls._icall_Unit_Object_Object_Long_Boolean import godot.icalls._icall_Unit_Object_String_Long_Long import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Long_Long import godot.icalls._icall_Unit_String_Long_Long_Long_Long import godot.icalls._icall_Unit_String_String_Long import godot.icalls._icall_Variant_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class PopupMenu : Popup() { val idFocused: Signal1 by signal("id") val idPressed: Signal1 by signal("id") val indexPressed: Signal1 by signal("index") open var allowSearch: Boolean get() { val mb = getMethodBind("PopupMenu","get_allow_search") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PopupMenu","set_allow_search") _icall_Unit_Boolean(mb, this.ptr, value) } open var hideOnCheckableItemSelection: Boolean get() { val mb = getMethodBind("PopupMenu","is_hide_on_checkable_item_selection") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PopupMenu","set_hide_on_checkable_item_selection") _icall_Unit_Boolean(mb, this.ptr, value) } open var hideOnItemSelection: Boolean get() { val mb = getMethodBind("PopupMenu","is_hide_on_item_selection") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PopupMenu","set_hide_on_item_selection") _icall_Unit_Boolean(mb, this.ptr, value) } open var hideOnStateItemSelection: Boolean get() { val mb = getMethodBind("PopupMenu","is_hide_on_state_item_selection") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PopupMenu","set_hide_on_state_item_selection") _icall_Unit_Boolean(mb, this.ptr, value) } open var submenuPopupDelay: Double get() { val mb = getMethodBind("PopupMenu","get_submenu_popup_delay") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PopupMenu","set_submenu_popup_delay") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PopupMenu", "PopupMenu") open fun _getItems(): VariantArray { throw NotImplementedError("_get_items is not implemented for PopupMenu") } override fun _guiInput(arg0: InputEvent) { } open fun _setItems(arg0: VariantArray) { } open fun _submenuTimeout() { } open fun addCheckItem( label: String, id: Long = -1, accel: Long = 0 ) { val mb = getMethodBind("PopupMenu","add_check_item") _icall_Unit_String_Long_Long( mb, this.ptr, label, id, accel) } open fun addCheckShortcut( shortcut: ShortCut, id: Long = -1, global: Boolean = false ) { val mb = getMethodBind("PopupMenu","add_check_shortcut") _icall_Unit_Object_Long_Boolean( mb, this.ptr, shortcut, id, global) } open fun addIconCheckItem( texture: Texture, label: String, id: Long = -1, accel: Long = 0 ) { val mb = getMethodBind("PopupMenu","add_icon_check_item") _icall_Unit_Object_String_Long_Long( mb, this.ptr, texture, label, id, accel) } open fun addIconCheckShortcut( texture: Texture, shortcut: ShortCut, id: Long = -1, global: Boolean = false ) { val mb = getMethodBind("PopupMenu","add_icon_check_shortcut") _icall_Unit_Object_Object_Long_Boolean( mb, this.ptr, texture, shortcut, id, global) } open fun addIconItem( texture: Texture, label: String, id: Long = -1, accel: Long = 0 ) { val mb = getMethodBind("PopupMenu","add_icon_item") _icall_Unit_Object_String_Long_Long( mb, this.ptr, texture, label, id, accel) } open fun addIconRadioCheckItem( texture: Texture, label: String, id: Long = -1, accel: Long = 0 ) { val mb = getMethodBind("PopupMenu","add_icon_radio_check_item") _icall_Unit_Object_String_Long_Long( mb, this.ptr, texture, label, id, accel) } open fun addIconRadioCheckShortcut( texture: Texture, shortcut: ShortCut, id: Long = -1, global: Boolean = false ) { val mb = getMethodBind("PopupMenu","add_icon_radio_check_shortcut") _icall_Unit_Object_Object_Long_Boolean( mb, this.ptr, texture, shortcut, id, global) } open fun addIconShortcut( texture: Texture, shortcut: ShortCut, id: Long = -1, global: Boolean = false ) { val mb = getMethodBind("PopupMenu","add_icon_shortcut") _icall_Unit_Object_Object_Long_Boolean( mb, this.ptr, texture, shortcut, id, global) } open fun addItem( label: String, id: Long = -1, accel: Long = 0 ) { val mb = getMethodBind("PopupMenu","add_item") _icall_Unit_String_Long_Long( mb, this.ptr, label, id, accel) } open fun addMultistateItem( label: String, maxStates: Long, defaultState: Long = 0, id: Long = -1, accel: Long = 0 ) { val mb = getMethodBind("PopupMenu","add_multistate_item") _icall_Unit_String_Long_Long_Long_Long( mb, this.ptr, label, maxStates, defaultState, id, accel) } open fun addRadioCheckItem( label: String, id: Long = -1, accel: Long = 0 ) { val mb = getMethodBind("PopupMenu","add_radio_check_item") _icall_Unit_String_Long_Long( mb, this.ptr, label, id, accel) } open fun addRadioCheckShortcut( shortcut: ShortCut, id: Long = -1, global: Boolean = false ) { val mb = getMethodBind("PopupMenu","add_radio_check_shortcut") _icall_Unit_Object_Long_Boolean( mb, this.ptr, shortcut, id, global) } open fun addSeparator(label: String = "") { val mb = getMethodBind("PopupMenu","add_separator") _icall_Unit_String( mb, this.ptr, label) } open fun addShortcut( shortcut: ShortCut, id: Long = -1, global: Boolean = false ) { val mb = getMethodBind("PopupMenu","add_shortcut") _icall_Unit_Object_Long_Boolean( mb, this.ptr, shortcut, id, global) } open fun addSubmenuItem( label: String, submenu: String, id: Long = -1 ) { val mb = getMethodBind("PopupMenu","add_submenu_item") _icall_Unit_String_String_Long( mb, this.ptr, label, submenu, id) } open fun clear() { val mb = getMethodBind("PopupMenu","clear") _icall_Unit( mb, this.ptr) } open fun getAllowSearch(): Boolean { val mb = getMethodBind("PopupMenu","get_allow_search") return _icall_Boolean( mb, this.ptr) } open fun getCurrentIndex(): Long { val mb = getMethodBind("PopupMenu","get_current_index") return _icall_Long( mb, this.ptr) } open fun getItemAccelerator(idx: Long): Long { val mb = getMethodBind("PopupMenu","get_item_accelerator") return _icall_Long_Long( mb, this.ptr, idx) } open fun getItemCount(): Long { val mb = getMethodBind("PopupMenu","get_item_count") return _icall_Long( mb, this.ptr) } open fun getItemIcon(idx: Long): Texture { val mb = getMethodBind("PopupMenu","get_item_icon") return _icall_Texture_Long( mb, this.ptr, idx) } open fun getItemId(idx: Long): Long { val mb = getMethodBind("PopupMenu","get_item_id") return _icall_Long_Long( mb, this.ptr, idx) } open fun getItemIndex(id: Long): Long { val mb = getMethodBind("PopupMenu","get_item_index") return _icall_Long_Long( mb, this.ptr, id) } open fun getItemMetadata(idx: Long): Variant { val mb = getMethodBind("PopupMenu","get_item_metadata") return _icall_Variant_Long( mb, this.ptr, idx) } open fun getItemShortcut(idx: Long): ShortCut { val mb = getMethodBind("PopupMenu","get_item_shortcut") return _icall_ShortCut_Long( mb, this.ptr, idx) } open fun getItemSubmenu(idx: Long): String { val mb = getMethodBind("PopupMenu","get_item_submenu") return _icall_String_Long( mb, this.ptr, idx) } open fun getItemText(idx: Long): String { val mb = getMethodBind("PopupMenu","get_item_text") return _icall_String_Long( mb, this.ptr, idx) } open fun getItemTooltip(idx: Long): String { val mb = getMethodBind("PopupMenu","get_item_tooltip") return _icall_String_Long( mb, this.ptr, idx) } open fun getSubmenuPopupDelay(): Double { val mb = getMethodBind("PopupMenu","get_submenu_popup_delay") return _icall_Double( mb, this.ptr) } open fun isHideOnCheckableItemSelection(): Boolean { val mb = getMethodBind("PopupMenu","is_hide_on_checkable_item_selection") return _icall_Boolean( mb, this.ptr) } open fun isHideOnItemSelection(): Boolean { val mb = getMethodBind("PopupMenu","is_hide_on_item_selection") return _icall_Boolean( mb, this.ptr) } open fun isHideOnStateItemSelection(): Boolean { val mb = getMethodBind("PopupMenu","is_hide_on_state_item_selection") return _icall_Boolean( mb, this.ptr) } open fun isHideOnWindowLoseFocus(): Boolean { val mb = getMethodBind("PopupMenu","is_hide_on_window_lose_focus") return _icall_Boolean( mb, this.ptr) } open fun isItemCheckable(idx: Long): Boolean { val mb = getMethodBind("PopupMenu","is_item_checkable") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isItemChecked(idx: Long): Boolean { val mb = getMethodBind("PopupMenu","is_item_checked") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isItemDisabled(idx: Long): Boolean { val mb = getMethodBind("PopupMenu","is_item_disabled") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isItemRadioCheckable(idx: Long): Boolean { val mb = getMethodBind("PopupMenu","is_item_radio_checkable") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isItemSeparator(idx: Long): Boolean { val mb = getMethodBind("PopupMenu","is_item_separator") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun isItemShortcutDisabled(idx: Long): Boolean { val mb = getMethodBind("PopupMenu","is_item_shortcut_disabled") return _icall_Boolean_Long( mb, this.ptr, idx) } open fun removeItem(idx: Long) { val mb = getMethodBind("PopupMenu","remove_item") _icall_Unit_Long( mb, this.ptr, idx) } open fun setAllowSearch(allow: Boolean) { val mb = getMethodBind("PopupMenu","set_allow_search") _icall_Unit_Boolean( mb, this.ptr, allow) } open fun setHideOnCheckableItemSelection(enable: Boolean) { val mb = getMethodBind("PopupMenu","set_hide_on_checkable_item_selection") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setHideOnItemSelection(enable: Boolean) { val mb = getMethodBind("PopupMenu","set_hide_on_item_selection") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setHideOnStateItemSelection(enable: Boolean) { val mb = getMethodBind("PopupMenu","set_hide_on_state_item_selection") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setHideOnWindowLoseFocus(enable: Boolean) { val mb = getMethodBind("PopupMenu","set_hide_on_window_lose_focus") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setItemAccelerator(idx: Long, accel: Long) { val mb = getMethodBind("PopupMenu","set_item_accelerator") _icall_Unit_Long_Long( mb, this.ptr, idx, accel) } open fun setItemAsCheckable(idx: Long, enable: Boolean) { val mb = getMethodBind("PopupMenu","set_item_as_checkable") _icall_Unit_Long_Boolean( mb, this.ptr, idx, enable) } open fun setItemAsRadioCheckable(idx: Long, enable: Boolean) { val mb = getMethodBind("PopupMenu","set_item_as_radio_checkable") _icall_Unit_Long_Boolean( mb, this.ptr, idx, enable) } open fun setItemAsSeparator(idx: Long, enable: Boolean) { val mb = getMethodBind("PopupMenu","set_item_as_separator") _icall_Unit_Long_Boolean( mb, this.ptr, idx, enable) } open fun setItemChecked(idx: Long, checked: Boolean) { val mb = getMethodBind("PopupMenu","set_item_checked") _icall_Unit_Long_Boolean( mb, this.ptr, idx, checked) } open fun setItemDisabled(idx: Long, disabled: Boolean) { val mb = getMethodBind("PopupMenu","set_item_disabled") _icall_Unit_Long_Boolean( mb, this.ptr, idx, disabled) } open fun setItemIcon(idx: Long, icon: Texture) { val mb = getMethodBind("PopupMenu","set_item_icon") _icall_Unit_Long_Object( mb, this.ptr, idx, icon) } open fun setItemId(idx: Long, id: Long) { val mb = getMethodBind("PopupMenu","set_item_id") _icall_Unit_Long_Long( mb, this.ptr, idx, id) } open fun setItemMetadata(idx: Long, metadata: Variant) { val mb = getMethodBind("PopupMenu","set_item_metadata") _icall_Unit_Long_Variant( mb, this.ptr, idx, metadata) } open fun setItemMultistate(idx: Long, state: Long) { val mb = getMethodBind("PopupMenu","set_item_multistate") _icall_Unit_Long_Long( mb, this.ptr, idx, state) } open fun setItemShortcut( idx: Long, shortcut: ShortCut, global: Boolean = false ) { val mb = getMethodBind("PopupMenu","set_item_shortcut") _icall_Unit_Long_Object_Boolean( mb, this.ptr, idx, shortcut, global) } open fun setItemShortcutDisabled(idx: Long, disabled: Boolean) { val mb = getMethodBind("PopupMenu","set_item_shortcut_disabled") _icall_Unit_Long_Boolean( mb, this.ptr, idx, disabled) } open fun setItemSubmenu(idx: Long, submenu: String) { val mb = getMethodBind("PopupMenu","set_item_submenu") _icall_Unit_Long_String( mb, this.ptr, idx, submenu) } open fun setItemText(idx: Long, text: String) { val mb = getMethodBind("PopupMenu","set_item_text") _icall_Unit_Long_String( mb, this.ptr, idx, text) } open fun setItemTooltip(idx: Long, tooltip: String) { val mb = getMethodBind("PopupMenu","set_item_tooltip") _icall_Unit_Long_String( mb, this.ptr, idx, tooltip) } open fun setSubmenuPopupDelay(seconds: Double) { val mb = getMethodBind("PopupMenu","set_submenu_popup_delay") _icall_Unit_Double( mb, this.ptr, seconds) } open fun toggleItemChecked(idx: Long) { val mb = getMethodBind("PopupMenu","toggle_item_checked") _icall_Unit_Long( mb, this.ptr, idx) } open fun toggleItemMultistate(idx: Long) { val mb = getMethodBind("PopupMenu","toggle_item_multistate") _icall_Unit_Long( mb, this.ptr, idx) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PopupPanel.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class PopupPanel : Popup() { override fun __new(): COpaquePointer = invokeConstructor("PopupPanel", "PopupPanel") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Position2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class Position2D : Node2D() { override fun __new(): COpaquePointer = invokeConstructor("Position2D", "Position2D") open fun _getGizmoExtents(): Double { throw NotImplementedError("_get_gizmo_extents is not implemented for Position2D") } open fun _setGizmoExtents(extents: Double) { } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Position3D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class Position3D : Spatial() { override fun __new(): COpaquePointer = invokeConstructor("Position3D", "Position3D") } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PrimitiveMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.AABB import godot.core.VariantArray import godot.icalls._icall_AABB import godot.icalls._icall_Boolean import godot.icalls._icall_Material import godot.icalls._icall_Unit_AABB import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Unit open class PrimitiveMesh internal constructor() : Mesh() { open var customAabb: AABB get() { val mb = getMethodBind("PrimitiveMesh","get_custom_aabb") return _icall_AABB(mb, this.ptr) } set(value) { val mb = getMethodBind("PrimitiveMesh","set_custom_aabb") _icall_Unit_AABB(mb, this.ptr, value) } open var flipFaces: Boolean get() { val mb = getMethodBind("PrimitiveMesh","get_flip_faces") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("PrimitiveMesh","set_flip_faces") _icall_Unit_Boolean(mb, this.ptr, value) } open var material: Material get() { val mb = getMethodBind("PrimitiveMesh","get_material") return _icall_Material(mb, this.ptr) } set(value) { val mb = getMethodBind("PrimitiveMesh","set_material") _icall_Unit_Object(mb, this.ptr, value) } open fun customAabb(schedule: AABB.() -> Unit): AABB = customAabb.apply{ schedule(this) customAabb = this } open fun _update() { } open fun getCustomAabb(): AABB { val mb = getMethodBind("PrimitiveMesh","get_custom_aabb") return _icall_AABB( mb, this.ptr) } open fun getFlipFaces(): Boolean { val mb = getMethodBind("PrimitiveMesh","get_flip_faces") return _icall_Boolean( mb, this.ptr) } open fun getMaterial(): Material { val mb = getMethodBind("PrimitiveMesh","get_material") return _icall_Material( mb, this.ptr) } open fun getMeshArrays(): VariantArray { val mb = getMethodBind("PrimitiveMesh","get_mesh_arrays") return _icall_VariantArray( mb, this.ptr) } open fun setCustomAabb(aabb: AABB) { val mb = getMethodBind("PrimitiveMesh","set_custom_aabb") _icall_Unit_AABB( mb, this.ptr, aabb) } open fun setFlipFaces(flipFaces: Boolean) { val mb = getMethodBind("PrimitiveMesh","set_flip_faces") _icall_Unit_Boolean( mb, this.ptr, flipFaces) } open fun setMaterial(material: Material) { val mb = getMethodBind("PrimitiveMesh","set_material") _icall_Unit_Object( mb, this.ptr, material) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/PrismMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector3 import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class PrismMesh : PrimitiveMesh() { open var leftToRight: Double get() { val mb = getMethodBind("PrismMesh","get_left_to_right") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("PrismMesh","set_left_to_right") _icall_Unit_Double(mb, this.ptr, value) } open var size: Vector3 get() { val mb = getMethodBind("PrismMesh","get_size") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("PrismMesh","set_size") _icall_Unit_Vector3(mb, this.ptr, value) } open var subdivideDepth: Long get() { val mb = getMethodBind("PrismMesh","get_subdivide_depth") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PrismMesh","set_subdivide_depth") _icall_Unit_Long(mb, this.ptr, value) } open var subdivideHeight: Long get() { val mb = getMethodBind("PrismMesh","get_subdivide_height") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PrismMesh","set_subdivide_height") _icall_Unit_Long(mb, this.ptr, value) } open var subdivideWidth: Long get() { val mb = getMethodBind("PrismMesh","get_subdivide_width") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("PrismMesh","set_subdivide_width") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("PrismMesh", "PrismMesh") open fun size(schedule: Vector3.() -> Unit): Vector3 = size.apply{ schedule(this) size = this } open fun getLeftToRight(): Double { val mb = getMethodBind("PrismMesh","get_left_to_right") return _icall_Double( mb, this.ptr) } open fun getSize(): Vector3 { val mb = getMethodBind("PrismMesh","get_size") return _icall_Vector3( mb, this.ptr) } open fun getSubdivideDepth(): Long { val mb = getMethodBind("PrismMesh","get_subdivide_depth") return _icall_Long( mb, this.ptr) } open fun getSubdivideHeight(): Long { val mb = getMethodBind("PrismMesh","get_subdivide_height") return _icall_Long( mb, this.ptr) } open fun getSubdivideWidth(): Long { val mb = getMethodBind("PrismMesh","get_subdivide_width") return _icall_Long( mb, this.ptr) } open fun setLeftToRight(leftToRight: Double) { val mb = getMethodBind("PrismMesh","set_left_to_right") _icall_Unit_Double( mb, this.ptr, leftToRight) } open fun setSize(size: Vector3) { val mb = getMethodBind("PrismMesh","set_size") _icall_Unit_Vector3( mb, this.ptr, size) } open fun setSubdivideDepth(segments: Long) { val mb = getMethodBind("PrismMesh","set_subdivide_depth") _icall_Unit_Long( mb, this.ptr, segments) } open fun setSubdivideHeight(segments: Long) { val mb = getMethodBind("PrismMesh","set_subdivide_height") _icall_Unit_Long( mb, this.ptr, segments) } open fun setSubdivideWidth(segments: Long) { val mb = getMethodBind("PrismMesh","set_subdivide_width") _icall_Unit_Long( mb, this.ptr, segments) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ProceduralSky.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.ProceduralSky import godot.core.Color import godot.icalls._icall_Color import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ProceduralSky : Sky() { open var groundBottomColor: Color get() { val mb = getMethodBind("ProceduralSky","get_ground_bottom_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_ground_bottom_color") _icall_Unit_Color(mb, this.ptr, value) } open var groundCurve: Double get() { val mb = getMethodBind("ProceduralSky","get_ground_curve") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_ground_curve") _icall_Unit_Double(mb, this.ptr, value) } open var groundEnergy: Double get() { val mb = getMethodBind("ProceduralSky","get_ground_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_ground_energy") _icall_Unit_Double(mb, this.ptr, value) } open var groundHorizonColor: Color get() { val mb = getMethodBind("ProceduralSky","get_ground_horizon_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_ground_horizon_color") _icall_Unit_Color(mb, this.ptr, value) } open var skyCurve: Double get() { val mb = getMethodBind("ProceduralSky","get_sky_curve") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sky_curve") _icall_Unit_Double(mb, this.ptr, value) } open var skyEnergy: Double get() { val mb = getMethodBind("ProceduralSky","get_sky_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sky_energy") _icall_Unit_Double(mb, this.ptr, value) } open var skyHorizonColor: Color get() { val mb = getMethodBind("ProceduralSky","get_sky_horizon_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sky_horizon_color") _icall_Unit_Color(mb, this.ptr, value) } open var skyTopColor: Color get() { val mb = getMethodBind("ProceduralSky","get_sky_top_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sky_top_color") _icall_Unit_Color(mb, this.ptr, value) } open var sunAngleMax: Double get() { val mb = getMethodBind("ProceduralSky","get_sun_angle_max") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sun_angle_max") _icall_Unit_Double(mb, this.ptr, value) } open var sunAngleMin: Double get() { val mb = getMethodBind("ProceduralSky","get_sun_angle_min") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sun_angle_min") _icall_Unit_Double(mb, this.ptr, value) } open var sunColor: Color get() { val mb = getMethodBind("ProceduralSky","get_sun_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sun_color") _icall_Unit_Color(mb, this.ptr, value) } open var sunCurve: Double get() { val mb = getMethodBind("ProceduralSky","get_sun_curve") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sun_curve") _icall_Unit_Double(mb, this.ptr, value) } open var sunEnergy: Double get() { val mb = getMethodBind("ProceduralSky","get_sun_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sun_energy") _icall_Unit_Double(mb, this.ptr, value) } open var sunLatitude: Double get() { val mb = getMethodBind("ProceduralSky","get_sun_latitude") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sun_latitude") _icall_Unit_Double(mb, this.ptr, value) } open var sunLongitude: Double get() { val mb = getMethodBind("ProceduralSky","get_sun_longitude") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_sun_longitude") _icall_Unit_Double(mb, this.ptr, value) } open var textureSize: Long get() { val mb = getMethodBind("ProceduralSky","get_texture_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ProceduralSky","set_texture_size") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ProceduralSky", "ProceduralSky") open fun groundBottomColor(schedule: Color.() -> Unit): Color = groundBottomColor.apply{ schedule(this) groundBottomColor = this } open fun groundHorizonColor(schedule: Color.() -> Unit): Color = groundHorizonColor.apply{ schedule(this) groundHorizonColor = this } open fun skyHorizonColor(schedule: Color.() -> Unit): Color = skyHorizonColor.apply{ schedule(this) skyHorizonColor = this } open fun skyTopColor(schedule: Color.() -> Unit): Color = skyTopColor.apply{ schedule(this) skyTopColor = this } open fun sunColor(schedule: Color.() -> Unit): Color = sunColor.apply{ schedule(this) sunColor = this } open fun _threadDone(image: Image) { } open fun _updateSky() { } open fun getGroundBottomColor(): Color { val mb = getMethodBind("ProceduralSky","get_ground_bottom_color") return _icall_Color( mb, this.ptr) } open fun getGroundCurve(): Double { val mb = getMethodBind("ProceduralSky","get_ground_curve") return _icall_Double( mb, this.ptr) } open fun getGroundEnergy(): Double { val mb = getMethodBind("ProceduralSky","get_ground_energy") return _icall_Double( mb, this.ptr) } open fun getGroundHorizonColor(): Color { val mb = getMethodBind("ProceduralSky","get_ground_horizon_color") return _icall_Color( mb, this.ptr) } open fun getSkyCurve(): Double { val mb = getMethodBind("ProceduralSky","get_sky_curve") return _icall_Double( mb, this.ptr) } open fun getSkyEnergy(): Double { val mb = getMethodBind("ProceduralSky","get_sky_energy") return _icall_Double( mb, this.ptr) } open fun getSkyHorizonColor(): Color { val mb = getMethodBind("ProceduralSky","get_sky_horizon_color") return _icall_Color( mb, this.ptr) } open fun getSkyTopColor(): Color { val mb = getMethodBind("ProceduralSky","get_sky_top_color") return _icall_Color( mb, this.ptr) } open fun getSunAngleMax(): Double { val mb = getMethodBind("ProceduralSky","get_sun_angle_max") return _icall_Double( mb, this.ptr) } open fun getSunAngleMin(): Double { val mb = getMethodBind("ProceduralSky","get_sun_angle_min") return _icall_Double( mb, this.ptr) } open fun getSunColor(): Color { val mb = getMethodBind("ProceduralSky","get_sun_color") return _icall_Color( mb, this.ptr) } open fun getSunCurve(): Double { val mb = getMethodBind("ProceduralSky","get_sun_curve") return _icall_Double( mb, this.ptr) } open fun getSunEnergy(): Double { val mb = getMethodBind("ProceduralSky","get_sun_energy") return _icall_Double( mb, this.ptr) } open fun getSunLatitude(): Double { val mb = getMethodBind("ProceduralSky","get_sun_latitude") return _icall_Double( mb, this.ptr) } open fun getSunLongitude(): Double { val mb = getMethodBind("ProceduralSky","get_sun_longitude") return _icall_Double( mb, this.ptr) } open fun getTextureSize(): ProceduralSky.TextureSize { val mb = getMethodBind("ProceduralSky","get_texture_size") return ProceduralSky.TextureSize.from( _icall_Long( mb, this.ptr)) } open fun setGroundBottomColor(color: Color) { val mb = getMethodBind("ProceduralSky","set_ground_bottom_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setGroundCurve(curve: Double) { val mb = getMethodBind("ProceduralSky","set_ground_curve") _icall_Unit_Double( mb, this.ptr, curve) } open fun setGroundEnergy(energy: Double) { val mb = getMethodBind("ProceduralSky","set_ground_energy") _icall_Unit_Double( mb, this.ptr, energy) } open fun setGroundHorizonColor(color: Color) { val mb = getMethodBind("ProceduralSky","set_ground_horizon_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setSkyCurve(curve: Double) { val mb = getMethodBind("ProceduralSky","set_sky_curve") _icall_Unit_Double( mb, this.ptr, curve) } open fun setSkyEnergy(energy: Double) { val mb = getMethodBind("ProceduralSky","set_sky_energy") _icall_Unit_Double( mb, this.ptr, energy) } open fun setSkyHorizonColor(color: Color) { val mb = getMethodBind("ProceduralSky","set_sky_horizon_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setSkyTopColor(color: Color) { val mb = getMethodBind("ProceduralSky","set_sky_top_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setSunAngleMax(degrees: Double) { val mb = getMethodBind("ProceduralSky","set_sun_angle_max") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setSunAngleMin(degrees: Double) { val mb = getMethodBind("ProceduralSky","set_sun_angle_min") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setSunColor(color: Color) { val mb = getMethodBind("ProceduralSky","set_sun_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setSunCurve(curve: Double) { val mb = getMethodBind("ProceduralSky","set_sun_curve") _icall_Unit_Double( mb, this.ptr, curve) } open fun setSunEnergy(energy: Double) { val mb = getMethodBind("ProceduralSky","set_sun_energy") _icall_Unit_Double( mb, this.ptr, energy) } open fun setSunLatitude(degrees: Double) { val mb = getMethodBind("ProceduralSky","set_sun_latitude") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setSunLongitude(degrees: Double) { val mb = getMethodBind("ProceduralSky","set_sun_longitude") _icall_Unit_Double( mb, this.ptr, degrees) } open fun setTextureSize(size: Long) { val mb = getMethodBind("ProceduralSky","set_texture_size") _icall_Unit_Long( mb, this.ptr, size) } enum class TextureSize( id: Long ) { TEXTURE_SIZE_256(0), TEXTURE_SIZE_512(1), TEXTURE_SIZE_1024(2), TEXTURE_SIZE_2048(3), TEXTURE_SIZE_4096(4), TEXTURE_SIZE_MAX(5); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ProgressBar.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Unit_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class ProgressBar : Range() { open var percentVisible: Boolean get() { val mb = getMethodBind("ProgressBar","is_percent_visible") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ProgressBar","set_percent_visible") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ProgressBar", "ProgressBar") open fun isPercentVisible(): Boolean { val mb = getMethodBind("ProgressBar","is_percent_visible") return _icall_Boolean( mb, this.ptr) } open fun setPercentVisible(visible: Boolean) { val mb = getMethodBind("ProgressBar","set_percent_visible") _icall_Unit_Boolean( mb, this.ptr, visible) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ProjectSettings.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.Godot import godot.core.GodotError import godot.core.Variant import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_String_String import godot.icalls._icall_Unit_Dictionary import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Long import godot.icalls._icall_Unit_String_Variant import godot.icalls._icall_Variant_String import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object ProjectSettings : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("ProjectSettings".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton ProjectSettings" } ptr } fun addPropertyInfo(hint: Dictionary) { val mb = getMethodBind("ProjectSettings","add_property_info") _icall_Unit_Dictionary( mb, this.ptr, hint) } fun clear(name: String) { val mb = getMethodBind("ProjectSettings","clear") _icall_Unit_String( mb, this.ptr, name) } fun getOrder(name: String): Long { val mb = getMethodBind("ProjectSettings","get_order") return _icall_Long_String( mb, this.ptr, name) } fun getSetting(name: String): Variant { val mb = getMethodBind("ProjectSettings","get_setting") return _icall_Variant_String( mb, this.ptr, name) } fun globalizePath(path: String): String { val mb = getMethodBind("ProjectSettings","globalize_path") return _icall_String_String( mb, this.ptr, path) } fun hasSetting(name: String): Boolean { val mb = getMethodBind("ProjectSettings","has_setting") return _icall_Boolean_String( mb, this.ptr, name) } fun loadResourcePack(pack: String, replaceFiles: Boolean = true): Boolean { val mb = getMethodBind("ProjectSettings","load_resource_pack") return _icall_Boolean_String_Boolean( mb, this.ptr, pack, replaceFiles) } fun localizePath(path: String): String { val mb = getMethodBind("ProjectSettings","localize_path") return _icall_String_String( mb, this.ptr, path) } fun propertyCanRevert(name: String): Boolean { val mb = getMethodBind("ProjectSettings","property_can_revert") return _icall_Boolean_String( mb, this.ptr, name) } fun propertyGetRevert(name: String): Variant { val mb = getMethodBind("ProjectSettings","property_get_revert") return _icall_Variant_String( mb, this.ptr, name) } fun save(): GodotError { val mb = getMethodBind("ProjectSettings","save") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } fun saveCustom(file: String): GodotError { val mb = getMethodBind("ProjectSettings","save_custom") return GodotError.byValue( _icall_Long_String( mb, this.ptr, file).toUInt()) } fun setInitialValue(name: String, value: Variant) { val mb = getMethodBind("ProjectSettings","set_initial_value") _icall_Unit_String_Variant( mb, this.ptr, name, value) } fun setOrder(name: String, position: Long) { val mb = getMethodBind("ProjectSettings","set_order") _icall_Unit_String_Long( mb, this.ptr, name, position) } fun setSetting(name: String, value: Variant) { val mb = getMethodBind("ProjectSettings","set_setting") _icall_Unit_String_Variant( mb, this.ptr, name, value) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ProximityGroup.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.ProximityGroup import godot.core.Signal2 import godot.core.Variant import godot.core.VariantArray import godot.core.Vector3 import godot.core.signal import godot.icalls._icall_Long import godot.icalls._icall_String import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Variant import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ProximityGroup : Spatial() { val broadcast: Signal2 by signal("group_name", "parameters") open var dispatchMode: Long get() { val mb = getMethodBind("ProximityGroup","get_dispatch_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ProximityGroup","set_dispatch_mode") _icall_Unit_Long(mb, this.ptr, value) } open var gridRadius: Vector3 get() { val mb = getMethodBind("ProximityGroup","get_grid_radius") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("ProximityGroup","set_grid_radius") _icall_Unit_Vector3(mb, this.ptr, value) } open var groupName: String get() { val mb = getMethodBind("ProximityGroup","get_group_name") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("ProximityGroup","set_group_name") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ProximityGroup", "ProximityGroup") open fun gridRadius(schedule: Vector3.() -> Unit): Vector3 = gridRadius.apply{ schedule(this) gridRadius = this } open fun _proximityGroupBroadcast(name: String, params: Variant) { } open fun broadcast(name: String, parameters: Variant) { val mb = getMethodBind("ProximityGroup","broadcast") _icall_Unit_String_Variant( mb, this.ptr, name, parameters) } open fun getDispatchMode(): ProximityGroup.DispatchMode { val mb = getMethodBind("ProximityGroup","get_dispatch_mode") return ProximityGroup.DispatchMode.from( _icall_Long( mb, this.ptr)) } open fun getGridRadius(): Vector3 { val mb = getMethodBind("ProximityGroup","get_grid_radius") return _icall_Vector3( mb, this.ptr) } open fun getGroupName(): String { val mb = getMethodBind("ProximityGroup","get_group_name") return _icall_String( mb, this.ptr) } open fun setDispatchMode(mode: Long) { val mb = getMethodBind("ProximityGroup","set_dispatch_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setGridRadius(radius: Vector3) { val mb = getMethodBind("ProximityGroup","set_grid_radius") _icall_Unit_Vector3( mb, this.ptr, radius) } open fun setGroupName(name: String) { val mb = getMethodBind("ProximityGroup","set_group_name") _icall_Unit_String( mb, this.ptr, name) } enum class DispatchMode( id: Long ) { MODE_PROXY(0), MODE_SIGNAL(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ProxyTexture.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Texture import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlinx.cinterop.COpaquePointer open class ProxyTexture : Texture() { open var base: Texture get() { val mb = getMethodBind("ProxyTexture","get_base") return _icall_Texture(mb, this.ptr) } set(value) { val mb = getMethodBind("ProxyTexture","set_base") _icall_Unit_Object(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ProxyTexture", "ProxyTexture") open fun getBase(): Texture { val mb = getMethodBind("ProxyTexture","get_base") return _icall_Texture( mb, this.ptr) } open fun setBase(base: Texture) { val mb = getMethodBind("ProxyTexture","set_base") _icall_Unit_Object( mb, this.ptr, base) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/QuadMesh.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class QuadMesh : PrimitiveMesh() { open var size: Vector2 get() { val mb = getMethodBind("QuadMesh","get_size") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("QuadMesh","set_size") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("QuadMesh", "QuadMesh") open fun size(schedule: Vector2.() -> Unit): Vector2 = size.apply{ schedule(this) size = this } open fun getSize(): Vector2 { val mb = getMethodBind("QuadMesh","get_size") return _icall_Vector2( mb, this.ptr) } open fun setSize(size: Vector2) { val mb = getMethodBind("QuadMesh","set_size") _icall_Unit_Vector2( mb, this.ptr, size) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RandomNumberGenerator.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Double import godot.icalls._icall_Double_Double_Double import godot.icalls._icall_Long import godot.icalls._icall_Long_Long_Long import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Double import kotlin.Long import kotlinx.cinterop.COpaquePointer open class RandomNumberGenerator : Reference() { open var seed: Long get() { val mb = getMethodBind("RandomNumberGenerator","get_seed") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RandomNumberGenerator","set_seed") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RandomNumberGenerator", "RandomNumberGenerator") open fun getSeed(): Long { val mb = getMethodBind("RandomNumberGenerator","get_seed") return _icall_Long( mb, this.ptr) } open fun randf(): Double { val mb = getMethodBind("RandomNumberGenerator","randf") return _icall_Double( mb, this.ptr) } open fun randfRange(from: Double, to: Double): Double { val mb = getMethodBind("RandomNumberGenerator","randf_range") return _icall_Double_Double_Double( mb, this.ptr, from, to) } open fun randfn(mean: Double = 0.0, deviation: Double = 1.0): Double { val mb = getMethodBind("RandomNumberGenerator","randfn") return _icall_Double_Double_Double( mb, this.ptr, mean, deviation) } open fun randi(): Long { val mb = getMethodBind("RandomNumberGenerator","randi") return _icall_Long( mb, this.ptr) } open fun randiRange(from: Long, to: Long): Long { val mb = getMethodBind("RandomNumberGenerator","randi_range") return _icall_Long_Long_Long( mb, this.ptr, from, to) } open fun randomize() { val mb = getMethodBind("RandomNumberGenerator","randomize") _icall_Unit( mb, this.ptr) } open fun setSeed(seed: Long) { val mb = getMethodBind("RandomNumberGenerator","set_seed") _icall_Unit_Long( mb, this.ptr, seed) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Range.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Object import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Double open class Range internal constructor() : Control() { val changed: Signal0 by signal() val valueChanged: Signal1 by signal("value") open var allowGreater: Boolean get() { val mb = getMethodBind("Range","is_greater_allowed") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_allow_greater") _icall_Unit_Boolean(mb, this.ptr, value) } open var allowLesser: Boolean get() { val mb = getMethodBind("Range","is_lesser_allowed") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_allow_lesser") _icall_Unit_Boolean(mb, this.ptr, value) } open var expEdit: Boolean get() { val mb = getMethodBind("Range","is_ratio_exp") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_exp_ratio") _icall_Unit_Boolean(mb, this.ptr, value) } open var maxValue: Double get() { val mb = getMethodBind("Range","get_max") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_max") _icall_Unit_Double(mb, this.ptr, value) } open var minValue: Double get() { val mb = getMethodBind("Range","get_min") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_min") _icall_Unit_Double(mb, this.ptr, value) } open var page: Double get() { val mb = getMethodBind("Range","get_page") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_page") _icall_Unit_Double(mb, this.ptr, value) } open var ratio: Double get() { val mb = getMethodBind("Range","get_as_ratio") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_as_ratio") _icall_Unit_Double(mb, this.ptr, value) } open var rounded: Boolean get() { val mb = getMethodBind("Range","is_using_rounded_values") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_use_rounded_values") _icall_Unit_Boolean(mb, this.ptr, value) } open var step: Double get() { val mb = getMethodBind("Range","get_step") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_step") _icall_Unit_Double(mb, this.ptr, value) } open var value: Double get() { val mb = getMethodBind("Range","get_value") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("Range","set_value") _icall_Unit_Double(mb, this.ptr, value) } open fun getAsRatio(): Double { val mb = getMethodBind("Range","get_as_ratio") return _icall_Double( mb, this.ptr) } open fun getMax(): Double { val mb = getMethodBind("Range","get_max") return _icall_Double( mb, this.ptr) } open fun getMin(): Double { val mb = getMethodBind("Range","get_min") return _icall_Double( mb, this.ptr) } open fun getPage(): Double { val mb = getMethodBind("Range","get_page") return _icall_Double( mb, this.ptr) } open fun getStep(): Double { val mb = getMethodBind("Range","get_step") return _icall_Double( mb, this.ptr) } open fun getValue(): Double { val mb = getMethodBind("Range","get_value") return _icall_Double( mb, this.ptr) } open fun isGreaterAllowed(): Boolean { val mb = getMethodBind("Range","is_greater_allowed") return _icall_Boolean( mb, this.ptr) } open fun isLesserAllowed(): Boolean { val mb = getMethodBind("Range","is_lesser_allowed") return _icall_Boolean( mb, this.ptr) } open fun isRatioExp(): Boolean { val mb = getMethodBind("Range","is_ratio_exp") return _icall_Boolean( mb, this.ptr) } open fun isUsingRoundedValues(): Boolean { val mb = getMethodBind("Range","is_using_rounded_values") return _icall_Boolean( mb, this.ptr) } open fun setAllowGreater(allow: Boolean) { val mb = getMethodBind("Range","set_allow_greater") _icall_Unit_Boolean( mb, this.ptr, allow) } open fun setAllowLesser(allow: Boolean) { val mb = getMethodBind("Range","set_allow_lesser") _icall_Unit_Boolean( mb, this.ptr, allow) } open fun setAsRatio(value: Double) { val mb = getMethodBind("Range","set_as_ratio") _icall_Unit_Double( mb, this.ptr, value) } open fun setExpRatio(enabled: Boolean) { val mb = getMethodBind("Range","set_exp_ratio") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setMax(maximum: Double) { val mb = getMethodBind("Range","set_max") _icall_Unit_Double( mb, this.ptr, maximum) } open fun setMin(minimum: Double) { val mb = getMethodBind("Range","set_min") _icall_Unit_Double( mb, this.ptr, minimum) } open fun setPage(pagesize: Double) { val mb = getMethodBind("Range","set_page") _icall_Unit_Double( mb, this.ptr, pagesize) } open fun setStep(step: Double) { val mb = getMethodBind("Range","set_step") _icall_Unit_Double( mb, this.ptr, step) } open fun setUseRoundedValues(enabled: Boolean) { val mb = getMethodBind("Range","set_use_rounded_values") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setValue(value: Double) { val mb = getMethodBind("Range","set_value") _icall_Unit_Double( mb, this.ptr, value) } open fun share(with: Node) { val mb = getMethodBind("Range","share") _icall_Unit_Object( mb, this.ptr, with) } open fun unshare() { val mb = getMethodBind("Range","unshare") _icall_Unit( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RayCast.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Vector3 import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Long import godot.icalls._icall_Object import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_RID import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class RayCast : Spatial() { open var castTo: Vector3 get() { val mb = getMethodBind("RayCast","get_cast_to") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast","set_cast_to") _icall_Unit_Vector3(mb, this.ptr, value) } open var collideWithAreas: Boolean get() { val mb = getMethodBind("RayCast","is_collide_with_areas_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast","set_collide_with_areas") _icall_Unit_Boolean(mb, this.ptr, value) } open var collideWithBodies: Boolean get() { val mb = getMethodBind("RayCast","is_collide_with_bodies_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast","set_collide_with_bodies") _icall_Unit_Boolean(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("RayCast","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open var enabled: Boolean get() { val mb = getMethodBind("RayCast","is_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast","set_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var excludeParent: Boolean get() { val mb = getMethodBind("RayCast","get_exclude_parent_body") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast","set_exclude_parent_body") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RayCast", "RayCast") open fun castTo(schedule: Vector3.() -> Unit): Vector3 = castTo.apply{ schedule(this) castTo = this } open fun addException(node: Object) { val mb = getMethodBind("RayCast","add_exception") _icall_Unit_Object( mb, this.ptr, node) } open fun addExceptionRid(rid: RID) { val mb = getMethodBind("RayCast","add_exception_rid") _icall_Unit_RID( mb, this.ptr, rid) } open fun clearExceptions() { val mb = getMethodBind("RayCast","clear_exceptions") _icall_Unit( mb, this.ptr) } open fun forceRaycastUpdate() { val mb = getMethodBind("RayCast","force_raycast_update") _icall_Unit( mb, this.ptr) } open fun getCastTo(): Vector3 { val mb = getMethodBind("RayCast","get_cast_to") return _icall_Vector3( mb, this.ptr) } open fun getCollider(): Object { val mb = getMethodBind("RayCast","get_collider") return _icall_Object( mb, this.ptr) } open fun getColliderShape(): Long { val mb = getMethodBind("RayCast","get_collider_shape") return _icall_Long( mb, this.ptr) } open fun getCollisionMask(): Long { val mb = getMethodBind("RayCast","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("RayCast","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getCollisionNormal(): Vector3 { val mb = getMethodBind("RayCast","get_collision_normal") return _icall_Vector3( mb, this.ptr) } open fun getCollisionPoint(): Vector3 { val mb = getMethodBind("RayCast","get_collision_point") return _icall_Vector3( mb, this.ptr) } open fun getExcludeParentBody(): Boolean { val mb = getMethodBind("RayCast","get_exclude_parent_body") return _icall_Boolean( mb, this.ptr) } open fun isCollideWithAreasEnabled(): Boolean { val mb = getMethodBind("RayCast","is_collide_with_areas_enabled") return _icall_Boolean( mb, this.ptr) } open fun isCollideWithBodiesEnabled(): Boolean { val mb = getMethodBind("RayCast","is_collide_with_bodies_enabled") return _icall_Boolean( mb, this.ptr) } open fun isColliding(): Boolean { val mb = getMethodBind("RayCast","is_colliding") return _icall_Boolean( mb, this.ptr) } open fun isEnabled(): Boolean { val mb = getMethodBind("RayCast","is_enabled") return _icall_Boolean( mb, this.ptr) } open fun removeException(node: Object) { val mb = getMethodBind("RayCast","remove_exception") _icall_Unit_Object( mb, this.ptr, node) } open fun removeExceptionRid(rid: RID) { val mb = getMethodBind("RayCast","remove_exception_rid") _icall_Unit_RID( mb, this.ptr, rid) } open fun setCastTo(localPoint: Vector3) { val mb = getMethodBind("RayCast","set_cast_to") _icall_Unit_Vector3( mb, this.ptr, localPoint) } open fun setCollideWithAreas(enable: Boolean) { val mb = getMethodBind("RayCast","set_collide_with_areas") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollideWithBodies(enable: Boolean) { val mb = getMethodBind("RayCast","set_collide_with_bodies") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollisionMask(mask: Long) { val mb = getMethodBind("RayCast","set_collision_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("RayCast","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setEnabled(enabled: Boolean) { val mb = getMethodBind("RayCast","set_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setExcludeParentBody(mask: Boolean) { val mb = getMethodBind("RayCast","set_exclude_parent_body") _icall_Unit_Boolean( mb, this.ptr, mask) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RayCast2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Vector2 import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Long import godot.icalls._icall_Object import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_RID import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class RayCast2D : Node2D() { open var castTo: Vector2 get() { val mb = getMethodBind("RayCast2D","get_cast_to") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast2D","set_cast_to") _icall_Unit_Vector2(mb, this.ptr, value) } open var collideWithAreas: Boolean get() { val mb = getMethodBind("RayCast2D","is_collide_with_areas_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast2D","set_collide_with_areas") _icall_Unit_Boolean(mb, this.ptr, value) } open var collideWithBodies: Boolean get() { val mb = getMethodBind("RayCast2D","is_collide_with_bodies_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast2D","set_collide_with_bodies") _icall_Unit_Boolean(mb, this.ptr, value) } open var collisionMask: Long get() { val mb = getMethodBind("RayCast2D","get_collision_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast2D","set_collision_mask") _icall_Unit_Long(mb, this.ptr, value) } open var enabled: Boolean get() { val mb = getMethodBind("RayCast2D","is_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast2D","set_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var excludeParent: Boolean get() { val mb = getMethodBind("RayCast2D","get_exclude_parent_body") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayCast2D","set_exclude_parent_body") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RayCast2D", "RayCast2D") open fun castTo(schedule: Vector2.() -> Unit): Vector2 = castTo.apply{ schedule(this) castTo = this } open fun addException(node: Object) { val mb = getMethodBind("RayCast2D","add_exception") _icall_Unit_Object( mb, this.ptr, node) } open fun addExceptionRid(rid: RID) { val mb = getMethodBind("RayCast2D","add_exception_rid") _icall_Unit_RID( mb, this.ptr, rid) } open fun clearExceptions() { val mb = getMethodBind("RayCast2D","clear_exceptions") _icall_Unit( mb, this.ptr) } open fun forceRaycastUpdate() { val mb = getMethodBind("RayCast2D","force_raycast_update") _icall_Unit( mb, this.ptr) } open fun getCastTo(): Vector2 { val mb = getMethodBind("RayCast2D","get_cast_to") return _icall_Vector2( mb, this.ptr) } open fun getCollider(): Object { val mb = getMethodBind("RayCast2D","get_collider") return _icall_Object( mb, this.ptr) } open fun getColliderShape(): Long { val mb = getMethodBind("RayCast2D","get_collider_shape") return _icall_Long( mb, this.ptr) } open fun getCollisionMask(): Long { val mb = getMethodBind("RayCast2D","get_collision_mask") return _icall_Long( mb, this.ptr) } open fun getCollisionMaskBit(bit: Long): Boolean { val mb = getMethodBind("RayCast2D","get_collision_mask_bit") return _icall_Boolean_Long( mb, this.ptr, bit) } open fun getCollisionNormal(): Vector2 { val mb = getMethodBind("RayCast2D","get_collision_normal") return _icall_Vector2( mb, this.ptr) } open fun getCollisionPoint(): Vector2 { val mb = getMethodBind("RayCast2D","get_collision_point") return _icall_Vector2( mb, this.ptr) } open fun getExcludeParentBody(): Boolean { val mb = getMethodBind("RayCast2D","get_exclude_parent_body") return _icall_Boolean( mb, this.ptr) } open fun isCollideWithAreasEnabled(): Boolean { val mb = getMethodBind("RayCast2D","is_collide_with_areas_enabled") return _icall_Boolean( mb, this.ptr) } open fun isCollideWithBodiesEnabled(): Boolean { val mb = getMethodBind("RayCast2D","is_collide_with_bodies_enabled") return _icall_Boolean( mb, this.ptr) } open fun isColliding(): Boolean { val mb = getMethodBind("RayCast2D","is_colliding") return _icall_Boolean( mb, this.ptr) } open fun isEnabled(): Boolean { val mb = getMethodBind("RayCast2D","is_enabled") return _icall_Boolean( mb, this.ptr) } open fun removeException(node: Object) { val mb = getMethodBind("RayCast2D","remove_exception") _icall_Unit_Object( mb, this.ptr, node) } open fun removeExceptionRid(rid: RID) { val mb = getMethodBind("RayCast2D","remove_exception_rid") _icall_Unit_RID( mb, this.ptr, rid) } open fun setCastTo(localPoint: Vector2) { val mb = getMethodBind("RayCast2D","set_cast_to") _icall_Unit_Vector2( mb, this.ptr, localPoint) } open fun setCollideWithAreas(enable: Boolean) { val mb = getMethodBind("RayCast2D","set_collide_with_areas") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollideWithBodies(enable: Boolean) { val mb = getMethodBind("RayCast2D","set_collide_with_bodies") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCollisionMask(mask: Long) { val mb = getMethodBind("RayCast2D","set_collision_mask") _icall_Unit_Long( mb, this.ptr, mask) } open fun setCollisionMaskBit(bit: Long, value: Boolean) { val mb = getMethodBind("RayCast2D","set_collision_mask_bit") _icall_Unit_Long_Boolean( mb, this.ptr, bit, value) } open fun setEnabled(enabled: Boolean) { val mb = getMethodBind("RayCast2D","set_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setExcludeParentBody(mask: Boolean) { val mb = getMethodBind("RayCast2D","set_exclude_parent_body") _icall_Unit_Boolean( mb, this.ptr, mask) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RayShape.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlinx.cinterop.COpaquePointer open class RayShape : Shape() { open var length: Double get() { val mb = getMethodBind("RayShape","get_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RayShape","set_length") _icall_Unit_Double(mb, this.ptr, value) } open var slipsOnSlope: Boolean get() { val mb = getMethodBind("RayShape","get_slips_on_slope") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayShape","set_slips_on_slope") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RayShape", "RayShape") open fun getLength(): Double { val mb = getMethodBind("RayShape","get_length") return _icall_Double( mb, this.ptr) } open fun getSlipsOnSlope(): Boolean { val mb = getMethodBind("RayShape","get_slips_on_slope") return _icall_Boolean( mb, this.ptr) } open fun setLength(length: Double) { val mb = getMethodBind("RayShape","set_length") _icall_Unit_Double( mb, this.ptr, length) } open fun setSlipsOnSlope(active: Boolean) { val mb = getMethodBind("RayShape","set_slips_on_slope") _icall_Unit_Boolean( mb, this.ptr, active) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RayShape2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.icalls._icall_Double import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlinx.cinterop.COpaquePointer open class RayShape2D : Shape2D() { open var length: Double get() { val mb = getMethodBind("RayShape2D","get_length") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RayShape2D","set_length") _icall_Unit_Double(mb, this.ptr, value) } open var slipsOnSlope: Boolean get() { val mb = getMethodBind("RayShape2D","get_slips_on_slope") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RayShape2D","set_slips_on_slope") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RayShape2D", "RayShape2D") open fun getLength(): Double { val mb = getMethodBind("RayShape2D","get_length") return _icall_Double( mb, this.ptr) } open fun getSlipsOnSlope(): Boolean { val mb = getMethodBind("RayShape2D","get_slips_on_slope") return _icall_Boolean( mb, this.ptr) } open fun setLength(length: Double) { val mb = getMethodBind("RayShape2D","set_length") _icall_Unit_Double( mb, this.ptr, length) } open fun setSlipsOnSlope(active: Boolean) { val mb = getMethodBind("RayShape2D","set_slips_on_slope") _icall_Unit_Boolean( mb, this.ptr, active) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RectangleShape2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Vector2 import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class RectangleShape2D : Shape2D() { open var extents: Vector2 get() { val mb = getMethodBind("RectangleShape2D","get_extents") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("RectangleShape2D","set_extents") _icall_Unit_Vector2(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RectangleShape2D", "RectangleShape2D") open fun extents(schedule: Vector2.() -> Unit): Vector2 = extents.apply{ schedule(this) extents = this } open fun getExtents(): Vector2 { val mb = getMethodBind("RectangleShape2D","get_extents") return _icall_Vector2( mb, this.ptr) } open fun setExtents(extents: Vector2) { val mb = getMethodBind("RectangleShape2D","set_extents") _icall_Unit_Vector2( mb, this.ptr, extents) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Reference.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.icalls._icall_Boolean import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class Reference : Object() { override fun __new(): COpaquePointer = invokeConstructor("Reference", "Reference") open fun initRef(): Boolean { val mb = getMethodBind("Reference","init_ref") return _icall_Boolean( mb, this.ptr) } open fun reference(): Boolean { val mb = getMethodBind("Reference","reference") return _icall_Boolean( mb, this.ptr) } open fun unreference(): Boolean { val mb = getMethodBind("Reference","unreference") return _icall_Boolean( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ReferenceRect.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ReferenceRect : Control() { open var borderColor: Color get() { val mb = getMethodBind("ReferenceRect","get_border_color") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ReferenceRect","set_border_color") _icall_Unit_Color(mb, this.ptr, value) } open var editorOnly: Boolean get() { val mb = getMethodBind("ReferenceRect","get_editor_only") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ReferenceRect","set_editor_only") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ReferenceRect", "ReferenceRect") open fun borderColor(schedule: Color.() -> Unit): Color = borderColor.apply{ schedule(this) borderColor = this } open fun getBorderColor(): Color { val mb = getMethodBind("ReferenceRect","get_border_color") return _icall_Color( mb, this.ptr) } open fun getEditorOnly(): Boolean { val mb = getMethodBind("ReferenceRect","get_editor_only") return _icall_Boolean( mb, this.ptr) } open fun setBorderColor(color: Color) { val mb = getMethodBind("ReferenceRect","set_border_color") _icall_Unit_Color( mb, this.ptr, color) } open fun setEditorOnly(enabled: Boolean) { val mb = getMethodBind("ReferenceRect","set_editor_only") _icall_Unit_Boolean( mb, this.ptr, enabled) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ReflectionProbe.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.ReflectionProbe import godot.core.Color import godot.core.Vector3 import godot.icalls._icall_Boolean import godot.icalls._icall_Color import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class ReflectionProbe : VisualInstance() { open var boxProjection: Boolean get() { val mb = getMethodBind("ReflectionProbe","is_box_projection_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_enable_box_projection") _icall_Unit_Boolean(mb, this.ptr, value) } open var cullMask: Long get() { val mb = getMethodBind("ReflectionProbe","get_cull_mask") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_cull_mask") _icall_Unit_Long(mb, this.ptr, value) } open var enableShadows: Boolean get() { val mb = getMethodBind("ReflectionProbe","are_shadows_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_enable_shadows") _icall_Unit_Boolean(mb, this.ptr, value) } open var extents: Vector3 get() { val mb = getMethodBind("ReflectionProbe","get_extents") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_extents") _icall_Unit_Vector3(mb, this.ptr, value) } open var intensity: Double get() { val mb = getMethodBind("ReflectionProbe","get_intensity") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_intensity") _icall_Unit_Double(mb, this.ptr, value) } open var interiorAmbientColor: Color get() { val mb = getMethodBind("ReflectionProbe","get_interior_ambient") return _icall_Color(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_interior_ambient") _icall_Unit_Color(mb, this.ptr, value) } open var interiorAmbientContrib: Double get() { val mb = getMethodBind("ReflectionProbe","get_interior_ambient_probe_contribution") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_interior_ambient_probe_contribution") _icall_Unit_Double(mb, this.ptr, value) } open var interiorAmbientEnergy: Double get() { val mb = getMethodBind("ReflectionProbe","get_interior_ambient_energy") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_interior_ambient_energy") _icall_Unit_Double(mb, this.ptr, value) } open var interiorEnable: Boolean get() { val mb = getMethodBind("ReflectionProbe","is_set_as_interior") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_as_interior") _icall_Unit_Boolean(mb, this.ptr, value) } open var maxDistance: Double get() { val mb = getMethodBind("ReflectionProbe","get_max_distance") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_max_distance") _icall_Unit_Double(mb, this.ptr, value) } open var originOffset: Vector3 get() { val mb = getMethodBind("ReflectionProbe","get_origin_offset") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_origin_offset") _icall_Unit_Vector3(mb, this.ptr, value) } open var updateMode: Long get() { val mb = getMethodBind("ReflectionProbe","get_update_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("ReflectionProbe","set_update_mode") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("ReflectionProbe", "ReflectionProbe") open fun extents(schedule: Vector3.() -> Unit): Vector3 = extents.apply{ schedule(this) extents = this } open fun interiorAmbientColor(schedule: Color.() -> Unit): Color = interiorAmbientColor.apply{ schedule(this) interiorAmbientColor = this } open fun originOffset(schedule: Vector3.() -> Unit): Vector3 = originOffset.apply{ schedule(this) originOffset = this } open fun areShadowsEnabled(): Boolean { val mb = getMethodBind("ReflectionProbe","are_shadows_enabled") return _icall_Boolean( mb, this.ptr) } open fun getCullMask(): Long { val mb = getMethodBind("ReflectionProbe","get_cull_mask") return _icall_Long( mb, this.ptr) } open fun getExtents(): Vector3 { val mb = getMethodBind("ReflectionProbe","get_extents") return _icall_Vector3( mb, this.ptr) } open fun getIntensity(): Double { val mb = getMethodBind("ReflectionProbe","get_intensity") return _icall_Double( mb, this.ptr) } open fun getInteriorAmbient(): Color { val mb = getMethodBind("ReflectionProbe","get_interior_ambient") return _icall_Color( mb, this.ptr) } open fun getInteriorAmbientEnergy(): Double { val mb = getMethodBind("ReflectionProbe","get_interior_ambient_energy") return _icall_Double( mb, this.ptr) } open fun getInteriorAmbientProbeContribution(): Double { val mb = getMethodBind("ReflectionProbe","get_interior_ambient_probe_contribution") return _icall_Double( mb, this.ptr) } open fun getMaxDistance(): Double { val mb = getMethodBind("ReflectionProbe","get_max_distance") return _icall_Double( mb, this.ptr) } open fun getOriginOffset(): Vector3 { val mb = getMethodBind("ReflectionProbe","get_origin_offset") return _icall_Vector3( mb, this.ptr) } open fun getUpdateMode(): ReflectionProbe.UpdateMode { val mb = getMethodBind("ReflectionProbe","get_update_mode") return ReflectionProbe.UpdateMode.from( _icall_Long( mb, this.ptr)) } open fun isBoxProjectionEnabled(): Boolean { val mb = getMethodBind("ReflectionProbe","is_box_projection_enabled") return _icall_Boolean( mb, this.ptr) } open fun isSetAsInterior(): Boolean { val mb = getMethodBind("ReflectionProbe","is_set_as_interior") return _icall_Boolean( mb, this.ptr) } open fun setAsInterior(enable: Boolean) { val mb = getMethodBind("ReflectionProbe","set_as_interior") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setCullMask(layers: Long) { val mb = getMethodBind("ReflectionProbe","set_cull_mask") _icall_Unit_Long( mb, this.ptr, layers) } open fun setEnableBoxProjection(enable: Boolean) { val mb = getMethodBind("ReflectionProbe","set_enable_box_projection") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setEnableShadows(enable: Boolean) { val mb = getMethodBind("ReflectionProbe","set_enable_shadows") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setExtents(extents: Vector3) { val mb = getMethodBind("ReflectionProbe","set_extents") _icall_Unit_Vector3( mb, this.ptr, extents) } open fun setIntensity(intensity: Double) { val mb = getMethodBind("ReflectionProbe","set_intensity") _icall_Unit_Double( mb, this.ptr, intensity) } open fun setInteriorAmbient(ambient: Color) { val mb = getMethodBind("ReflectionProbe","set_interior_ambient") _icall_Unit_Color( mb, this.ptr, ambient) } open fun setInteriorAmbientEnergy(ambientEnergy: Double) { val mb = getMethodBind("ReflectionProbe","set_interior_ambient_energy") _icall_Unit_Double( mb, this.ptr, ambientEnergy) } open fun setInteriorAmbientProbeContribution(ambientProbeContribution: Double) { val mb = getMethodBind("ReflectionProbe","set_interior_ambient_probe_contribution") _icall_Unit_Double( mb, this.ptr, ambientProbeContribution) } open fun setMaxDistance(maxDistance: Double) { val mb = getMethodBind("ReflectionProbe","set_max_distance") _icall_Unit_Double( mb, this.ptr, maxDistance) } open fun setOriginOffset(originOffset: Vector3) { val mb = getMethodBind("ReflectionProbe","set_origin_offset") _icall_Unit_Vector3( mb, this.ptr, originOffset) } open fun setUpdateMode(mode: Long) { val mb = getMethodBind("ReflectionProbe","set_update_mode") _icall_Unit_Long( mb, this.ptr, mode) } enum class UpdateMode( id: Long ) { UPDATE_ONCE(0), UPDATE_ALWAYS(1); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RegEx.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_RegExMatch_String_Long_Long import godot.icalls._icall_String import godot.icalls._icall_String_String_String_Boolean_Long_Long import godot.icalls._icall_Unit import godot.icalls._icall_VariantArray import godot.icalls._icall_VariantArray_String_Long_Long import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class RegEx : Reference() { override fun __new(): COpaquePointer = invokeConstructor("RegEx", "RegEx") open fun clear() { val mb = getMethodBind("RegEx","clear") _icall_Unit( mb, this.ptr) } open fun compile(pattern: String): GodotError { val mb = getMethodBind("RegEx","compile") return GodotError.byValue( _icall_Long_String( mb, this.ptr, pattern).toUInt()) } open fun getGroupCount(): Long { val mb = getMethodBind("RegEx","get_group_count") return _icall_Long( mb, this.ptr) } open fun getNames(): VariantArray { val mb = getMethodBind("RegEx","get_names") return _icall_VariantArray( mb, this.ptr) } open fun getPattern(): String { val mb = getMethodBind("RegEx","get_pattern") return _icall_String( mb, this.ptr) } open fun isValid(): Boolean { val mb = getMethodBind("RegEx","is_valid") return _icall_Boolean( mb, this.ptr) } open fun search( subject: String, offset: Long = 0, end: Long = -1 ): RegExMatch { val mb = getMethodBind("RegEx","search") return _icall_RegExMatch_String_Long_Long( mb, this.ptr, subject, offset, end) } open fun searchAll( subject: String, offset: Long = 0, end: Long = -1 ): VariantArray { val mb = getMethodBind("RegEx","search_all") return _icall_VariantArray_String_Long_Long( mb, this.ptr, subject, offset, end) } open fun sub( subject: String, replacement: String, all: Boolean = false, offset: Long = 0, end: Long = -1 ): String { val mb = getMethodBind("RegEx","sub") return _icall_String_String_String_Boolean_Long_Long( mb, this.ptr, subject, replacement, all, offset, end) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RegExMatch.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.Variant import godot.core.VariantArray import godot.icalls._icall_Dictionary import godot.icalls._icall_Long import godot.icalls._icall_Long_Variant import godot.icalls._icall_String import godot.icalls._icall_String_Variant import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class RegExMatch : Reference() { open val names: Dictionary get() { val mb = getMethodBind("RegExMatch","get_names") return _icall_Dictionary(mb, this.ptr) } open val strings: VariantArray get() { val mb = getMethodBind("RegExMatch","get_strings") return _icall_VariantArray(mb, this.ptr) } open val subject: String get() { val mb = getMethodBind("RegExMatch","get_subject") return _icall_String(mb, this.ptr) } override fun __new(): COpaquePointer = invokeConstructor("RegExMatch", "RegExMatch") open fun getEnd(name: Variant = Variant(0)): Long { val mb = getMethodBind("RegExMatch","get_end") return _icall_Long_Variant( mb, this.ptr, name) } open fun getGroupCount(): Long { val mb = getMethodBind("RegExMatch","get_group_count") return _icall_Long( mb, this.ptr) } open fun getNames(): Dictionary { val mb = getMethodBind("RegExMatch","get_names") return _icall_Dictionary( mb, this.ptr) } open fun getStart(name: Variant = Variant(0)): Long { val mb = getMethodBind("RegExMatch","get_start") return _icall_Long_Variant( mb, this.ptr, name) } open fun getString(name: Variant = Variant(0)): String { val mb = getMethodBind("RegExMatch","get_string") return _icall_String_Variant( mb, this.ptr, name) } open fun getStrings(): VariantArray { val mb = getMethodBind("RegExMatch","get_strings") return _icall_VariantArray( mb, this.ptr) } open fun getSubject(): String { val mb = getMethodBind("RegExMatch","get_subject") return _icall_String( mb, this.ptr) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RemoteTransform.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.NodePath import godot.icalls._icall_Boolean import godot.icalls._icall_NodePath import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_NodePath import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class RemoteTransform : Spatial() { open var remotePath: NodePath get() { val mb = getMethodBind("RemoteTransform","get_remote_node") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform","set_remote_node") _icall_Unit_NodePath(mb, this.ptr, value) } open var updatePosition: Boolean get() { val mb = getMethodBind("RemoteTransform","get_update_position") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform","set_update_position") _icall_Unit_Boolean(mb, this.ptr, value) } open var updateRotation: Boolean get() { val mb = getMethodBind("RemoteTransform","get_update_rotation") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform","set_update_rotation") _icall_Unit_Boolean(mb, this.ptr, value) } open var updateScale: Boolean get() { val mb = getMethodBind("RemoteTransform","get_update_scale") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform","set_update_scale") _icall_Unit_Boolean(mb, this.ptr, value) } open var useGlobalCoordinates: Boolean get() { val mb = getMethodBind("RemoteTransform","get_use_global_coordinates") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform","set_use_global_coordinates") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RemoteTransform", "RemoteTransform") open fun forceUpdateCache() { val mb = getMethodBind("RemoteTransform","force_update_cache") _icall_Unit( mb, this.ptr) } open fun getRemoteNode(): NodePath { val mb = getMethodBind("RemoteTransform","get_remote_node") return _icall_NodePath( mb, this.ptr) } open fun getUpdatePosition(): Boolean { val mb = getMethodBind("RemoteTransform","get_update_position") return _icall_Boolean( mb, this.ptr) } open fun getUpdateRotation(): Boolean { val mb = getMethodBind("RemoteTransform","get_update_rotation") return _icall_Boolean( mb, this.ptr) } open fun getUpdateScale(): Boolean { val mb = getMethodBind("RemoteTransform","get_update_scale") return _icall_Boolean( mb, this.ptr) } open fun getUseGlobalCoordinates(): Boolean { val mb = getMethodBind("RemoteTransform","get_use_global_coordinates") return _icall_Boolean( mb, this.ptr) } open fun setRemoteNode(path: NodePath) { val mb = getMethodBind("RemoteTransform","set_remote_node") _icall_Unit_NodePath( mb, this.ptr, path) } open fun setUpdatePosition(updateRemotePosition: Boolean) { val mb = getMethodBind("RemoteTransform","set_update_position") _icall_Unit_Boolean( mb, this.ptr, updateRemotePosition) } open fun setUpdateRotation(updateRemoteRotation: Boolean) { val mb = getMethodBind("RemoteTransform","set_update_rotation") _icall_Unit_Boolean( mb, this.ptr, updateRemoteRotation) } open fun setUpdateScale(updateRemoteScale: Boolean) { val mb = getMethodBind("RemoteTransform","set_update_scale") _icall_Unit_Boolean( mb, this.ptr, updateRemoteScale) } open fun setUseGlobalCoordinates(useGlobalCoordinates: Boolean) { val mb = getMethodBind("RemoteTransform","set_use_global_coordinates") _icall_Unit_Boolean( mb, this.ptr, useGlobalCoordinates) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RemoteTransform2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.NodePath import godot.icalls._icall_Boolean import godot.icalls._icall_NodePath import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_NodePath import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlinx.cinterop.COpaquePointer open class RemoteTransform2D : Node2D() { open var remotePath: NodePath get() { val mb = getMethodBind("RemoteTransform2D","get_remote_node") return _icall_NodePath(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform2D","set_remote_node") _icall_Unit_NodePath(mb, this.ptr, value) } open var updatePosition: Boolean get() { val mb = getMethodBind("RemoteTransform2D","get_update_position") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform2D","set_update_position") _icall_Unit_Boolean(mb, this.ptr, value) } open var updateRotation: Boolean get() { val mb = getMethodBind("RemoteTransform2D","get_update_rotation") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform2D","set_update_rotation") _icall_Unit_Boolean(mb, this.ptr, value) } open var updateScale: Boolean get() { val mb = getMethodBind("RemoteTransform2D","get_update_scale") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform2D","set_update_scale") _icall_Unit_Boolean(mb, this.ptr, value) } open var useGlobalCoordinates: Boolean get() { val mb = getMethodBind("RemoteTransform2D","get_use_global_coordinates") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RemoteTransform2D","set_use_global_coordinates") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RemoteTransform2D", "RemoteTransform2D") open fun forceUpdateCache() { val mb = getMethodBind("RemoteTransform2D","force_update_cache") _icall_Unit( mb, this.ptr) } open fun getRemoteNode(): NodePath { val mb = getMethodBind("RemoteTransform2D","get_remote_node") return _icall_NodePath( mb, this.ptr) } open fun getUpdatePosition(): Boolean { val mb = getMethodBind("RemoteTransform2D","get_update_position") return _icall_Boolean( mb, this.ptr) } open fun getUpdateRotation(): Boolean { val mb = getMethodBind("RemoteTransform2D","get_update_rotation") return _icall_Boolean( mb, this.ptr) } open fun getUpdateScale(): Boolean { val mb = getMethodBind("RemoteTransform2D","get_update_scale") return _icall_Boolean( mb, this.ptr) } open fun getUseGlobalCoordinates(): Boolean { val mb = getMethodBind("RemoteTransform2D","get_use_global_coordinates") return _icall_Boolean( mb, this.ptr) } open fun setRemoteNode(path: NodePath) { val mb = getMethodBind("RemoteTransform2D","set_remote_node") _icall_Unit_NodePath( mb, this.ptr, path) } open fun setUpdatePosition(updateRemotePosition: Boolean) { val mb = getMethodBind("RemoteTransform2D","set_update_position") _icall_Unit_Boolean( mb, this.ptr, updateRemotePosition) } open fun setUpdateRotation(updateRemoteRotation: Boolean) { val mb = getMethodBind("RemoteTransform2D","set_update_rotation") _icall_Unit_Boolean( mb, this.ptr, updateRemoteRotation) } open fun setUpdateScale(updateRemoteScale: Boolean) { val mb = getMethodBind("RemoteTransform2D","set_update_scale") _icall_Unit_Boolean( mb, this.ptr, updateRemoteScale) } open fun setUseGlobalCoordinates(useGlobalCoordinates: Boolean) { val mb = getMethodBind("RemoteTransform2D","set_use_global_coordinates") _icall_Unit_Boolean( mb, this.ptr, useGlobalCoordinates) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Resource.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.RID import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Node import godot.icalls._icall_RID import godot.icalls._icall_Resource_Boolean import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.String import kotlinx.cinterop.COpaquePointer open class Resource : Reference() { val changed: Signal0 by signal() open var resourceLocalToScene: Boolean get() { val mb = getMethodBind("Resource","is_local_to_scene") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("Resource","set_local_to_scene") _icall_Unit_Boolean(mb, this.ptr, value) } open var resourceName: String get() { val mb = getMethodBind("Resource","get_name") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Resource","set_name") _icall_Unit_String(mb, this.ptr, value) } open var resourcePath: String get() { val mb = getMethodBind("Resource","get_path") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Resource","set_path") _icall_Unit_String(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("Resource", "Resource") open fun _setupLocalToScene() { } open fun duplicate(subresources: Boolean = false): Resource { val mb = getMethodBind("Resource","duplicate") return _icall_Resource_Boolean( mb, this.ptr, subresources) } open fun getLocalScene(): Node { val mb = getMethodBind("Resource","get_local_scene") return _icall_Node( mb, this.ptr) } open fun getName(): String { val mb = getMethodBind("Resource","get_name") return _icall_String( mb, this.ptr) } open fun getPath(): String { val mb = getMethodBind("Resource","get_path") return _icall_String( mb, this.ptr) } open fun getRid(): RID { val mb = getMethodBind("Resource","get_rid") return _icall_RID( mb, this.ptr) } open fun isLocalToScene(): Boolean { val mb = getMethodBind("Resource","is_local_to_scene") return _icall_Boolean( mb, this.ptr) } open fun setLocalToScene(enable: Boolean) { val mb = getMethodBind("Resource","set_local_to_scene") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setName(name: String) { val mb = getMethodBind("Resource","set_name") _icall_Unit_String( mb, this.ptr, name) } open fun setPath(path: String) { val mb = getMethodBind("Resource","set_path") _icall_Unit_String( mb, this.ptr, path) } open fun setupLocalToScene() { val mb = getMethodBind("Resource","setup_local_to_scene") _icall_Unit( mb, this.ptr) } open fun takeOverPath(path: String) { val mb = getMethodBind("Resource","take_over_path") _icall_Unit_String( mb, this.ptr, path) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ResourceFormatLoader.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.core.Variant import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class ResourceFormatLoader : Reference() { override fun __new(): COpaquePointer = invokeConstructor("ResourceFormatLoader", "ResourceFormatLoader") open fun getDependencies(path: String, addTypes: String) { } open fun getRecognizedExtensions(): PoolStringArray { throw NotImplementedError("get_recognized_extensions is not implemented for ResourceFormatLoader") } open fun getResourceType(path: String): String { throw NotImplementedError("get_resource_type is not implemented for ResourceFormatLoader") } open fun handlesType(typename: String): Boolean { throw NotImplementedError("handles_type is not implemented for ResourceFormatLoader") } open fun load(path: String, originalPath: String): Variant { throw NotImplementedError("load is not implemented for ResourceFormatLoader") } open fun renameDependencies(path: String, renames: String): Long { throw NotImplementedError("rename_dependencies is not implemented for ResourceFormatLoader") } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ResourceFormatSaver.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Long import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class ResourceFormatSaver : Reference() { override fun __new(): COpaquePointer = invokeConstructor("ResourceFormatSaver", "ResourceFormatSaver") open fun getRecognizedExtensions(resource: Resource): PoolStringArray { throw NotImplementedError("get_recognized_extensions is not implemented for ResourceFormatSaver") } open fun recognize(resource: Resource): Boolean { throw NotImplementedError("recognize is not implemented for ResourceFormatSaver") } open fun save( path: String, resource: Resource, flags: Long ): Long { throw NotImplementedError("save is not implemented for ResourceFormatSaver") } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ResourceImporter.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class ResourceImporter internal constructor() : Reference() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ResourceInteractiveLoader.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.icalls._icall_Long import godot.icalls._icall_Resource import godot.internal.utils.getMethodBind import kotlin.Long open class ResourceInteractiveLoader internal constructor() : Reference() { open fun getResource(): Resource { val mb = getMethodBind("ResourceInteractiveLoader","get_resource") return _icall_Resource( mb, this.ptr) } open fun getStage(): Long { val mb = getMethodBind("ResourceInteractiveLoader","get_stage") return _icall_Long( mb, this.ptr) } open fun getStageCount(): Long { val mb = getMethodBind("ResourceInteractiveLoader","get_stage_count") return _icall_Long( mb, this.ptr) } open fun poll(): GodotError { val mb = getMethodBind("ResourceInteractiveLoader","poll") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } open fun wait(): GodotError { val mb = getMethodBind("ResourceInteractiveLoader","wait") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ResourceLoader.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.core.PoolStringArray import godot.icalls._icall_Boolean_String import godot.icalls._icall_Boolean_String_String import godot.icalls._icall_PoolStringArray_String import godot.icalls._icall_ResourceInteractiveLoader_String_String import godot.icalls._icall_Resource_String_String_Boolean import godot.icalls._icall_Unit_Boolean import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object ResourceLoader : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("ResourceLoader".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton ResourceLoader" } ptr } fun exists(path: String, typeHint: String = ""): Boolean { val mb = getMethodBind("_ResourceLoader","exists") return _icall_Boolean_String_String( mb, this.ptr, path, typeHint) } fun getDependencies(path: String): PoolStringArray { val mb = getMethodBind("_ResourceLoader","get_dependencies") return _icall_PoolStringArray_String( mb, this.ptr, path) } fun getRecognizedExtensionsForType(type: String): PoolStringArray { val mb = getMethodBind("_ResourceLoader","get_recognized_extensions_for_type") return _icall_PoolStringArray_String( mb, this.ptr, type) } fun has(path: String): Boolean { val mb = getMethodBind("_ResourceLoader","has") return _icall_Boolean_String( mb, this.ptr, path) } fun hasCached(path: String): Boolean { val mb = getMethodBind("_ResourceLoader","has_cached") return _icall_Boolean_String( mb, this.ptr, path) } fun load( path: String, typeHint: String = "", noCache: Boolean = false ): Resource { val mb = getMethodBind("_ResourceLoader","load") return _icall_Resource_String_String_Boolean( mb, this.ptr, path, typeHint, noCache) } fun loadInteractive(path: String, typeHint: String = ""): ResourceInteractiveLoader { val mb = getMethodBind("_ResourceLoader","load_interactive") return _icall_ResourceInteractiveLoader_String_String( mb, this.ptr, path, typeHint) } fun setAbortOnMissingResources(abort: Boolean) { val mb = getMethodBind("_ResourceLoader","set_abort_on_missing_resources") _icall_Unit_Boolean( mb, this.ptr, abort) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ResourcePreloader.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.PoolStringArray import godot.core.VariantArray import godot.icalls._icall_Boolean_String import godot.icalls._icall_PoolStringArray import godot.icalls._icall_Resource_String import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_String_Object import godot.icalls._icall_Unit_String_String import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.NotImplementedError import kotlin.String import kotlinx.cinterop.COpaquePointer open class ResourcePreloader : Node() { override fun __new(): COpaquePointer = invokeConstructor("ResourcePreloader", "ResourcePreloader") open fun _getResources(): VariantArray { throw NotImplementedError("_get_resources is not implemented for ResourcePreloader") } open fun _setResources(arg0: VariantArray) { } open fun addResource(name: String, resource: Resource) { val mb = getMethodBind("ResourcePreloader","add_resource") _icall_Unit_String_Object( mb, this.ptr, name, resource) } open fun getResource(name: String): Resource { val mb = getMethodBind("ResourcePreloader","get_resource") return _icall_Resource_String( mb, this.ptr, name) } open fun getResourceList(): PoolStringArray { val mb = getMethodBind("ResourcePreloader","get_resource_list") return _icall_PoolStringArray( mb, this.ptr) } open fun hasResource(name: String): Boolean { val mb = getMethodBind("ResourcePreloader","has_resource") return _icall_Boolean_String( mb, this.ptr, name) } open fun removeResource(name: String) { val mb = getMethodBind("ResourcePreloader","remove_resource") _icall_Unit_String( mb, this.ptr, name) } open fun renameResource(name: String, newname: String) { val mb = getMethodBind("ResourcePreloader","rename_resource") _icall_Unit_String_String( mb, this.ptr, name, newname) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ResourceSaver.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Godot import godot.core.GodotError import godot.core.PoolStringArray import godot.icalls._icall_Long_String_Object_Long import godot.icalls._icall_PoolStringArray_Object import godot.internal.type.nullSafe import godot.internal.utils.getMethodBind import kotlin.Long import kotlin.String import kotlin.requireNotNull import kotlinx.cinterop.COpaquePointer import kotlinx.cinterop.cstr import kotlinx.cinterop.invoke import kotlinx.cinterop.memScoped object ResourceSaver : Object() { override fun __new(): COpaquePointer = memScoped { val ptr = nullSafe(Godot.gdnative.godot_global_get_singleton).invoke("ResourceSaver".cstr.ptr) requireNotNull(ptr) { "No instance found for singleton ResourceSaver" } ptr } fun getRecognizedExtensions(type: Resource): PoolStringArray { val mb = getMethodBind("_ResourceSaver","get_recognized_extensions") return _icall_PoolStringArray_Object( mb, this.ptr, type) } fun save( path: String, resource: Resource, flags: Long = 0 ): GodotError { val mb = getMethodBind("_ResourceSaver","save") return GodotError.byValue( _icall_Long_String_Object_Long( mb, this.ptr, path, resource, flags).toUInt()) } enum class SaverFlags( id: Long ) { FLAG_RELATIVE_PATHS(1), FLAG_BUNDLE_RESOURCES(2), FLAG_CHANGE_PATH(4), FLAG_OMIT_EDITOR_PROPERTIES(8), FLAG_SAVE_BIG_ENDIAN(16), FLAG_COMPRESS(32), FLAG_REPLACE_SUBRESOURCE_PATHS(64); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RichTextEffect.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.NotImplementedError import kotlinx.cinterop.COpaquePointer open class RichTextEffect : Resource() { override fun __new(): COpaquePointer = invokeConstructor("RichTextEffect", "RichTextEffect") open fun _processCustomFx(charFx: CharFXTransform): Boolean { throw NotImplementedError("_process_custom_fx is not implemented for RichTextEffect") } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RichTextLabel.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Color import godot.core.Dictionary import godot.core.GodotError import godot.core.PoolStringArray import godot.core.Signal1 import godot.core.Variant import godot.core.VariantArray import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Dictionary_PoolStringArray import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_Long_String import godot.icalls._icall_String import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Color import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Object_Long_Long import godot.icalls._icall_Unit_String import godot.icalls._icall_Unit_Variant import godot.icalls._icall_Unit_VariantArray import godot.icalls._icall_VScrollBar import godot.icalls._icall_VariantArray import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlinx.cinterop.COpaquePointer open class RichTextLabel : Control() { val metaClicked: Signal1 by signal("meta") val metaHoverEnded: Signal1 by signal("meta") val metaHoverStarted: Signal1 by signal("meta") open var bbcodeEnabled: Boolean get() { val mb = getMethodBind("RichTextLabel","is_using_bbcode") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_use_bbcode") _icall_Unit_Boolean(mb, this.ptr, value) } open var bbcodeText: String get() { val mb = getMethodBind("RichTextLabel","get_bbcode") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_bbcode") _icall_Unit_String(mb, this.ptr, value) } open var customEffects: VariantArray get() { val mb = getMethodBind("RichTextLabel","get_effects") return _icall_VariantArray(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_effects") _icall_Unit_VariantArray(mb, this.ptr, value) } open var metaUnderlined: Boolean get() { val mb = getMethodBind("RichTextLabel","is_meta_underlined") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_meta_underline") _icall_Unit_Boolean(mb, this.ptr, value) } open var overrideSelectedFontColor: Boolean get() { val mb = getMethodBind("RichTextLabel","is_overriding_selected_font_color") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_override_selected_font_color") _icall_Unit_Boolean(mb, this.ptr, value) } open var percentVisible: Double get() { val mb = getMethodBind("RichTextLabel","get_percent_visible") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_percent_visible") _icall_Unit_Double(mb, this.ptr, value) } open var scrollActive: Boolean get() { val mb = getMethodBind("RichTextLabel","is_scroll_active") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_scroll_active") _icall_Unit_Boolean(mb, this.ptr, value) } open var scrollFollowing: Boolean get() { val mb = getMethodBind("RichTextLabel","is_scroll_following") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_scroll_follow") _icall_Unit_Boolean(mb, this.ptr, value) } open var selectionEnabled: Boolean get() { val mb = getMethodBind("RichTextLabel","is_selection_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_selection_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var tabSize: Long get() { val mb = getMethodBind("RichTextLabel","get_tab_size") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_tab_size") _icall_Unit_Long(mb, this.ptr, value) } open var text: String get() { val mb = getMethodBind("RichTextLabel","get_text") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_text") _icall_Unit_String(mb, this.ptr, value) } open var visibleCharacters: Long get() { val mb = getMethodBind("RichTextLabel","get_visible_characters") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RichTextLabel","set_visible_characters") _icall_Unit_Long(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RichTextLabel", "RichTextLabel") override fun _guiInput(arg0: InputEvent) { } open fun _scrollChanged(arg0: Double) { } open fun addImage( image: Texture, width: Long = 0, height: Long = 0 ) { val mb = getMethodBind("RichTextLabel","add_image") _icall_Unit_Object_Long_Long( mb, this.ptr, image, width, height) } open fun addText(text: String) { val mb = getMethodBind("RichTextLabel","add_text") _icall_Unit_String( mb, this.ptr, text) } open fun appendBbcode(bbcode: String): GodotError { val mb = getMethodBind("RichTextLabel","append_bbcode") return GodotError.byValue( _icall_Long_String( mb, this.ptr, bbcode).toUInt()) } open fun clear() { val mb = getMethodBind("RichTextLabel","clear") _icall_Unit( mb, this.ptr) } open fun getBbcode(): String { val mb = getMethodBind("RichTextLabel","get_bbcode") return _icall_String( mb, this.ptr) } open fun getContentHeight(): Long { val mb = getMethodBind("RichTextLabel","get_content_height") return _icall_Long( mb, this.ptr) } open fun getEffects(): VariantArray { val mb = getMethodBind("RichTextLabel","get_effects") return _icall_VariantArray( mb, this.ptr) } open fun getLineCount(): Long { val mb = getMethodBind("RichTextLabel","get_line_count") return _icall_Long( mb, this.ptr) } open fun getPercentVisible(): Double { val mb = getMethodBind("RichTextLabel","get_percent_visible") return _icall_Double( mb, this.ptr) } open fun getTabSize(): Long { val mb = getMethodBind("RichTextLabel","get_tab_size") return _icall_Long( mb, this.ptr) } open fun getText(): String { val mb = getMethodBind("RichTextLabel","get_text") return _icall_String( mb, this.ptr) } open fun getTotalCharacterCount(): Long { val mb = getMethodBind("RichTextLabel","get_total_character_count") return _icall_Long( mb, this.ptr) } open fun getVScroll(): VScrollBar { val mb = getMethodBind("RichTextLabel","get_v_scroll") return _icall_VScrollBar( mb, this.ptr) } open fun getVisibleCharacters(): Long { val mb = getMethodBind("RichTextLabel","get_visible_characters") return _icall_Long( mb, this.ptr) } open fun getVisibleLineCount(): Long { val mb = getMethodBind("RichTextLabel","get_visible_line_count") return _icall_Long( mb, this.ptr) } open fun installEffect(effect: Variant) { val mb = getMethodBind("RichTextLabel","install_effect") _icall_Unit_Variant( mb, this.ptr, effect) } open fun isMetaUnderlined(): Boolean { val mb = getMethodBind("RichTextLabel","is_meta_underlined") return _icall_Boolean( mb, this.ptr) } open fun isOverridingSelectedFontColor(): Boolean { val mb = getMethodBind("RichTextLabel","is_overriding_selected_font_color") return _icall_Boolean( mb, this.ptr) } open fun isScrollActive(): Boolean { val mb = getMethodBind("RichTextLabel","is_scroll_active") return _icall_Boolean( mb, this.ptr) } open fun isScrollFollowing(): Boolean { val mb = getMethodBind("RichTextLabel","is_scroll_following") return _icall_Boolean( mb, this.ptr) } open fun isSelectionEnabled(): Boolean { val mb = getMethodBind("RichTextLabel","is_selection_enabled") return _icall_Boolean( mb, this.ptr) } open fun isUsingBbcode(): Boolean { val mb = getMethodBind("RichTextLabel","is_using_bbcode") return _icall_Boolean( mb, this.ptr) } open fun newline() { val mb = getMethodBind("RichTextLabel","newline") _icall_Unit( mb, this.ptr) } open fun parseBbcode(bbcode: String): GodotError { val mb = getMethodBind("RichTextLabel","parse_bbcode") return GodotError.byValue( _icall_Long_String( mb, this.ptr, bbcode).toUInt()) } open fun parseExpressionsForValues(expressions: PoolStringArray): Dictionary { val mb = getMethodBind("RichTextLabel","parse_expressions_for_values") return _icall_Dictionary_PoolStringArray( mb, this.ptr, expressions) } open fun pop() { val mb = getMethodBind("RichTextLabel","pop") _icall_Unit( mb, this.ptr) } open fun pushAlign(align: Long) { val mb = getMethodBind("RichTextLabel","push_align") _icall_Unit_Long( mb, this.ptr, align) } open fun pushBold() { val mb = getMethodBind("RichTextLabel","push_bold") _icall_Unit( mb, this.ptr) } open fun pushBoldItalics() { val mb = getMethodBind("RichTextLabel","push_bold_italics") _icall_Unit( mb, this.ptr) } open fun pushCell() { val mb = getMethodBind("RichTextLabel","push_cell") _icall_Unit( mb, this.ptr) } open fun pushColor(color: Color) { val mb = getMethodBind("RichTextLabel","push_color") _icall_Unit_Color( mb, this.ptr, color) } open fun pushFont(font: Font) { val mb = getMethodBind("RichTextLabel","push_font") _icall_Unit_Object( mb, this.ptr, font) } open fun pushIndent(level: Long) { val mb = getMethodBind("RichTextLabel","push_indent") _icall_Unit_Long( mb, this.ptr, level) } open fun pushItalics() { val mb = getMethodBind("RichTextLabel","push_italics") _icall_Unit( mb, this.ptr) } open fun pushList(type: Long) { val mb = getMethodBind("RichTextLabel","push_list") _icall_Unit_Long( mb, this.ptr, type) } open fun pushMeta(data: Variant) { val mb = getMethodBind("RichTextLabel","push_meta") _icall_Unit_Variant( mb, this.ptr, data) } open fun pushMono() { val mb = getMethodBind("RichTextLabel","push_mono") _icall_Unit( mb, this.ptr) } open fun pushNormal() { val mb = getMethodBind("RichTextLabel","push_normal") _icall_Unit( mb, this.ptr) } open fun pushStrikethrough() { val mb = getMethodBind("RichTextLabel","push_strikethrough") _icall_Unit( mb, this.ptr) } open fun pushTable(columns: Long) { val mb = getMethodBind("RichTextLabel","push_table") _icall_Unit_Long( mb, this.ptr, columns) } open fun pushUnderline() { val mb = getMethodBind("RichTextLabel","push_underline") _icall_Unit( mb, this.ptr) } open fun removeLine(line: Long): Boolean { val mb = getMethodBind("RichTextLabel","remove_line") return _icall_Boolean_Long( mb, this.ptr, line) } open fun scrollToLine(line: Long) { val mb = getMethodBind("RichTextLabel","scroll_to_line") _icall_Unit_Long( mb, this.ptr, line) } open fun setBbcode(text: String) { val mb = getMethodBind("RichTextLabel","set_bbcode") _icall_Unit_String( mb, this.ptr, text) } open fun setEffects(effects: VariantArray) { val mb = getMethodBind("RichTextLabel","set_effects") _icall_Unit_VariantArray( mb, this.ptr, effects) } open fun setMetaUnderline(enable: Boolean) { val mb = getMethodBind("RichTextLabel","set_meta_underline") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setOverrideSelectedFontColor(override: Boolean) { val mb = getMethodBind("RichTextLabel","set_override_selected_font_color") _icall_Unit_Boolean( mb, this.ptr, override) } open fun setPercentVisible(percentVisible: Double) { val mb = getMethodBind("RichTextLabel","set_percent_visible") _icall_Unit_Double( mb, this.ptr, percentVisible) } open fun setScrollActive(active: Boolean) { val mb = getMethodBind("RichTextLabel","set_scroll_active") _icall_Unit_Boolean( mb, this.ptr, active) } open fun setScrollFollow(follow: Boolean) { val mb = getMethodBind("RichTextLabel","set_scroll_follow") _icall_Unit_Boolean( mb, this.ptr, follow) } open fun setSelectionEnabled(enabled: Boolean) { val mb = getMethodBind("RichTextLabel","set_selection_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setTabSize(spaces: Long) { val mb = getMethodBind("RichTextLabel","set_tab_size") _icall_Unit_Long( mb, this.ptr, spaces) } open fun setTableColumnExpand( column: Long, expand: Boolean, ratio: Long ) { val mb = getMethodBind("RichTextLabel","set_table_column_expand") _icall_Unit_Long_Boolean_Long( mb, this.ptr, column, expand, ratio) } open fun setText(text: String) { val mb = getMethodBind("RichTextLabel","set_text") _icall_Unit_String( mb, this.ptr, text) } open fun setUseBbcode(enable: Boolean) { val mb = getMethodBind("RichTextLabel","set_use_bbcode") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setVisibleCharacters(amount: Long) { val mb = getMethodBind("RichTextLabel","set_visible_characters") _icall_Unit_Long( mb, this.ptr, amount) } enum class Align( id: Long ) { ALIGN_LEFT(0), ALIGN_CENTER(1), ALIGN_RIGHT(2), ALIGN_FILL(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ListType( id: Long ) { LIST_NUMBERS(0), LIST_LETTERS(1), LIST_DOTS(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class ItemType( id: Long ) { ITEM_FRAME(0), ITEM_TEXT(1), ITEM_IMAGE(2), ITEM_NEWLINE(3), ITEM_FONT(4), ITEM_COLOR(5), ITEM_UNDERLINE(6), ITEM_STRIKETHROUGH(7), ITEM_ALIGN(8), ITEM_INDENT(9), ITEM_LIST(10), ITEM_TABLE(11), ITEM_FADE(12), ITEM_SHAKE(13), ITEM_WAVE(14), ITEM_TORNADO(15), ITEM_RAINBOW(16), ITEM_META(17), ITEM_CUSTOMFX(18); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RigidBody.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.RigidBody import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal4 import godot.core.VariantArray import godot.core.Vector3 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_PhysicsMaterial import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Boolean import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector3 import godot.icalls._icall_Unit_Vector3_Vector3 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector3 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class RigidBody : PhysicsBody() { val bodyEntered: Signal1 by signal("body") val bodyExited: Signal1 by signal("body") val bodyShapeEntered: Signal4 by signal("body_id", "body", "body_shape", "local_shape") val bodyShapeExited: Signal4 by signal("body_id", "body", "body_shape", "local_shape") val sleepingStateChanged: Signal0 by signal() open var angularDamp: Double get() { val mb = getMethodBind("RigidBody","get_angular_damp") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_angular_damp") _icall_Unit_Double(mb, this.ptr, value) } open var angularVelocity: Vector3 get() { val mb = getMethodBind("RigidBody","get_angular_velocity") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_angular_velocity") _icall_Unit_Vector3(mb, this.ptr, value) } open var axisLockAngularX: Boolean get() { val mb = getMethodBind("RigidBody","get_axis_lock") return _icall_Boolean_Long(mb, this.ptr, 8) } set(value) { val mb = getMethodBind("RigidBody","set_axis_lock") _icall_Unit_Long_Boolean(mb, this.ptr, 8, value) } open var axisLockAngularY: Boolean get() { val mb = getMethodBind("RigidBody","get_axis_lock") return _icall_Boolean_Long(mb, this.ptr, 16) } set(value) { val mb = getMethodBind("RigidBody","set_axis_lock") _icall_Unit_Long_Boolean(mb, this.ptr, 16, value) } open var axisLockAngularZ: Boolean get() { val mb = getMethodBind("RigidBody","get_axis_lock") return _icall_Boolean_Long(mb, this.ptr, 32) } set(value) { val mb = getMethodBind("RigidBody","set_axis_lock") _icall_Unit_Long_Boolean(mb, this.ptr, 32, value) } open var axisLockLinearX: Boolean get() { val mb = getMethodBind("RigidBody","get_axis_lock") return _icall_Boolean_Long(mb, this.ptr, 1) } set(value) { val mb = getMethodBind("RigidBody","set_axis_lock") _icall_Unit_Long_Boolean(mb, this.ptr, 1, value) } open var axisLockLinearY: Boolean get() { val mb = getMethodBind("RigidBody","get_axis_lock") return _icall_Boolean_Long(mb, this.ptr, 2) } set(value) { val mb = getMethodBind("RigidBody","set_axis_lock") _icall_Unit_Long_Boolean(mb, this.ptr, 2, value) } open var axisLockLinearZ: Boolean get() { val mb = getMethodBind("RigidBody","get_axis_lock") return _icall_Boolean_Long(mb, this.ptr, 4) } set(value) { val mb = getMethodBind("RigidBody","set_axis_lock") _icall_Unit_Long_Boolean(mb, this.ptr, 4, value) } open var bounce: Double get() { val mb = getMethodBind("RigidBody","get_bounce") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_bounce") _icall_Unit_Double(mb, this.ptr, value) } open var canSleep: Boolean get() { val mb = getMethodBind("RigidBody","is_able_to_sleep") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_can_sleep") _icall_Unit_Boolean(mb, this.ptr, value) } open var contactMonitor: Boolean get() { val mb = getMethodBind("RigidBody","is_contact_monitor_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_contact_monitor") _icall_Unit_Boolean(mb, this.ptr, value) } open var contactsReported: Long get() { val mb = getMethodBind("RigidBody","get_max_contacts_reported") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_max_contacts_reported") _icall_Unit_Long(mb, this.ptr, value) } open var continuousCd: Boolean get() { val mb = getMethodBind("RigidBody","is_using_continuous_collision_detection") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_use_continuous_collision_detection") _icall_Unit_Boolean(mb, this.ptr, value) } open var customIntegrator: Boolean get() { val mb = getMethodBind("RigidBody","is_using_custom_integrator") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_use_custom_integrator") _icall_Unit_Boolean(mb, this.ptr, value) } open var friction: Double get() { val mb = getMethodBind("RigidBody","get_friction") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_friction") _icall_Unit_Double(mb, this.ptr, value) } open var gravityScale: Double get() { val mb = getMethodBind("RigidBody","get_gravity_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_gravity_scale") _icall_Unit_Double(mb, this.ptr, value) } open var linearDamp: Double get() { val mb = getMethodBind("RigidBody","get_linear_damp") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_linear_damp") _icall_Unit_Double(mb, this.ptr, value) } open var linearVelocity: Vector3 get() { val mb = getMethodBind("RigidBody","get_linear_velocity") return _icall_Vector3(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_linear_velocity") _icall_Unit_Vector3(mb, this.ptr, value) } open var mass: Double get() { val mb = getMethodBind("RigidBody","get_mass") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_mass") _icall_Unit_Double(mb, this.ptr, value) } open var mode: Long get() { val mb = getMethodBind("RigidBody","get_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_mode") _icall_Unit_Long(mb, this.ptr, value) } open var physicsMaterialOverride: PhysicsMaterial get() { val mb = getMethodBind("RigidBody","get_physics_material_override") return _icall_PhysicsMaterial(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_physics_material_override") _icall_Unit_Object(mb, this.ptr, value) } open var sleeping: Boolean get() { val mb = getMethodBind("RigidBody","is_sleeping") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_sleeping") _icall_Unit_Boolean(mb, this.ptr, value) } open var weight: Double get() { val mb = getMethodBind("RigidBody","get_weight") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody","set_weight") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RigidBody", "RigidBody") open fun angularVelocity(schedule: Vector3.() -> Unit): Vector3 = angularVelocity.apply{ schedule(this) angularVelocity = this } open fun linearVelocity(schedule: Vector3.() -> Unit): Vector3 = linearVelocity.apply{ schedule(this) linearVelocity = this } open fun _bodyEnterTree(arg0: Long) { } open fun _bodyExitTree(arg0: Long) { } open fun _directStateChanged(arg0: Object) { } open fun _integrateForces(state: PhysicsDirectBodyState) { } open fun _reloadPhysicsCharacteristics() { } open fun addCentralForce(force: Vector3) { val mb = getMethodBind("RigidBody","add_central_force") _icall_Unit_Vector3( mb, this.ptr, force) } open fun addForce(force: Vector3, position: Vector3) { val mb = getMethodBind("RigidBody","add_force") _icall_Unit_Vector3_Vector3( mb, this.ptr, force, position) } open fun addTorque(torque: Vector3) { val mb = getMethodBind("RigidBody","add_torque") _icall_Unit_Vector3( mb, this.ptr, torque) } open fun applyCentralImpulse(impulse: Vector3) { val mb = getMethodBind("RigidBody","apply_central_impulse") _icall_Unit_Vector3( mb, this.ptr, impulse) } open fun applyImpulse(position: Vector3, impulse: Vector3) { val mb = getMethodBind("RigidBody","apply_impulse") _icall_Unit_Vector3_Vector3( mb, this.ptr, position, impulse) } open fun applyTorqueImpulse(impulse: Vector3) { val mb = getMethodBind("RigidBody","apply_torque_impulse") _icall_Unit_Vector3( mb, this.ptr, impulse) } open fun getAngularDamp(): Double { val mb = getMethodBind("RigidBody","get_angular_damp") return _icall_Double( mb, this.ptr) } open fun getAngularVelocity(): Vector3 { val mb = getMethodBind("RigidBody","get_angular_velocity") return _icall_Vector3( mb, this.ptr) } open fun getAxisLock(axis: Long): Boolean { val mb = getMethodBind("RigidBody","get_axis_lock") return _icall_Boolean_Long( mb, this.ptr, axis) } open fun getBounce(): Double { val mb = getMethodBind("RigidBody","get_bounce") return _icall_Double( mb, this.ptr) } open fun getCollidingBodies(): VariantArray { val mb = getMethodBind("RigidBody","get_colliding_bodies") return _icall_VariantArray( mb, this.ptr) } open fun getFriction(): Double { val mb = getMethodBind("RigidBody","get_friction") return _icall_Double( mb, this.ptr) } open fun getGravityScale(): Double { val mb = getMethodBind("RigidBody","get_gravity_scale") return _icall_Double( mb, this.ptr) } open fun getLinearDamp(): Double { val mb = getMethodBind("RigidBody","get_linear_damp") return _icall_Double( mb, this.ptr) } open fun getLinearVelocity(): Vector3 { val mb = getMethodBind("RigidBody","get_linear_velocity") return _icall_Vector3( mb, this.ptr) } open fun getMass(): Double { val mb = getMethodBind("RigidBody","get_mass") return _icall_Double( mb, this.ptr) } open fun getMaxContactsReported(): Long { val mb = getMethodBind("RigidBody","get_max_contacts_reported") return _icall_Long( mb, this.ptr) } open fun getMode(): RigidBody.Mode { val mb = getMethodBind("RigidBody","get_mode") return RigidBody.Mode.from( _icall_Long( mb, this.ptr)) } open fun getPhysicsMaterialOverride(): PhysicsMaterial { val mb = getMethodBind("RigidBody","get_physics_material_override") return _icall_PhysicsMaterial( mb, this.ptr) } open fun getWeight(): Double { val mb = getMethodBind("RigidBody","get_weight") return _icall_Double( mb, this.ptr) } open fun isAbleToSleep(): Boolean { val mb = getMethodBind("RigidBody","is_able_to_sleep") return _icall_Boolean( mb, this.ptr) } open fun isContactMonitorEnabled(): Boolean { val mb = getMethodBind("RigidBody","is_contact_monitor_enabled") return _icall_Boolean( mb, this.ptr) } open fun isSleeping(): Boolean { val mb = getMethodBind("RigidBody","is_sleeping") return _icall_Boolean( mb, this.ptr) } open fun isUsingContinuousCollisionDetection(): Boolean { val mb = getMethodBind("RigidBody","is_using_continuous_collision_detection") return _icall_Boolean( mb, this.ptr) } open fun isUsingCustomIntegrator(): Boolean { val mb = getMethodBind("RigidBody","is_using_custom_integrator") return _icall_Boolean( mb, this.ptr) } open fun setAngularDamp(angularDamp: Double) { val mb = getMethodBind("RigidBody","set_angular_damp") _icall_Unit_Double( mb, this.ptr, angularDamp) } open fun setAngularVelocity(angularVelocity: Vector3) { val mb = getMethodBind("RigidBody","set_angular_velocity") _icall_Unit_Vector3( mb, this.ptr, angularVelocity) } open fun setAxisLock(axis: Long, lock: Boolean) { val mb = getMethodBind("RigidBody","set_axis_lock") _icall_Unit_Long_Boolean( mb, this.ptr, axis, lock) } open fun setAxisVelocity(axisVelocity: Vector3) { val mb = getMethodBind("RigidBody","set_axis_velocity") _icall_Unit_Vector3( mb, this.ptr, axisVelocity) } open fun setBounce(bounce: Double) { val mb = getMethodBind("RigidBody","set_bounce") _icall_Unit_Double( mb, this.ptr, bounce) } open fun setCanSleep(ableToSleep: Boolean) { val mb = getMethodBind("RigidBody","set_can_sleep") _icall_Unit_Boolean( mb, this.ptr, ableToSleep) } open fun setContactMonitor(enabled: Boolean) { val mb = getMethodBind("RigidBody","set_contact_monitor") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setFriction(friction: Double) { val mb = getMethodBind("RigidBody","set_friction") _icall_Unit_Double( mb, this.ptr, friction) } open fun setGravityScale(gravityScale: Double) { val mb = getMethodBind("RigidBody","set_gravity_scale") _icall_Unit_Double( mb, this.ptr, gravityScale) } open fun setLinearDamp(linearDamp: Double) { val mb = getMethodBind("RigidBody","set_linear_damp") _icall_Unit_Double( mb, this.ptr, linearDamp) } open fun setLinearVelocity(linearVelocity: Vector3) { val mb = getMethodBind("RigidBody","set_linear_velocity") _icall_Unit_Vector3( mb, this.ptr, linearVelocity) } open fun setMass(mass: Double) { val mb = getMethodBind("RigidBody","set_mass") _icall_Unit_Double( mb, this.ptr, mass) } open fun setMaxContactsReported(amount: Long) { val mb = getMethodBind("RigidBody","set_max_contacts_reported") _icall_Unit_Long( mb, this.ptr, amount) } open fun setMode(mode: Long) { val mb = getMethodBind("RigidBody","set_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setPhysicsMaterialOverride(physicsMaterialOverride: PhysicsMaterial) { val mb = getMethodBind("RigidBody","set_physics_material_override") _icall_Unit_Object( mb, this.ptr, physicsMaterialOverride) } open fun setSleeping(sleeping: Boolean) { val mb = getMethodBind("RigidBody","set_sleeping") _icall_Unit_Boolean( mb, this.ptr, sleeping) } open fun setUseContinuousCollisionDetection(enable: Boolean) { val mb = getMethodBind("RigidBody","set_use_continuous_collision_detection") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setUseCustomIntegrator(enable: Boolean) { val mb = getMethodBind("RigidBody","set_use_custom_integrator") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setWeight(weight: Double) { val mb = getMethodBind("RigidBody","set_weight") _icall_Unit_Double( mb, this.ptr, weight) } enum class Mode( id: Long ) { MODE_RIGID(0), MODE_STATIC(1), MODE_CHARACTER(2), MODE_KINEMATIC(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RigidBody2D.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.RigidBody2D import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal4 import godot.core.VariantArray import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Vector2_Boolean_Double_nObject import godot.icalls._icall_Double import godot.icalls._icall_Long import godot.icalls._icall_PhysicsMaterial import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Double import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_Vector2 import godot.icalls._icall_Unit_Vector2_Vector2 import godot.icalls._icall_VariantArray import godot.icalls._icall_Vector2 import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class RigidBody2D : PhysicsBody2D() { val bodyEntered: Signal1 by signal("body") val bodyExited: Signal1 by signal("body") val bodyShapeEntered: Signal4 by signal("body_id", "body", "body_shape", "local_shape") val bodyShapeExited: Signal4 by signal("body_id", "body", "body_shape", "local_shape") val sleepingStateChanged: Signal0 by signal() open var angularDamp: Double get() { val mb = getMethodBind("RigidBody2D","get_angular_damp") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_angular_damp") _icall_Unit_Double(mb, this.ptr, value) } open var angularVelocity: Double get() { val mb = getMethodBind("RigidBody2D","get_angular_velocity") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_angular_velocity") _icall_Unit_Double(mb, this.ptr, value) } open var appliedForce: Vector2 get() { val mb = getMethodBind("RigidBody2D","get_applied_force") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_applied_force") _icall_Unit_Vector2(mb, this.ptr, value) } open var appliedTorque: Double get() { val mb = getMethodBind("RigidBody2D","get_applied_torque") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_applied_torque") _icall_Unit_Double(mb, this.ptr, value) } open var bounce: Double get() { val mb = getMethodBind("RigidBody2D","get_bounce") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_bounce") _icall_Unit_Double(mb, this.ptr, value) } open var canSleep: Boolean get() { val mb = getMethodBind("RigidBody2D","is_able_to_sleep") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_can_sleep") _icall_Unit_Boolean(mb, this.ptr, value) } open var contactMonitor: Boolean get() { val mb = getMethodBind("RigidBody2D","is_contact_monitor_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_contact_monitor") _icall_Unit_Boolean(mb, this.ptr, value) } open var contactsReported: Long get() { val mb = getMethodBind("RigidBody2D","get_max_contacts_reported") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_max_contacts_reported") _icall_Unit_Long(mb, this.ptr, value) } open var continuousCd: Long get() { val mb = getMethodBind("RigidBody2D","get_continuous_collision_detection_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_continuous_collision_detection_mode") _icall_Unit_Long(mb, this.ptr, value) } open var customIntegrator: Boolean get() { val mb = getMethodBind("RigidBody2D","is_using_custom_integrator") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_use_custom_integrator") _icall_Unit_Boolean(mb, this.ptr, value) } open var friction: Double get() { val mb = getMethodBind("RigidBody2D","get_friction") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_friction") _icall_Unit_Double(mb, this.ptr, value) } open var gravityScale: Double get() { val mb = getMethodBind("RigidBody2D","get_gravity_scale") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_gravity_scale") _icall_Unit_Double(mb, this.ptr, value) } open var inertia: Double get() { val mb = getMethodBind("RigidBody2D","get_inertia") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_inertia") _icall_Unit_Double(mb, this.ptr, value) } open var linearDamp: Double get() { val mb = getMethodBind("RigidBody2D","get_linear_damp") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_linear_damp") _icall_Unit_Double(mb, this.ptr, value) } open var linearVelocity: Vector2 get() { val mb = getMethodBind("RigidBody2D","get_linear_velocity") return _icall_Vector2(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_linear_velocity") _icall_Unit_Vector2(mb, this.ptr, value) } open var mass: Double get() { val mb = getMethodBind("RigidBody2D","get_mass") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_mass") _icall_Unit_Double(mb, this.ptr, value) } open var mode: Long get() { val mb = getMethodBind("RigidBody2D","get_mode") return _icall_Long(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_mode") _icall_Unit_Long(mb, this.ptr, value) } open var physicsMaterialOverride: PhysicsMaterial get() { val mb = getMethodBind("RigidBody2D","get_physics_material_override") return _icall_PhysicsMaterial(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_physics_material_override") _icall_Unit_Object(mb, this.ptr, value) } open var sleeping: Boolean get() { val mb = getMethodBind("RigidBody2D","is_sleeping") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_sleeping") _icall_Unit_Boolean(mb, this.ptr, value) } open var weight: Double get() { val mb = getMethodBind("RigidBody2D","get_weight") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("RigidBody2D","set_weight") _icall_Unit_Double(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("RigidBody2D", "RigidBody2D") open fun appliedForce(schedule: Vector2.() -> Unit): Vector2 = appliedForce.apply{ schedule(this) appliedForce = this } open fun linearVelocity(schedule: Vector2.() -> Unit): Vector2 = linearVelocity.apply{ schedule(this) linearVelocity = this } open fun _bodyEnterTree(arg0: Long) { } open fun _bodyExitTree(arg0: Long) { } open fun _directStateChanged(arg0: Object) { } open fun _integrateForces(state: Physics2DDirectBodyState) { } open fun _reloadPhysicsCharacteristics() { } open fun addCentralForce(force: Vector2) { val mb = getMethodBind("RigidBody2D","add_central_force") _icall_Unit_Vector2( mb, this.ptr, force) } open fun addForce(offset: Vector2, force: Vector2) { val mb = getMethodBind("RigidBody2D","add_force") _icall_Unit_Vector2_Vector2( mb, this.ptr, offset, force) } open fun addTorque(torque: Double) { val mb = getMethodBind("RigidBody2D","add_torque") _icall_Unit_Double( mb, this.ptr, torque) } open fun applyCentralImpulse(impulse: Vector2) { val mb = getMethodBind("RigidBody2D","apply_central_impulse") _icall_Unit_Vector2( mb, this.ptr, impulse) } open fun applyImpulse(offset: Vector2, impulse: Vector2) { val mb = getMethodBind("RigidBody2D","apply_impulse") _icall_Unit_Vector2_Vector2( mb, this.ptr, offset, impulse) } open fun applyTorqueImpulse(torque: Double) { val mb = getMethodBind("RigidBody2D","apply_torque_impulse") _icall_Unit_Double( mb, this.ptr, torque) } open fun getAngularDamp(): Double { val mb = getMethodBind("RigidBody2D","get_angular_damp") return _icall_Double( mb, this.ptr) } open fun getAngularVelocity(): Double { val mb = getMethodBind("RigidBody2D","get_angular_velocity") return _icall_Double( mb, this.ptr) } open fun getAppliedForce(): Vector2 { val mb = getMethodBind("RigidBody2D","get_applied_force") return _icall_Vector2( mb, this.ptr) } open fun getAppliedTorque(): Double { val mb = getMethodBind("RigidBody2D","get_applied_torque") return _icall_Double( mb, this.ptr) } open fun getBounce(): Double { val mb = getMethodBind("RigidBody2D","get_bounce") return _icall_Double( mb, this.ptr) } open fun getCollidingBodies(): VariantArray { val mb = getMethodBind("RigidBody2D","get_colliding_bodies") return _icall_VariantArray( mb, this.ptr) } open fun getContinuousCollisionDetectionMode(): RigidBody2D.CCDMode { val mb = getMethodBind("RigidBody2D","get_continuous_collision_detection_mode") return RigidBody2D.CCDMode.from( _icall_Long( mb, this.ptr)) } open fun getFriction(): Double { val mb = getMethodBind("RigidBody2D","get_friction") return _icall_Double( mb, this.ptr) } open fun getGravityScale(): Double { val mb = getMethodBind("RigidBody2D","get_gravity_scale") return _icall_Double( mb, this.ptr) } open fun getInertia(): Double { val mb = getMethodBind("RigidBody2D","get_inertia") return _icall_Double( mb, this.ptr) } open fun getLinearDamp(): Double { val mb = getMethodBind("RigidBody2D","get_linear_damp") return _icall_Double( mb, this.ptr) } open fun getLinearVelocity(): Vector2 { val mb = getMethodBind("RigidBody2D","get_linear_velocity") return _icall_Vector2( mb, this.ptr) } open fun getMass(): Double { val mb = getMethodBind("RigidBody2D","get_mass") return _icall_Double( mb, this.ptr) } open fun getMaxContactsReported(): Long { val mb = getMethodBind("RigidBody2D","get_max_contacts_reported") return _icall_Long( mb, this.ptr) } open fun getMode(): RigidBody2D.Mode { val mb = getMethodBind("RigidBody2D","get_mode") return RigidBody2D.Mode.from( _icall_Long( mb, this.ptr)) } open fun getPhysicsMaterialOverride(): PhysicsMaterial { val mb = getMethodBind("RigidBody2D","get_physics_material_override") return _icall_PhysicsMaterial( mb, this.ptr) } open fun getWeight(): Double { val mb = getMethodBind("RigidBody2D","get_weight") return _icall_Double( mb, this.ptr) } open fun isAbleToSleep(): Boolean { val mb = getMethodBind("RigidBody2D","is_able_to_sleep") return _icall_Boolean( mb, this.ptr) } open fun isContactMonitorEnabled(): Boolean { val mb = getMethodBind("RigidBody2D","is_contact_monitor_enabled") return _icall_Boolean( mb, this.ptr) } open fun isSleeping(): Boolean { val mb = getMethodBind("RigidBody2D","is_sleeping") return _icall_Boolean( mb, this.ptr) } open fun isUsingCustomIntegrator(): Boolean { val mb = getMethodBind("RigidBody2D","is_using_custom_integrator") return _icall_Boolean( mb, this.ptr) } open fun setAngularDamp(angularDamp: Double) { val mb = getMethodBind("RigidBody2D","set_angular_damp") _icall_Unit_Double( mb, this.ptr, angularDamp) } open fun setAngularVelocity(angularVelocity: Double) { val mb = getMethodBind("RigidBody2D","set_angular_velocity") _icall_Unit_Double( mb, this.ptr, angularVelocity) } open fun setAppliedForce(force: Vector2) { val mb = getMethodBind("RigidBody2D","set_applied_force") _icall_Unit_Vector2( mb, this.ptr, force) } open fun setAppliedTorque(torque: Double) { val mb = getMethodBind("RigidBody2D","set_applied_torque") _icall_Unit_Double( mb, this.ptr, torque) } open fun setAxisVelocity(axisVelocity: Vector2) { val mb = getMethodBind("RigidBody2D","set_axis_velocity") _icall_Unit_Vector2( mb, this.ptr, axisVelocity) } open fun setBounce(bounce: Double) { val mb = getMethodBind("RigidBody2D","set_bounce") _icall_Unit_Double( mb, this.ptr, bounce) } open fun setCanSleep(ableToSleep: Boolean) { val mb = getMethodBind("RigidBody2D","set_can_sleep") _icall_Unit_Boolean( mb, this.ptr, ableToSleep) } open fun setContactMonitor(enabled: Boolean) { val mb = getMethodBind("RigidBody2D","set_contact_monitor") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setContinuousCollisionDetectionMode(mode: Long) { val mb = getMethodBind("RigidBody2D","set_continuous_collision_detection_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setFriction(friction: Double) { val mb = getMethodBind("RigidBody2D","set_friction") _icall_Unit_Double( mb, this.ptr, friction) } open fun setGravityScale(gravityScale: Double) { val mb = getMethodBind("RigidBody2D","set_gravity_scale") _icall_Unit_Double( mb, this.ptr, gravityScale) } open fun setInertia(inertia: Double) { val mb = getMethodBind("RigidBody2D","set_inertia") _icall_Unit_Double( mb, this.ptr, inertia) } open fun setLinearDamp(linearDamp: Double) { val mb = getMethodBind("RigidBody2D","set_linear_damp") _icall_Unit_Double( mb, this.ptr, linearDamp) } open fun setLinearVelocity(linearVelocity: Vector2) { val mb = getMethodBind("RigidBody2D","set_linear_velocity") _icall_Unit_Vector2( mb, this.ptr, linearVelocity) } open fun setMass(mass: Double) { val mb = getMethodBind("RigidBody2D","set_mass") _icall_Unit_Double( mb, this.ptr, mass) } open fun setMaxContactsReported(amount: Long) { val mb = getMethodBind("RigidBody2D","set_max_contacts_reported") _icall_Unit_Long( mb, this.ptr, amount) } open fun setMode(mode: Long) { val mb = getMethodBind("RigidBody2D","set_mode") _icall_Unit_Long( mb, this.ptr, mode) } open fun setPhysicsMaterialOverride(physicsMaterialOverride: PhysicsMaterial) { val mb = getMethodBind("RigidBody2D","set_physics_material_override") _icall_Unit_Object( mb, this.ptr, physicsMaterialOverride) } open fun setSleeping(sleeping: Boolean) { val mb = getMethodBind("RigidBody2D","set_sleeping") _icall_Unit_Boolean( mb, this.ptr, sleeping) } open fun setUseCustomIntegrator(enable: Boolean) { val mb = getMethodBind("RigidBody2D","set_use_custom_integrator") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setWeight(weight: Double) { val mb = getMethodBind("RigidBody2D","set_weight") _icall_Unit_Double( mb, this.ptr, weight) } open fun testMotion( motion: Vector2, infiniteInertia: Boolean = true, margin: Double = 0.08, result: Physics2DTestMotionResult? = null ): Boolean { val mb = getMethodBind("RigidBody2D","test_motion") return _icall_Boolean_Vector2_Boolean_Double_nObject( mb, this.ptr, motion, infiniteInertia, margin, result) } enum class Mode( id: Long ) { MODE_RIGID(0), MODE_STATIC(1), MODE_CHARACTER(2), MODE_KINEMATIC(3); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class CCDMode( id: Long ) { CCD_MODE_DISABLED(0), CCD_MODE_CAST_RAY(1), CCD_MODE_CAST_SHAPE(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/RootMotionView.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot open class RootMotionView internal constructor() : VisualInstance() ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/SceneState.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.NodePath import godot.core.PoolStringArray import godot.core.Variant import godot.core.VariantArray import godot.icalls._icall_Boolean_Long import godot.icalls._icall_Long import godot.icalls._icall_Long_Long import godot.icalls._icall_NodePath_Long import godot.icalls._icall_NodePath_Long_Boolean import godot.icalls._icall_PackedScene_Long import godot.icalls._icall_PoolStringArray_Long import godot.icalls._icall_String_Long import godot.icalls._icall_String_Long_Long import godot.icalls._icall_VariantArray_Long import godot.icalls._icall_Variant_Long_Long import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class SceneState internal constructor() : Reference() { open fun getConnectionBinds(idx: Long): VariantArray { val mb = getMethodBind("SceneState","get_connection_binds") return _icall_VariantArray_Long( mb, this.ptr, idx) } open fun getConnectionCount(): Long { val mb = getMethodBind("SceneState","get_connection_count") return _icall_Long( mb, this.ptr) } open fun getConnectionFlags(idx: Long): Long { val mb = getMethodBind("SceneState","get_connection_flags") return _icall_Long_Long( mb, this.ptr, idx) } open fun getConnectionMethod(idx: Long): String { val mb = getMethodBind("SceneState","get_connection_method") return _icall_String_Long( mb, this.ptr, idx) } open fun getConnectionSignal(idx: Long): String { val mb = getMethodBind("SceneState","get_connection_signal") return _icall_String_Long( mb, this.ptr, idx) } open fun getConnectionSource(idx: Long): NodePath { val mb = getMethodBind("SceneState","get_connection_source") return _icall_NodePath_Long( mb, this.ptr, idx) } open fun getConnectionTarget(idx: Long): NodePath { val mb = getMethodBind("SceneState","get_connection_target") return _icall_NodePath_Long( mb, this.ptr, idx) } open fun getNodeCount(): Long { val mb = getMethodBind("SceneState","get_node_count") return _icall_Long( mb, this.ptr) } open fun getNodeGroups(idx: Long): PoolStringArray { val mb = getMethodBind("SceneState","get_node_groups") return _icall_PoolStringArray_Long( mb, this.ptr, idx) } open fun getNodeIndex(idx: Long): Long { val mb = getMethodBind("SceneState","get_node_index") return _icall_Long_Long( mb, this.ptr, idx) } open fun getNodeInstance(idx: Long): PackedScene { val mb = getMethodBind("SceneState","get_node_instance") return _icall_PackedScene_Long( mb, this.ptr, idx) } open fun getNodeInstancePlaceholder(idx: Long): String { val mb = getMethodBind("SceneState","get_node_instance_placeholder") return _icall_String_Long( mb, this.ptr, idx) } open fun getNodeName(idx: Long): String { val mb = getMethodBind("SceneState","get_node_name") return _icall_String_Long( mb, this.ptr, idx) } open fun getNodeOwnerPath(idx: Long): NodePath { val mb = getMethodBind("SceneState","get_node_owner_path") return _icall_NodePath_Long( mb, this.ptr, idx) } open fun getNodePath(idx: Long, forParent: Boolean = false): NodePath { val mb = getMethodBind("SceneState","get_node_path") return _icall_NodePath_Long_Boolean( mb, this.ptr, idx, forParent) } open fun getNodePropertyCount(idx: Long): Long { val mb = getMethodBind("SceneState","get_node_property_count") return _icall_Long_Long( mb, this.ptr, idx) } open fun getNodePropertyName(idx: Long, propIdx: Long): String { val mb = getMethodBind("SceneState","get_node_property_name") return _icall_String_Long_Long( mb, this.ptr, idx, propIdx) } open fun getNodePropertyValue(idx: Long, propIdx: Long): Variant { val mb = getMethodBind("SceneState","get_node_property_value") return _icall_Variant_Long_Long( mb, this.ptr, idx, propIdx) } open fun getNodeType(idx: Long): String { val mb = getMethodBind("SceneState","get_node_type") return _icall_String_Long( mb, this.ptr, idx) } open fun isNodeInstancePlaceholder(idx: Long): Boolean { val mb = getMethodBind("SceneState","is_node_instance_placeholder") return _icall_Boolean_Long( mb, this.ptr, idx) } enum class GenEditState( id: Long ) { GEN_EDIT_STATE_DISABLED(0), GEN_EDIT_STATE_INSTANCE(1), GEN_EDIT_STATE_MAIN(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/SceneTree.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.GodotError import godot.core.PoolIntArray import godot.core.PoolStringArray import godot.core.Signal0 import godot.core.Signal1 import godot.core.Signal2 import godot.core.Variant import godot.core.VariantArray import godot.core.Vector2 import godot.core.signal import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_String import godot.icalls._icall_Long import godot.icalls._icall_Long_Object import godot.icalls._icall_Long_String import godot.icalls._icall_MultiplayerAPI import godot.icalls._icall_NetworkedMultiplayerPeer import godot.icalls._icall_Node import godot.icalls._icall_PoolIntArray import godot.icalls._icall_SceneTreeTimer_Double_Boolean import godot.icalls._icall_Unit import godot.icalls._icall_Unit_Boolean import godot.icalls._icall_Unit_Long import godot.icalls._icall_Unit_Long_Long_Vector2_Double import godot.icalls._icall_Unit_Long_String_Long import godot.icalls._icall_Unit_Long_String_String_Variant import godot.icalls._icall_Unit_Object import godot.icalls._icall_Unit_String_Long import godot.icalls._icall_Unit_String_String_Variant import godot.icalls._icall_VariantArray_String import godot.icalls._icall_Viewport import godot.icalls._icall_varargs import godot.internal.utils.getMethodBind import godot.internal.utils.invokeConstructor import kotlin.Any import kotlin.Boolean import kotlin.Double import kotlin.Long import kotlin.String import kotlin.Unit import kotlinx.cinterop.COpaquePointer open class SceneTree : MainLoop() { val connectedToServer: Signal0 by signal() val connectionFailed: Signal0 by signal() val filesDropped: Signal2 by signal("files", "screen") val globalMenuAction: Signal2 by signal("id", "meta") val idleFrame: Signal0 by signal() val networkPeerConnected: Signal1 by signal("id") val networkPeerDisconnected: Signal1 by signal("id") val nodeAdded: Signal1 by signal("node") val nodeConfigurationWarningChanged: Signal1 by signal("node") val nodeRemoved: Signal1 by signal("node") val nodeRenamed: Signal1 by signal("node") val physicsFrame: Signal0 by signal() val screenResized: Signal0 by signal() val serverDisconnected: Signal0 by signal() val treeChanged: Signal0 by signal() open var currentScene: Node get() { val mb = getMethodBind("SceneTree","get_current_scene") return _icall_Node(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_current_scene") _icall_Unit_Object(mb, this.ptr, value) } open var debugCollisionsHint: Boolean get() { val mb = getMethodBind("SceneTree","is_debugging_collisions_hint") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_debug_collisions_hint") _icall_Unit_Boolean(mb, this.ptr, value) } open var debugNavigationHint: Boolean get() { val mb = getMethodBind("SceneTree","is_debugging_navigation_hint") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_debug_navigation_hint") _icall_Unit_Boolean(mb, this.ptr, value) } open var editedSceneRoot: Node get() { val mb = getMethodBind("SceneTree","get_edited_scene_root") return _icall_Node(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_edited_scene_root") _icall_Unit_Object(mb, this.ptr, value) } open var multiplayer: MultiplayerAPI get() { val mb = getMethodBind("SceneTree","get_multiplayer") return _icall_MultiplayerAPI(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_multiplayer") _icall_Unit_Object(mb, this.ptr, value) } open var multiplayerPoll: Boolean get() { val mb = getMethodBind("SceneTree","is_multiplayer_poll_enabled") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_multiplayer_poll_enabled") _icall_Unit_Boolean(mb, this.ptr, value) } open var networkPeer: NetworkedMultiplayerPeer get() { val mb = getMethodBind("SceneTree","get_network_peer") return _icall_NetworkedMultiplayerPeer(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_network_peer") _icall_Unit_Object(mb, this.ptr, value) } open var paused: Boolean get() { val mb = getMethodBind("SceneTree","is_paused") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_pause") _icall_Unit_Boolean(mb, this.ptr, value) } open var refuseNewNetworkConnections: Boolean get() { val mb = getMethodBind("SceneTree","is_refusing_new_network_connections") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_refuse_new_network_connections") _icall_Unit_Boolean(mb, this.ptr, value) } open val root: Viewport get() { val mb = getMethodBind("SceneTree","get_root") return _icall_Viewport(mb, this.ptr) } open var useFontOversampling: Boolean get() { val mb = getMethodBind("SceneTree","is_using_font_oversampling") return _icall_Boolean(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTree","set_use_font_oversampling") _icall_Unit_Boolean(mb, this.ptr, value) } override fun __new(): COpaquePointer = invokeConstructor("SceneTree", "SceneTree") open fun _changeScene(arg0: Node) { } open fun _connectedToServer() { } open fun _connectionFailed() { } open fun _networkPeerConnected(arg0: Long) { } open fun _networkPeerDisconnected(arg0: Long) { } open fun _serverDisconnected() { } open fun callGroup( group: String, method: String, vararg __var_args: Any? ): Variant { val mb = getMethodBind("SceneTree","call_group") return _icall_varargs( mb, this.ptr, arrayOf(group, method, *__var_args)) } open fun callGroupFlags( flags: Long, group: String, method: String, vararg __var_args: Any? ): Variant { val mb = getMethodBind("SceneTree","call_group_flags") return _icall_varargs( mb, this.ptr, arrayOf(flags, group, method, *__var_args)) } open fun changeScene(path: String): GodotError { val mb = getMethodBind("SceneTree","change_scene") return GodotError.byValue( _icall_Long_String( mb, this.ptr, path).toUInt()) } open fun changeSceneTo(packedScene: PackedScene): GodotError { val mb = getMethodBind("SceneTree","change_scene_to") return GodotError.byValue( _icall_Long_Object( mb, this.ptr, packedScene).toUInt()) } open fun createTimer(timeSec: Double, pauseModeProcess: Boolean = true): SceneTreeTimer { val mb = getMethodBind("SceneTree","create_timer") return _icall_SceneTreeTimer_Double_Boolean( mb, this.ptr, timeSec, pauseModeProcess) } open fun getCurrentScene(): Node { val mb = getMethodBind("SceneTree","get_current_scene") return _icall_Node( mb, this.ptr) } open fun getEditedSceneRoot(): Node { val mb = getMethodBind("SceneTree","get_edited_scene_root") return _icall_Node( mb, this.ptr) } open fun getFrame(): Long { val mb = getMethodBind("SceneTree","get_frame") return _icall_Long( mb, this.ptr) } open fun getMultiplayer(): MultiplayerAPI { val mb = getMethodBind("SceneTree","get_multiplayer") return _icall_MultiplayerAPI( mb, this.ptr) } open fun getNetworkConnectedPeers(): PoolIntArray { val mb = getMethodBind("SceneTree","get_network_connected_peers") return _icall_PoolIntArray( mb, this.ptr) } open fun getNetworkPeer(): NetworkedMultiplayerPeer { val mb = getMethodBind("SceneTree","get_network_peer") return _icall_NetworkedMultiplayerPeer( mb, this.ptr) } open fun getNetworkUniqueId(): Long { val mb = getMethodBind("SceneTree","get_network_unique_id") return _icall_Long( mb, this.ptr) } open fun getNodeCount(): Long { val mb = getMethodBind("SceneTree","get_node_count") return _icall_Long( mb, this.ptr) } open fun getNodesInGroup(group: String): VariantArray { val mb = getMethodBind("SceneTree","get_nodes_in_group") return _icall_VariantArray_String( mb, this.ptr, group) } open fun getRoot(): Viewport { val mb = getMethodBind("SceneTree","get_root") return _icall_Viewport( mb, this.ptr) } open fun getRpcSenderId(): Long { val mb = getMethodBind("SceneTree","get_rpc_sender_id") return _icall_Long( mb, this.ptr) } open fun hasGroup(name: String): Boolean { val mb = getMethodBind("SceneTree","has_group") return _icall_Boolean_String( mb, this.ptr, name) } open fun hasNetworkPeer(): Boolean { val mb = getMethodBind("SceneTree","has_network_peer") return _icall_Boolean( mb, this.ptr) } open fun isDebuggingCollisionsHint(): Boolean { val mb = getMethodBind("SceneTree","is_debugging_collisions_hint") return _icall_Boolean( mb, this.ptr) } open fun isDebuggingNavigationHint(): Boolean { val mb = getMethodBind("SceneTree","is_debugging_navigation_hint") return _icall_Boolean( mb, this.ptr) } open fun isInputHandled(): Boolean { val mb = getMethodBind("SceneTree","is_input_handled") return _icall_Boolean( mb, this.ptr) } open fun isMultiplayerPollEnabled(): Boolean { val mb = getMethodBind("SceneTree","is_multiplayer_poll_enabled") return _icall_Boolean( mb, this.ptr) } open fun isNetworkServer(): Boolean { val mb = getMethodBind("SceneTree","is_network_server") return _icall_Boolean( mb, this.ptr) } open fun isPaused(): Boolean { val mb = getMethodBind("SceneTree","is_paused") return _icall_Boolean( mb, this.ptr) } open fun isRefusingNewNetworkConnections(): Boolean { val mb = getMethodBind("SceneTree","is_refusing_new_network_connections") return _icall_Boolean( mb, this.ptr) } open fun isUsingFontOversampling(): Boolean { val mb = getMethodBind("SceneTree","is_using_font_oversampling") return _icall_Boolean( mb, this.ptr) } open fun notifyGroup(group: String, notification: Long) { val mb = getMethodBind("SceneTree","notify_group") _icall_Unit_String_Long( mb, this.ptr, group, notification) } open fun notifyGroupFlags( callFlags: Long, group: String, notification: Long ) { val mb = getMethodBind("SceneTree","notify_group_flags") _icall_Unit_Long_String_Long( mb, this.ptr, callFlags, group, notification) } open fun queueDelete(obj: Object) { val mb = getMethodBind("SceneTree","queue_delete") _icall_Unit_Object( mb, this.ptr, obj) } open fun quit(exitCode: Long = -1) { val mb = getMethodBind("SceneTree","quit") _icall_Unit_Long( mb, this.ptr, exitCode) } open fun reloadCurrentScene(): GodotError { val mb = getMethodBind("SceneTree","reload_current_scene") return GodotError.byValue( _icall_Long( mb, this.ptr).toUInt()) } open fun setAutoAcceptQuit(enabled: Boolean) { val mb = getMethodBind("SceneTree","set_auto_accept_quit") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setCurrentScene(childNode: Node) { val mb = getMethodBind("SceneTree","set_current_scene") _icall_Unit_Object( mb, this.ptr, childNode) } open fun setDebugCollisionsHint(enable: Boolean) { val mb = getMethodBind("SceneTree","set_debug_collisions_hint") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setDebugNavigationHint(enable: Boolean) { val mb = getMethodBind("SceneTree","set_debug_navigation_hint") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setEditedSceneRoot(scene: Node) { val mb = getMethodBind("SceneTree","set_edited_scene_root") _icall_Unit_Object( mb, this.ptr, scene) } open fun setGroup( group: String, property: String, value: Variant ) { val mb = getMethodBind("SceneTree","set_group") _icall_Unit_String_String_Variant( mb, this.ptr, group, property, value) } open fun setGroupFlags( callFlags: Long, group: String, property: String, value: Variant ) { val mb = getMethodBind("SceneTree","set_group_flags") _icall_Unit_Long_String_String_Variant( mb, this.ptr, callFlags, group, property, value) } open fun setInputAsHandled() { val mb = getMethodBind("SceneTree","set_input_as_handled") _icall_Unit( mb, this.ptr) } open fun setMultiplayer(multiplayer: MultiplayerAPI) { val mb = getMethodBind("SceneTree","set_multiplayer") _icall_Unit_Object( mb, this.ptr, multiplayer) } open fun setMultiplayerPollEnabled(enabled: Boolean) { val mb = getMethodBind("SceneTree","set_multiplayer_poll_enabled") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setNetworkPeer(peer: NetworkedMultiplayerPeer) { val mb = getMethodBind("SceneTree","set_network_peer") _icall_Unit_Object( mb, this.ptr, peer) } open fun setPause(enable: Boolean) { val mb = getMethodBind("SceneTree","set_pause") _icall_Unit_Boolean( mb, this.ptr, enable) } open fun setQuitOnGoBack(enabled: Boolean) { val mb = getMethodBind("SceneTree","set_quit_on_go_back") _icall_Unit_Boolean( mb, this.ptr, enabled) } open fun setRefuseNewNetworkConnections(refuse: Boolean) { val mb = getMethodBind("SceneTree","set_refuse_new_network_connections") _icall_Unit_Boolean( mb, this.ptr, refuse) } open fun setScreenStretch( mode: Long, aspect: Long, minsize: Vector2, shrink: Double = 1.0 ) { val mb = getMethodBind("SceneTree","set_screen_stretch") _icall_Unit_Long_Long_Vector2_Double( mb, this.ptr, mode, aspect, minsize, shrink) } open fun setUseFontOversampling(enable: Boolean) { val mb = getMethodBind("SceneTree","set_use_font_oversampling") _icall_Unit_Boolean( mb, this.ptr, enable) } enum class StretchAspect( id: Long ) { STRETCH_ASPECT_IGNORE(0), STRETCH_ASPECT_KEEP(1), STRETCH_ASPECT_KEEP_WIDTH(2), STRETCH_ASPECT_KEEP_HEIGHT(3), STRETCH_ASPECT_EXPAND(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class GroupCallFlags( id: Long ) { GROUP_CALL_DEFAULT(0), GROUP_CALL_REVERSE(1), GROUP_CALL_REALTIME(2), GROUP_CALL_UNIQUE(4); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } enum class StretchMode( id: Long ) { STRETCH_MODE_DISABLED(0), STRETCH_MODE_2D(1), STRETCH_MODE_VIEWPORT(2); val id: Long init { this.id = id } companion object { fun from(value: Long) = values().single { it.id == value } } } companion object } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/SceneTreeTimer.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal0 import godot.core.signal import godot.icalls._icall_Double import godot.icalls._icall_Unit_Double import godot.internal.utils.getMethodBind import kotlin.Double open class SceneTreeTimer internal constructor() : Reference() { val timeout: Signal0 by signal() open var timeLeft: Double get() { val mb = getMethodBind("SceneTreeTimer","get_time_left") return _icall_Double(mb, this.ptr) } set(value) { val mb = getMethodBind("SceneTreeTimer","set_time_left") _icall_Unit_Double(mb, this.ptr, value) } open fun getTimeLeft(): Double { val mb = getMethodBind("SceneTreeTimer","get_time_left") return _icall_Double( mb, this.ptr) } open fun setTimeLeft(time: Double) { val mb = getMethodBind("SceneTreeTimer","set_time_left") _icall_Unit_Double( mb, this.ptr, time) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/Script.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Dictionary import godot.core.GodotError import godot.core.Variant import godot.core.VariantArray import godot.icalls._icall_Boolean import godot.icalls._icall_Boolean_Object import godot.icalls._icall_Boolean_String import godot.icalls._icall_Dictionary import godot.icalls._icall_Long_Boolean import godot.icalls._icall_Script import godot.icalls._icall_String import godot.icalls._icall_Unit_String import godot.icalls._icall_VariantArray import godot.icalls._icall_Variant_String import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.String open class Script internal constructor() : Resource() { open var sourceCode: String get() { val mb = getMethodBind("Script","get_source_code") return _icall_String(mb, this.ptr) } set(value) { val mb = getMethodBind("Script","set_source_code") _icall_Unit_String(mb, this.ptr, value) } open fun canInstance(): Boolean { val mb = getMethodBind("Script","can_instance") return _icall_Boolean( mb, this.ptr) } open fun getBaseScript(): Script { val mb = getMethodBind("Script","get_base_script") return _icall_Script( mb, this.ptr) } open fun getInstanceBaseType(): String { val mb = getMethodBind("Script","get_instance_base_type") return _icall_String( mb, this.ptr) } open fun getPropertyDefaultValue(property: String): Variant { val mb = getMethodBind("Script","get_property_default_value") return _icall_Variant_String( mb, this.ptr, property) } open fun getScriptConstantMap(): Dictionary { val mb = getMethodBind("Script","get_script_constant_map") return _icall_Dictionary( mb, this.ptr) } open fun getScriptMethodList(): VariantArray { val mb = getMethodBind("Script","get_script_method_list") return _icall_VariantArray( mb, this.ptr) } open fun getScriptPropertyList(): VariantArray { val mb = getMethodBind("Script","get_script_property_list") return _icall_VariantArray( mb, this.ptr) } open fun getScriptSignalList(): VariantArray { val mb = getMethodBind("Script","get_script_signal_list") return _icall_VariantArray( mb, this.ptr) } open fun getSourceCode(): String { val mb = getMethodBind("Script","get_source_code") return _icall_String( mb, this.ptr) } open fun hasScriptSignal(signalName: String): Boolean { val mb = getMethodBind("Script","has_script_signal") return _icall_Boolean_String( mb, this.ptr, signalName) } open fun hasSourceCode(): Boolean { val mb = getMethodBind("Script","has_source_code") return _icall_Boolean( mb, this.ptr) } open fun instanceHas(baseObject: Object): Boolean { val mb = getMethodBind("Script","instance_has") return _icall_Boolean_Object( mb, this.ptr, baseObject) } open fun isTool(): Boolean { val mb = getMethodBind("Script","is_tool") return _icall_Boolean( mb, this.ptr) } open fun reload(keepState: Boolean = false): GodotError { val mb = getMethodBind("Script","reload") return GodotError.byValue( _icall_Long_Boolean( mb, this.ptr, keepState).toUInt()) } open fun setSourceCode(source: String) { val mb = getMethodBind("Script","set_source_code") _icall_Unit_String( mb, this.ptr, source) } } ================================================ FILE: godot-kotlin/godot-library/src/nativeGen/kotlin/godot/ScriptCreateDialog.kt ================================================ // THIS FILE IS GENERATED! DO NOT EDIT IT MANUALLY! ALL CHANGES TO IT WILL BE OVERWRITTEN ON EACH BUILD package godot import godot.core.Signal1 import godot.core.signal import godot.icalls._icall_Unit_String_String_Boolean_Boolean import godot.internal.utils.getMethodBind import kotlin.Boolean import kotlin.Long import kotlin.String open class ScriptCreateDialog internal constructor() : ConfirmationDialog() { val scriptCreated: Signal1