gdnative

package
v0.0.0-...-1746202 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 24, 2018 License: MIT Imports: 9 Imported by: 14

Documentation

Overview

Package gdnative provides a wrapper around the Godot GDNative API.

Package gdnative provides a wrapper around Godot's nativescript extension. It exists to provide a way to use Go as an alternative scripting language from GDScript.

Index

Constants

This section is empty.

Variables

View Source 
var CreateFuncRegistry = map[string]CreateFunc{}

CreateFuncRegistry is a mapping of instance creation functions. This map is used whenever a CreateFunc is registered. It is also used to look up a Creation function when Godot asks Go to create a new class instance.

View Source 
var DestroyFuncRegistry = map[string]DestroyFunc{}

DestroyFuncRegistry is a mapping of instance destroy functions. This map is used whenever a DestroyFunc is registered. It is also used to look up a Destroy function when Godot asks Go to destroy a class instance.

View Source 
var ErrorLookupMap = map[string]Error{
	"Ok":                         Ok,
	"Failed":                     Failed,
	"ErrUnavailable":             ErrUnavailable,
	"ErrUnconfigured":            ErrUnconfigured,
	"ErrUnauthorized":            ErrUnauthorized,
	"ErrParameterRangeError":     ErrParameterRangeError,
	"ErrOutOfMemory":             ErrOutOfMemory,
	"ErrFileNotFound":            ErrFileNotFound,
	"ErrFileBadDrive":            ErrFileBadDrive,
	"ErrFileBadPath":             ErrFileBadPath,
	"ErrFileNoPermission":        ErrFileNoPermission,
	"ErrFileAlreadyInUse":        ErrFileAlreadyInUse,
	"ErrFileCantOpen":            ErrFileCantOpen,
	"ErrFileCantWrite":           ErrFileCantWrite,
	"ErrFileCantRead":            ErrFileCantRead,
	"ErrFileUnrecognized":        ErrFileUnrecognized,
	"ErrFileCorrupt":             ErrFileCorrupt,
	"ErrFileMissingDependencies": ErrFileMissingDependencies,
	"ErrFileEof":                 ErrFileEof,
	"ErrCantOpen":                ErrCantOpen,
	"ErrCantCreate":              ErrCantCreate,
	"ErrQueryFailed":             ErrQueryFailed,
	"ErrAlreadyInUse":            ErrAlreadyInUse,
	"ErrLocked":                  ErrLocked,
	"ErrTimeout":                 ErrTimeout,
	"ErrCantConnect":             ErrCantConnect,
	"ErrCantResolve":             ErrCantResolve,
	"ErrConnectionError":         ErrConnectionError,
	"ErrCantAcquireResource":     ErrCantAcquireResource,
	"ErrCantFork":                ErrCantFork,
	"ErrInvalidData":             ErrInvalidData,
	"ErrInvalidParameter":        ErrInvalidParameter,
	"ErrAlreadyExists":           ErrAlreadyExists,
	"ErrDoesNotExist":            ErrDoesNotExist,
	"ErrDatabaseCantRead":        ErrDatabaseCantRead,
	"ErrDatabaseCantWrite":       ErrDatabaseCantWrite,
	"ErrCompilationFailed":       ErrCompilationFailed,
	"ErrMethodNotFound":          ErrMethodNotFound,
	"ErrLinkFailed":              ErrLinkFailed,
	"ErrScriptFailed":            ErrScriptFailed,
	"ErrCyclicLink":              ErrCyclicLink,
	"ErrInvalidDeclaration":      ErrInvalidDeclaration,
	"ErrDuplicateSymbol":         ErrDuplicateSymbol,
	"ErrParseError":              ErrParseError,
	"ErrBusy":                    ErrBusy,
	"ErrSkip":                    ErrSkip,
	"ErrHelp":                    ErrHelp,
	"ErrBug":                     ErrBug,
	"ErrPrinterOnFire":           ErrPrinterOnFire,
}

ErrorLookupMap is a string-based lookup table of constants for Error.

View Source 
var FreeFuncRegistry = map[string]FreeFunc{}

FreeFuncRegistry is a mapping of instance free functions. This map is used whenever a FreeFunc is registered. It is also used to look up a Free function when Godot asks Go to free a class instance.

View Source 
var GDNative = &gdNative{}

Set our API to null. This will be set when 'godot_gdnative_init' is called by Godot when the library is loaded.

View Source 
var GetPropertyFuncRegistry = map[string]GetPropertyFunc{}

GetPropertyFuncRegistry is a mapping of instance property getters. This map is used whenever a GetPropertyFunc is registered. It is also used to look up a property getter function when Godot asks Go to get a property on an object.

View Source 
var Log = &Logger{StackNum: 2}

Log is used to log messages to Godot, and makes them viewable inside the Godot debugger.

View Source 
var MethodFuncRegistry = map[string]MethodFunc{}

MethodFuncRegistry is a mapping of instance method functions. This map is used whenever a MethofFunc is registered. It is also used to look up a Method function when Godot asks Go to call a class method.

View Source 
var MethodRpcModeLookupMap = map[string]MethodRpcMode{
	"MethodRpcModeDisabled": MethodRpcModeDisabled,
	"MethodRpcModeRemote":   MethodRpcModeRemote,
	"MethodRpcModeSync":     MethodRpcModeSync,
	"MethodRpcModeMaster":   MethodRpcModeMaster,
	"MethodRpcModeSlave":    MethodRpcModeSlave,
}

MethodRpcModeLookupMap is a string-based lookup table of constants for MethodRpcMode.

View Source 
var NativeScript = &nativeScript{}

NativeScript is a wrapper for the NativeScriptAPI.

View Source 
var PropertyHintLookupMap = map[string]PropertyHint{
	"PropertyHintNone":                  PropertyHintNone,
	"PropertyHintRange":                 PropertyHintRange,
	"PropertyHintExpRange":              PropertyHintExpRange,
	"PropertyHintEnum":                  PropertyHintEnum,
	"PropertyHintExpEasing":             PropertyHintExpEasing,
	"PropertyHintLength":                PropertyHintLength,
	"PropertyHintSpriteFrame":           PropertyHintSpriteFrame,
	"PropertyHintKeyAccel":              PropertyHintKeyAccel,
	"PropertyHintFlags":                 PropertyHintFlags,
	"PropertyHintLayers2DRender":        PropertyHintLayers2DRender,
	"PropertyHintLayers2DPhysics":       PropertyHintLayers2DPhysics,
	"PropertyHintLayers3DRender":        PropertyHintLayers3DRender,
	"PropertyHintLayers3DPhysics":       PropertyHintLayers3DPhysics,
	"PropertyHintFile":                  PropertyHintFile,
	"PropertyHintDir":                   PropertyHintDir,
	"PropertyHintGlobalFile":            PropertyHintGlobalFile,
	"PropertyHintGlobalDir":             PropertyHintGlobalDir,
	"PropertyHintResourceType":          PropertyHintResourceType,
	"PropertyHintMultilineText":         PropertyHintMultilineText,
	"PropertyHintColorNoAlpha":          PropertyHintColorNoAlpha,
	"PropertyHintImageCompressLossy":    PropertyHintImageCompressLossy,
	"PropertyHintImageCompressLossless": PropertyHintImageCompressLossless,
	"PropertyHintObjectId":              PropertyHintObjectId,
	"PropertyHintTypeString":            PropertyHintTypeString,
	"PropertyHintNodePathToEditedNode":  PropertyHintNodePathToEditedNode,
	"PropertyHintMethodOfVariantType":   PropertyHintMethodOfVariantType,
	"PropertyHintMethodOfBaseType":      PropertyHintMethodOfBaseType,
	"PropertyHintMethodOfInstance":      PropertyHintMethodOfInstance,
	"PropertyHintMethodOfScript":        PropertyHintMethodOfScript,
	"PropertyHintPropertyOfVariantType": PropertyHintPropertyOfVariantType,
	"PropertyHintPropertyOfBaseType":    PropertyHintPropertyOfBaseType,
	"PropertyHintPropertyOfInstance":    PropertyHintPropertyOfInstance,
	"PropertyHintPropertyOfScript":      PropertyHintPropertyOfScript,
	"PropertyHintMax":                   PropertyHintMax,
}

PropertyHintLookupMap is a string-based lookup table of constants for PropertyHint.

View Source 
var PropertyUsageFlagsLookupMap = map[string]PropertyUsageFlags{
	"PropertyUsageStorage":             PropertyUsageStorage,
	"PropertyUsageEditor":              PropertyUsageEditor,
	"PropertyUsageNetwork":             PropertyUsageNetwork,
	"PropertyUsageEditorHelper":        PropertyUsageEditorHelper,
	"PropertyUsageCheckable":           PropertyUsageCheckable,
	"PropertyUsageChecked":             PropertyUsageChecked,
	"PropertyUsageInternationalized":   PropertyUsageInternationalized,
	"PropertyUsageGroup":               PropertyUsageGroup,
	"PropertyUsageCategory":            PropertyUsageCategory,
	"PropertyUsageStoreIfNonZero":      PropertyUsageStoreIfNonZero,
	"PropertyUsageStoreIfNonOne":       PropertyUsageStoreIfNonOne,
	"PropertyUsageNoInstanceState":     PropertyUsageNoInstanceState,
	"PropertyUsageRestartIfChanged":    PropertyUsageRestartIfChanged,
	"PropertyUsageScriptVariable":      PropertyUsageScriptVariable,
	"PropertyUsageStoreIfNull":         PropertyUsageStoreIfNull,
	"PropertyUsageAnimateAsTrigger":    PropertyUsageAnimateAsTrigger,
	"PropertyUsageUpdateAllIfModified": PropertyUsageUpdateAllIfModified,
	"PropertyUsageDefault":             PropertyUsageDefault,
	"PropertyUsageDefaultIntl":         PropertyUsageDefaultIntl,
	"PropertyUsageNoEditor":            PropertyUsageNoEditor,
}

PropertyUsageFlags is a string-based lookup table of constants for PropertyUsageFlags.

View Source 
var SetPropertyFuncRegistry = map[string]SetPropertyFunc{}

SetPropertyFuncRegistry is a mapping of instance property setters. This map is used whenever a SetPropertyFunc is registered. It is also used to look up a property setter function when Godot asks Go to set a property on an object.

View Source 
var VariantCallErrorErrorLookupMap = map[string]VariantCallErrorError{
	"CallErrorCallOk":                    CallErrorCallOk,
	"CallErrorCallErrorInvalidMethod":    CallErrorCallErrorInvalidMethod,
	"CallErrorCallErrorInvalidArgument":  CallErrorCallErrorInvalidArgument,
	"CallErrorCallErrorTooManyArguments": CallErrorCallErrorTooManyArguments,
	"CallErrorCallErrorTooFewArguments":  CallErrorCallErrorTooFewArguments,
	"CallErrorCallErrorInstanceIsNull":   CallErrorCallErrorInstanceIsNull,
}

VariantCallErrorErrorLookupMap is a string-based lookup table of constants for VariantCallErrorError.

View Source 
var VariantTypeLookupMap = map[string]VariantType{
	"VariantTypeNil":              VariantTypeNil,
	"VariantTypeBool":             VariantTypeBool,
	"VariantTypeInt":              VariantTypeInt,
	"VariantTypeReal":             VariantTypeReal,
	"VariantTypeString":           VariantTypeString,
	"VariantTypeVector2":          VariantTypeVector2,
	"VariantTypeRect2":            VariantTypeRect2,
	"VariantTypeVector3":          VariantTypeVector3,
	"VariantTypeTransform2D":      VariantTypeTransform2D,
	"VariantTypePlane":            VariantTypePlane,
	"VariantTypeQuat":             VariantTypeQuat,
	"VariantTypeAabb":             VariantTypeAabb,
	"VariantTypeBasis":            VariantTypeBasis,
	"VariantTypeTransform":        VariantTypeTransform,
	"VariantTypeColor":            VariantTypeColor,
	"VariantTypeNodePath":         VariantTypeNodePath,
	"VariantTypeRid":              VariantTypeRid,
	"VariantTypeObject":           VariantTypeObject,
	"VariantTypeDictionary":       VariantTypeDictionary,
	"VariantTypeArray":            VariantTypeArray,
	"VariantTypePoolByteArray":    VariantTypePoolByteArray,
	"VariantTypePoolIntArray":     VariantTypePoolIntArray,
	"VariantTypePoolRealArray":    VariantTypePoolRealArray,
	"VariantTypePoolStringArray":  VariantTypePoolStringArray,
	"VariantTypePoolVector2Array": VariantTypePoolVector2Array,
	"VariantTypePoolVector3Array": VariantTypePoolVector3Array,
	"VariantTypePoolColorArray":   VariantTypePoolColorArray,
}

VariantTypeLookupMap is a string-based lookup table of constants for VariantType.

View Source 
var Vector3AxisLookupMap = map[string]Vector3Axis{
	"Vector3AxisX": Vector3AxisX,
	"Vector3AxisY": Vector3AxisY,
	"Vector3AxisZ": Vector3AxisZ,
}

Vector3AxisLookupMap is a string-based lookup table of constants for Vector3Axis.

Functions

func EnableDebug 

func EnableDebug()

EnableDebug will enable logging of GDNative debug messages.

func SetNativeScriptInit 

func SetNativeScriptInit(initFunc ...func())

SetNativeScriptInit will configure the given function to be called when `godot_nativescript_init` is called by Godot upon NativeScript initialization. This is used so you can define a function that will run to register all of the classes that you want exposed to Godot.

Types

type Aabb 

type Aabb struct {
	// contains filtered or unexported fields
}

func NewAabb 

func NewAabb(pos Vector3, size Vector3) Aabb

NewAabb godot_aabb_new [[godot_aabb * r_dest] [const godot_vector3 * p_pos] [const godot_vector3 * p_size]] void

func NewAabbFromPointer 

func NewAabbFromPointer(ptr Pointer) Aabb

NewAabbFromPointer will return a Aabb from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func (*Aabb) AsString 

func (gdt *Aabb) AsString() String

AsString godot_aabb_as_string [[const godot_aabb * p_self]] godot_string

func (*Aabb) Encloses 

func (gdt *Aabb) Encloses(with Aabb) Bool

Encloses godot_aabb_encloses [[const godot_aabb * p_self] [const godot_aabb * p_with]] godot_bool

func (*Aabb) Expand 

func (gdt *Aabb) Expand(toPoint Vector3) Aabb

Expand godot_aabb_expand [[const godot_aabb * p_self] [const godot_vector3 * p_to_point]] godot_aabb

func (*Aabb) GetArea 

func (gdt *Aabb) GetArea() Real

GetArea godot_aabb_get_area [[const godot_aabb * p_self]] godot_real

func (*Aabb) GetEndpoint 

func (gdt *Aabb) GetEndpoint(idx Int) Vector3

GetEndpoint godot_aabb_get_endpoint [[const godot_aabb * p_self] [const godot_int p_idx]] godot_vector3

func (*Aabb) GetLongestAxis 

func (gdt *Aabb) GetLongestAxis() Vector3

GetLongestAxis godot_aabb_get_longest_axis [[const godot_aabb * p_self]] godot_vector3

func (*Aabb) GetLongestAxisIndex 

func (gdt *Aabb) GetLongestAxisIndex() Int

GetLongestAxisIndex godot_aabb_get_longest_axis_index [[const godot_aabb * p_self]] godot_int

func (*Aabb) GetLongestAxisSize 

func (gdt *Aabb) GetLongestAxisSize() Real

GetLongestAxisSize godot_aabb_get_longest_axis_size [[const godot_aabb * p_self]] godot_real

func (*Aabb) GetPosition 

func (gdt *Aabb) GetPosition() Vector3

GetPosition godot_aabb_get_position [[const godot_aabb * p_self]] godot_vector3

func (*Aabb) GetShortestAxis 

func (gdt *Aabb) GetShortestAxis() Vector3

GetShortestAxis godot_aabb_get_shortest_axis [[const godot_aabb * p_self]] godot_vector3

func (*Aabb) GetShortestAxisIndex 

func (gdt *Aabb) GetShortestAxisIndex() Int

GetShortestAxisIndex godot_aabb_get_shortest_axis_index [[const godot_aabb * p_self]] godot_int

func (*Aabb) GetShortestAxisSize 

func (gdt *Aabb) GetShortestAxisSize() Real

GetShortestAxisSize godot_aabb_get_shortest_axis_size [[const godot_aabb * p_self]] godot_real

func (*Aabb) GetSize 

func (gdt *Aabb) GetSize() Vector3

GetSize godot_aabb_get_size [[const godot_aabb * p_self]] godot_vector3

func (*Aabb) GetSupport 

func (gdt *Aabb) GetSupport(dir Vector3) Vector3

GetSupport godot_aabb_get_support [[const godot_aabb * p_self] [const godot_vector3 * p_dir]] godot_vector3

func (*Aabb) Grow 

func (gdt *Aabb) Grow(by Real) Aabb

Grow godot_aabb_grow [[const godot_aabb * p_self] [const godot_real p_by]] godot_aabb

func (*Aabb) HasNoArea 

func (gdt *Aabb) HasNoArea() Bool

HasNoArea godot_aabb_has_no_area [[const godot_aabb * p_self]] godot_bool

func (*Aabb) HasNoSurface 

func (gdt *Aabb) HasNoSurface() Bool

HasNoSurface godot_aabb_has_no_surface [[const godot_aabb * p_self]] godot_bool

func (*Aabb) HasPoint 

func (gdt *Aabb) HasPoint(point Vector3) Bool

HasPoint godot_aabb_has_point [[const godot_aabb * p_self] [const godot_vector3 * p_point]] godot_bool

func (*Aabb) Intersection 

func (gdt *Aabb) Intersection(with Aabb) Aabb

Intersection godot_aabb_intersection [[const godot_aabb * p_self] [const godot_aabb * p_with]] godot_aabb

func (*Aabb) Intersects 

func (gdt *Aabb) Intersects(with Aabb) Bool

Intersects godot_aabb_intersects [[const godot_aabb * p_self] [const godot_aabb * p_with]] godot_bool

func (*Aabb) IntersectsPlane 

func (gdt *Aabb) IntersectsPlane(plane Plane) Bool

IntersectsPlane godot_aabb_intersects_plane [[const godot_aabb * p_self] [const godot_plane * p_plane]] godot_bool

func (*Aabb) IntersectsSegment 

func (gdt *Aabb) IntersectsSegment(from Vector3, to Vector3) Bool

IntersectsSegment godot_aabb_intersects_segment [[const godot_aabb * p_self] [const godot_vector3 * p_from] [const godot_vector3 * p_to]] godot_bool

func (*Aabb) Merge 

func (gdt *Aabb) Merge(with Aabb) Aabb

Merge godot_aabb_merge [[const godot_aabb * p_self] [const godot_aabb * p_with]] godot_aabb

func (*Aabb) OperatorEqual 

func (gdt *Aabb) OperatorEqual(b Aabb) Bool

OperatorEqual godot_aabb_operator_equal [[const godot_aabb * p_self] [const godot_aabb * p_b]] godot_bool

func (*Aabb) SetPosition 

func (gdt *Aabb) SetPosition(v Vector3)

SetPosition godot_aabb_set_position [[const godot_aabb * p_self] [const godot_vector3 * p_v]] void

func (*Aabb) SetSize 

func (gdt *Aabb) SetSize(v Vector3)

SetSize godot_aabb_set_size [[const godot_aabb * p_self] [const godot_vector3 * p_v]] void

type Array 

type Array struct {
	// contains filtered or unexported fields
}

func NewArray 

func NewArray() Array

NewArray godot_array_new [[godot_array * r_dest]] void

func NewArrayCopy 

func NewArrayCopy(src Array) Array

NewArrayCopy godot_array_new_copy [[godot_array * r_dest] [const godot_array * p_src]] void

func NewArrayFromPointer 

func NewArrayFromPointer(ptr Pointer) Array

NewArrayFromPointer will return a Array from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewArrayPoolByteArray 

func NewArrayPoolByteArray(pba PoolByteArray) Array

NewArrayPoolByteArray godot_array_new_pool_byte_array [[godot_array * r_dest] [const godot_pool_byte_array * p_pba]] void

func NewArrayPoolColorArray 

func NewArrayPoolColorArray(pca PoolColorArray) Array

NewArrayPoolColorArray godot_array_new_pool_color_array [[godot_array * r_dest] [const godot_pool_color_array * p_pca]] void

func NewArrayPoolIntArray 

func NewArrayPoolIntArray(pia PoolIntArray) Array

NewArrayPoolIntArray godot_array_new_pool_int_array [[godot_array * r_dest] [const godot_pool_int_array * p_pia]] void

func NewArrayPoolRealArray 

func NewArrayPoolRealArray(pra PoolRealArray) Array

NewArrayPoolRealArray godot_array_new_pool_real_array [[godot_array * r_dest] [const godot_pool_real_array * p_pra]] void

func NewArrayPoolStringArray 

func NewArrayPoolStringArray(psa PoolStringArray) Array

NewArrayPoolStringArray godot_array_new_pool_string_array [[godot_array * r_dest] [const godot_pool_string_array * p_psa]] void

func NewArrayPoolVector2Array 

func NewArrayPoolVector2Array(pv2A PoolVector2Array) Array

NewArrayPoolVector2Array godot_array_new_pool_vector2_array [[godot_array * r_dest] [const godot_pool_vector2_array * p_pv2a]] void

func NewArrayPoolVector3Array 

func NewArrayPoolVector3Array(pv3A PoolVector3Array) Array

NewArrayPoolVector3Array godot_array_new_pool_vector3_array [[godot_array * r_dest] [const godot_pool_vector3_array * p_pv3a]] void

func (*Array) Append 

func (gdt *Array) Append(value Variant)

Append godot_array_append [[godot_array * p_self] [const godot_variant * p_value]] void

func (*Array) Back 

func (gdt *Array) Back() Variant

Back godot_array_back [[const godot_array * p_self]] godot_variant

func (*Array) Bsearch 

func (gdt *Array) Bsearch(value Variant, before Bool) Int

Bsearch godot_array_bsearch [[godot_array * p_self] [const godot_variant * p_value] [const godot_bool p_before]] godot_int

func (*Array) BsearchCustom 

func (gdt *Array) BsearchCustom(value Variant, obj Object, function String, before Bool) Int

BsearchCustom godot_array_bsearch_custom [[godot_array * p_self] [const godot_variant * p_value] [godot_object * p_obj] [const godot_string * p_func] [const godot_bool p_before]] godot_int

func (*Array) Clear 

func (gdt *Array) Clear()

Clear godot_array_clear [[godot_array * p_self]] void

func (*Array) Count 

func (gdt *Array) Count(value Variant) Int

Count godot_array_count [[const godot_array * p_self] [const godot_variant * p_value]] godot_int

func (*Array) Destroy 

func (gdt *Array) Destroy()

Destroy godot_array_destroy [[godot_array * p_self]] void

func (*Array) Empty 

func (gdt *Array) Empty() Bool

Empty godot_array_empty [[const godot_array * p_self]] godot_bool

func (*Array) Erase 

func (gdt *Array) Erase(value Variant)

Erase godot_array_erase [[godot_array * p_self] [const godot_variant * p_value]] void

func (*Array) Find 

func (gdt *Array) Find(what Variant, from Int) Int

Find godot_array_find [[const godot_array * p_self] [const godot_variant * p_what] [const godot_int p_from]] godot_int

func (*Array) FindLast 

func (gdt *Array) FindLast(what Variant) Int

FindLast godot_array_find_last [[const godot_array * p_self] [const godot_variant * p_what]] godot_int

func (*Array) Front 

func (gdt *Array) Front() Variant

Front godot_array_front [[const godot_array * p_self]] godot_variant

func (*Array) Get 

func (gdt *Array) Get(idx Int) Variant

Get godot_array_get [[const godot_array * p_self] [const godot_int p_idx]] godot_variant

func (*Array) Has 

func (gdt *Array) Has(value Variant) Bool

Has godot_array_has [[const godot_array * p_self] [const godot_variant * p_value]] godot_bool

func (*Array) Hash 

func (gdt *Array) Hash() Int

Hash godot_array_hash [[const godot_array * p_self]] godot_int

func (*Array) Insert 

func (gdt *Array) Insert(pos Int, value Variant)

Insert godot_array_insert [[godot_array * p_self] [const godot_int p_pos] [const godot_variant * p_value]] void

func (*Array) Invert 

func (gdt *Array) Invert()

Invert godot_array_invert [[godot_array * p_self]] void

func (*Array) OperatorIndex 

func (gdt *Array) OperatorIndex(idx Int) Variant

OperatorIndex godot_array_operator_index [[godot_array * p_self] [const godot_int p_idx]] godot_variant *

func (*Array) OperatorIndexConst 

func (gdt *Array) OperatorIndexConst(idx Int) Variant

OperatorIndexConst godot_array_operator_index_const [[const godot_array * p_self] [const godot_int p_idx]] const godot_variant *

func (*Array) PopBack 

func (gdt *Array) PopBack() Variant

PopBack godot_array_pop_back [[godot_array * p_self]] godot_variant

func (*Array) PopFront 

func (gdt *Array) PopFront() Variant

PopFront godot_array_pop_front [[godot_array * p_self]] godot_variant

func (*Array) PushBack 

func (gdt *Array) PushBack(value Variant)

PushBack godot_array_push_back [[godot_array * p_self] [const godot_variant * p_value]] void

func (*Array) PushFront 

func (gdt *Array) PushFront(value Variant)

PushFront godot_array_push_front [[godot_array * p_self] [const godot_variant * p_value]] void

func (*Array) Remove 

func (gdt *Array) Remove(idx Int)

Remove godot_array_remove [[godot_array * p_self] [const godot_int p_idx]] void

func (*Array) Resize 

func (gdt *Array) Resize(size Int)

Resize godot_array_resize [[godot_array * p_self] [const godot_int p_size]] void

func (*Array) Rfind 

func (gdt *Array) Rfind(what Variant, from Int) Int

Rfind godot_array_rfind [[const godot_array * p_self] [const godot_variant * p_what] [const godot_int p_from]] godot_int

func (*Array) Set 

func (gdt *Array) Set(idx Int, value Variant)

Set godot_array_set [[godot_array * p_self] [const godot_int p_idx] [const godot_variant * p_value]] void

func (*Array) Size 

func (gdt *Array) Size() Int

Size godot_array_size [[const godot_array * p_self]] godot_int

func (*Array) Sort 

func (gdt *Array) Sort()

Sort godot_array_sort [[godot_array * p_self]] void

func (*Array) SortCustom 

func (gdt *Array) SortCustom(obj Object, function String)

SortCustom godot_array_sort_custom [[godot_array * p_self] [godot_object * p_obj] [const godot_string * p_func]] void

type ArvrInterfaceGdnative 

type ArvrInterfaceGdnative struct {
	// contains filtered or unexported fields
}

func NewArvrInterfaceGdnativeFromPointer 

func NewArvrInterfaceGdnativeFromPointer(ptr Pointer) ArvrInterfaceGdnative

NewArvrInterfaceGdnativeFromPointer will return a ArvrInterfaceGdnative from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type Basis 

type Basis struct {
	// contains filtered or unexported fields
}

func NewBasis 

func NewBasis() Basis

NewBasis godot_basis_new [[godot_basis * r_dest]] void

func NewBasisFromPointer 

func NewBasisFromPointer(ptr Pointer) Basis

NewBasisFromPointer will return a Basis from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewBasisWithAxisAndAngle 

func NewBasisWithAxisAndAngle(axis Vector3, phi Real) Basis

NewBasisWithAxisAndAngle godot_basis_new_with_axis_and_angle [[godot_basis * r_dest] [const godot_vector3 * p_axis] [const godot_real p_phi]] void

func NewBasisWithEuler 

func NewBasisWithEuler(euler Vector3) Basis

NewBasisWithEuler godot_basis_new_with_euler [[godot_basis * r_dest] [const godot_vector3 * p_euler]] void

func NewBasisWithEulerQuat 

func NewBasisWithEulerQuat(euler Quat) Basis

NewBasisWithEulerQuat godot_basis_new_with_euler_quat [[godot_basis * r_dest] [const godot_quat * p_euler]] void

func NewBasisWithRows 

func NewBasisWithRows(xAxis Vector3, yAxis Vector3, zAxis Vector3) Basis

NewBasisWithRows godot_basis_new_with_rows [[godot_basis * r_dest] [const godot_vector3 * p_x_axis] [const godot_vector3 * p_y_axis] [const godot_vector3 * p_z_axis]] void

func (*Basis) AsString 

func (gdt *Basis) AsString() String

AsString godot_basis_as_string [[const godot_basis * p_self]] godot_string

func (*Basis) Determinant 

func (gdt *Basis) Determinant() Real

Determinant godot_basis_determinant [[const godot_basis * p_self]] godot_real

func (*Basis) GetAxis 

func (gdt *Basis) GetAxis(axis Int) Vector3

GetAxis godot_basis_get_axis [[const godot_basis * p_self] [const godot_int p_axis]] godot_vector3

func (*Basis) GetElements 

func (gdt *Basis) GetElements(elements Vector3)

GetElements godot_basis_get_elements [[const godot_basis * p_self] [godot_vector3 * p_elements]] void

func (*Basis) GetEuler 

func (gdt *Basis) GetEuler() Vector3

GetEuler godot_basis_get_euler [[const godot_basis * p_self]] godot_vector3

func (*Basis) GetOrthogonalIndex 

func (gdt *Basis) GetOrthogonalIndex() Int

GetOrthogonalIndex godot_basis_get_orthogonal_index [[const godot_basis * p_self]] godot_int

func (*Basis) GetRow 

func (gdt *Basis) GetRow(row Int) Vector3

GetRow godot_basis_get_row [[const godot_basis * p_self] [const godot_int p_row]] godot_vector3

func (*Basis) GetScale 

func (gdt *Basis) GetScale() Vector3

GetScale godot_basis_get_scale [[const godot_basis * p_self]] godot_vector3

func (*Basis) Inverse 

func (gdt *Basis) Inverse() Basis

Inverse godot_basis_inverse [[const godot_basis * p_self]] godot_basis

func (*Basis) OperatorAdd 

func (gdt *Basis) OperatorAdd(b Basis) Basis

OperatorAdd godot_basis_operator_add [[const godot_basis * p_self] [const godot_basis * p_b]] godot_basis

func (*Basis) OperatorEqual 

func (gdt *Basis) OperatorEqual(b Basis) Bool

OperatorEqual godot_basis_operator_equal [[const godot_basis * p_self] [const godot_basis * p_b]] godot_bool

func (*Basis) OperatorMultiplyScalar 

func (gdt *Basis) OperatorMultiplyScalar(b Real) Basis

OperatorMultiplyScalar godot_basis_operator_multiply_scalar [[const godot_basis * p_self] [const godot_real p_b]] godot_basis

func (*Basis) OperatorMultiplyVector 

func (gdt *Basis) OperatorMultiplyVector(b Basis) Basis

OperatorMultiplyVector godot_basis_operator_multiply_vector [[const godot_basis * p_self] [const godot_basis * p_b]] godot_basis

func (*Basis) OperatorSubtract 

func (gdt *Basis) OperatorSubtract(b Basis) Basis

OperatorSubtract godot_basis_operator_subtract [[const godot_basis * p_self] [const godot_basis * p_b]] godot_basis

func (*Basis) Orthonormalized 

func (gdt *Basis) Orthonormalized() Basis

Orthonormalized godot_basis_orthonormalized [[const godot_basis * p_self]] godot_basis

func (*Basis) Rotated 

func (gdt *Basis) Rotated(axis Vector3, phi Real) Basis

Rotated godot_basis_rotated [[const godot_basis * p_self] [const godot_vector3 * p_axis] [const godot_real p_phi]] godot_basis

func (*Basis) Scaled 

func (gdt *Basis) Scaled(scale Vector3) Basis

Scaled godot_basis_scaled [[const godot_basis * p_self] [const godot_vector3 * p_scale]] godot_basis

func (*Basis) SetAxis 

func (gdt *Basis) SetAxis(axis Int, value Vector3)

SetAxis godot_basis_set_axis [[godot_basis * p_self] [const godot_int p_axis] [const godot_vector3 * p_value]] void

func (*Basis) SetRow 

func (gdt *Basis) SetRow(row Int, value Vector3)

SetRow godot_basis_set_row [[godot_basis * p_self] [const godot_int p_row] [const godot_vector3 * p_value]] void

func (*Basis) Tdotx 

func (gdt *Basis) Tdotx(with Vector3) Real

Tdotx godot_basis_tdotx [[const godot_basis * p_self] [const godot_vector3 * p_with]] godot_real

func (*Basis) Tdoty 

func (gdt *Basis) Tdoty(with Vector3) Real

Tdoty godot_basis_tdoty [[const godot_basis * p_self] [const godot_vector3 * p_with]] godot_real

func (*Basis) Tdotz 

func (gdt *Basis) Tdotz(with Vector3) Real

Tdotz godot_basis_tdotz [[const godot_basis * p_self] [const godot_vector3 * p_with]] godot_real

func (*Basis) Transposed 

func (gdt *Basis) Transposed() Basis

Transposed godot_basis_transposed [[const godot_basis * p_self]] godot_basis

func (*Basis) Xform 

func (gdt *Basis) Xform(v Vector3) Vector3

Xform godot_basis_xform [[const godot_basis * p_self] [const godot_vector3 * p_v]] godot_vector3

func (*Basis) XformInv 

func (gdt *Basis) XformInv(v Vector3) Vector3

XformInv godot_basis_xform_inv [[const godot_basis * p_self] [const godot_vector3 * p_v]] godot_vector3

type Bool 

type Bool bool

Bool is a Go wrapper for the base C.godot_bool type

func NewBoolFromPointer 

func NewBoolFromPointer(ptr Pointer) Bool

NewBoolFromPointer will return a Bool from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type Char 

type Char string

type CharString 

type CharString struct {
	// contains filtered or unexported fields
}

func NewCharStringFromPointer 

func NewCharStringFromPointer(ptr Pointer) CharString

NewCharStringFromPointer will return a CharString from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type Color 

type Color struct {
	// contains filtered or unexported fields
}

func NewColorFromPointer 

func NewColorFromPointer(ptr Pointer) Color

NewColorFromPointer will return a Color from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewColorRgb 

func NewColorRgb(r Real, g Real, b Real) Color

NewColorRgb godot_color_new_rgb [[godot_color * r_dest] [const godot_real p_r] [const godot_real p_g] [const godot_real p_b]] void

func NewColorRgba 

func NewColorRgba(r Real, g Real, b Real, a Real) Color

NewColorRgba godot_color_new_rgba [[godot_color * r_dest] [const godot_real p_r] [const godot_real p_g] [const godot_real p_b] [const godot_real p_a]] void

func (*Color) AsString 

func (gdt *Color) AsString() String

AsString godot_color_as_string [[const godot_color * p_self]] godot_string

func (*Color) Blend 

func (gdt *Color) Blend(over Color) Color

Blend godot_color_blend [[const godot_color * p_self] [const godot_color * p_over]] godot_color

func (*Color) Contrasted 

func (gdt *Color) Contrasted() Color

Contrasted godot_color_contrasted [[const godot_color * p_self]] godot_color

func (*Color) GetA 

func (gdt *Color) GetA() Real

GetA godot_color_get_a [[const godot_color * p_self]] godot_real

func (*Color) GetB 

func (gdt *Color) GetB() Real

GetB godot_color_get_b [[const godot_color * p_self]] godot_real

func (*Color) GetG 

func (gdt *Color) GetG() Real

GetG godot_color_get_g [[const godot_color * p_self]] godot_real

func (*Color) GetH 

func (gdt *Color) GetH() Real

GetH godot_color_get_h [[const godot_color * p_self]] godot_real

func (*Color) GetR 

func (gdt *Color) GetR() Real

GetR godot_color_get_r [[const godot_color * p_self]] godot_real

func (*Color) GetS 

func (gdt *Color) GetS() Real

GetS godot_color_get_s [[const godot_color * p_self]] godot_real

func (*Color) GetV 

func (gdt *Color) GetV() Real

GetV godot_color_get_v [[const godot_color * p_self]] godot_real

func (*Color) Gray 

func (gdt *Color) Gray() Real

Gray godot_color_gray [[const godot_color * p_self]] godot_real

func (*Color) Inverted 

func (gdt *Color) Inverted() Color

Inverted godot_color_inverted [[const godot_color * p_self]] godot_color

func (*Color) LinearInterpolate 

func (gdt *Color) LinearInterpolate(b Color, t Real) Color

LinearInterpolate godot_color_linear_interpolate [[const godot_color * p_self] [const godot_color * p_b] [const godot_real p_t]] godot_color

func (*Color) OperatorEqual 

func (gdt *Color) OperatorEqual(b Color) Bool

OperatorEqual godot_color_operator_equal [[const godot_color * p_self] [const godot_color * p_b]] godot_bool

func (*Color) OperatorLess 

func (gdt *Color) OperatorLess(b Color) Bool

OperatorLess godot_color_operator_less [[const godot_color * p_self] [const godot_color * p_b]] godot_bool

func (*Color) SetA 

func (gdt *Color) SetA(a Real)

SetA godot_color_set_a [[godot_color * p_self] [const godot_real a]] void

func (*Color) SetB 

func (gdt *Color) SetB(b Real)

SetB godot_color_set_b [[godot_color * p_self] [const godot_real b]] void

func (*Color) SetG 

func (gdt *Color) SetG(g Real)

SetG godot_color_set_g [[godot_color * p_self] [const godot_real g]] void

func (*Color) SetR 

func (gdt *Color) SetR(r Real)

SetR godot_color_set_r [[godot_color * p_self] [const godot_real r]] void

func (*Color) ToArgb32 

func (gdt *Color) ToArgb32() Int

ToArgb32 godot_color_to_argb32 [[const godot_color * p_self]] godot_int

func (*Color) ToHtml 

func (gdt *Color) ToHtml(withAlpha Bool) String

ToHtml godot_color_to_html [[const godot_color * p_self] [const godot_bool p_with_alpha]] godot_string

func (*Color) ToRgba32 

func (gdt *Color) ToRgba32() Int

ToRgba32 godot_color_to_rgba32 [[const godot_color * p_self]] godot_int

type CreateFunc 

type CreateFunc func(Object, string) string

CreateFunc will be called when we need to create a new instance of a class. When it is called, the Godot object will passed as an argument, as well as the methodData string, which is usually the name of the class to be created.

type DestroyFunc 

type DestroyFunc func(Object, string, string)

DestroyFunc will be called when the object is destroyed. Takes the instance object, method data, user data. The method data is generally the class name, and the user data is generally the class instance id to destroy.

type Dictionary 

type Dictionary struct {
	// contains filtered or unexported fields
}

func NewDictionary 

func NewDictionary() Dictionary

NewDictionary godot_dictionary_new [[godot_dictionary * r_dest]] void

func NewDictionaryCopy 

func NewDictionaryCopy(src Dictionary) Dictionary

NewDictionaryCopy godot_dictionary_new_copy [[godot_dictionary * r_dest] [const godot_dictionary * p_src]] void

func NewDictionaryFromPointer 

func NewDictionaryFromPointer(ptr Pointer) Dictionary

NewDictionaryFromPointer will return a Dictionary from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func (*Dictionary) Clear 

func (gdt *Dictionary) Clear()

Clear godot_dictionary_clear [[godot_dictionary * p_self]] void

func (*Dictionary) Destroy 

func (gdt *Dictionary) Destroy()

Destroy godot_dictionary_destroy [[godot_dictionary * p_self]] void

func (*Dictionary) Empty 

func (gdt *Dictionary) Empty() Bool

Empty godot_dictionary_empty [[const godot_dictionary * p_self]] godot_bool

func (*Dictionary) Erase 

func (gdt *Dictionary) Erase(key Variant)

Erase godot_dictionary_erase [[godot_dictionary * p_self] [const godot_variant * p_key]] void

func (*Dictionary) Get 

func (gdt *Dictionary) Get(key Variant) Variant

Get godot_dictionary_get [[const godot_dictionary * p_self] [const godot_variant * p_key]] godot_variant

func (*Dictionary) Has 

func (gdt *Dictionary) Has(key Variant) Bool

Has godot_dictionary_has [[const godot_dictionary * p_self] [const godot_variant * p_key]] godot_bool

func (*Dictionary) HasAll 

func (gdt *Dictionary) HasAll(keys Array) Bool

HasAll godot_dictionary_has_all [[const godot_dictionary * p_self] [const godot_array * p_keys]] godot_bool

func (*Dictionary) Hash 

func (gdt *Dictionary) Hash() Int

Hash godot_dictionary_hash [[const godot_dictionary * p_self]] godot_int

func (*Dictionary) Keys 

func (gdt *Dictionary) Keys() Array

Keys godot_dictionary_keys [[const godot_dictionary * p_self]] godot_array

func (*Dictionary) Next 

func (gdt *Dictionary) Next(key Variant) Variant

Next godot_dictionary_next [[const godot_dictionary * p_self] [const godot_variant * p_key]] godot_variant *

func (*Dictionary) OperatorEqual 

func (gdt *Dictionary) OperatorEqual(b Dictionary) Bool

OperatorEqual godot_dictionary_operator_equal [[const godot_dictionary * p_self] [const godot_dictionary * p_b]] godot_bool

func (*Dictionary) OperatorIndex 

func (gdt *Dictionary) OperatorIndex(key Variant) Variant

OperatorIndex godot_dictionary_operator_index [[godot_dictionary * p_self] [const godot_variant * p_key]] godot_variant *

func (*Dictionary) OperatorIndexConst 

func (gdt *Dictionary) OperatorIndexConst(key Variant) Variant

OperatorIndexConst godot_dictionary_operator_index_const [[const godot_dictionary * p_self] [const godot_variant * p_key]] const godot_variant *

func (*Dictionary) Set 

func (gdt *Dictionary) Set(key Variant, value Variant)

Set godot_dictionary_set [[godot_dictionary * p_self] [const godot_variant * p_key] [const godot_variant * p_value]] void

func (*Dictionary) Size 

func (gdt *Dictionary) Size() Int

Size godot_dictionary_size [[const godot_dictionary * p_self]] godot_int

func (*Dictionary) ToJson 

func (gdt *Dictionary) ToJson() String

ToJson godot_dictionary_to_json [[const godot_dictionary * p_self]] godot_string

func (*Dictionary) Values 

func (gdt *Dictionary) Values() Array

Values godot_dictionary_values [[const godot_dictionary * p_self]] godot_array

type Double 

type Double float64

type Error 

type Error int

Error is a Go wrapper for the C.godot_error enum type. 

const (
	Ok                         Error = 0
	Failed                     Error = 1 // < Generic fail error
	ErrUnavailable             Error = 2 // < What is requested is unsupported/unavailable
	ErrUnconfigured            Error = 3 // < The object being used hasn't been properly set up yet
	ErrUnauthorized            Error = 4 // < Missing credentials for requested resource
	ErrParameterRangeError     Error = 5 // < Parameter given out of range (5)
	ErrOutOfMemory             Error = 6 // < Out of memory
	ErrFileNotFound            Error = 7
	ErrFileBadDrive            Error = 8
	ErrFileBadPath             Error = 9
	ErrFileNoPermission        Error = 10 // (10)
	ErrFileAlreadyInUse        Error = 11
	ErrFileCantOpen            Error = 12
	ErrFileCantWrite           Error = 13
	ErrFileCantRead            Error = 14
	ErrFileUnrecognized        Error = 15 // (15)
	ErrFileCorrupt             Error = 16
	ErrFileMissingDependencies Error = 17
	ErrFileEof                 Error = 18
	ErrCantOpen                Error = 19 // < Can't open a resource/socket/file
	ErrCantCreate              Error = 20 // (20)
	ErrQueryFailed             Error = 21
	ErrAlreadyInUse            Error = 22
	ErrLocked                  Error = 23 // < resource is locked
	ErrTimeout                 Error = 24
	ErrCantConnect             Error = 25 // (25)
	ErrCantResolve             Error = 26
	ErrConnectionError         Error = 27
	ErrCantAcquireResource     Error = 28
	ErrCantFork                Error = 29
	ErrInvalidData             Error = 30 // < Data passed is invalid	(30)
	ErrInvalidParameter        Error = 31 // < Parameter passed is invalid
	ErrAlreadyExists           Error = 32 // < When adding, item already exists
	ErrDoesNotExist            Error = 33 // < When retrieving/erasing, it item does not exist
	ErrDatabaseCantRead        Error = 34 // < database is full
	ErrDatabaseCantWrite       Error = 35 // < database is full	(35)
	ErrCompilationFailed       Error = 36
	ErrMethodNotFound          Error = 37
	ErrLinkFailed              Error = 38
	ErrScriptFailed            Error = 39
	ErrCyclicLink              Error = 40 // (40)
	ErrInvalidDeclaration      Error = 41
	ErrDuplicateSymbol         Error = 42
	ErrParseError              Error = 43
	ErrBusy                    Error = 44
	ErrSkip                    Error = 45 // (45)
	ErrHelp                    Error = 46 // < user requested help!!
	ErrBug                     Error = 47 // < a bug in the software certainly happened, due to a double check failing or unexpected behavior.
	ErrPrinterOnFire           Error = 48 //  the parallel port printer is engulfed in flames
)

type Float 

type Float float64

func NewFloatFromPointer 

func NewFloatFromPointer(ptr Pointer) Float

NewFloatFromPointer will return a Float from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type FreeFunc 

type FreeFunc func(string)

FreeFunc will be called when we should free the instance from memory. Takes in method data. The method data is generally the class name to be freed.

type GdnativeApiVersion 

type GdnativeApiVersion struct {
	Major Uint
	Minor Uint
	// contains filtered or unexported fields
}

func NewGdnativeApiVersionFromPointer 

func NewGdnativeApiVersionFromPointer(ptr Pointer) GdnativeApiVersion

NewGdnativeApiVersionFromPointer will return a GdnativeApiVersion from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type GdnativeTerminateOptions 

type GdnativeTerminateOptions struct {
	InEditor Bool
	// contains filtered or unexported fields
}

func NewGdnativeTerminateOptionsFromPointer 

func NewGdnativeTerminateOptionsFromPointer(ptr Pointer) GdnativeTerminateOptions

NewGdnativeTerminateOptionsFromPointer will return a GdnativeTerminateOptions from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type GetPropertyFunc 

type GetPropertyFunc func(Object, string, string) Variant

GetPropertyFunc will be called when Godot requests a property on a given class instance. When it is called, Godot will pass the Godot object instance as an argument, as well as the methodData (which is usually the name of the class), and the userData (which is generally the instance ID of the object. You should return the property as a Variant.

type InstanceCreateFunc 

type InstanceCreateFunc struct {
	CreateFunc CreateFunc
	MethodData string
	FreeFunc   FreeFunc
	// contains filtered or unexported fields
}

InstanceCreateFunc is a structure that contains the instance creation function that will be called when Godot asks Go to create a new instance of a class.

type InstanceDestroyFunc 

type InstanceDestroyFunc struct {
	DestroyFunc DestroyFunc
	MethodData  string
	FreeFunc    FreeFunc
	// contains filtered or unexported fields
}

InstanceDestroyFunc is a structure that contains the instance destruction function that will be called when Godot asks Go to destroy a class instance.

type InstanceMethod 

type InstanceMethod struct {
	Method     MethodFunc
	MethodData string
	FreeFunc   FreeFunc
	// contains filtered or unexported fields
}

InstanceMethod is a structure that contains an instance method function that will be called when Godot asks Go to call a method on a class.

type InstancePropertyGet 

type InstancePropertyGet struct {
	GetFunc    GetPropertyFunc
	MethodData string
	FreeFunc   FreeFunc
	// contains filtered or unexported fields
}

InstancePropertyGet is a structure that contains an instance property getter function that will be called when Godot asks Go to get a property from a class instance.

type InstancePropertySet 

type InstancePropertySet struct {
	SetFunc    SetPropertyFunc
	MethodData string
	FreeFunc   FreeFunc
	// contains filtered or unexported fields
}

InstancePropertySet is a structure that contains an instance property setter function that will be called when Godot asks Go to set a property on a class.

type Int 

type Int int

Int is a Go wrapper for the base C.godot_int type

func NewIntFromPointer 

func NewIntFromPointer(ptr Pointer) Int

NewIntFromPointer will return a Int from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type Int64T 

type Int64T int64

type Logger 

type Logger struct {
	// StackNum is how far up the stack logs should show up as.
	StackNum int
}

Logger is a native Go structure for logging in Godot.

func (*Logger) Error 

func (l *Logger) Error(message ...interface{})

Error will print an error message to the Godot debugger and console.

func (*Logger) Println 

func (l *Logger) Println(message ...interface{})

Print will print the given message to the Godot debugger and console.

func (*Logger) Warning 

func (l *Logger) Warning(message ...interface{})

Warning will print a warning message to the Godot debugger and console.

func (*Logger) Write 

func (l *Logger) Write(data []byte) (int, error)

Write will call Logger.Println from the given bytes, to implement the io.Writer interface.

type MethodArg 

type MethodArg struct {
	Name       String
	Type       VariantType
	Hint       PropertyHint
	HintString String
	// contains filtered or unexported fields
}

func NewMethodArgFromPointer 

func NewMethodArgFromPointer(ptr Pointer) MethodArg

NewMethodArgFromPointer will return a MethodArg from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type MethodAttributes 

type MethodAttributes struct {
	RPCType MethodRpcMode
	// contains filtered or unexported fields
}

type MethodBind 

type MethodBind struct {
	// contains filtered or unexported fields
}

func NewMethodBind 

func NewMethodBind(class, method string) MethodBind

NewMethodBind will return a method binding using the given class name and method name.

func NewMethodBindFromPointer 

func NewMethodBindFromPointer(ptr Pointer) MethodBind

NewMethodBindFromPointer will return a MethodBind from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type MethodFunc 

type MethodFunc func(Object, string, string, int, []Variant) Variant

MethodFunc will be called when a method attached to an instance is called. When it is called, it will be passed the Godot object the method is attached to, the methodData string (which is usually the class and method name that is being called), the userData string (which is usually the class instance ID), the number of arguments being passed to the function, and a list of Variant arguments to pass to the function.

type MethodRpcMode 

type MethodRpcMode int

MethodRpcMode is a Go wrapper for the C.godot_method_rpc_mode enum type. 

const (
	MethodRpcModeDisabled MethodRpcMode = 0
	MethodRpcModeRemote   MethodRpcMode = 1
	MethodRpcModeSync     MethodRpcMode = 2
	MethodRpcModeMaster   MethodRpcMode = 3
	MethodRpcModeSlave    MethodRpcMode = 4
)

type NodePath 

type NodePath struct {
	// contains filtered or unexported fields
}

func NewNodePath 

func NewNodePath(from String) NodePath

NewNodePath godot_node_path_new [[godot_node_path * r_dest] [const godot_string * p_from]] void

func NewNodePathCopy 

func NewNodePathCopy(src NodePath) NodePath

NewNodePathCopy godot_node_path_new_copy [[godot_node_path * r_dest] [const godot_node_path * p_src]] void

func NewNodePathFromPointer 

func NewNodePathFromPointer(ptr Pointer) NodePath

NewNodePathFromPointer will return a NodePath from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func (*NodePath) AsString 

func (gdt *NodePath) AsString() String

AsString godot_node_path_as_string [[const godot_node_path * p_self]] godot_string

func (*NodePath) Destroy 

func (gdt *NodePath) Destroy()

Destroy godot_node_path_destroy [[godot_node_path * p_self]] void

func (*NodePath) GetConcatenatedSubnames 

func (gdt *NodePath) GetConcatenatedSubnames() String

GetConcatenatedSubnames godot_node_path_get_concatenated_subnames [[const godot_node_path * p_self]] godot_string

func (*NodePath) GetName 

func (gdt *NodePath) GetName(idx Int) String

GetName godot_node_path_get_name [[const godot_node_path * p_self] [const godot_int p_idx]] godot_string

func (*NodePath) GetNameCount 

func (gdt *NodePath) GetNameCount() Int

GetNameCount godot_node_path_get_name_count [[const godot_node_path * p_self]] godot_int

func (*NodePath) GetSubname 

func (gdt *NodePath) GetSubname(idx Int) String

GetSubname godot_node_path_get_subname [[const godot_node_path * p_self] [const godot_int p_idx]] godot_string

func (*NodePath) GetSubnameCount 

func (gdt *NodePath) GetSubnameCount() Int

GetSubnameCount godot_node_path_get_subname_count [[const godot_node_path * p_self]] godot_int

func (*NodePath) IsAbsolute 

func (gdt *NodePath) IsAbsolute() Bool

IsAbsolute godot_node_path_is_absolute [[const godot_node_path * p_self]] godot_bool

func (*NodePath) IsEmpty 

func (gdt *NodePath) IsEmpty() Bool

IsEmpty godot_node_path_is_empty [[const godot_node_path * p_self]] godot_bool

func (*NodePath) OperatorEqual 

func (gdt *NodePath) OperatorEqual(b NodePath) Bool

OperatorEqual godot_node_path_operator_equal [[const godot_node_path * p_self] [const godot_node_path * p_b]] godot_bool

type Object 

type Object struct {
	// contains filtered or unexported fields
}

func GetSingleton 

func GetSingleton(name String) Object

GetSingleton will return an instance of the given singleton.

func NewObjectFromPointer 

func NewObjectFromPointer(ptr Pointer) Object

NewObjectFromPointer will return a Object from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func (Object) ID 

func (gdt Object) ID() string

ID will return the Godot object memory address as a string, which can be used in an instance registry for registering classes.

type Plane 

type Plane struct {
	// contains filtered or unexported fields
}

func NewPlaneFromPointer 

func NewPlaneFromPointer(ptr Pointer) Plane

NewPlaneFromPointer will return a Plane from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewPlaneWithNormal 

func NewPlaneWithNormal(normal Vector3, d Real) Plane

NewPlaneWithNormal godot_plane_new_with_normal [[godot_plane * r_dest] [const godot_vector3 * p_normal] [const godot_real p_d]] void

func NewPlaneWithReals 

func NewPlaneWithReals(a Real, b Real, c Real, d Real) Plane

NewPlaneWithReals godot_plane_new_with_reals [[godot_plane * r_dest] [const godot_real p_a] [const godot_real p_b] [const godot_real p_c] [const godot_real p_d]] void

func NewPlaneWithVectors 

func NewPlaneWithVectors(v1 Vector3, v2 Vector3, v3 Vector3) Plane

NewPlaneWithVectors godot_plane_new_with_vectors [[godot_plane * r_dest] [const godot_vector3 * p_v1] [const godot_vector3 * p_v2] [const godot_vector3 * p_v3]] void

func (*Plane) AsString 

func (gdt *Plane) AsString() String

AsString godot_plane_as_string [[const godot_plane * p_self]] godot_string

func (*Plane) Center 

func (gdt *Plane) Center() Vector3

Center godot_plane_center [[const godot_plane * p_self]] godot_vector3

func (*Plane) DistanceTo 

func (gdt *Plane) DistanceTo(point Vector3) Real

DistanceTo godot_plane_distance_to [[const godot_plane * p_self] [const godot_vector3 * p_point]] godot_real

func (*Plane) GetAnyPoint 

func (gdt *Plane) GetAnyPoint() Vector3

GetAnyPoint godot_plane_get_any_point [[const godot_plane * p_self]] godot_vector3

func (*Plane) GetD 

func (gdt *Plane) GetD() Real

GetD godot_plane_get_d [[const godot_plane * p_self]] godot_real

func (*Plane) GetNormal 

func (gdt *Plane) GetNormal() Vector3

GetNormal godot_plane_get_normal [[const godot_plane * p_self]] godot_vector3

func (*Plane) HasPoint 

func (gdt *Plane) HasPoint(point Vector3, epsilon Real) Bool

HasPoint godot_plane_has_point [[const godot_plane * p_self] [const godot_vector3 * p_point] [const godot_real p_epsilon]] godot_bool

func (*Plane) Intersect3 

func (gdt *Plane) Intersect3(dest Vector3, b Plane, c Plane) Bool

Intersect3 godot_plane_intersect_3 [[const godot_plane * p_self] [godot_vector3 * r_dest] [const godot_plane * p_b] [const godot_plane * p_c]] godot_bool

func (*Plane) IntersectsRay 

func (gdt *Plane) IntersectsRay(dest Vector3, from Vector3, dir Vector3) Bool

IntersectsRay godot_plane_intersects_ray [[const godot_plane * p_self] [godot_vector3 * r_dest] [const godot_vector3 * p_from] [const godot_vector3 * p_dir]] godot_bool

func (*Plane) IntersectsSegment 

func (gdt *Plane) IntersectsSegment(dest Vector3, begin Vector3, end Vector3) Bool

IntersectsSegment godot_plane_intersects_segment [[const godot_plane * p_self] [godot_vector3 * r_dest] [const godot_vector3 * p_begin] [const godot_vector3 * p_end]] godot_bool

func (*Plane) IsPointOver 

func (gdt *Plane) IsPointOver(point Vector3) Bool

IsPointOver godot_plane_is_point_over [[const godot_plane * p_self] [const godot_vector3 * p_point]] godot_bool

func (*Plane) Normalized 

func (gdt *Plane) Normalized() Plane

Normalized godot_plane_normalized [[const godot_plane * p_self]] godot_plane

func (*Plane) OperatorEqual 

func (gdt *Plane) OperatorEqual(b Plane) Bool

OperatorEqual godot_plane_operator_equal [[const godot_plane * p_self] [const godot_plane * p_b]] godot_bool

func (*Plane) OperatorNeg 

func (gdt *Plane) OperatorNeg() Plane

OperatorNeg godot_plane_operator_neg [[const godot_plane * p_self]] godot_plane

func (*Plane) Project 

func (gdt *Plane) Project(point Vector3) Vector3

Project godot_plane_project [[const godot_plane * p_self] [const godot_vector3 * p_point]] godot_vector3

func (*Plane) SetD 

func (gdt *Plane) SetD(d Real)

SetD godot_plane_set_d [[godot_plane * p_self] [const godot_real p_d]] void

func (*Plane) SetNormal 

func (gdt *Plane) SetNormal(normal Vector3)

SetNormal godot_plane_set_normal [[godot_plane * p_self] [const godot_vector3 * p_normal]] void

type Pointer 

type Pointer struct {
	// contains filtered or unexported fields
}

Pointer is a pointer to arbitrary underlying data. This is primarily used in conjunction with MethodBindPtrCall.

func MethodBindPtrCall 

func MethodBindPtrCall(methodBind MethodBind, instance Object, args []Pointer, returns Pointer) Pointer

MethodBindPtrCall will call the given method on the given Godot Object. Its return value is given as a pointer, which can be used to convert it to a variant.

func NewEmptyAabb 

func NewEmptyAabb() Pointer

NewEmptyAabb will return a pointer to an empty initialized Aabb. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyArray 

func NewEmptyArray() Pointer

NewEmptyArray will return a pointer to an empty initialized Array. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyArvrInterfaceGdnative 

func NewEmptyArvrInterfaceGdnative() Pointer

NewEmptyArvrInterfaceGdnative will return a pointer to an empty initialized ArvrInterfaceGdnative. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyBasis 

func NewEmptyBasis() Pointer

NewEmptyBasis will return a pointer to an empty initialized Basis. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyBool 

func NewEmptyBool() Pointer

NewEmptyBool will return a pointer to an empty initialized Bool. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyCharString 

func NewEmptyCharString() Pointer

NewEmptyCharString will return a pointer to an empty initialized CharString. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyColor 

func NewEmptyColor() Pointer

NewEmptyColor will return a pointer to an empty initialized Color. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyDictionary 

func NewEmptyDictionary() Pointer

NewEmptyDictionary will return a pointer to an empty initialized Dictionary. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyFloat 

func NewEmptyFloat() Pointer

NewEmptyFloat will return a pointer to an empty initialized Float. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyGdnativeApiVersion 

func NewEmptyGdnativeApiVersion() Pointer

NewEmptyGdnativeApiVersion will return a pointer to an empty initialized GdnativeApiVersion. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyGdnativeTerminateOptions 

func NewEmptyGdnativeTerminateOptions() Pointer

NewEmptyGdnativeTerminateOptions will return a pointer to an empty initialized GdnativeTerminateOptions. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyInt 

func NewEmptyInt() Pointer

NewEmptyInt will return a pointer to an empty initialized Int. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyMethodArg 

func NewEmptyMethodArg() Pointer

NewEmptyMethodArg will return a pointer to an empty initialized MethodArg. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyMethodBind 

func NewEmptyMethodBind() Pointer

NewEmptyMethodBind will return a pointer to an empty initialized MethodBind. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyNodePath 

func NewEmptyNodePath() Pointer

NewEmptyNodePath will return a pointer to an empty initialized NodePath. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyObject 

func NewEmptyObject() Pointer

NewEmptyObject will return a pointer to an empty initialized Object. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPlane 

func NewEmptyPlane() Pointer

NewEmptyPlane will return a pointer to an empty initialized Plane. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolArrayReadAccess 

func NewEmptyPoolArrayReadAccess() Pointer

NewEmptyPoolArrayReadAccess will return a pointer to an empty initialized PoolArrayReadAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolArrayWriteAccess 

func NewEmptyPoolArrayWriteAccess() Pointer

NewEmptyPoolArrayWriteAccess will return a pointer to an empty initialized PoolArrayWriteAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolByteArray 

func NewEmptyPoolByteArray() Pointer

NewEmptyPoolByteArray will return a pointer to an empty initialized PoolByteArray. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolByteArrayReadAccess 

func NewEmptyPoolByteArrayReadAccess() Pointer

NewEmptyPoolByteArrayReadAccess will return a pointer to an empty initialized PoolByteArrayReadAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolByteArrayWriteAccess 

func NewEmptyPoolByteArrayWriteAccess() Pointer

NewEmptyPoolByteArrayWriteAccess will return a pointer to an empty initialized PoolByteArrayWriteAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolColorArray 

func NewEmptyPoolColorArray() Pointer

NewEmptyPoolColorArray will return a pointer to an empty initialized PoolColorArray. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolColorArrayReadAccess 

func NewEmptyPoolColorArrayReadAccess() Pointer

NewEmptyPoolColorArrayReadAccess will return a pointer to an empty initialized PoolColorArrayReadAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolColorArrayWriteAccess 

func NewEmptyPoolColorArrayWriteAccess() Pointer

NewEmptyPoolColorArrayWriteAccess will return a pointer to an empty initialized PoolColorArrayWriteAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolIntArray 

func NewEmptyPoolIntArray() Pointer

NewEmptyPoolIntArray will return a pointer to an empty initialized PoolIntArray. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolIntArrayReadAccess 

func NewEmptyPoolIntArrayReadAccess() Pointer

NewEmptyPoolIntArrayReadAccess will return a pointer to an empty initialized PoolIntArrayReadAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolIntArrayWriteAccess 

func NewEmptyPoolIntArrayWriteAccess() Pointer

NewEmptyPoolIntArrayWriteAccess will return a pointer to an empty initialized PoolIntArrayWriteAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolRealArray 

func NewEmptyPoolRealArray() Pointer

NewEmptyPoolRealArray will return a pointer to an empty initialized PoolRealArray. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolRealArrayReadAccess 

func NewEmptyPoolRealArrayReadAccess() Pointer

NewEmptyPoolRealArrayReadAccess will return a pointer to an empty initialized PoolRealArrayReadAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolRealArrayWriteAccess 

func NewEmptyPoolRealArrayWriteAccess() Pointer

NewEmptyPoolRealArrayWriteAccess will return a pointer to an empty initialized PoolRealArrayWriteAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolStringArray 

func NewEmptyPoolStringArray() Pointer

NewEmptyPoolStringArray will return a pointer to an empty initialized PoolStringArray. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolStringArrayReadAccess 

func NewEmptyPoolStringArrayReadAccess() Pointer

NewEmptyPoolStringArrayReadAccess will return a pointer to an empty initialized PoolStringArrayReadAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolStringArrayWriteAccess 

func NewEmptyPoolStringArrayWriteAccess() Pointer

NewEmptyPoolStringArrayWriteAccess will return a pointer to an empty initialized PoolStringArrayWriteAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolVector2Array 

func NewEmptyPoolVector2Array() Pointer

NewEmptyPoolVector2Array will return a pointer to an empty initialized PoolVector2Array. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolVector2ArrayReadAccess 

func NewEmptyPoolVector2ArrayReadAccess() Pointer

NewEmptyPoolVector2ArrayReadAccess will return a pointer to an empty initialized PoolVector2ArrayReadAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolVector2ArrayWriteAccess 

func NewEmptyPoolVector2ArrayWriteAccess() Pointer

NewEmptyPoolVector2ArrayWriteAccess will return a pointer to an empty initialized PoolVector2ArrayWriteAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolVector3Array 

func NewEmptyPoolVector3Array() Pointer

NewEmptyPoolVector3Array will return a pointer to an empty initialized PoolVector3Array. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolVector3ArrayReadAccess 

func NewEmptyPoolVector3ArrayReadAccess() Pointer

NewEmptyPoolVector3ArrayReadAccess will return a pointer to an empty initialized PoolVector3ArrayReadAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPoolVector3ArrayWriteAccess 

func NewEmptyPoolVector3ArrayWriteAccess() Pointer

NewEmptyPoolVector3ArrayWriteAccess will return a pointer to an empty initialized PoolVector3ArrayWriteAccess. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyPropertyAttributes 

func NewEmptyPropertyAttributes() Pointer

NewEmptyPropertyAttributes will return a pointer to an empty initialized PropertyAttributes. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyQuat 

func NewEmptyQuat() Pointer

NewEmptyQuat will return a pointer to an empty initialized Quat. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyReal 

func NewEmptyReal() Pointer

NewEmptyReal will return a pointer to an empty initialized Real. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyRect2 

func NewEmptyRect2() Pointer

NewEmptyRect2 will return a pointer to an empty initialized Rect2. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyRid 

func NewEmptyRid() Pointer

NewEmptyRid will return a pointer to an empty initialized Rid. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptySignal 

func NewEmptySignal() Pointer

NewEmptySignal will return a pointer to an empty initialized Signal. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptySignalArgument 

func NewEmptySignalArgument() Pointer

NewEmptySignalArgument will return a pointer to an empty initialized SignalArgument. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyString 

func NewEmptyString() Pointer

NewEmptyString will return a pointer to an empty initialized String. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyStringName 

func NewEmptyStringName() Pointer

NewEmptyStringName will return a pointer to an empty initialized StringName. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyTransform 

func NewEmptyTransform() Pointer

NewEmptyTransform will return a pointer to an empty initialized Transform. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyTransform2D 

func NewEmptyTransform2D() Pointer

NewEmptyTransform2D will return a pointer to an empty initialized Transform2D. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyVariant 

func NewEmptyVariant() Pointer

NewEmptyVariant will return a pointer to an empty initialized Variant. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyVariantCallError 

func NewEmptyVariantCallError() Pointer

NewEmptyVariantCallError will return a pointer to an empty initialized VariantCallError. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyVector2 

func NewEmptyVector2() Pointer

NewEmptyVector2 will return a pointer to an empty initialized Vector2. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyVector3 

func NewEmptyVector3() Pointer

NewEmptyVector3 will return a pointer to an empty initialized Vector3. This is primarily used in conjunction with MethodBindPtrCall.

func NewEmptyVoid 

func NewEmptyVoid() Pointer

func NewPointerFromAabb 

func NewPointerFromAabb(obj Aabb) Pointer

NewPointerFromAabb will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromArray 

func NewPointerFromArray(obj Array) Pointer

NewPointerFromArray will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromArvrInterfaceGdnative 

func NewPointerFromArvrInterfaceGdnative(obj ArvrInterfaceGdnative) Pointer

NewPointerFromArvrInterfaceGdnative will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromBasis 

func NewPointerFromBasis(obj Basis) Pointer

NewPointerFromBasis will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromBool 

func NewPointerFromBool(obj Bool) Pointer

NewPointerFromBool will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromCharString 

func NewPointerFromCharString(obj CharString) Pointer

NewPointerFromCharString will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromColor 

func NewPointerFromColor(obj Color) Pointer

NewPointerFromColor will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromDictionary 

func NewPointerFromDictionary(obj Dictionary) Pointer

NewPointerFromDictionary will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromFloat 

func NewPointerFromFloat(obj Float) Pointer

NewPointerFromFloat will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromGdnativeApiVersion 

func NewPointerFromGdnativeApiVersion(obj GdnativeApiVersion) Pointer

NewPointerFromGdnativeApiVersion will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromGdnativeTerminateOptions 

func NewPointerFromGdnativeTerminateOptions(obj GdnativeTerminateOptions) Pointer

NewPointerFromGdnativeTerminateOptions will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromInt 

func NewPointerFromInt(obj Int) Pointer

NewPointerFromInt will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromMethodArg 

func NewPointerFromMethodArg(obj MethodArg) Pointer

NewPointerFromMethodArg will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromMethodBind 

func NewPointerFromMethodBind(obj MethodBind) Pointer

NewPointerFromMethodBind will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromNodePath 

func NewPointerFromNodePath(obj NodePath) Pointer

NewPointerFromNodePath will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromObject 

func NewPointerFromObject(obj Object) Pointer

NewPointerFromObject will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPlane 

func NewPointerFromPlane(obj Plane) Pointer

NewPointerFromPlane will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolArrayReadAccess 

func NewPointerFromPoolArrayReadAccess(obj PoolArrayReadAccess) Pointer

NewPointerFromPoolArrayReadAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolArrayWriteAccess 

func NewPointerFromPoolArrayWriteAccess(obj PoolArrayWriteAccess) Pointer

NewPointerFromPoolArrayWriteAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolByteArray 

func NewPointerFromPoolByteArray(obj PoolByteArray) Pointer

NewPointerFromPoolByteArray will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolByteArrayReadAccess 

func NewPointerFromPoolByteArrayReadAccess(obj PoolByteArrayReadAccess) Pointer

NewPointerFromPoolByteArrayReadAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolByteArrayWriteAccess 

func NewPointerFromPoolByteArrayWriteAccess(obj PoolByteArrayWriteAccess) Pointer

NewPointerFromPoolByteArrayWriteAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolColorArray 

func NewPointerFromPoolColorArray(obj PoolColorArray) Pointer

NewPointerFromPoolColorArray will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolColorArrayReadAccess 

func NewPointerFromPoolColorArrayReadAccess(obj PoolColorArrayReadAccess) Pointer

NewPointerFromPoolColorArrayReadAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolColorArrayWriteAccess 

func NewPointerFromPoolColorArrayWriteAccess(obj PoolColorArrayWriteAccess) Pointer

NewPointerFromPoolColorArrayWriteAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolIntArray 

func NewPointerFromPoolIntArray(obj PoolIntArray) Pointer

NewPointerFromPoolIntArray will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolIntArrayReadAccess 

func NewPointerFromPoolIntArrayReadAccess(obj PoolIntArrayReadAccess) Pointer

NewPointerFromPoolIntArrayReadAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolIntArrayWriteAccess 

func NewPointerFromPoolIntArrayWriteAccess(obj PoolIntArrayWriteAccess) Pointer

NewPointerFromPoolIntArrayWriteAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolRealArray 

func NewPointerFromPoolRealArray(obj PoolRealArray) Pointer

NewPointerFromPoolRealArray will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolRealArrayReadAccess 

func NewPointerFromPoolRealArrayReadAccess(obj PoolRealArrayReadAccess) Pointer

NewPointerFromPoolRealArrayReadAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolRealArrayWriteAccess 

func NewPointerFromPoolRealArrayWriteAccess(obj PoolRealArrayWriteAccess) Pointer

NewPointerFromPoolRealArrayWriteAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolStringArray 

func NewPointerFromPoolStringArray(obj PoolStringArray) Pointer

NewPointerFromPoolStringArray will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolStringArrayReadAccess 

func NewPointerFromPoolStringArrayReadAccess(obj PoolStringArrayReadAccess) Pointer

NewPointerFromPoolStringArrayReadAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolStringArrayWriteAccess 

func NewPointerFromPoolStringArrayWriteAccess(obj PoolStringArrayWriteAccess) Pointer

NewPointerFromPoolStringArrayWriteAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolVector2Array 

func NewPointerFromPoolVector2Array(obj PoolVector2Array) Pointer

NewPointerFromPoolVector2Array will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolVector2ArrayReadAccess 

func NewPointerFromPoolVector2ArrayReadAccess(obj PoolVector2ArrayReadAccess) Pointer

NewPointerFromPoolVector2ArrayReadAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolVector2ArrayWriteAccess 

func NewPointerFromPoolVector2ArrayWriteAccess(obj PoolVector2ArrayWriteAccess) Pointer

NewPointerFromPoolVector2ArrayWriteAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolVector3Array 

func NewPointerFromPoolVector3Array(obj PoolVector3Array) Pointer

NewPointerFromPoolVector3Array will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolVector3ArrayReadAccess 

func NewPointerFromPoolVector3ArrayReadAccess(obj PoolVector3ArrayReadAccess) Pointer

NewPointerFromPoolVector3ArrayReadAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPoolVector3ArrayWriteAccess 

func NewPointerFromPoolVector3ArrayWriteAccess(obj PoolVector3ArrayWriteAccess) Pointer

NewPointerFromPoolVector3ArrayWriteAccess will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromPropertyAttributes 

func NewPointerFromPropertyAttributes(obj PropertyAttributes) Pointer

NewPointerFromPropertyAttributes will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromQuat 

func NewPointerFromQuat(obj Quat) Pointer

NewPointerFromQuat will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromReal 

func NewPointerFromReal(obj Real) Pointer

NewPointerFromReal will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromRect2 

func NewPointerFromRect2(obj Rect2) Pointer

NewPointerFromRect2 will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromRid 

func NewPointerFromRid(obj Rid) Pointer

NewPointerFromRid will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromSignal 

func NewPointerFromSignal(obj Signal) Pointer

NewPointerFromSignal will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromSignalArgument 

func NewPointerFromSignalArgument(obj SignalArgument) Pointer

NewPointerFromSignalArgument will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromString 

func NewPointerFromString(obj String) Pointer

NewPointerFromString will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromStringName 

func NewPointerFromStringName(obj StringName) Pointer

NewPointerFromStringName will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromTransform 

func NewPointerFromTransform(obj Transform) Pointer

NewPointerFromTransform will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromTransform2D 

func NewPointerFromTransform2D(obj Transform2D) Pointer

NewPointerFromTransform2D will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromVariant 

func NewPointerFromVariant(obj Variant) Pointer

NewPointerFromVariant will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromVariantCallError 

func NewPointerFromVariantCallError(obj VariantCallError) Pointer

NewPointerFromVariantCallError will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromVector2 

func NewPointerFromVector2(obj Vector2) Pointer

NewPointerFromVector2 will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

func NewPointerFromVector3 

func NewPointerFromVector3(obj Vector3) Pointer

NewPointerFromVector3 will return an unsafe pointer to the given object. This is primarily used in conjunction with MethodBindPtrCall.

type PoolArrayReadAccess 

type PoolArrayReadAccess struct {
	// contains filtered or unexported fields
}

func NewPoolArrayReadAccessFromPointer 

func NewPoolArrayReadAccessFromPointer(ptr Pointer) PoolArrayReadAccess

NewPoolArrayReadAccessFromPointer will return a PoolArrayReadAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolArrayWriteAccess 

type PoolArrayWriteAccess struct {
	// contains filtered or unexported fields
}

func NewPoolArrayWriteAccessFromPointer 

func NewPoolArrayWriteAccessFromPointer(ptr Pointer) PoolArrayWriteAccess

NewPoolArrayWriteAccessFromPointer will return a PoolArrayWriteAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolByteArray 

type PoolByteArray struct {
	// contains filtered or unexported fields
}

func NewPoolByteArray 

func NewPoolByteArray() PoolByteArray

NewPoolByteArray godot_pool_byte_array_new [[godot_pool_byte_array * r_dest]] void

func NewPoolByteArrayCopy 

func NewPoolByteArrayCopy(src PoolByteArray) PoolByteArray

NewPoolByteArrayCopy godot_pool_byte_array_new_copy [[godot_pool_byte_array * r_dest] [const godot_pool_byte_array * p_src]] void

func NewPoolByteArrayFromPointer 

func NewPoolByteArrayFromPointer(ptr Pointer) PoolByteArray

NewPoolByteArrayFromPointer will return a PoolByteArray from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewPoolByteArrayWithArray 

func NewPoolByteArrayWithArray(a Array) PoolByteArray

NewPoolByteArrayWithArray godot_pool_byte_array_new_with_array [[godot_pool_byte_array * r_dest] [const godot_array * p_a]] void

func (*PoolByteArray) Append 

func (gdt *PoolByteArray) Append(data Uint8T)

Append godot_pool_byte_array_append [[godot_pool_byte_array * p_self] [const uint8_t p_data]] void

func (*PoolByteArray) AppendArray 

func (gdt *PoolByteArray) AppendArray(array PoolByteArray)

AppendArray godot_pool_byte_array_append_array [[godot_pool_byte_array * p_self] [const godot_pool_byte_array * p_array]] void

func (*PoolByteArray) Destroy 

func (gdt *PoolByteArray) Destroy()

Destroy godot_pool_byte_array_destroy [[godot_pool_byte_array * p_self]] void

func (*PoolByteArray) Get 

func (gdt *PoolByteArray) Get(idx Int) Uint8T

Get godot_pool_byte_array_get [[const godot_pool_byte_array * p_self] [const godot_int p_idx]] uint8_t

func (*PoolByteArray) Insert 

func (gdt *PoolByteArray) Insert(idx Int, data Uint8T) Error

Insert godot_pool_byte_array_insert [[godot_pool_byte_array * p_self] [const godot_int p_idx] [const uint8_t p_data]] godot_error

func (*PoolByteArray) Invert 

func (gdt *PoolByteArray) Invert()

Invert godot_pool_byte_array_invert [[godot_pool_byte_array * p_self]] void

func (*PoolByteArray) PushBack 

func (gdt *PoolByteArray) PushBack(data Uint8T)

PushBack godot_pool_byte_array_push_back [[godot_pool_byte_array * p_self] [const uint8_t p_data]] void

func (*PoolByteArray) Read 

func (gdt *PoolByteArray) Read() PoolByteArrayReadAccess

Read godot_pool_byte_array_read [[const godot_pool_byte_array * p_self]] godot_pool_byte_array_read_access *

func (*PoolByteArray) Remove 

func (gdt *PoolByteArray) Remove(idx Int)

Remove godot_pool_byte_array_remove [[godot_pool_byte_array * p_self] [const godot_int p_idx]] void

func (*PoolByteArray) Resize 

func (gdt *PoolByteArray) Resize(size Int)

Resize godot_pool_byte_array_resize [[godot_pool_byte_array * p_self] [const godot_int p_size]] void

func (*PoolByteArray) Set 

func (gdt *PoolByteArray) Set(idx Int, data Uint8T)

Set godot_pool_byte_array_set [[godot_pool_byte_array * p_self] [const godot_int p_idx] [const uint8_t p_data]] void

func (*PoolByteArray) Size 

func (gdt *PoolByteArray) Size() Int

Size godot_pool_byte_array_size [[const godot_pool_byte_array * p_self]] godot_int

func (*PoolByteArray) Write 

func (gdt *PoolByteArray) Write() PoolByteArrayWriteAccess

Write godot_pool_byte_array_write [[godot_pool_byte_array * p_self]] godot_pool_byte_array_write_access *

type PoolByteArrayReadAccess 

type PoolByteArrayReadAccess struct {
	// contains filtered or unexported fields
}

func NewPoolByteArrayReadAccessFromPointer 

func NewPoolByteArrayReadAccessFromPointer(ptr Pointer) PoolByteArrayReadAccess

NewPoolByteArrayReadAccessFromPointer will return a PoolByteArrayReadAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolByteArrayWriteAccess 

type PoolByteArrayWriteAccess struct {
	// contains filtered or unexported fields
}

func NewPoolByteArrayWriteAccessFromPointer 

func NewPoolByteArrayWriteAccessFromPointer(ptr Pointer) PoolByteArrayWriteAccess

NewPoolByteArrayWriteAccessFromPointer will return a PoolByteArrayWriteAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolColorArray 

type PoolColorArray struct {
	// contains filtered or unexported fields
}

func NewPoolColorArray 

func NewPoolColorArray() PoolColorArray

NewPoolColorArray godot_pool_color_array_new [[godot_pool_color_array * r_dest]] void

func NewPoolColorArrayCopy 

func NewPoolColorArrayCopy(src PoolColorArray) PoolColorArray

NewPoolColorArrayCopy godot_pool_color_array_new_copy [[godot_pool_color_array * r_dest] [const godot_pool_color_array * p_src]] void

func NewPoolColorArrayFromPointer 

func NewPoolColorArrayFromPointer(ptr Pointer) PoolColorArray

NewPoolColorArrayFromPointer will return a PoolColorArray from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewPoolColorArrayWithArray 

func NewPoolColorArrayWithArray(a Array) PoolColorArray

NewPoolColorArrayWithArray godot_pool_color_array_new_with_array [[godot_pool_color_array * r_dest] [const godot_array * p_a]] void

func (*PoolColorArray) Append 

func (gdt *PoolColorArray) Append(data Color)

Append godot_pool_color_array_append [[godot_pool_color_array * p_self] [const godot_color * p_data]] void

func (*PoolColorArray) AppendArray 

func (gdt *PoolColorArray) AppendArray(array PoolColorArray)

AppendArray godot_pool_color_array_append_array [[godot_pool_color_array * p_self] [const godot_pool_color_array * p_array]] void

func (*PoolColorArray) Destroy 

func (gdt *PoolColorArray) Destroy()

Destroy godot_pool_color_array_destroy [[godot_pool_color_array * p_self]] void

func (*PoolColorArray) Get 

func (gdt *PoolColorArray) Get(idx Int) Color

Get godot_pool_color_array_get [[const godot_pool_color_array * p_self] [const godot_int p_idx]] godot_color

func (*PoolColorArray) Insert 

func (gdt *PoolColorArray) Insert(idx Int, data Color) Error

Insert godot_pool_color_array_insert [[godot_pool_color_array * p_self] [const godot_int p_idx] [const godot_color * p_data]] godot_error

func (*PoolColorArray) Invert 

func (gdt *PoolColorArray) Invert()

Invert godot_pool_color_array_invert [[godot_pool_color_array * p_self]] void

func (*PoolColorArray) PushBack 

func (gdt *PoolColorArray) PushBack(data Color)

PushBack godot_pool_color_array_push_back [[godot_pool_color_array * p_self] [const godot_color * p_data]] void

func (*PoolColorArray) Read 

func (gdt *PoolColorArray) Read() PoolColorArrayReadAccess

Read godot_pool_color_array_read [[const godot_pool_color_array * p_self]] godot_pool_color_array_read_access *

func (*PoolColorArray) Remove 

func (gdt *PoolColorArray) Remove(idx Int)

Remove godot_pool_color_array_remove [[godot_pool_color_array * p_self] [const godot_int p_idx]] void

func (*PoolColorArray) Resize 

func (gdt *PoolColorArray) Resize(size Int)

Resize godot_pool_color_array_resize [[godot_pool_color_array * p_self] [const godot_int p_size]] void

func (*PoolColorArray) Set 

func (gdt *PoolColorArray) Set(idx Int, data Color)

Set godot_pool_color_array_set [[godot_pool_color_array * p_self] [const godot_int p_idx] [const godot_color * p_data]] void

func (*PoolColorArray) Size 

func (gdt *PoolColorArray) Size() Int

Size godot_pool_color_array_size [[const godot_pool_color_array * p_self]] godot_int

func (*PoolColorArray) Write 

func (gdt *PoolColorArray) Write() PoolColorArrayWriteAccess

Write godot_pool_color_array_write [[godot_pool_color_array * p_self]] godot_pool_color_array_write_access *

type PoolColorArrayReadAccess 

type PoolColorArrayReadAccess struct {
	// contains filtered or unexported fields
}

func NewPoolColorArrayReadAccessFromPointer 

func NewPoolColorArrayReadAccessFromPointer(ptr Pointer) PoolColorArrayReadAccess

NewPoolColorArrayReadAccessFromPointer will return a PoolColorArrayReadAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolColorArrayWriteAccess 

type PoolColorArrayWriteAccess struct {
	// contains filtered or unexported fields
}

func NewPoolColorArrayWriteAccessFromPointer 

func NewPoolColorArrayWriteAccessFromPointer(ptr Pointer) PoolColorArrayWriteAccess

NewPoolColorArrayWriteAccessFromPointer will return a PoolColorArrayWriteAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolIntArray 

type PoolIntArray struct {
	// contains filtered or unexported fields
}

func NewPoolIntArray 

func NewPoolIntArray() PoolIntArray

NewPoolIntArray godot_pool_int_array_new [[godot_pool_int_array * r_dest]] void

func NewPoolIntArrayCopy 

func NewPoolIntArrayCopy(src PoolIntArray) PoolIntArray

NewPoolIntArrayCopy godot_pool_int_array_new_copy [[godot_pool_int_array * r_dest] [const godot_pool_int_array * p_src]] void

func NewPoolIntArrayFromPointer 

func NewPoolIntArrayFromPointer(ptr Pointer) PoolIntArray

NewPoolIntArrayFromPointer will return a PoolIntArray from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewPoolIntArrayWithArray 

func NewPoolIntArrayWithArray(a Array) PoolIntArray

NewPoolIntArrayWithArray godot_pool_int_array_new_with_array [[godot_pool_int_array * r_dest] [const godot_array * p_a]] void

func (*PoolIntArray) Append 

func (gdt *PoolIntArray) Append(data Int)

Append godot_pool_int_array_append [[godot_pool_int_array * p_self] [const godot_int p_data]] void

func (*PoolIntArray) AppendArray 

func (gdt *PoolIntArray) AppendArray(array PoolIntArray)

AppendArray godot_pool_int_array_append_array [[godot_pool_int_array * p_self] [const godot_pool_int_array * p_array]] void

func (*PoolIntArray) Destroy 

func (gdt *PoolIntArray) Destroy()

Destroy godot_pool_int_array_destroy [[godot_pool_int_array * p_self]] void

func (*PoolIntArray) Get 

func (gdt *PoolIntArray) Get(idx Int) Int

Get godot_pool_int_array_get [[const godot_pool_int_array * p_self] [const godot_int p_idx]] godot_int

func (*PoolIntArray) Insert 

func (gdt *PoolIntArray) Insert(idx Int, data Int) Error

Insert godot_pool_int_array_insert [[godot_pool_int_array * p_self] [const godot_int p_idx] [const godot_int p_data]] godot_error

func (*PoolIntArray) Invert 

func (gdt *PoolIntArray) Invert()

Invert godot_pool_int_array_invert [[godot_pool_int_array * p_self]] void

func (*PoolIntArray) PushBack 

func (gdt *PoolIntArray) PushBack(data Int)

PushBack godot_pool_int_array_push_back [[godot_pool_int_array * p_self] [const godot_int p_data]] void

func (*PoolIntArray) Read 

func (gdt *PoolIntArray) Read() PoolIntArrayReadAccess

Read godot_pool_int_array_read [[const godot_pool_int_array * p_self]] godot_pool_int_array_read_access *

func (*PoolIntArray) Remove 

func (gdt *PoolIntArray) Remove(idx Int)

Remove godot_pool_int_array_remove [[godot_pool_int_array * p_self] [const godot_int p_idx]] void

func (*PoolIntArray) Resize 

func (gdt *PoolIntArray) Resize(size Int)

Resize godot_pool_int_array_resize [[godot_pool_int_array * p_self] [const godot_int p_size]] void

func (*PoolIntArray) Set 

func (gdt *PoolIntArray) Set(idx Int, data Int)

Set godot_pool_int_array_set [[godot_pool_int_array * p_self] [const godot_int p_idx] [const godot_int p_data]] void

func (*PoolIntArray) Size 

func (gdt *PoolIntArray) Size() Int

Size godot_pool_int_array_size [[const godot_pool_int_array * p_self]] godot_int

func (*PoolIntArray) Write 

func (gdt *PoolIntArray) Write() PoolIntArrayWriteAccess

Write godot_pool_int_array_write [[godot_pool_int_array * p_self]] godot_pool_int_array_write_access *

type PoolIntArrayReadAccess 

type PoolIntArrayReadAccess struct {
	// contains filtered or unexported fields
}

func NewPoolIntArrayReadAccessFromPointer 

func NewPoolIntArrayReadAccessFromPointer(ptr Pointer) PoolIntArrayReadAccess

NewPoolIntArrayReadAccessFromPointer will return a PoolIntArrayReadAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolIntArrayWriteAccess 

type PoolIntArrayWriteAccess struct {
	// contains filtered or unexported fields
}

func NewPoolIntArrayWriteAccessFromPointer 

func NewPoolIntArrayWriteAccessFromPointer(ptr Pointer) PoolIntArrayWriteAccess

NewPoolIntArrayWriteAccessFromPointer will return a PoolIntArrayWriteAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolRealArray 

type PoolRealArray struct {
	// contains filtered or unexported fields
}

func NewPoolRealArray 

func NewPoolRealArray() PoolRealArray

NewPoolRealArray godot_pool_real_array_new [[godot_pool_real_array * r_dest]] void

func NewPoolRealArrayCopy 

func NewPoolRealArrayCopy(src PoolRealArray) PoolRealArray

NewPoolRealArrayCopy godot_pool_real_array_new_copy [[godot_pool_real_array * r_dest] [const godot_pool_real_array * p_src]] void

func NewPoolRealArrayFromPointer 

func NewPoolRealArrayFromPointer(ptr Pointer) PoolRealArray

NewPoolRealArrayFromPointer will return a PoolRealArray from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewPoolRealArrayWithArray 

func NewPoolRealArrayWithArray(a Array) PoolRealArray

NewPoolRealArrayWithArray godot_pool_real_array_new_with_array [[godot_pool_real_array * r_dest] [const godot_array * p_a]] void

func (*PoolRealArray) Append 

func (gdt *PoolRealArray) Append(data Real)

Append godot_pool_real_array_append [[godot_pool_real_array * p_self] [const godot_real p_data]] void

func (*PoolRealArray) AppendArray 

func (gdt *PoolRealArray) AppendArray(array PoolRealArray)

AppendArray godot_pool_real_array_append_array [[godot_pool_real_array * p_self] [const godot_pool_real_array * p_array]] void

func (*PoolRealArray) Destroy 

func (gdt *PoolRealArray) Destroy()

Destroy godot_pool_real_array_destroy [[godot_pool_real_array * p_self]] void

func (*PoolRealArray) Get 

func (gdt *PoolRealArray) Get(idx Int) Real

Get godot_pool_real_array_get [[const godot_pool_real_array * p_self] [const godot_int p_idx]] godot_real

func (*PoolRealArray) Insert 

func (gdt *PoolRealArray) Insert(idx Int, data Real) Error

Insert godot_pool_real_array_insert [[godot_pool_real_array * p_self] [const godot_int p_idx] [const godot_real p_data]] godot_error

func (*PoolRealArray) Invert 

func (gdt *PoolRealArray) Invert()

Invert godot_pool_real_array_invert [[godot_pool_real_array * p_self]] void

func (*PoolRealArray) PushBack 

func (gdt *PoolRealArray) PushBack(data Real)

PushBack godot_pool_real_array_push_back [[godot_pool_real_array * p_self] [const godot_real p_data]] void

func (*PoolRealArray) Read 

func (gdt *PoolRealArray) Read() PoolRealArrayReadAccess

Read godot_pool_real_array_read [[const godot_pool_real_array * p_self]] godot_pool_real_array_read_access *

func (*PoolRealArray) Remove 

func (gdt *PoolRealArray) Remove(idx Int)

Remove godot_pool_real_array_remove [[godot_pool_real_array * p_self] [const godot_int p_idx]] void

func (*PoolRealArray) Resize 

func (gdt *PoolRealArray) Resize(size Int)

Resize godot_pool_real_array_resize [[godot_pool_real_array * p_self] [const godot_int p_size]] void

func (*PoolRealArray) Set 

func (gdt *PoolRealArray) Set(idx Int, data Real)

Set godot_pool_real_array_set [[godot_pool_real_array * p_self] [const godot_int p_idx] [const godot_real p_data]] void

func (*PoolRealArray) Size 

func (gdt *PoolRealArray) Size() Int

Size godot_pool_real_array_size [[const godot_pool_real_array * p_self]] godot_int

func (*PoolRealArray) Write 

func (gdt *PoolRealArray) Write() PoolRealArrayWriteAccess

Write godot_pool_real_array_write [[godot_pool_real_array * p_self]] godot_pool_real_array_write_access *

type PoolRealArrayReadAccess 

type PoolRealArrayReadAccess struct {
	// contains filtered or unexported fields
}

func NewPoolRealArrayReadAccessFromPointer 

func NewPoolRealArrayReadAccessFromPointer(ptr Pointer) PoolRealArrayReadAccess

NewPoolRealArrayReadAccessFromPointer will return a PoolRealArrayReadAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolRealArrayWriteAccess 

type PoolRealArrayWriteAccess struct {
	// contains filtered or unexported fields
}

func NewPoolRealArrayWriteAccessFromPointer 

func NewPoolRealArrayWriteAccessFromPointer(ptr Pointer) PoolRealArrayWriteAccess

NewPoolRealArrayWriteAccessFromPointer will return a PoolRealArrayWriteAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolStringArray 

type PoolStringArray struct {
	// contains filtered or unexported fields
}

func NewPoolStringArray 

func NewPoolStringArray() PoolStringArray

NewPoolStringArray godot_pool_string_array_new [[godot_pool_string_array * r_dest]] void

func NewPoolStringArrayCopy 

func NewPoolStringArrayCopy(src PoolStringArray) PoolStringArray

NewPoolStringArrayCopy godot_pool_string_array_new_copy [[godot_pool_string_array * r_dest] [const godot_pool_string_array * p_src]] void

func NewPoolStringArrayFromPointer 

func NewPoolStringArrayFromPointer(ptr Pointer) PoolStringArray

NewPoolStringArrayFromPointer will return a PoolStringArray from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewPoolStringArrayWithArray 

func NewPoolStringArrayWithArray(a Array) PoolStringArray

NewPoolStringArrayWithArray godot_pool_string_array_new_with_array [[godot_pool_string_array * r_dest] [const godot_array * p_a]] void

func (*PoolStringArray) Append 

func (gdt *PoolStringArray) Append(data String)

Append godot_pool_string_array_append [[godot_pool_string_array * p_self] [const godot_string * p_data]] void

func (*PoolStringArray) AppendArray 

func (gdt *PoolStringArray) AppendArray(array PoolStringArray)

AppendArray godot_pool_string_array_append_array [[godot_pool_string_array * p_self] [const godot_pool_string_array * p_array]] void

func (*PoolStringArray) Destroy 

func (gdt *PoolStringArray) Destroy()

Destroy godot_pool_string_array_destroy [[godot_pool_string_array * p_self]] void

func (*PoolStringArray) Get 

func (gdt *PoolStringArray) Get(idx Int) String

Get godot_pool_string_array_get [[const godot_pool_string_array * p_self] [const godot_int p_idx]] godot_string

func (*PoolStringArray) Insert 

func (gdt *PoolStringArray) Insert(idx Int, data String) Error

Insert godot_pool_string_array_insert [[godot_pool_string_array * p_self] [const godot_int p_idx] [const godot_string * p_data]] godot_error

func (*PoolStringArray) Invert 

func (gdt *PoolStringArray) Invert()

Invert godot_pool_string_array_invert [[godot_pool_string_array * p_self]] void

func (*PoolStringArray) PushBack 

func (gdt *PoolStringArray) PushBack(data String)

PushBack godot_pool_string_array_push_back [[godot_pool_string_array * p_self] [const godot_string * p_data]] void

func (*PoolStringArray) Read 

func (gdt *PoolStringArray) Read() PoolStringArrayReadAccess

Read godot_pool_string_array_read [[const godot_pool_string_array * p_self]] godot_pool_string_array_read_access *

func (*PoolStringArray) Remove 

func (gdt *PoolStringArray) Remove(idx Int)

Remove godot_pool_string_array_remove [[godot_pool_string_array * p_self] [const godot_int p_idx]] void

func (*PoolStringArray) Resize 

func (gdt *PoolStringArray) Resize(size Int)

Resize godot_pool_string_array_resize [[godot_pool_string_array * p_self] [const godot_int p_size]] void

func (*PoolStringArray) Set 

func (gdt *PoolStringArray) Set(idx Int, data String)

Set godot_pool_string_array_set [[godot_pool_string_array * p_self] [const godot_int p_idx] [const godot_string * p_data]] void

func (*PoolStringArray) Size 

func (gdt *PoolStringArray) Size() Int

Size godot_pool_string_array_size [[const godot_pool_string_array * p_self]] godot_int

func (*PoolStringArray) Write 

func (gdt *PoolStringArray) Write() PoolStringArrayWriteAccess

Write godot_pool_string_array_write [[godot_pool_string_array * p_self]] godot_pool_string_array_write_access *

type PoolStringArrayReadAccess 

type PoolStringArrayReadAccess struct {
	// contains filtered or unexported fields
}

func NewPoolStringArrayReadAccessFromPointer 

func NewPoolStringArrayReadAccessFromPointer(ptr Pointer) PoolStringArrayReadAccess

NewPoolStringArrayReadAccessFromPointer will return a PoolStringArrayReadAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolStringArrayWriteAccess 

type PoolStringArrayWriteAccess struct {
	// contains filtered or unexported fields
}

func NewPoolStringArrayWriteAccessFromPointer 

func NewPoolStringArrayWriteAccessFromPointer(ptr Pointer) PoolStringArrayWriteAccess

NewPoolStringArrayWriteAccessFromPointer will return a PoolStringArrayWriteAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolVector2Array 

type PoolVector2Array struct {
	// contains filtered or unexported fields
}

func NewPoolVector2Array 

func NewPoolVector2Array() PoolVector2Array

NewPoolVector2Array godot_pool_vector2_array_new [[godot_pool_vector2_array * r_dest]] void

func NewPoolVector2ArrayCopy 

func NewPoolVector2ArrayCopy(src PoolVector2Array) PoolVector2Array

NewPoolVector2ArrayCopy godot_pool_vector2_array_new_copy [[godot_pool_vector2_array * r_dest] [const godot_pool_vector2_array * p_src]] void

func NewPoolVector2ArrayFromPointer 

func NewPoolVector2ArrayFromPointer(ptr Pointer) PoolVector2Array

NewPoolVector2ArrayFromPointer will return a PoolVector2Array from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewPoolVector2ArrayWithArray 

func NewPoolVector2ArrayWithArray(a Array) PoolVector2Array

NewPoolVector2ArrayWithArray godot_pool_vector2_array_new_with_array [[godot_pool_vector2_array * r_dest] [const godot_array * p_a]] void

func (*PoolVector2Array) Append 

func (gdt *PoolVector2Array) Append(data Vector2)

Append godot_pool_vector2_array_append [[godot_pool_vector2_array * p_self] [const godot_vector2 * p_data]] void

func (*PoolVector2Array) AppendArray 

func (gdt *PoolVector2Array) AppendArray(array PoolVector2Array)

AppendArray godot_pool_vector2_array_append_array [[godot_pool_vector2_array * p_self] [const godot_pool_vector2_array * p_array]] void

func (*PoolVector2Array) Destroy 

func (gdt *PoolVector2Array) Destroy()

Destroy godot_pool_vector2_array_destroy [[godot_pool_vector2_array * p_self]] void

func (*PoolVector2Array) Get 

func (gdt *PoolVector2Array) Get(idx Int) Vector2

Get godot_pool_vector2_array_get [[const godot_pool_vector2_array * p_self] [const godot_int p_idx]] godot_vector2

func (*PoolVector2Array) Insert 

func (gdt *PoolVector2Array) Insert(idx Int, data Vector2) Error

Insert godot_pool_vector2_array_insert [[godot_pool_vector2_array * p_self] [const godot_int p_idx] [const godot_vector2 * p_data]] godot_error

func (*PoolVector2Array) Invert 

func (gdt *PoolVector2Array) Invert()

Invert godot_pool_vector2_array_invert [[godot_pool_vector2_array * p_self]] void

func (*PoolVector2Array) PushBack 

func (gdt *PoolVector2Array) PushBack(data Vector2)

PushBack godot_pool_vector2_array_push_back [[godot_pool_vector2_array * p_self] [const godot_vector2 * p_data]] void

func (*PoolVector2Array) Read 

func (gdt *PoolVector2Array) Read() PoolVector2ArrayReadAccess

Read godot_pool_vector2_array_read [[const godot_pool_vector2_array * p_self]] godot_pool_vector2_array_read_access *

func (*PoolVector2Array) Remove 

func (gdt *PoolVector2Array) Remove(idx Int)

Remove godot_pool_vector2_array_remove [[godot_pool_vector2_array * p_self] [const godot_int p_idx]] void

func (*PoolVector2Array) Resize 

func (gdt *PoolVector2Array) Resize(size Int)

Resize godot_pool_vector2_array_resize [[godot_pool_vector2_array * p_self] [const godot_int p_size]] void

func (*PoolVector2Array) Set 

func (gdt *PoolVector2Array) Set(idx Int, data Vector2)

Set godot_pool_vector2_array_set [[godot_pool_vector2_array * p_self] [const godot_int p_idx] [const godot_vector2 * p_data]] void

func (*PoolVector2Array) Size 

func (gdt *PoolVector2Array) Size() Int

Size godot_pool_vector2_array_size [[const godot_pool_vector2_array * p_self]] godot_int

func (*PoolVector2Array) Write 

func (gdt *PoolVector2Array) Write() PoolVector2ArrayWriteAccess

Write godot_pool_vector2_array_write [[godot_pool_vector2_array * p_self]] godot_pool_vector2_array_write_access *

type PoolVector2ArrayReadAccess 

type PoolVector2ArrayReadAccess struct {
	// contains filtered or unexported fields
}

func NewPoolVector2ArrayReadAccessFromPointer 

func NewPoolVector2ArrayReadAccessFromPointer(ptr Pointer) PoolVector2ArrayReadAccess

NewPoolVector2ArrayReadAccessFromPointer will return a PoolVector2ArrayReadAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolVector2ArrayWriteAccess 

type PoolVector2ArrayWriteAccess struct {
	// contains filtered or unexported fields
}

func NewPoolVector2ArrayWriteAccessFromPointer 

func NewPoolVector2ArrayWriteAccessFromPointer(ptr Pointer) PoolVector2ArrayWriteAccess

NewPoolVector2ArrayWriteAccessFromPointer will return a PoolVector2ArrayWriteAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolVector3Array 

type PoolVector3Array struct {
	// contains filtered or unexported fields
}

func NewPoolVector3Array 

func NewPoolVector3Array() PoolVector3Array

NewPoolVector3Array godot_pool_vector3_array_new [[godot_pool_vector3_array * r_dest]] void

func NewPoolVector3ArrayCopy 

func NewPoolVector3ArrayCopy(src PoolVector3Array) PoolVector3Array

NewPoolVector3ArrayCopy godot_pool_vector3_array_new_copy [[godot_pool_vector3_array * r_dest] [const godot_pool_vector3_array * p_src]] void

func NewPoolVector3ArrayFromPointer 

func NewPoolVector3ArrayFromPointer(ptr Pointer) PoolVector3Array

NewPoolVector3ArrayFromPointer will return a PoolVector3Array from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewPoolVector3ArrayWithArray 

func NewPoolVector3ArrayWithArray(a Array) PoolVector3Array

NewPoolVector3ArrayWithArray godot_pool_vector3_array_new_with_array [[godot_pool_vector3_array * r_dest] [const godot_array * p_a]] void

func (*PoolVector3Array) Append 

func (gdt *PoolVector3Array) Append(data Vector3)

Append godot_pool_vector3_array_append [[godot_pool_vector3_array * p_self] [const godot_vector3 * p_data]] void

func (*PoolVector3Array) AppendArray 

func (gdt *PoolVector3Array) AppendArray(array PoolVector3Array)

AppendArray godot_pool_vector3_array_append_array [[godot_pool_vector3_array * p_self] [const godot_pool_vector3_array * p_array]] void

func (*PoolVector3Array) Destroy 

func (gdt *PoolVector3Array) Destroy()

Destroy godot_pool_vector3_array_destroy [[godot_pool_vector3_array * p_self]] void

func (*PoolVector3Array) Get 

func (gdt *PoolVector3Array) Get(idx Int) Vector3

Get godot_pool_vector3_array_get [[const godot_pool_vector3_array * p_self] [const godot_int p_idx]] godot_vector3

func (*PoolVector3Array) Insert 

func (gdt *PoolVector3Array) Insert(idx Int, data Vector3) Error

Insert godot_pool_vector3_array_insert [[godot_pool_vector3_array * p_self] [const godot_int p_idx] [const godot_vector3 * p_data]] godot_error

func (*PoolVector3Array) Invert 

func (gdt *PoolVector3Array) Invert()

Invert godot_pool_vector3_array_invert [[godot_pool_vector3_array * p_self]] void

func (*PoolVector3Array) PushBack 

func (gdt *PoolVector3Array) PushBack(data Vector3)

PushBack godot_pool_vector3_array_push_back [[godot_pool_vector3_array * p_self] [const godot_vector3 * p_data]] void

func (*PoolVector3Array) Read 

func (gdt *PoolVector3Array) Read() PoolVector3ArrayReadAccess

Read godot_pool_vector3_array_read [[const godot_pool_vector3_array * p_self]] godot_pool_vector3_array_read_access *

func (*PoolVector3Array) Remove 

func (gdt *PoolVector3Array) Remove(idx Int)

Remove godot_pool_vector3_array_remove [[godot_pool_vector3_array * p_self] [const godot_int p_idx]] void

func (*PoolVector3Array) Resize 

func (gdt *PoolVector3Array) Resize(size Int)

Resize godot_pool_vector3_array_resize [[godot_pool_vector3_array * p_self] [const godot_int p_size]] void

func (*PoolVector3Array) Set 

func (gdt *PoolVector3Array) Set(idx Int, data Vector3)

Set godot_pool_vector3_array_set [[godot_pool_vector3_array * p_self] [const godot_int p_idx] [const godot_vector3 * p_data]] void

func (*PoolVector3Array) Size 

func (gdt *PoolVector3Array) Size() Int

Size godot_pool_vector3_array_size [[const godot_pool_vector3_array * p_self]] godot_int

func (*PoolVector3Array) Write 

func (gdt *PoolVector3Array) Write() PoolVector3ArrayWriteAccess

Write godot_pool_vector3_array_write [[godot_pool_vector3_array * p_self]] godot_pool_vector3_array_write_access *

type PoolVector3ArrayReadAccess 

type PoolVector3ArrayReadAccess struct {
	// contains filtered or unexported fields
}

func NewPoolVector3ArrayReadAccessFromPointer 

func NewPoolVector3ArrayReadAccessFromPointer(ptr Pointer) PoolVector3ArrayReadAccess

NewPoolVector3ArrayReadAccessFromPointer will return a PoolVector3ArrayReadAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PoolVector3ArrayWriteAccess 

type PoolVector3ArrayWriteAccess struct {
	// contains filtered or unexported fields
}

func NewPoolVector3ArrayWriteAccessFromPointer 

func NewPoolVector3ArrayWriteAccessFromPointer(ptr Pointer) PoolVector3ArrayWriteAccess

NewPoolVector3ArrayWriteAccessFromPointer will return a PoolVector3ArrayWriteAccess from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PropertyAttributes 

type PropertyAttributes struct {
	RsetType     MethodRpcMode
	Type         Int
	Hint         PropertyHint
	HintString   String
	Usage        PropertyUsageFlags
	DefaultValue Variant
	// contains filtered or unexported fields
}

func NewPropertyAttributesFromPointer 

func NewPropertyAttributesFromPointer(ptr Pointer) PropertyAttributes

NewPropertyAttributesFromPointer will return a PropertyAttributes from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type PropertyHint 

type PropertyHint int

PropertyHint is a Go wrapper for the C.godot_property_hint enum type. 

const (
	PropertyHintNone                  PropertyHint = 0 // < no hint provided.
	PropertyHintRange                 PropertyHint = 1 // < hint_text = "min,max,step,slider;
	PropertyHintExpRange              PropertyHint = 2 // < hint_text = "min,max,step", exponential edit
	PropertyHintEnum                  PropertyHint = 3 // < hint_text= "val1,val2,val3,etc"
	PropertyHintExpEasing             PropertyHint = 4 //  exponential easing function (Math::ease)
	PropertyHintLength                PropertyHint = 5 // < hint_text= "length" (as integer)
	PropertyHintSpriteFrame           PropertyHint = 6
	PropertyHintKeyAccel              PropertyHint = 7 // < hint_text= "length" (as integer)
	PropertyHintFlags                 PropertyHint = 8 // < hint_text= "flag1,flag2,etc" (as bit flags)
	PropertyHintLayers2DRender        PropertyHint = 9
	PropertyHintLayers2DPhysics       PropertyHint = 10
	PropertyHintLayers3DRender        PropertyHint = 11
	PropertyHintLayers3DPhysics       PropertyHint = 12
	PropertyHintFile                  PropertyHint = 13 // < a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
	PropertyHintDir                   PropertyHint = 14 // < a directort path must be passed
	PropertyHintGlobalFile            PropertyHint = 15 // < a file path must be passed, hint_text (optionally) is a filter "*.png,*.wav,*.doc,"
	PropertyHintGlobalDir             PropertyHint = 16 // < a directort path must be passed
	PropertyHintResourceType          PropertyHint = 17 // < a resource object type
	PropertyHintMultilineText         PropertyHint = 18 // < used for string properties that can contain multiple lines
	PropertyHintColorNoAlpha          PropertyHint = 19 // < used for ignoring alpha component when editing a color
	PropertyHintImageCompressLossy    PropertyHint = 20
	PropertyHintImageCompressLossless PropertyHint = 21
	PropertyHintObjectId              PropertyHint = 22
	PropertyHintTypeString            PropertyHint = 23 // < a type string, the hint is the base type to choose
	PropertyHintNodePathToEditedNode  PropertyHint = 24 // < so something else can provide this (used in scripts)
	PropertyHintMethodOfVariantType   PropertyHint = 25 // < a method of a type
	PropertyHintMethodOfBaseType      PropertyHint = 26 // < a method of a base type
	PropertyHintMethodOfInstance      PropertyHint = 27 // < a method of an instance
	PropertyHintMethodOfScript        PropertyHint = 28 // < a method of a script & base
	PropertyHintPropertyOfVariantType PropertyHint = 29 // < a property of a type
	PropertyHintPropertyOfBaseType    PropertyHint = 30 // < a property of a base type
	PropertyHintPropertyOfInstance    PropertyHint = 31 // < a property of an instance
	PropertyHintPropertyOfScript      PropertyHint = 32 // < a property of a script & base
	PropertyHintMax                   PropertyHint = 33
)

type PropertyUsageFlags 

type PropertyUsageFlags int
const (
	PropertyUsageStorage             PropertyUsageFlags = 1
	PropertyUsageEditor              PropertyUsageFlags = 2
	PropertyUsageNetwork             PropertyUsageFlags = 4
	PropertyUsageEditorHelper        PropertyUsageFlags = 8
	PropertyUsageCheckable           PropertyUsageFlags = 16  //used for editing global variables
	PropertyUsageChecked             PropertyUsageFlags = 32  //used for editing global variables
	PropertyUsageInternationalized   PropertyUsageFlags = 64  //hint for internationalized strings
	PropertyUsageGroup               PropertyUsageFlags = 128 //used for grouping props in the editor
	PropertyUsageCategory            PropertyUsageFlags = 256
	PropertyUsageStoreIfNonZero      PropertyUsageFlags = 512  //only store if nonzero
	PropertyUsageStoreIfNonOne       PropertyUsageFlags = 1024 //only store if false
	PropertyUsageNoInstanceState     PropertyUsageFlags = 2048
	PropertyUsageRestartIfChanged    PropertyUsageFlags = 4096
	PropertyUsageScriptVariable      PropertyUsageFlags = 8192
	PropertyUsageStoreIfNull         PropertyUsageFlags = 16384
	PropertyUsageAnimateAsTrigger    PropertyUsageFlags = 32768
	PropertyUsageUpdateAllIfModified PropertyUsageFlags = 65536

	PropertyUsageDefault     PropertyUsageFlags = PropertyUsageStorage | PropertyUsageEditor | PropertyUsageNetwork
	PropertyUsageDefaultIntl PropertyUsageFlags = PropertyUsageStorage | PropertyUsageEditor | PropertyUsageNetwork | PropertyUsageInternationalized
	PropertyUsageNoEditor    PropertyUsageFlags = PropertyUsageStorage | PropertyUsageNetwork
)

type Quat 

type Quat struct {
	// contains filtered or unexported fields
}

func NewQuat 

func NewQuat(x Real, y Real, z Real, w Real) Quat

NewQuat godot_quat_new [[godot_quat * r_dest] [const godot_real p_x] [const godot_real p_y] [const godot_real p_z] [const godot_real p_w]] void

func NewQuatFromPointer 

func NewQuatFromPointer(ptr Pointer) Quat

NewQuatFromPointer will return a Quat from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewQuatWithAxisAngle 

func NewQuatWithAxisAngle(axis Vector3, angle Real) Quat

NewQuatWithAxisAngle godot_quat_new_with_axis_angle [[godot_quat * r_dest] [const godot_vector3 * p_axis] [const godot_real p_angle]] void

func (*Quat) AsString 

func (gdt *Quat) AsString() String

AsString godot_quat_as_string [[const godot_quat * p_self]] godot_string

func (*Quat) CubicSlerp 

func (gdt *Quat) CubicSlerp(b Quat, preA Quat, postB Quat, t Real) Quat

CubicSlerp godot_quat_cubic_slerp [[const godot_quat * p_self] [const godot_quat * p_b] [const godot_quat * p_pre_a] [const godot_quat * p_post_b] [const godot_real p_t]] godot_quat

func (*Quat) Dot 

func (gdt *Quat) Dot(b Quat) Real

Dot godot_quat_dot [[const godot_quat * p_self] [const godot_quat * p_b]] godot_real

func (*Quat) GetW 

func (gdt *Quat) GetW() Real

GetW godot_quat_get_w [[const godot_quat * p_self]] godot_real

func (*Quat) GetX 

func (gdt *Quat) GetX() Real

GetX godot_quat_get_x [[const godot_quat * p_self]] godot_real

func (*Quat) GetY 

func (gdt *Quat) GetY() Real

GetY godot_quat_get_y [[const godot_quat * p_self]] godot_real

func (*Quat) GetZ 

func (gdt *Quat) GetZ() Real

GetZ godot_quat_get_z [[const godot_quat * p_self]] godot_real

func (*Quat) Inverse 

func (gdt *Quat) Inverse() Quat

Inverse godot_quat_inverse [[const godot_quat * p_self]] godot_quat

func (*Quat) IsNormalized 

func (gdt *Quat) IsNormalized() Bool

IsNormalized godot_quat_is_normalized [[const godot_quat * p_self]] godot_bool

func (*Quat) Length 

func (gdt *Quat) Length() Real

Length godot_quat_length [[const godot_quat * p_self]] godot_real

func (*Quat) LengthSquared 

func (gdt *Quat) LengthSquared() Real

LengthSquared godot_quat_length_squared [[const godot_quat * p_self]] godot_real

func (*Quat) Normalized 

func (gdt *Quat) Normalized() Quat

Normalized godot_quat_normalized [[const godot_quat * p_self]] godot_quat

func (*Quat) OperatorAdd 

func (gdt *Quat) OperatorAdd(b Quat) Quat

OperatorAdd godot_quat_operator_add [[const godot_quat * p_self] [const godot_quat * p_b]] godot_quat

func (*Quat) OperatorDivide 

func (gdt *Quat) OperatorDivide(b Real) Quat

OperatorDivide godot_quat_operator_divide [[const godot_quat * p_self] [const godot_real p_b]] godot_quat

func (*Quat) OperatorEqual 

func (gdt *Quat) OperatorEqual(b Quat) Bool

OperatorEqual godot_quat_operator_equal [[const godot_quat * p_self] [const godot_quat * p_b]] godot_bool

func (*Quat) OperatorMultiply 

func (gdt *Quat) OperatorMultiply(b Real) Quat

OperatorMultiply godot_quat_operator_multiply [[const godot_quat * p_self] [const godot_real p_b]] godot_quat

func (*Quat) OperatorNeg 

func (gdt *Quat) OperatorNeg() Quat

OperatorNeg godot_quat_operator_neg [[const godot_quat * p_self]] godot_quat

func (*Quat) OperatorSubtract 

func (gdt *Quat) OperatorSubtract(b Quat) Quat

OperatorSubtract godot_quat_operator_subtract [[const godot_quat * p_self] [const godot_quat * p_b]] godot_quat

func (*Quat) SetW 

func (gdt *Quat) SetW(val Real)

SetW godot_quat_set_w [[godot_quat * p_self] [const godot_real val]] void

func (*Quat) SetX 

func (gdt *Quat) SetX(val Real)

SetX godot_quat_set_x [[godot_quat * p_self] [const godot_real val]] void

func (*Quat) SetY 

func (gdt *Quat) SetY(val Real)

SetY godot_quat_set_y [[godot_quat * p_self] [const godot_real val]] void

func (*Quat) SetZ 

func (gdt *Quat) SetZ(val Real)

SetZ godot_quat_set_z [[godot_quat * p_self] [const godot_real val]] void

func (*Quat) Slerp 

func (gdt *Quat) Slerp(b Quat, t Real) Quat

Slerp godot_quat_slerp [[const godot_quat * p_self] [const godot_quat * p_b] [const godot_real p_t]] godot_quat

func (*Quat) Slerpni 

func (gdt *Quat) Slerpni(b Quat, t Real) Quat

Slerpni godot_quat_slerpni [[const godot_quat * p_self] [const godot_quat * p_b] [const godot_real p_t]] godot_quat

func (*Quat) Xform 

func (gdt *Quat) Xform(v Vector3) Vector3

Xform godot_quat_xform [[const godot_quat * p_self] [const godot_vector3 * p_v]] godot_vector3

type Real 

type Real float64

Real is a Go wrapper for the base C.godot_real type

func NewRealFromPointer 

func NewRealFromPointer(ptr Pointer) Real

NewRealFromPointer will return a Real from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type Rect2 

type Rect2 struct {
	// contains filtered or unexported fields
}

func NewRect2 

func NewRect2(x Real, y Real, width Real, height Real) Rect2

NewRect2 godot_rect2_new [[godot_rect2 * r_dest] [const godot_real p_x] [const godot_real p_y] [const godot_real p_width] [const godot_real p_height]] void

func NewRect2FromPointer 

func NewRect2FromPointer(ptr Pointer) Rect2

NewRect2FromPointer will return a Rect2 from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewRect2WithPositionAndSize 

func NewRect2WithPositionAndSize(pos Vector2, size Vector2) Rect2

NewRect2WithPositionAndSize godot_rect2_new_with_position_and_size [[godot_rect2 * r_dest] [const godot_vector2 * p_pos] [const godot_vector2 * p_size]] void

func (*Rect2) AsString 

func (gdt *Rect2) AsString() String

AsString godot_rect2_as_string [[const godot_rect2 * p_self]] godot_string

func (*Rect2) Clip 

func (gdt *Rect2) Clip(b Rect2) Rect2

Clip godot_rect2_clip [[const godot_rect2 * p_self] [const godot_rect2 * p_b]] godot_rect2

func (*Rect2) Encloses 

func (gdt *Rect2) Encloses(b Rect2) Bool

Encloses godot_rect2_encloses [[const godot_rect2 * p_self] [const godot_rect2 * p_b]] godot_bool

func (*Rect2) Expand 

func (gdt *Rect2) Expand(to Vector2) Rect2

Expand godot_rect2_expand [[const godot_rect2 * p_self] [const godot_vector2 * p_to]] godot_rect2

func (*Rect2) GetArea 

func (gdt *Rect2) GetArea() Real

GetArea godot_rect2_get_area [[const godot_rect2 * p_self]] godot_real

func (*Rect2) GetPosition 

func (gdt *Rect2) GetPosition() Vector2

GetPosition godot_rect2_get_position [[const godot_rect2 * p_self]] godot_vector2

func (*Rect2) GetSize 

func (gdt *Rect2) GetSize() Vector2

GetSize godot_rect2_get_size [[const godot_rect2 * p_self]] godot_vector2

func (*Rect2) Grow 

func (gdt *Rect2) Grow(by Real) Rect2

Grow godot_rect2_grow [[const godot_rect2 * p_self] [const godot_real p_by]] godot_rect2

func (*Rect2) HasNoArea 

func (gdt *Rect2) HasNoArea() Bool

HasNoArea godot_rect2_has_no_area [[const godot_rect2 * p_self]] godot_bool

func (*Rect2) HasPoint 

func (gdt *Rect2) HasPoint(point Vector2) Bool

HasPoint godot_rect2_has_point [[const godot_rect2 * p_self] [const godot_vector2 * p_point]] godot_bool

func (*Rect2) Intersects 

func (gdt *Rect2) Intersects(b Rect2) Bool

Intersects godot_rect2_intersects [[const godot_rect2 * p_self] [const godot_rect2 * p_b]] godot_bool

func (*Rect2) Merge 

func (gdt *Rect2) Merge(b Rect2) Rect2

Merge godot_rect2_merge [[const godot_rect2 * p_self] [const godot_rect2 * p_b]] godot_rect2

func (*Rect2) OperatorEqual 

func (gdt *Rect2) OperatorEqual(b Rect2) Bool

OperatorEqual godot_rect2_operator_equal [[const godot_rect2 * p_self] [const godot_rect2 * p_b]] godot_bool

func (*Rect2) SetPosition 

func (gdt *Rect2) SetPosition(pos Vector2)

SetPosition godot_rect2_set_position [[godot_rect2 * p_self] [const godot_vector2 * p_pos]] void

func (*Rect2) SetSize 

func (gdt *Rect2) SetSize(size Vector2)

SetSize godot_rect2_set_size [[godot_rect2 * p_self] [const godot_vector2 * p_size]] void

type Rid 

type Rid struct {
	// contains filtered or unexported fields
}

func NewRid 

func NewRid() Rid

NewRid godot_rid_new [[godot_rid * r_dest]] void

func NewRidFromPointer 

func NewRidFromPointer(ptr Pointer) Rid

NewRidFromPointer will return a Rid from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewRidWithResource 

func NewRidWithResource(from Object) Rid

NewRidWithResource godot_rid_new_with_resource [[godot_rid * r_dest] [const godot_object * p_from]] void

func (*Rid) GetId 

func (gdt *Rid) GetId() Int

GetId godot_rid_get_id [[const godot_rid * p_self]] godot_int

func (*Rid) OperatorEqual 

func (gdt *Rid) OperatorEqual(b Rid) Bool

OperatorEqual godot_rid_operator_equal [[const godot_rid * p_self] [const godot_rid * p_b]] godot_bool

func (*Rid) OperatorLess 

func (gdt *Rid) OperatorLess(b Rid) Bool

OperatorLess godot_rid_operator_less [[const godot_rid * p_self] [const godot_rid * p_b]] godot_bool

type SetPropertyFunc 

type SetPropertyFunc func(Object, string, string, Variant)

SetPropertyFunc will be called when Godot requests to set a property on a given class. When it is called, the Godot object instance will be passed as an argument, as well as the methodData (which is usually the name of the class), the userData (which is generally the instance ID of the object), and the value to set.

type Signal 

type Signal struct {
	Name           String
	NumArgs        Int
	Args           []SignalArgument
	NumDefaultArgs Int
	DefaultArgs    []Variant
	// contains filtered or unexported fields
}

func NewSignalFromPointer 

func NewSignalFromPointer(ptr Pointer) Signal

NewSignalFromPointer will return a Signal from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type SignalArgument 

type SignalArgument struct {
	Name         String
	Type         Int
	Hint         PropertyHint
	HintString   String
	Usage        PropertyUsageFlags
	DefaultValue Variant
	// contains filtered or unexported fields
}

func NewSignalArgumentFromPointer 

func NewSignalArgumentFromPointer(ptr Pointer) SignalArgument

NewSignalArgumentFromPointer will return a SignalArgument from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type SignedChar 

type SignedChar int8

type String 

type String string

func NewString 

func NewString() String

func NewStringCopy 

func NewStringCopy(src String) String

func NewStringFromPointer 

func NewStringFromPointer(ptr Pointer) String

NewStringFromPointer will return a String from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewStringWithWideString 

func NewStringWithWideString(str string) String

func (*String) Ascii 

func (gdt *String) Ascii() CharString

Ascii godot_string_ascii [[const godot_string * p_self]] godot_char_string

func (*String) AsciiExtended 

func (gdt *String) AsciiExtended() CharString

AsciiExtended godot_string_ascii_extended [[const godot_string * p_self]] godot_char_string

func (*String) BeginsWith 

func (gdt *String) BeginsWith(str String) Bool

BeginsWith godot_string_begins_with [[const godot_string * p_self] [const godot_string * p_string]] godot_bool

func (*String) BeginsWithCharArray 

func (gdt *String) BeginsWithCharArray(charArray Char) Bool

BeginsWithCharArray godot_string_begins_with_char_array [[const godot_string * p_self] [const char * p_char_array]] godot_bool

func (*String) Bigrams 

func (gdt *String) Bigrams() Array

Bigrams godot_string_bigrams [[const godot_string * p_self]] godot_array

func (*String) CEscape 

func (gdt *String) CEscape() String

CEscape godot_string_c_escape [[const godot_string * p_self]] godot_string

func (*String) CEscapeMultiline 

func (gdt *String) CEscapeMultiline() String

CEscapeMultiline godot_string_c_escape_multiline [[const godot_string * p_self]] godot_string

func (*String) CUnescape 

func (gdt *String) CUnescape() String

CUnescape godot_string_c_unescape [[const godot_string * p_self]] godot_string

func (*String) CamelcaseToUnderscore 

func (gdt *String) CamelcaseToUnderscore() String

CamelcaseToUnderscore godot_string_camelcase_to_underscore [[const godot_string * p_self]] godot_string

func (*String) CamelcaseToUnderscoreLowercased 

func (gdt *String) CamelcaseToUnderscoreLowercased() String

CamelcaseToUnderscoreLowercased godot_string_camelcase_to_underscore_lowercased [[const godot_string * p_self]] godot_string

func (*String) Capitalize 

func (gdt *String) Capitalize() String

Capitalize godot_string_capitalize [[const godot_string * p_self]] godot_string

func (*String) CasecmpTo 

func (gdt *String) CasecmpTo(str String) SignedChar

CasecmpTo godot_string_casecmp_to [[const godot_string * p_self] [const godot_string * p_str]] signed char

func (*String) Destroy 

func (gdt *String) Destroy()

Destroy godot_string_destroy [[godot_string * p_self]] void

func (*String) Empty 

func (gdt *String) Empty() Bool

Empty godot_string_empty [[const godot_string * p_self]] godot_bool

func (*String) EndsWith 

func (gdt *String) EndsWith(str String) Bool

EndsWith godot_string_ends_with [[const godot_string * p_self] [const godot_string * p_string]] godot_bool

func (*String) Erase 

func (gdt *String) Erase(pos Int, chars Int)

Erase godot_string_erase [[godot_string * p_self] [godot_int p_pos] [godot_int p_chars]] void

func (*String) Find 

func (gdt *String) Find(what String) Int

Find godot_string_find [[const godot_string * p_self] [godot_string p_what]] godot_int

func (*String) FindFrom 

func (gdt *String) FindFrom(what String, from Int) Int

FindFrom godot_string_find_from [[const godot_string * p_self] [godot_string p_what] [godot_int p_from]] godot_int

func (*String) FindLast 

func (gdt *String) FindLast(what String) Int

FindLast godot_string_find_last [[const godot_string * p_self] [godot_string p_what]] godot_int

func (*String) Findmk 

func (gdt *String) Findmk(keys Array) Int

Findmk godot_string_findmk [[const godot_string * p_self] [const godot_array * p_keys]] godot_int

func (*String) FindmkFrom 

func (gdt *String) FindmkFrom(keys Array, from Int) Int

FindmkFrom godot_string_findmk_from [[const godot_string * p_self] [const godot_array * p_keys] [godot_int p_from]] godot_int

func (*String) FindmkFromInPlace 

func (gdt *String) FindmkFromInPlace(keys Array, from Int, key Int) Int

FindmkFromInPlace godot_string_findmk_from_in_place [[const godot_string * p_self] [const godot_array * p_keys] [godot_int p_from] [godot_int * r_key]] godot_int

func (*String) Findn 

func (gdt *String) Findn(what String) Int

Findn godot_string_findn [[const godot_string * p_self] [godot_string p_what]] godot_int

func (*String) FindnFrom 

func (gdt *String) FindnFrom(what String, from Int) Int

FindnFrom godot_string_findn_from [[const godot_string * p_self] [godot_string p_what] [godot_int p_from]] godot_int

func (*String) Format 

func (gdt *String) Format(values Variant) String

Format godot_string_format [[const godot_string * p_self] [const godot_variant * p_values]] godot_string

func (*String) FormatWithCustomPlaceholder 

func (gdt *String) FormatWithCustomPlaceholder(values Variant, placeholder Char) String

FormatWithCustomPlaceholder godot_string_format_with_custom_placeholder [[const godot_string * p_self] [const godot_variant * p_values] [const char * p_placeholder]] godot_string

func (*String) GetBaseDir 

func (gdt *String) GetBaseDir() String

GetBaseDir godot_string_get_base_dir [[const godot_string * p_self]] godot_string

func (*String) GetBasename 

func (gdt *String) GetBasename() String

GetBasename godot_string_get_basename [[const godot_string * p_self]] godot_string

func (*String) GetExtension 

func (gdt *String) GetExtension() String

GetExtension godot_string_get_extension [[const godot_string * p_self]] godot_string

func (*String) GetFile 

func (gdt *String) GetFile() String

GetFile godot_string_get_file [[const godot_string * p_self]] godot_string

func (*String) GetSlice 

func (gdt *String) GetSlice(splitter String, slice Int) String

GetSlice godot_string_get_slice [[const godot_string * p_self] [godot_string p_splitter] [godot_int p_slice]] godot_string

func (*String) GetSliceCount 

func (gdt *String) GetSliceCount(splitter String) Int

GetSliceCount godot_string_get_slice_count [[const godot_string * p_self] [godot_string p_splitter]] godot_int

func (*String) GetSlicec 

func (gdt *String) GetSlicec(splitter WcharT, slice Int) String

GetSlicec godot_string_get_slicec [[const godot_string * p_self] [wchar_t p_splitter] [godot_int p_slice]] godot_string

func (*String) Hash 

func (gdt *String) Hash() Uint32T

Hash godot_string_hash [[const godot_string * p_self]] uint32_t

func (*String) Hash64 

func (gdt *String) Hash64() Uint64T

Hash64 godot_string_hash64 [[const godot_string * p_self]] uint64_t

func (*String) HexToInt 

func (gdt *String) HexToInt() Int

HexToInt godot_string_hex_to_int [[const godot_string * p_self]] godot_int

func (*String) HexToInt64 

func (gdt *String) HexToInt64() Int64T

HexToInt64 godot_string_hex_to_int64 [[const godot_string * p_self]] int64_t

func (*String) HexToInt64WithPrefix 

func (gdt *String) HexToInt64WithPrefix() Int64T

HexToInt64WithPrefix godot_string_hex_to_int64_with_prefix [[const godot_string * p_self]] int64_t

func (*String) HexToIntWithoutPrefix 

func (gdt *String) HexToIntWithoutPrefix() Int

HexToIntWithoutPrefix godot_string_hex_to_int_without_prefix [[const godot_string * p_self]] godot_int

func (*String) HttpEscape 

func (gdt *String) HttpEscape() String

HttpEscape godot_string_http_escape [[const godot_string * p_self]] godot_string

func (*String) HttpUnescape 

func (gdt *String) HttpUnescape() String

HttpUnescape godot_string_http_unescape [[const godot_string * p_self]] godot_string

func (*String) Insert 

func (gdt *String) Insert(atPos Int, str String) String

Insert godot_string_insert [[const godot_string * p_self] [godot_int p_at_pos] [godot_string p_string]] godot_string

func (*String) IsAbsPath 

func (gdt *String) IsAbsPath() Bool

IsAbsPath godot_string_is_abs_path [[const godot_string * p_self]] godot_bool

func (*String) IsNumeric 

func (gdt *String) IsNumeric() Bool

IsNumeric godot_string_is_numeric [[const godot_string * p_self]] godot_bool

func (*String) IsRelPath 

func (gdt *String) IsRelPath() Bool

IsRelPath godot_string_is_rel_path [[const godot_string * p_self]] godot_bool

func (*String) IsResourceFile 

func (gdt *String) IsResourceFile() Bool

IsResourceFile godot_string_is_resource_file [[const godot_string * p_self]] godot_bool

func (*String) IsSubsequenceOf 

func (gdt *String) IsSubsequenceOf(str String) Bool

IsSubsequenceOf godot_string_is_subsequence_of [[const godot_string * p_self] [const godot_string * p_string]] godot_bool

func (*String) IsSubsequenceOfi 

func (gdt *String) IsSubsequenceOfi(str String) Bool

IsSubsequenceOfi godot_string_is_subsequence_ofi [[const godot_string * p_self] [const godot_string * p_string]] godot_bool

func (*String) IsValidFloat 

func (gdt *String) IsValidFloat() Bool

IsValidFloat godot_string_is_valid_float [[const godot_string * p_self]] godot_bool

func (*String) IsValidHexNumber 

func (gdt *String) IsValidHexNumber(withPrefix Bool) Bool

IsValidHexNumber godot_string_is_valid_hex_number [[const godot_string * p_self] [godot_bool p_with_prefix]] godot_bool

func (*String) IsValidHtmlColor 

func (gdt *String) IsValidHtmlColor() Bool

IsValidHtmlColor godot_string_is_valid_html_color [[const godot_string * p_self]] godot_bool

func (*String) IsValidIdentifier 

func (gdt *String) IsValidIdentifier() Bool

IsValidIdentifier godot_string_is_valid_identifier [[const godot_string * p_self]] godot_bool

func (*String) IsValidInteger 

func (gdt *String) IsValidInteger() Bool

IsValidInteger godot_string_is_valid_integer [[const godot_string * p_self]] godot_bool

func (*String) IsValidIpAddress 

func (gdt *String) IsValidIpAddress() Bool

IsValidIpAddress godot_string_is_valid_ip_address [[const godot_string * p_self]] godot_bool

func (*String) JsonEscape 

func (gdt *String) JsonEscape() String

JsonEscape godot_string_json_escape [[const godot_string * p_self]] godot_string

func (*String) Left 

func (gdt *String) Left(pos Int) String

Left godot_string_left [[const godot_string * p_self] [godot_int p_pos]] godot_string

func (*String) Length 

func (gdt *String) Length() Int

Length godot_string_length [[const godot_string * p_self]] godot_int

func (*String) Lpad 

func (gdt *String) Lpad(minLength Int) String

Lpad godot_string_lpad [[const godot_string * p_self] [godot_int p_min_length]] godot_string

func (*String) LpadWithCustomCharacter 

func (gdt *String) LpadWithCustomCharacter(minLength Int, character String) String

LpadWithCustomCharacter godot_string_lpad_with_custom_character [[const godot_string * p_self] [godot_int p_min_length] [const godot_string * p_character]] godot_string

func (*String) Match 

func (gdt *String) Match(wildcard String) Bool

Match godot_string_match [[const godot_string * p_self] [const godot_string * p_wildcard]] godot_bool

func (*String) Matchn 

func (gdt *String) Matchn(wildcard String) Bool

Matchn godot_string_matchn [[const godot_string * p_self] [const godot_string * p_wildcard]] godot_bool

func (*String) Md5Buffer 

func (gdt *String) Md5Buffer() PoolByteArray

Md5Buffer godot_string_md5_buffer [[const godot_string * p_self]] godot_pool_byte_array

func (*String) Md5Text 

func (gdt *String) Md5Text() String

Md5Text godot_string_md5_text [[const godot_string * p_self]] godot_string

func (*String) NaturalnocasecmpTo 

func (gdt *String) NaturalnocasecmpTo(str String) SignedChar

NaturalnocasecmpTo godot_string_naturalnocasecmp_to [[const godot_string * p_self] [const godot_string * p_str]] signed char

func (*String) NocasecmpTo 

func (gdt *String) NocasecmpTo(str String) SignedChar

NocasecmpTo godot_string_nocasecmp_to [[const godot_string * p_self] [const godot_string * p_str]] signed char

func (*String) OperatorEqual 

func (gdt *String) OperatorEqual(b String) Bool

OperatorEqual godot_string_operator_equal [[const godot_string * p_self] [const godot_string * p_b]] godot_bool

func (*String) OperatorIndex 

func (gdt *String) OperatorIndex(idx Int) WcharT

OperatorIndex godot_string_operator_index [[godot_string * p_self] [const godot_int p_idx]] wchar_t *

func (*String) OperatorIndexConst 

func (gdt *String) OperatorIndexConst(idx Int) WcharT

OperatorIndexConst godot_string_operator_index_const [[const godot_string * p_self] [const godot_int p_idx]] wchar_t

func (*String) OperatorLess 

func (gdt *String) OperatorLess(b String) Bool

OperatorLess godot_string_operator_less [[const godot_string * p_self] [const godot_string * p_b]] godot_bool

func (*String) OperatorPlus 

func (gdt *String) OperatorPlus(b String) String

OperatorPlus godot_string_operator_plus [[const godot_string * p_self] [const godot_string * p_b]] godot_string

func (*String) OrdAt 

func (gdt *String) OrdAt(idx Int) WcharT

OrdAt godot_string_ord_at [[const godot_string * p_self] [godot_int p_idx]] wchar_t

func (*String) PadDecimals 

func (gdt *String) PadDecimals(digits Int) String

PadDecimals godot_string_pad_decimals [[const godot_string * p_self] [godot_int p_digits]] godot_string

func (*String) PadZeros 

func (gdt *String) PadZeros(digits Int) String

PadZeros godot_string_pad_zeros [[const godot_string * p_self] [godot_int p_digits]] godot_string

func (*String) ParseUtf8 

func (gdt *String) ParseUtf8(utf8 Char) Bool

ParseUtf8 godot_string_parse_utf8 [[godot_string * p_self] [const char * p_utf8]] godot_bool

func (*String) ParseUtf8WithLen 

func (gdt *String) ParseUtf8WithLen(utf8 Char, len Int) Bool

ParseUtf8WithLen godot_string_parse_utf8_with_len [[godot_string * p_self] [const char * p_utf8] [godot_int p_len]] godot_bool

func (*String) PathTo 

func (gdt *String) PathTo(path String) String

PathTo godot_string_path_to [[const godot_string * p_self] [const godot_string * p_path]] godot_string

func (*String) PathToFile 

func (gdt *String) PathToFile(path String) String

PathToFile godot_string_path_to_file [[const godot_string * p_self] [const godot_string * p_path]] godot_string

func (*String) PercentDecode 

func (gdt *String) PercentDecode() String

PercentDecode godot_string_percent_decode [[const godot_string * p_self]] godot_string

func (*String) PercentEncode 

func (gdt *String) PercentEncode() String

PercentEncode godot_string_percent_encode [[const godot_string * p_self]] godot_string

func (*String) PlusFile 

func (gdt *String) PlusFile(file String) String

PlusFile godot_string_plus_file [[const godot_string * p_self] [const godot_string * p_file]] godot_string

func (*String) Replace 

func (gdt *String) Replace(key String, with String) String

Replace godot_string_replace [[const godot_string * p_self] [godot_string p_key] [godot_string p_with]] godot_string

func (*String) ReplaceFirst 

func (gdt *String) ReplaceFirst(key String, with String) String

ReplaceFirst godot_string_replace_first [[const godot_string * p_self] [godot_string p_key] [godot_string p_with]] godot_string

func (*String) Replacen 

func (gdt *String) Replacen(key String, with String) String

Replacen godot_string_replacen [[const godot_string * p_self] [godot_string p_key] [godot_string p_with]] godot_string

func (*String) Rfind 

func (gdt *String) Rfind(what String) Int

Rfind godot_string_rfind [[const godot_string * p_self] [godot_string p_what]] godot_int

func (*String) RfindFrom 

func (gdt *String) RfindFrom(what String, from Int) Int

RfindFrom godot_string_rfind_from [[const godot_string * p_self] [godot_string p_what] [godot_int p_from]] godot_int

func (*String) Rfindn 

func (gdt *String) Rfindn(what String) Int

Rfindn godot_string_rfindn [[const godot_string * p_self] [godot_string p_what]] godot_int

func (*String) RfindnFrom 

func (gdt *String) RfindnFrom(what String, from Int) Int

RfindnFrom godot_string_rfindn_from [[const godot_string * p_self] [godot_string p_what] [godot_int p_from]] godot_int

func (*String) Right 

func (gdt *String) Right(pos Int) String

Right godot_string_right [[const godot_string * p_self] [godot_int p_pos]] godot_string

func (*String) Rpad 

func (gdt *String) Rpad(minLength Int) String

Rpad godot_string_rpad [[const godot_string * p_self] [godot_int p_min_length]] godot_string

func (*String) RpadWithCustomCharacter 

func (gdt *String) RpadWithCustomCharacter(minLength Int, character String) String

RpadWithCustomCharacter godot_string_rpad_with_custom_character [[const godot_string * p_self] [godot_int p_min_length] [const godot_string * p_character]] godot_string

func (*String) Sha256Buffer 

func (gdt *String) Sha256Buffer() PoolByteArray

Sha256Buffer godot_string_sha256_buffer [[const godot_string * p_self]] godot_pool_byte_array

func (*String) Sha256Text 

func (gdt *String) Sha256Text() String

Sha256Text godot_string_sha256_text [[const godot_string * p_self]] godot_string

func (*String) Similarity 

func (gdt *String) Similarity(str String) Real

Similarity godot_string_similarity [[const godot_string * p_self] [const godot_string * p_string]] godot_real

func (*String) SimplifyPath 

func (gdt *String) SimplifyPath() String

SimplifyPath godot_string_simplify_path [[const godot_string * p_self]] godot_string

func (*String) Split 

func (gdt *String) Split(splitter String) Array

Split godot_string_split [[const godot_string * p_self] [const godot_string * p_splitter]] godot_array

func (*String) SplitAllowEmpty 

func (gdt *String) SplitAllowEmpty(splitter String) Array

SplitAllowEmpty godot_string_split_allow_empty [[const godot_string * p_self] [const godot_string * p_splitter]] godot_array

func (*String) SplitFloats 

func (gdt *String) SplitFloats(splitter String) Array

SplitFloats godot_string_split_floats [[const godot_string * p_self] [const godot_string * p_splitter]] godot_array

func (*String) SplitFloatsAllowsEmpty 

func (gdt *String) SplitFloatsAllowsEmpty(splitter String) Array

SplitFloatsAllowsEmpty godot_string_split_floats_allows_empty [[const godot_string * p_self] [const godot_string * p_splitter]] godot_array

func (*String) SplitFloatsMk 

func (gdt *String) SplitFloatsMk(splitters Array) Array

SplitFloatsMk godot_string_split_floats_mk [[const godot_string * p_self] [const godot_array * p_splitters]] godot_array

func (*String) SplitFloatsMkAllowsEmpty 

func (gdt *String) SplitFloatsMkAllowsEmpty(splitters Array) Array

SplitFloatsMkAllowsEmpty godot_string_split_floats_mk_allows_empty [[const godot_string * p_self] [const godot_array * p_splitters]] godot_array

func (*String) SplitInts 

func (gdt *String) SplitInts(splitter String) Array

SplitInts godot_string_split_ints [[const godot_string * p_self] [const godot_string * p_splitter]] godot_array

func (*String) SplitIntsAllowsEmpty 

func (gdt *String) SplitIntsAllowsEmpty(splitter String) Array

SplitIntsAllowsEmpty godot_string_split_ints_allows_empty [[const godot_string * p_self] [const godot_string * p_splitter]] godot_array

func (*String) SplitIntsMk 

func (gdt *String) SplitIntsMk(splitters Array) Array

SplitIntsMk godot_string_split_ints_mk [[const godot_string * p_self] [const godot_array * p_splitters]] godot_array

func (*String) SplitIntsMkAllowsEmpty 

func (gdt *String) SplitIntsMkAllowsEmpty(splitters Array) Array

SplitIntsMkAllowsEmpty godot_string_split_ints_mk_allows_empty [[const godot_string * p_self] [const godot_array * p_splitters]] godot_array

func (*String) SplitSpaces 

func (gdt *String) SplitSpaces() Array

SplitSpaces godot_string_split_spaces [[const godot_string * p_self]] godot_array

func (*String) Sprintf 

func (gdt *String) Sprintf(values Array, error Bool) String

Sprintf godot_string_sprintf [[const godot_string * p_self] [const godot_array * p_values] [godot_bool * p_error]] godot_string

func (*String) StripEdges 

func (gdt *String) StripEdges(left Bool, right Bool) String

StripEdges godot_string_strip_edges [[const godot_string * p_self] [godot_bool p_left] [godot_bool p_right]] godot_string

func (*String) StripEscapes 

func (gdt *String) StripEscapes() String

StripEscapes godot_string_strip_escapes [[const godot_string * p_self]] godot_string

func (*String) Substr 

func (gdt *String) Substr(from Int, chars Int) String

Substr godot_string_substr [[const godot_string * p_self] [godot_int p_from] [godot_int p_chars]] godot_string

func (*String) ToDouble 

func (gdt *String) ToDouble() Double

ToDouble godot_string_to_double [[const godot_string * p_self]] double

func (*String) ToFloat 

func (gdt *String) ToFloat() Real

ToFloat godot_string_to_float [[const godot_string * p_self]] godot_real

func (*String) ToInt 

func (gdt *String) ToInt() Int

ToInt godot_string_to_int [[const godot_string * p_self]] godot_int

func (*String) ToInt64 

func (gdt *String) ToInt64() Int64T

ToInt64 godot_string_to_int64 [[const godot_string * p_self]] int64_t

func (*String) ToLower 

func (gdt *String) ToLower() String

ToLower godot_string_to_lower [[const godot_string * p_self]] godot_string

func (*String) ToUpper 

func (gdt *String) ToUpper() String

ToUpper godot_string_to_upper [[const godot_string * p_self]] godot_string

func (*String) Utf8 

func (gdt *String) Utf8() CharString

Utf8 godot_string_utf8 [[const godot_string * p_self]] godot_char_string

func (*String) WideStr 

func (gdt *String) WideStr() WcharT

WideStr godot_string_wide_str [[const godot_string * p_self]] const wchar_t *

func (*String) WordWrap 

func (gdt *String) WordWrap(charsPerLine Int) String

WordWrap godot_string_word_wrap [[const godot_string * p_self] [godot_int p_chars_per_line]] godot_string

func (*String) XmlEscape 

func (gdt *String) XmlEscape() String

XmlEscape godot_string_xml_escape [[const godot_string * p_self]] godot_string

func (*String) XmlEscapeWithQuotes 

func (gdt *String) XmlEscapeWithQuotes() String

XmlEscapeWithQuotes godot_string_xml_escape_with_quotes [[const godot_string * p_self]] godot_string

func (*String) XmlUnescape 

func (gdt *String) XmlUnescape() String

XmlUnescape godot_string_xml_unescape [[const godot_string * p_self]] godot_string

type StringName 

type StringName struct {
	// contains filtered or unexported fields
}

func NewStringName 

func NewStringName(name String) *StringName

func NewStringNameData 

func NewStringNameData(name Char) *StringName

func NewStringNameFromPointer 

func NewStringNameFromPointer(ptr Pointer) StringName

NewStringNameFromPointer will return a StringName from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func (*StringName) Destroy 

func (gdt *StringName) Destroy()

Destroy godot_string_name_destroy [[godot_string_name * p_self]] void

func (*StringName) GetDataUniquePointer 

func (gdt *StringName) GetDataUniquePointer()

GetDataUniquePointer godot_string_name_get_data_unique_pointer [[const godot_string_name * p_self]] const void *

func (*StringName) GetHash 

func (gdt *StringName) GetHash() Uint32T

GetHash godot_string_name_get_hash [[const godot_string_name * p_self]] uint32_t

func (*StringName) GetName 

func (gdt *StringName) GetName() String

GetName godot_string_name_get_name [[const godot_string_name * p_self]] godot_string

func (*StringName) OperatorEqual 

func (gdt *StringName) OperatorEqual(other StringName) Bool

OperatorEqual godot_string_name_operator_equal [[const godot_string_name * p_self] [const godot_string_name * p_other]] godot_bool

func (*StringName) OperatorLess 

func (gdt *StringName) OperatorLess(other StringName) Bool

OperatorLess godot_string_name_operator_less [[const godot_string_name * p_self] [const godot_string_name * p_other]] godot_bool

type Transform 

type Transform struct {
	// contains filtered or unexported fields
}

func NewTransform 

func NewTransform(basis Basis, origin Vector3) Transform

NewTransform godot_transform_new [[godot_transform * r_dest] [const godot_basis * p_basis] [const godot_vector3 * p_origin]] void

func NewTransformFromPointer 

func NewTransformFromPointer(ptr Pointer) Transform

NewTransformFromPointer will return a Transform from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewTransformIdentity 

func NewTransformIdentity() Transform

NewTransformIdentity godot_transform_new_identity [[godot_transform * r_dest]] void

func NewTransformWithAxisOrigin 

func NewTransformWithAxisOrigin(xAxis Vector3, yAxis Vector3, zAxis Vector3, origin Vector3) Transform

NewTransformWithAxisOrigin godot_transform_new_with_axis_origin [[godot_transform * r_dest] [const godot_vector3 * p_x_axis] [const godot_vector3 * p_y_axis] [const godot_vector3 * p_z_axis] [const godot_vector3 * p_origin]] void

func (*Transform) AffineInverse 

func (gdt *Transform) AffineInverse() Transform

AffineInverse godot_transform_affine_inverse [[const godot_transform * p_self]] godot_transform

func (*Transform) AsString 

func (gdt *Transform) AsString() String

AsString godot_transform_as_string [[const godot_transform * p_self]] godot_string

func (*Transform) GetBasis 

func (gdt *Transform) GetBasis() Basis

GetBasis godot_transform_get_basis [[const godot_transform * p_self]] godot_basis

func (*Transform) GetOrigin 

func (gdt *Transform) GetOrigin() Vector3

GetOrigin godot_transform_get_origin [[const godot_transform * p_self]] godot_vector3

func (*Transform) Inverse 

func (gdt *Transform) Inverse() Transform

Inverse godot_transform_inverse [[const godot_transform * p_self]] godot_transform

func (*Transform) LookingAt 

func (gdt *Transform) LookingAt(target Vector3, up Vector3) Transform

LookingAt godot_transform_looking_at [[const godot_transform * p_self] [const godot_vector3 * p_target] [const godot_vector3 * p_up]] godot_transform

func (*Transform) OperatorEqual 

func (gdt *Transform) OperatorEqual(b Transform) Bool

OperatorEqual godot_transform_operator_equal [[const godot_transform * p_self] [const godot_transform * p_b]] godot_bool

func (*Transform) OperatorMultiply 

func (gdt *Transform) OperatorMultiply(b Transform) Transform

OperatorMultiply godot_transform_operator_multiply [[const godot_transform * p_self] [const godot_transform * p_b]] godot_transform

func (*Transform) Orthonormalized 

func (gdt *Transform) Orthonormalized() Transform

Orthonormalized godot_transform_orthonormalized [[const godot_transform * p_self]] godot_transform

func (*Transform) Rotated 

func (gdt *Transform) Rotated(axis Vector3, phi Real) Transform

Rotated godot_transform_rotated [[const godot_transform * p_self] [const godot_vector3 * p_axis] [const godot_real p_phi]] godot_transform

func (*Transform) Scaled 

func (gdt *Transform) Scaled(scale Vector3) Transform

Scaled godot_transform_scaled [[const godot_transform * p_self] [const godot_vector3 * p_scale]] godot_transform

func (*Transform) SetBasis 

func (gdt *Transform) SetBasis(v Basis)

SetBasis godot_transform_set_basis [[godot_transform * p_self] [const godot_basis * p_v]] void

func (*Transform) SetOrigin 

func (gdt *Transform) SetOrigin(v Vector3)

SetOrigin godot_transform_set_origin [[godot_transform * p_self] [const godot_vector3 * p_v]] void

func (*Transform) Translated 

func (gdt *Transform) Translated(ofs Vector3) Transform

Translated godot_transform_translated [[const godot_transform * p_self] [const godot_vector3 * p_ofs]] godot_transform

func (*Transform) XformAabb 

func (gdt *Transform) XformAabb(v Aabb) Aabb

XformAabb godot_transform_xform_aabb [[const godot_transform * p_self] [const godot_aabb * p_v]] godot_aabb

func (*Transform) XformInvAabb 

func (gdt *Transform) XformInvAabb(v Aabb) Aabb

XformInvAabb godot_transform_xform_inv_aabb [[const godot_transform * p_self] [const godot_aabb * p_v]] godot_aabb

func (*Transform) XformInvPlane 

func (gdt *Transform) XformInvPlane(v Plane) Plane

XformInvPlane godot_transform_xform_inv_plane [[const godot_transform * p_self] [const godot_plane * p_v]] godot_plane

func (*Transform) XformInvVector3 

func (gdt *Transform) XformInvVector3(v Vector3) Vector3

XformInvVector3 godot_transform_xform_inv_vector3 [[const godot_transform * p_self] [const godot_vector3 * p_v]] godot_vector3

func (*Transform) XformPlane 

func (gdt *Transform) XformPlane(v Plane) Plane

XformPlane godot_transform_xform_plane [[const godot_transform * p_self] [const godot_plane * p_v]] godot_plane

func (*Transform) XformVector3 

func (gdt *Transform) XformVector3(v Vector3) Vector3

XformVector3 godot_transform_xform_vector3 [[const godot_transform * p_self] [const godot_vector3 * p_v]] godot_vector3

type Transform2D 

type Transform2D struct {
	// contains filtered or unexported fields
}

func NewTransform2D 

func NewTransform2D(rot Real, pos Vector2) *Transform2D

NewTransform2D godot_transform2d_new [[godot_transform2d * r_dest] [const godot_real p_rot] [const godot_vector2 * p_pos]] void

func NewTransform2DAxisOrigin 

func NewTransform2DAxisOrigin(xAxis Vector2, yAxis Vector2, origin Vector2) *Transform2D

NewTransform2DAxisOrigin godot_transform2d_new_axis_origin [[godot_transform2d * r_dest] [const godot_vector2 * p_x_axis] [const godot_vector2 * p_y_axis] [const godot_vector2 * p_origin]] void

func NewTransform2DFromPointer 

func NewTransform2DFromPointer(ptr Pointer) Transform2D

NewTransform2DFromPointer will return a Transform2D from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewTransform2DIdentity 

func NewTransform2DIdentity() *Transform2D

NewTransform2DIdentity godot_transform2d_new_identity [[godot_transform2d * r_dest]] void

func (*Transform2D) AffineInverse 

func (gdt *Transform2D) AffineInverse() Transform2D

AffineInverse godot_transform2d_affine_inverse [[const godot_transform2d * p_self]] godot_transform2d

func (*Transform2D) AsString 

func (gdt *Transform2D) AsString() String

AsString godot_transform2d_as_string [[const godot_transform2d * p_self]] godot_string

func (*Transform2D) BasisXformInvVector2 

func (gdt *Transform2D) BasisXformInvVector2(v Vector2) Vector2

BasisXformInvVector2 godot_transform2d_basis_xform_inv_vector2 [[const godot_transform2d * p_self] [const godot_vector2 * p_v]] godot_vector2

func (*Transform2D) BasisXformVector2 

func (gdt *Transform2D) BasisXformVector2(v Vector2) Vector2

BasisXformVector2 godot_transform2d_basis_xform_vector2 [[const godot_transform2d * p_self] [const godot_vector2 * p_v]] godot_vector2

func (*Transform2D) GetOrigin 

func (gdt *Transform2D) GetOrigin() Vector2

GetOrigin godot_transform2d_get_origin [[const godot_transform2d * p_self]] godot_vector2

func (*Transform2D) GetRotation 

func (gdt *Transform2D) GetRotation() Real

GetRotation godot_transform2d_get_rotation [[const godot_transform2d * p_self]] godot_real

func (*Transform2D) GetScale 

func (gdt *Transform2D) GetScale() Vector2

GetScale godot_transform2d_get_scale [[const godot_transform2d * p_self]] godot_vector2

func (*Transform2D) InterpolateWith 

func (gdt *Transform2D) InterpolateWith(m Transform2D, c Real) Transform2D

InterpolateWith godot_transform2d_interpolate_with [[const godot_transform2d * p_self] [const godot_transform2d * p_m] [const godot_real p_c]] godot_transform2d

func (*Transform2D) Inverse 

func (gdt *Transform2D) Inverse() Transform2D

Inverse godot_transform2d_inverse [[const godot_transform2d * p_self]] godot_transform2d

func (*Transform2D) OperatorEqual 

func (gdt *Transform2D) OperatorEqual(b Transform2D) Bool

OperatorEqual godot_transform2d_operator_equal [[const godot_transform2d * p_self] [const godot_transform2d * p_b]] godot_bool

func (*Transform2D) OperatorMultiply 

func (gdt *Transform2D) OperatorMultiply(b Transform2D) Transform2D

OperatorMultiply godot_transform2d_operator_multiply [[const godot_transform2d * p_self] [const godot_transform2d * p_b]] godot_transform2d

func (*Transform2D) Orthonormalized 

func (gdt *Transform2D) Orthonormalized() Transform2D

Orthonormalized godot_transform2d_orthonormalized [[const godot_transform2d * p_self]] godot_transform2d

func (*Transform2D) Rotated 

func (gdt *Transform2D) Rotated(phi Real) Transform2D

Rotated godot_transform2d_rotated [[const godot_transform2d * p_self] [const godot_real p_phi]] godot_transform2d

func (*Transform2D) Scaled 

func (gdt *Transform2D) Scaled(scale Vector2) Transform2D

Scaled godot_transform2d_scaled [[const godot_transform2d * p_self] [const godot_vector2 * p_scale]] godot_transform2d

func (*Transform2D) Translated 

func (gdt *Transform2D) Translated(offset Vector2) Transform2D

Translated godot_transform2d_translated [[const godot_transform2d * p_self] [const godot_vector2 * p_offset]] godot_transform2d

func (*Transform2D) XformInvRect2 

func (gdt *Transform2D) XformInvRect2(v Rect2) Rect2

XformInvRect2 godot_transform2d_xform_inv_rect2 [[const godot_transform2d * p_self] [const godot_rect2 * p_v]] godot_rect2

func (*Transform2D) XformInvVector2 

func (gdt *Transform2D) XformInvVector2(v Vector2) Vector2

XformInvVector2 godot_transform2d_xform_inv_vector2 [[const godot_transform2d * p_self] [const godot_vector2 * p_v]] godot_vector2

func (*Transform2D) XformRect2 

func (gdt *Transform2D) XformRect2(v Rect2) Rect2

XformRect2 godot_transform2d_xform_rect2 [[const godot_transform2d * p_self] [const godot_rect2 * p_v]] godot_rect2

func (*Transform2D) XformVector2 

func (gdt *Transform2D) XformVector2(v Vector2) Vector2

XformVector2 godot_transform2d_xform_vector2 [[const godot_transform2d * p_self] [const godot_vector2 * p_v]] godot_vector2

type Uint 

type Uint uint

Uint is a Godot C uint wrapper

type Uint32T 

type Uint32T uint32

Uint32T is a Godot C uint32_t wrapper

type Uint64T 

type Uint64T uint64

Uint64T is a Godot C uint64_t wrapper

type Uint8T 

type Uint8T uint8

Uint8T is a Godot C uint8_t wrapper

type Variant 

type Variant struct {
	// contains filtered or unexported fields
}

func NewVariantAabb 

func NewVariantAabb(aabb Aabb) Variant

NewVariantAabb godot_variant_new_aabb [[godot_variant * r_dest] [const godot_aabb * p_aabb]] void

func NewVariantArray 

func NewVariantArray(arr Array) Variant

NewVariantArray godot_variant_new_array [[godot_variant * r_dest] [const godot_array * p_arr]] void

func NewVariantBasis 

func NewVariantBasis(basis Basis) Variant

NewVariantBasis godot_variant_new_basis [[godot_variant * r_dest] [const godot_basis * p_basis]] void

func NewVariantBool 

func NewVariantBool(b Bool) Variant

NewVariantBool godot_variant_new_bool [[godot_variant * p_v] [const godot_bool p_b]] void

func NewVariantColor 

func NewVariantColor(color Color) Variant

NewVariantColor godot_variant_new_color [[godot_variant * r_dest] [const godot_color * p_color]] void

func NewVariantCopy 

func NewVariantCopy(src Variant) Variant

NewVariantCopy godot_variant_new_copy [[godot_variant * r_dest] [const godot_variant * p_src]] void

func NewVariantDictionary 

func NewVariantDictionary(dict Dictionary) Variant

NewVariantDictionary godot_variant_new_dictionary [[godot_variant * r_dest] [const godot_dictionary * p_dict]] void

func NewVariantFromPointer 

func NewVariantFromPointer(ptr Pointer) Variant

NewVariantFromPointer will return a Variant from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func NewVariantInt 

func NewVariantInt(i Int64T) Variant

NewVariantInt godot_variant_new_int [[godot_variant * r_dest] [const int64_t p_i]] void

func NewVariantNil 

func NewVariantNil() Variant

NewVariantNil godot_variant_new_nil [[godot_variant * r_dest]] void

func NewVariantNodePath 

func NewVariantNodePath(np NodePath) Variant

NewVariantNodePath godot_variant_new_node_path [[godot_variant * r_dest] [const godot_node_path * p_np]] void

func NewVariantObject 

func NewVariantObject(obj Object) Variant

NewVariantObject godot_variant_new_object [[godot_variant * r_dest] [const godot_object * p_obj]] void

func NewVariantPlane 

func NewVariantPlane(plane Plane) Variant

NewVariantPlane godot_variant_new_plane [[godot_variant * r_dest] [const godot_plane * p_plane]] void

func NewVariantPoolByteArray 

func NewVariantPoolByteArray(pba PoolByteArray) Variant

NewVariantPoolByteArray godot_variant_new_pool_byte_array [[godot_variant * r_dest] [const godot_pool_byte_array * p_pba]] void

func NewVariantPoolColorArray 

func NewVariantPoolColorArray(pca PoolColorArray) Variant

NewVariantPoolColorArray godot_variant_new_pool_color_array [[godot_variant * r_dest] [const godot_pool_color_array * p_pca]] void

func NewVariantPoolIntArray 

func NewVariantPoolIntArray(pia PoolIntArray) Variant

NewVariantPoolIntArray godot_variant_new_pool_int_array [[godot_variant * r_dest] [const godot_pool_int_array * p_pia]] void

func NewVariantPoolRealArray 

func NewVariantPoolRealArray(pra PoolRealArray) Variant

NewVariantPoolRealArray godot_variant_new_pool_real_array [[godot_variant * r_dest] [const godot_pool_real_array * p_pra]] void

func NewVariantPoolStringArray 

func NewVariantPoolStringArray(psa PoolStringArray) Variant

NewVariantPoolStringArray godot_variant_new_pool_string_array [[godot_variant * r_dest] [const godot_pool_string_array * p_psa]] void

func NewVariantPoolVector2Array 

func NewVariantPoolVector2Array(pv2A PoolVector2Array) Variant

NewVariantPoolVector2Array godot_variant_new_pool_vector2_array [[godot_variant * r_dest] [const godot_pool_vector2_array * p_pv2a]] void

func NewVariantPoolVector3Array 

func NewVariantPoolVector3Array(pv3A PoolVector3Array) Variant

NewVariantPoolVector3Array godot_variant_new_pool_vector3_array [[godot_variant * r_dest] [const godot_pool_vector3_array * p_pv3a]] void

func NewVariantQuat 

func NewVariantQuat(quat Quat) Variant

NewVariantQuat godot_variant_new_quat [[godot_variant * r_dest] [const godot_quat * p_quat]] void

func NewVariantReal 

func NewVariantReal(r Double) Variant

NewVariantReal godot_variant_new_real [[godot_variant * r_dest] [const double p_r]] void

func NewVariantRect2 

func NewVariantRect2(rect2 Rect2) Variant

NewVariantRect2 godot_variant_new_rect2 [[godot_variant * r_dest] [const godot_rect2 * p_rect2]] void

func NewVariantRid 

func NewVariantRid(rid Rid) Variant

NewVariantRid godot_variant_new_rid [[godot_variant * r_dest] [const godot_rid * p_rid]] void

func NewVariantString 

func NewVariantString(s String) Variant

NewVariantString godot_variant_new_string [[godot_variant * r_dest] [const godot_string * p_s]] void

func NewVariantTransform 

func NewVariantTransform(trans Transform) Variant

NewVariantTransform godot_variant_new_transform [[godot_variant * r_dest] [const godot_transform * p_trans]] void

func NewVariantTransform2D 

func NewVariantTransform2D(t2D Transform2D) Variant

NewVariantTransform2D godot_variant_new_transform2d [[godot_variant * r_dest] [const godot_transform2d * p_t2d]] void

func NewVariantUint 

func NewVariantUint(i Uint64T) Variant

NewVariantUint godot_variant_new_uint [[godot_variant * r_dest] [const uint64_t p_i]] void

func NewVariantVector2 

func NewVariantVector2(v2 Vector2) Variant

NewVariantVector2 godot_variant_new_vector2 [[godot_variant * r_dest] [const godot_vector2 * p_v2]] void

func NewVariantVector3 

func NewVariantVector3(v3 Vector3) Variant

NewVariantVector3 godot_variant_new_vector3 [[godot_variant * r_dest] [const godot_vector3 * p_v3]] void

func NewVariantWithString 

func NewVariantWithString(str String) Variant

func (*Variant) AsAabb 

func (gdt *Variant) AsAabb() Aabb

AsAabb godot_variant_as_aabb [[const godot_variant * p_self]] godot_aabb

func (*Variant) AsArray 

func (gdt *Variant) AsArray() Array

AsArray godot_variant_as_array [[const godot_variant * p_self]] godot_array

func (*Variant) AsBasis 

func (gdt *Variant) AsBasis() Basis

AsBasis godot_variant_as_basis [[const godot_variant * p_self]] godot_basis

func (*Variant) AsBool 

func (gdt *Variant) AsBool() Bool

AsBool godot_variant_as_bool [[const godot_variant * p_self]] godot_bool

func (*Variant) AsColor 

func (gdt *Variant) AsColor() Color

AsColor godot_variant_as_color [[const godot_variant * p_self]] godot_color

func (*Variant) AsDictionary 

func (gdt *Variant) AsDictionary() Dictionary

AsDictionary godot_variant_as_dictionary [[const godot_variant * p_self]] godot_dictionary

func (*Variant) AsInt 

func (gdt *Variant) AsInt() Int64T

AsInt godot_variant_as_int [[const godot_variant * p_self]] int64_t

func (*Variant) AsNodePath 

func (gdt *Variant) AsNodePath() NodePath

AsNodePath godot_variant_as_node_path [[const godot_variant * p_self]] godot_node_path

func (*Variant) AsObject 

func (gdt *Variant) AsObject() Object

AsObject godot_variant_as_object [[const godot_variant * p_self]] godot_object *

func (*Variant) AsPlane 

func (gdt *Variant) AsPlane() Plane

AsPlane godot_variant_as_plane [[const godot_variant * p_self]] godot_plane

func (*Variant) AsPoolByteArray 

func (gdt *Variant) AsPoolByteArray() PoolByteArray

AsPoolByteArray godot_variant_as_pool_byte_array [[const godot_variant * p_self]] godot_pool_byte_array

func (*Variant) AsPoolColorArray 

func (gdt *Variant) AsPoolColorArray() PoolColorArray

AsPoolColorArray godot_variant_as_pool_color_array [[const godot_variant * p_self]] godot_pool_color_array

func (*Variant) AsPoolIntArray 

func (gdt *Variant) AsPoolIntArray() PoolIntArray

AsPoolIntArray godot_variant_as_pool_int_array [[const godot_variant * p_self]] godot_pool_int_array

func (*Variant) AsPoolRealArray 

func (gdt *Variant) AsPoolRealArray() PoolRealArray

AsPoolRealArray godot_variant_as_pool_real_array [[const godot_variant * p_self]] godot_pool_real_array

func (*Variant) AsPoolStringArray 

func (gdt *Variant) AsPoolStringArray() PoolStringArray

AsPoolStringArray godot_variant_as_pool_string_array [[const godot_variant * p_self]] godot_pool_string_array

func (*Variant) AsPoolVector2Array 

func (gdt *Variant) AsPoolVector2Array() PoolVector2Array

AsPoolVector2Array godot_variant_as_pool_vector2_array [[const godot_variant * p_self]] godot_pool_vector2_array

func (*Variant) AsPoolVector3Array 

func (gdt *Variant) AsPoolVector3Array() PoolVector3Array

AsPoolVector3Array godot_variant_as_pool_vector3_array [[const godot_variant * p_self]] godot_pool_vector3_array

func (*Variant) AsQuat 

func (gdt *Variant) AsQuat() Quat

AsQuat godot_variant_as_quat [[const godot_variant * p_self]] godot_quat

func (*Variant) AsReal 

func (gdt *Variant) AsReal() Double

AsReal godot_variant_as_real [[const godot_variant * p_self]] double

func (*Variant) AsRect2 

func (gdt *Variant) AsRect2() Rect2

AsRect2 godot_variant_as_rect2 [[const godot_variant * p_self]] godot_rect2

func (*Variant) AsRid 

func (gdt *Variant) AsRid() Rid

AsRid godot_variant_as_rid [[const godot_variant * p_self]] godot_rid

func (*Variant) AsString 

func (gdt *Variant) AsString() String

AsString godot_variant_as_string [[const godot_variant * p_self]] godot_string

func (*Variant) AsTransform 

func (gdt *Variant) AsTransform() Transform

AsTransform godot_variant_as_transform [[const godot_variant * p_self]] godot_transform

func (*Variant) AsTransform2D 

func (gdt *Variant) AsTransform2D() Transform2D

AsTransform2D godot_variant_as_transform2d [[const godot_variant * p_self]] godot_transform2d

func (*Variant) AsUint 

func (gdt *Variant) AsUint() Uint64T

AsUint godot_variant_as_uint [[const godot_variant * p_self]] uint64_t

func (*Variant) AsVector2 

func (gdt *Variant) AsVector2() Vector2

AsVector2 godot_variant_as_vector2 [[const godot_variant * p_self]] godot_vector2

func (*Variant) AsVector3 

func (gdt *Variant) AsVector3() Vector3

AsVector3 godot_variant_as_vector3 [[const godot_variant * p_self]] godot_vector3

func (*Variant) Booleanize 

func (gdt *Variant) Booleanize() Bool

Booleanize godot_variant_booleanize [[const godot_variant * p_self]] godot_bool

func (*Variant) Call 

func (gdt *Variant) Call(method String, args []Variant, argcount Int, error VariantCallError) Variant

Call godot_variant_call [[godot_variant * p_self] [const godot_string * p_method] [const godot_variant ** p_args] [const godot_int p_argcount] [godot_variant_call_error * r_error]] godot_variant

func (*Variant) Destroy 

func (gdt *Variant) Destroy()

Destroy godot_variant_destroy [[godot_variant * p_self]] void

func (*Variant) GetType 

func (gdt *Variant) GetType() VariantType

func (*Variant) HasMethod 

func (gdt *Variant) HasMethod(method String) Bool

HasMethod godot_variant_has_method [[const godot_variant * p_self] [const godot_string * p_method]] godot_bool

func (*Variant) HashCompare 

func (gdt *Variant) HashCompare(other Variant) Bool

HashCompare godot_variant_hash_compare [[const godot_variant * p_self] [const godot_variant * p_other]] godot_bool

func (*Variant) OperatorEqual 

func (gdt *Variant) OperatorEqual(other Variant) Bool

OperatorEqual godot_variant_operator_equal [[const godot_variant * p_self] [const godot_variant * p_other]] godot_bool

func (*Variant) OperatorLess 

func (gdt *Variant) OperatorLess(other Variant) Bool

OperatorLess godot_variant_operator_less [[const godot_variant * p_self] [const godot_variant * p_other]] godot_bool

type VariantArray 

type VariantArray struct {
	// contains filtered or unexported fields
}

type VariantCallError 

type VariantCallError struct {
	Error    VariantCallErrorError
	Argument Int
	Expected VariantType
	// contains filtered or unexported fields
}

func NewVariantCallErrorFromPointer 

func NewVariantCallErrorFromPointer(ptr Pointer) VariantCallError

NewVariantCallErrorFromPointer will return a VariantCallError from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

type VariantCallErrorError 

type VariantCallErrorError int

VariantCallErrorError is a Go wrapper for the C.godot_variant_call_error_error enum type. 

const (
	CallErrorCallOk                    VariantCallErrorError = 0
	CallErrorCallErrorInvalidMethod    VariantCallErrorError = 1
	CallErrorCallErrorInvalidArgument  VariantCallErrorError = 2
	CallErrorCallErrorTooManyArguments VariantCallErrorError = 3
	CallErrorCallErrorTooFewArguments  VariantCallErrorError = 4
	CallErrorCallErrorInstanceIsNull   VariantCallErrorError = 5
)

type VariantOperator 

type VariantOperator int

type VariantType 

type VariantType int

VariantType is a Go wrapper for the C.godot_variant_type enum type. 

const (
	VariantTypeNil              VariantType = 0
	VariantTypeBool             VariantType = 1
	VariantTypeInt              VariantType = 2
	VariantTypeReal             VariantType = 3
	VariantTypeString           VariantType = 4
	VariantTypeVector2          VariantType = 5 // 5
	VariantTypeRect2            VariantType = 6
	VariantTypeVector3          VariantType = 7
	VariantTypeTransform2D      VariantType = 8
	VariantTypePlane            VariantType = 9
	VariantTypeQuat             VariantType = 10 // 10
	VariantTypeAabb             VariantType = 11
	VariantTypeBasis            VariantType = 12
	VariantTypeTransform        VariantType = 13
	VariantTypeColor            VariantType = 14
	VariantTypeNodePath         VariantType = 15 // 15
	VariantTypeRid              VariantType = 16
	VariantTypeObject           VariantType = 17
	VariantTypeDictionary       VariantType = 18
	VariantTypeArray            VariantType = 19 // 20
	VariantTypePoolByteArray    VariantType = 20
	VariantTypePoolIntArray     VariantType = 21
	VariantTypePoolRealArray    VariantType = 22
	VariantTypePoolStringArray  VariantType = 23
	VariantTypePoolVector2Array VariantType = 24 // 25
	VariantTypePoolVector3Array VariantType = 25
	VariantTypePoolColorArray   VariantType = 26
)

type Vector2 

type Vector2 struct {
	// contains filtered or unexported fields
}

func NewVector2 

func NewVector2(x Real, y Real) Vector2

NewVector2 godot_vector2_new [[godot_vector2 * r_dest] [const godot_real p_x] [const godot_real p_y]] void

func NewVector2FromPointer 

func NewVector2FromPointer(ptr Pointer) Vector2

NewVector2FromPointer will return a Vector2 from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func (*Vector2) Abs 

func (gdt *Vector2) Abs() Vector2

Abs godot_vector2_abs [[const godot_vector2 * p_self]] godot_vector2

func (*Vector2) Angle 

func (gdt *Vector2) Angle() Real

Angle godot_vector2_angle [[const godot_vector2 * p_self]] godot_real

func (*Vector2) AngleTo 

func (gdt *Vector2) AngleTo(to Vector2) Real

AngleTo godot_vector2_angle_to [[const godot_vector2 * p_self] [const godot_vector2 * p_to]] godot_real

func (*Vector2) AngleToPoint 

func (gdt *Vector2) AngleToPoint(to Vector2) Real

AngleToPoint godot_vector2_angle_to_point [[const godot_vector2 * p_self] [const godot_vector2 * p_to]] godot_real

func (*Vector2) AsString 

func (gdt *Vector2) AsString() String

AsString godot_vector2_as_string [[const godot_vector2 * p_self]] godot_string

func (*Vector2) Aspect 

func (gdt *Vector2) Aspect() Real

Aspect godot_vector2_aspect [[const godot_vector2 * p_self]] godot_real

func (*Vector2) Bounce 

func (gdt *Vector2) Bounce(n Vector2) Vector2

Bounce godot_vector2_bounce [[const godot_vector2 * p_self] [const godot_vector2 * p_n]] godot_vector2

func (*Vector2) Clamped 

func (gdt *Vector2) Clamped(length Real) Vector2

Clamped godot_vector2_clamped [[const godot_vector2 * p_self] [const godot_real p_length]] godot_vector2

func (*Vector2) CubicInterpolate 

func (gdt *Vector2) CubicInterpolate(b Vector2, preA Vector2, postB Vector2, t Real) Vector2

CubicInterpolate godot_vector2_cubic_interpolate [[const godot_vector2 * p_self] [const godot_vector2 * p_b] [const godot_vector2 * p_pre_a] [const godot_vector2 * p_post_b] [const godot_real p_t]] godot_vector2

func (*Vector2) DistanceSquaredTo 

func (gdt *Vector2) DistanceSquaredTo(to Vector2) Real

DistanceSquaredTo godot_vector2_distance_squared_to [[const godot_vector2 * p_self] [const godot_vector2 * p_to]] godot_real

func (*Vector2) DistanceTo 

func (gdt *Vector2) DistanceTo(to Vector2) Real

DistanceTo godot_vector2_distance_to [[const godot_vector2 * p_self] [const godot_vector2 * p_to]] godot_real

func (*Vector2) Dot 

func (gdt *Vector2) Dot(with Vector2) Real

Dot godot_vector2_dot [[const godot_vector2 * p_self] [const godot_vector2 * p_with]] godot_real

func (*Vector2) Floor 

func (gdt *Vector2) Floor() Vector2

Floor godot_vector2_floor [[const godot_vector2 * p_self]] godot_vector2

func (*Vector2) GetX 

func (gdt *Vector2) GetX() Real

GetX godot_vector2_get_x [[const godot_vector2 * p_self]] godot_real

func (*Vector2) GetY 

func (gdt *Vector2) GetY() Real

GetY godot_vector2_get_y [[const godot_vector2 * p_self]] godot_real

func (*Vector2) IsNormalized 

func (gdt *Vector2) IsNormalized() Bool

IsNormalized godot_vector2_is_normalized [[const godot_vector2 * p_self]] godot_bool

func (*Vector2) Length 

func (gdt *Vector2) Length() Real

Length godot_vector2_length [[const godot_vector2 * p_self]] godot_real

func (*Vector2) LengthSquared 

func (gdt *Vector2) LengthSquared() Real

LengthSquared godot_vector2_length_squared [[const godot_vector2 * p_self]] godot_real

func (*Vector2) LinearInterpolate 

func (gdt *Vector2) LinearInterpolate(b Vector2, t Real) Vector2

LinearInterpolate godot_vector2_linear_interpolate [[const godot_vector2 * p_self] [const godot_vector2 * p_b] [const godot_real p_t]] godot_vector2

func (*Vector2) Normalized 

func (gdt *Vector2) Normalized() Vector2

Normalized godot_vector2_normalized [[const godot_vector2 * p_self]] godot_vector2

func (*Vector2) OperatorAdd 

func (gdt *Vector2) OperatorAdd(b Vector2) Vector2

OperatorAdd godot_vector2_operator_add [[const godot_vector2 * p_self] [const godot_vector2 * p_b]] godot_vector2

func (*Vector2) OperatorDivideScalar 

func (gdt *Vector2) OperatorDivideScalar(b Real) Vector2

OperatorDivideScalar godot_vector2_operator_divide_scalar [[const godot_vector2 * p_self] [const godot_real p_b]] godot_vector2

func (*Vector2) OperatorDivideVector 

func (gdt *Vector2) OperatorDivideVector(b Vector2) Vector2

OperatorDivideVector godot_vector2_operator_divide_vector [[const godot_vector2 * p_self] [const godot_vector2 * p_b]] godot_vector2

func (*Vector2) OperatorEqual 

func (gdt *Vector2) OperatorEqual(b Vector2) Bool

OperatorEqual godot_vector2_operator_equal [[const godot_vector2 * p_self] [const godot_vector2 * p_b]] godot_bool

func (*Vector2) OperatorLess 

func (gdt *Vector2) OperatorLess(b Vector2) Bool

OperatorLess godot_vector2_operator_less [[const godot_vector2 * p_self] [const godot_vector2 * p_b]] godot_bool

func (*Vector2) OperatorMultiplyScalar 

func (gdt *Vector2) OperatorMultiplyScalar(b Real) Vector2

OperatorMultiplyScalar godot_vector2_operator_multiply_scalar [[const godot_vector2 * p_self] [const godot_real p_b]] godot_vector2

func (*Vector2) OperatorMultiplyVector 

func (gdt *Vector2) OperatorMultiplyVector(b Vector2) Vector2

OperatorMultiplyVector godot_vector2_operator_multiply_vector [[const godot_vector2 * p_self] [const godot_vector2 * p_b]] godot_vector2

func (*Vector2) OperatorNeg 

func (gdt *Vector2) OperatorNeg() Vector2

OperatorNeg godot_vector2_operator_neg [[const godot_vector2 * p_self]] godot_vector2

func (*Vector2) OperatorSubtract 

func (gdt *Vector2) OperatorSubtract(b Vector2) Vector2

OperatorSubtract godot_vector2_operator_subtract [[const godot_vector2 * p_self] [const godot_vector2 * p_b]] godot_vector2

func (*Vector2) Reflect 

func (gdt *Vector2) Reflect(n Vector2) Vector2

Reflect godot_vector2_reflect [[const godot_vector2 * p_self] [const godot_vector2 * p_n]] godot_vector2

func (*Vector2) Rotated 

func (gdt *Vector2) Rotated(phi Real) Vector2

Rotated godot_vector2_rotated [[const godot_vector2 * p_self] [const godot_real p_phi]] godot_vector2

func (*Vector2) SetX 

func (gdt *Vector2) SetX(x Real)

SetX godot_vector2_set_x [[godot_vector2 * p_self] [const godot_real p_x]] void

func (*Vector2) SetY 

func (gdt *Vector2) SetY(y Real)

SetY godot_vector2_set_y [[godot_vector2 * p_self] [const godot_real p_y]] void

func (*Vector2) Slide 

func (gdt *Vector2) Slide(n Vector2) Vector2

Slide godot_vector2_slide [[const godot_vector2 * p_self] [const godot_vector2 * p_n]] godot_vector2

func (*Vector2) Snapped 

func (gdt *Vector2) Snapped(by Vector2) Vector2

Snapped godot_vector2_snapped [[const godot_vector2 * p_self] [const godot_vector2 * p_by]] godot_vector2

func (*Vector2) Tangent 

func (gdt *Vector2) Tangent() Vector2

Tangent godot_vector2_tangent [[const godot_vector2 * p_self]] godot_vector2

type Vector3 

type Vector3 struct {
	// contains filtered or unexported fields
}

func NewVector3 

func NewVector3(x Real, y Real, z Real) Vector3

NewVector3 godot_vector3_new [[godot_vector3 * r_dest] [const godot_real p_x] [const godot_real p_y] [const godot_real p_z]] void

func NewVector3FromPointer 

func NewVector3FromPointer(ptr Pointer) Vector3

NewVector3FromPointer will return a Vector3 from the given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.

func (*Vector3) Abs 

func (gdt *Vector3) Abs() Vector3

Abs godot_vector3_abs [[const godot_vector3 * p_self]] godot_vector3

func (*Vector3) AngleTo 

func (gdt *Vector3) AngleTo(to Vector3) Real

AngleTo godot_vector3_angle_to [[const godot_vector3 * p_self] [const godot_vector3 * p_to]] godot_real

func (*Vector3) AsString 

func (gdt *Vector3) AsString() String

AsString godot_vector3_as_string [[const godot_vector3 * p_self]] godot_string

func (*Vector3) Bounce 

func (gdt *Vector3) Bounce(n Vector3) Vector3

Bounce godot_vector3_bounce [[const godot_vector3 * p_self] [const godot_vector3 * p_n]] godot_vector3

func (*Vector3) Ceil 

func (gdt *Vector3) Ceil() Vector3

Ceil godot_vector3_ceil [[const godot_vector3 * p_self]] godot_vector3

func (*Vector3) Cross 

func (gdt *Vector3) Cross(b Vector3) Vector3

Cross godot_vector3_cross [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_vector3

func (*Vector3) CubicInterpolate 

func (gdt *Vector3) CubicInterpolate(b Vector3, preA Vector3, postB Vector3, t Real) Vector3

CubicInterpolate godot_vector3_cubic_interpolate [[const godot_vector3 * p_self] [const godot_vector3 * p_b] [const godot_vector3 * p_pre_a] [const godot_vector3 * p_post_b] [const godot_real p_t]] godot_vector3

func (*Vector3) DistanceSquaredTo 

func (gdt *Vector3) DistanceSquaredTo(b Vector3) Real

DistanceSquaredTo godot_vector3_distance_squared_to [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_real

func (*Vector3) DistanceTo 

func (gdt *Vector3) DistanceTo(b Vector3) Real

DistanceTo godot_vector3_distance_to [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_real

func (*Vector3) Dot 

func (gdt *Vector3) Dot(b Vector3) Real

Dot godot_vector3_dot [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_real

func (*Vector3) Floor 

func (gdt *Vector3) Floor() Vector3

Floor godot_vector3_floor [[const godot_vector3 * p_self]] godot_vector3

func (*Vector3) GetAxis 

func (gdt *Vector3) GetAxis(axis Vector3Axis) Real

GetAxis godot_vector3_get_axis [[const godot_vector3 * p_self] [const godot_vector3_axis p_axis]] godot_real

func (*Vector3) Inverse 

func (gdt *Vector3) Inverse() Vector3

Inverse godot_vector3_inverse [[const godot_vector3 * p_self]] godot_vector3

func (*Vector3) IsNormalized 

func (gdt *Vector3) IsNormalized() Bool

IsNormalized godot_vector3_is_normalized [[const godot_vector3 * p_self]] godot_bool

func (*Vector3) Length 

func (gdt *Vector3) Length() Real

Length godot_vector3_length [[const godot_vector3 * p_self]] godot_real

func (*Vector3) LengthSquared 

func (gdt *Vector3) LengthSquared() Real

LengthSquared godot_vector3_length_squared [[const godot_vector3 * p_self]] godot_real

func (*Vector3) LinearInterpolate 

func (gdt *Vector3) LinearInterpolate(b Vector3, t Real) Vector3

LinearInterpolate godot_vector3_linear_interpolate [[const godot_vector3 * p_self] [const godot_vector3 * p_b] [const godot_real p_t]] godot_vector3

func (*Vector3) MaxAxis 

func (gdt *Vector3) MaxAxis() Int

MaxAxis godot_vector3_max_axis [[const godot_vector3 * p_self]] godot_int

func (*Vector3) MinAxis 

func (gdt *Vector3) MinAxis() Int

MinAxis godot_vector3_min_axis [[const godot_vector3 * p_self]] godot_int

func (*Vector3) Normalized 

func (gdt *Vector3) Normalized() Vector3

Normalized godot_vector3_normalized [[const godot_vector3 * p_self]] godot_vector3

func (*Vector3) OperatorAdd 

func (gdt *Vector3) OperatorAdd(b Vector3) Vector3

OperatorAdd godot_vector3_operator_add [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_vector3

func (*Vector3) OperatorDivideScalar 

func (gdt *Vector3) OperatorDivideScalar(b Real) Vector3

OperatorDivideScalar godot_vector3_operator_divide_scalar [[const godot_vector3 * p_self] [const godot_real p_b]] godot_vector3

func (*Vector3) OperatorDivideVector 

func (gdt *Vector3) OperatorDivideVector(b Vector3) Vector3

OperatorDivideVector godot_vector3_operator_divide_vector [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_vector3

func (*Vector3) OperatorEqual 

func (gdt *Vector3) OperatorEqual(b Vector3) Bool

OperatorEqual godot_vector3_operator_equal [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_bool

func (*Vector3) OperatorLess 

func (gdt *Vector3) OperatorLess(b Vector3) Bool

OperatorLess godot_vector3_operator_less [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_bool

func (*Vector3) OperatorMultiplyScalar 

func (gdt *Vector3) OperatorMultiplyScalar(b Real) Vector3

OperatorMultiplyScalar godot_vector3_operator_multiply_scalar [[const godot_vector3 * p_self] [const godot_real p_b]] godot_vector3

func (*Vector3) OperatorMultiplyVector 

func (gdt *Vector3) OperatorMultiplyVector(b Vector3) Vector3

OperatorMultiplyVector godot_vector3_operator_multiply_vector [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_vector3

func (*Vector3) OperatorNeg 

func (gdt *Vector3) OperatorNeg() Vector3

OperatorNeg godot_vector3_operator_neg [[const godot_vector3 * p_self]] godot_vector3

func (*Vector3) OperatorSubtract 

func (gdt *Vector3) OperatorSubtract(b Vector3) Vector3

OperatorSubtract godot_vector3_operator_subtract [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_vector3

func (*Vector3) Outer 

func (gdt *Vector3) Outer(b Vector3) Basis

Outer godot_vector3_outer [[const godot_vector3 * p_self] [const godot_vector3 * p_b]] godot_basis

func (*Vector3) Reflect 

func (gdt *Vector3) Reflect(n Vector3) Vector3

Reflect godot_vector3_reflect [[const godot_vector3 * p_self] [const godot_vector3 * p_n]] godot_vector3

func (*Vector3) Rotated 

func (gdt *Vector3) Rotated(axis Vector3, phi Real) Vector3

Rotated godot_vector3_rotated [[const godot_vector3 * p_self] [const godot_vector3 * p_axis] [const godot_real p_phi]] godot_vector3

func (*Vector3) SetAxis 

func (gdt *Vector3) SetAxis(axis Vector3Axis, val Real)

SetAxis godot_vector3_set_axis [[godot_vector3 * p_self] [const godot_vector3_axis p_axis] [const godot_real p_val]] void

func (*Vector3) Slide 

func (gdt *Vector3) Slide(n Vector3) Vector3

Slide godot_vector3_slide [[const godot_vector3 * p_self] [const godot_vector3 * p_n]] godot_vector3

func (*Vector3) Snapped 

func (gdt *Vector3) Snapped(by Vector3) Vector3

Snapped godot_vector3_snapped [[const godot_vector3 * p_self] [const godot_vector3 * p_by]] godot_vector3

func (*Vector3) ToDiagonalMatrix 

func (gdt *Vector3) ToDiagonalMatrix() Basis

ToDiagonalMatrix godot_vector3_to_diagonal_matrix [[const godot_vector3 * p_self]] godot_basis

type Vector3Axis 

type Vector3Axis int

Vector3Axis is a Go wrapper for the C.godot_vector3_axis enum type. 

const (
	Vector3AxisX Vector3Axis = 0
	Vector3AxisY Vector3Axis = 1
	Vector3AxisZ Vector3Axis = 2
)

type WcharT 

type WcharT string

WcharT is a Godot C wchar_t wrapper

func (WcharT) AsString 

func (w WcharT) AsString() String

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.