spritekit

package
v0.5.0 Latest Latest
Warning

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

 Go to latest Published: Jun 18, 2026 License: MIT Imports: 16 Imported by: 0

Documentation

Rendered for darwin/amd64

Overview

Package spritekit provides purego-based Go bindings for the macOS SpriteKit framework.

Apple documentation: https://developer.apple.com/documentation/spritekit

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func SKTextureAtlasPreloadTextureAtlasesNamedWithCompletionHandler 

func SKTextureAtlasPreloadTextureAtlasesNamedWithCompletionHandler(atlasNames *foundation.NSArray[*foundation.NSString], completionHandler func(unsafe.Pointer, *foundation.NSArray[*SKTextureAtlas]))

Start a texture atlas preload operation on an array of texture atlas identifiers, error == nil if all atlases were found, else an NSError is returned and the user info will contain a list of the atlases that couldn't be found the ones that could be found are looked up and prefetched. @param atlasNames is an array of the SKTextureAtlas, that were located and preloaded. @param completionHandler will be called upon the preload completion.

func SKTextureAtlasPreloadTextureAtlasesWithCompletionHandler 

func SKTextureAtlasPreloadTextureAtlasesWithCompletionHandler(textureAtlases *foundation.NSArray[*SKTextureAtlas], completionHandler func())

Start a texture atlas preload operation on an array of texture atlas @param textureAtlases an array of SKTextureAtlas to be preloaded @param completionHandler will be called upon the preload completion

func SKTexturePreloadTexturesWithCompletionHandler 

func SKTexturePreloadTexturesWithCompletionHandler(textures *foundation.NSArray[*SKTexture], completionHandler func())

Start a texture preload operation on an array of textures @param textures an array of SKTextures to be preloaded @param completionHandler will be called upon the preload completion

Types

type Acl_entry_id_t 

type Acl_entry_id_t int64
const (
	ACL_FIRST_ENTRY Acl_entry_id_t = 0
	ACL_NEXT_ENTRY  Acl_entry_id_t = -1
	ACL_LAST_ENTRY  Acl_entry_id_t = -2
)

func (Acl_entry_id_t) String 

func (e Acl_entry_id_t) String() string

type Acl_flag_t 

type Acl_flag_t int64
const (
	ACL_FLAG_DEFER_INHERIT      Acl_flag_t = 1
	ACL_FLAG_NO_INHERIT         Acl_flag_t = 131072
	ACL_ENTRY_INHERITED         Acl_flag_t = 16
	ACL_ENTRY_FILE_INHERIT      Acl_flag_t = 32
	ACL_ENTRY_DIRECTORY_INHERIT Acl_flag_t = 64
	ACL_ENTRY_LIMIT_INHERIT     Acl_flag_t = 128
	ACL_ENTRY_ONLY_INHERIT      Acl_flag_t = 256
)

func (Acl_flag_t) String 

func (e Acl_flag_t) String() string

type Acl_perm_t 

type Acl_perm_t int64
const (
	ACL_READ_DATA           Acl_perm_t = 2
	ACL_LIST_DIRECTORY      Acl_perm_t = 2
	ACL_WRITE_DATA          Acl_perm_t = 4
	ACL_ADD_FILE            Acl_perm_t = 4
	ACL_EXECUTE             Acl_perm_t = 8
	ACL_SEARCH              Acl_perm_t = 8
	ACL_DELETE              Acl_perm_t = 16
	ACL_APPEND_DATA         Acl_perm_t = 32
	ACL_ADD_SUBDIRECTORY    Acl_perm_t = 32
	ACL_DELETE_CHILD        Acl_perm_t = 64
	ACL_READ_ATTRIBUTES     Acl_perm_t = 128
	ACL_WRITE_ATTRIBUTES    Acl_perm_t = 256
	ACL_READ_EXTATTRIBUTES  Acl_perm_t = 512
	ACL_WRITE_EXTATTRIBUTES Acl_perm_t = 1024
	ACL_READ_SECURITY       Acl_perm_t = 2048
	ACL_WRITE_SECURITY      Acl_perm_t = 4096
	ACL_CHANGE_OWNER        Acl_perm_t = 8192
	ACL_SYNCHRONIZE         Acl_perm_t = 1048576
)

func (Acl_perm_t) String 

func (e Acl_perm_t) String() string

type Acl_tag_t 

type Acl_tag_t int64
const (
	ACL_UNDEFINED_TAG  Acl_tag_t = 0
	ACL_EXTENDED_ALLOW Acl_tag_t = 1
	ACL_EXTENDED_DENY  Acl_tag_t = 2
)

func (Acl_tag_t) String 

func (e Acl_tag_t) String() string

type Acl_type_t 

type Acl_type_t int64
const (
	ACL_TYPE_EXTENDED Acl_type_t = 256
	ACL_TYPE_ACCESS   Acl_type_t = 0
	ACL_TYPE_DEFAULT  Acl_type_t = 1
	ACL_TYPE_AFS      Acl_type_t = 2
	ACL_TYPE_CODA     Acl_type_t = 3
	ACL_TYPE_NTFS     Acl_type_t = 4
	ACL_TYPE_NWFS     Acl_type_t = 5
)

func (Acl_type_t) String 

func (e Acl_type_t) String() string

type CGLCPContextPriorityRequest 

type CGLCPContextPriorityRequest int64
const (
	KCGLCPContextPriorityRequestHigh   CGLCPContextPriorityRequest = 0
	KCGLCPContextPriorityRequestNormal CGLCPContextPriorityRequest = 1
	KCGLCPContextPriorityRequestLow    CGLCPContextPriorityRequest = 2
)

func (CGLCPContextPriorityRequest) String 

func (e CGLCPContextPriorityRequest) String() string

type Clockid_t 

type Clockid_t int64

func (Clockid_t) String 

func (e Clockid_t) String() string

type Dispatch_autorelease_frequency_t 

type Dispatch_autorelease_frequency_t uint64
const (
	DISPATCH_AUTORELEASE_FREQUENCY_INHERIT   Dispatch_autorelease_frequency_t = 0
	DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM Dispatch_autorelease_frequency_t = 1
	DISPATCH_AUTORELEASE_FREQUENCY_NEVER     Dispatch_autorelease_frequency_t = 2
)

func (Dispatch_autorelease_frequency_t) String 

func (e Dispatch_autorelease_frequency_t) String() string

type Dispatch_block_flags_t 

type Dispatch_block_flags_t uint64
const (
	DISPATCH_BLOCK_BARRIER           Dispatch_block_flags_t = 1
	DISPATCH_BLOCK_DETACHED          Dispatch_block_flags_t = 2
	DISPATCH_BLOCK_ASSIGN_CURRENT    Dispatch_block_flags_t = 4
	DISPATCH_BLOCK_NO_QOS_CLASS      Dispatch_block_flags_t = 8
	DISPATCH_BLOCK_INHERIT_QOS_CLASS Dispatch_block_flags_t = 16
	DISPATCH_BLOCK_ENFORCE_QOS_CLASS Dispatch_block_flags_t = 32
)

func (Dispatch_block_flags_t) String 

func (e Dispatch_block_flags_t) String() string

type EvCmd 

type EvCmd int64
const (
	EVNOP   EvCmd = 0
	EVHIDE  EvCmd = 1
	EVSHOW  EvCmd = 2
	EVMOVE  EvCmd = 3
	EVLEVEL EvCmd = 4
)

func (EvCmd) String 

func (e EvCmd) String() string

type Filesec_property_t 

type Filesec_property_t int64
const (
	FILESEC_OWNER         Filesec_property_t = 1
	FILESEC_GROUP         Filesec_property_t = 2
	FILESEC_UUID          Filesec_property_t = 3
	FILESEC_MODE          Filesec_property_t = 4
	FILESEC_ACL           Filesec_property_t = 5
	FILESEC_GRPUUID       Filesec_property_t = 6
	FILESEC_ACL_RAW       Filesec_property_t = 100
	FILESEC_ACL_ALLOCSIZE Filesec_property_t = 101
)

func (Filesec_property_t) String 

func (e Filesec_property_t) String() string

type Idtype_t 

type Idtype_t int64
const (
	P_ALL  Idtype_t = 0
	P_PID  Idtype_t = 1
	P_PGID Idtype_t = 2
)

func (Idtype_t) String 

func (e Idtype_t) String() string

type Ipc_info_object_type_t 

type Ipc_info_object_type_t int64
const (
	IPC_OTYPE_NONE                 Ipc_info_object_type_t = 0
	IPC_OTYPE_THREAD_CONTROL       Ipc_info_object_type_t = 1
	IPC_OTYPE_TASK_CONTROL         Ipc_info_object_type_t = 2
	IPC_OTYPE_HOST                 Ipc_info_object_type_t = 3
	IPC_OTYPE_HOST_PRIV            Ipc_info_object_type_t = 4
	IPC_OTYPE_PROCESSOR            Ipc_info_object_type_t = 5
	IPC_OTYPE_PROCESSOR_SET        Ipc_info_object_type_t = 6
	IPC_OTYPE_PROCESSOR_SET_NAME   Ipc_info_object_type_t = 7
	IPC_OTYPE_TIMER                Ipc_info_object_type_t = 8
	IPC_OTYPE_PORT_SUBST_ONCE      Ipc_info_object_type_t = 9
	IPC_OTYPE_MIG                  Ipc_info_object_type_t = 10
	IPC_OTYPE_MEMORY_OBJECT        Ipc_info_object_type_t = 11
	IPC_OTYPE_XMM_PAGER            Ipc_info_object_type_t = 12
	IPC_OTYPE_XMM_KERNEL           Ipc_info_object_type_t = 13
	IPC_OTYPE_XMM_REPLY            Ipc_info_object_type_t = 14
	IPC_OTYPE_UND_REPLY            Ipc_info_object_type_t = 15
	IPC_OTYPE_HOST_NOTIFY          Ipc_info_object_type_t = 16
	IPC_OTYPE_HOST_SECURITY        Ipc_info_object_type_t = 17
	IPC_OTYPE_LEDGER               Ipc_info_object_type_t = 18
	IPC_OTYPE_MAIN_DEVICE          Ipc_info_object_type_t = 19
	IPC_OTYPE_TASK_NAME            Ipc_info_object_type_t = 20
	IPC_OTYPE_SUBSYSTEM            Ipc_info_object_type_t = 21
	IPC_OTYPE_IO_DONE_QUEUE        Ipc_info_object_type_t = 22
	IPC_OTYPE_SEMAPHORE            Ipc_info_object_type_t = 23
	IPC_OTYPE_LOCK_SET             Ipc_info_object_type_t = 24
	IPC_OTYPE_CLOCK                Ipc_info_object_type_t = 25
	IPC_OTYPE_CLOCK_CTRL           Ipc_info_object_type_t = 26
	IPC_OTYPE_IOKIT_IDENT          Ipc_info_object_type_t = 27
	IPC_OTYPE_NAMED_ENTRY          Ipc_info_object_type_t = 28
	IPC_OTYPE_IOKIT_CONNECT        Ipc_info_object_type_t = 29
	IPC_OTYPE_IOKIT_OBJECT         Ipc_info_object_type_t = 30
	IPC_OTYPE_UPL                  Ipc_info_object_type_t = 31
	IPC_OTYPE_MEM_OBJ_CONTROL      Ipc_info_object_type_t = 32
	IPC_OTYPE_AU_SESSIONPORT       Ipc_info_object_type_t = 33
	IPC_OTYPE_FILEPORT             Ipc_info_object_type_t = 34
	IPC_OTYPE_LABELH               Ipc_info_object_type_t = 35
	IPC_OTYPE_TASK_RESUME          Ipc_info_object_type_t = 36
	IPC_OTYPE_VOUCHER              Ipc_info_object_type_t = 37
	IPC_OTYPE_VOUCHER_ATTR_CONTROL Ipc_info_object_type_t = 38
	IPC_OTYPE_WORK_INTERVAL        Ipc_info_object_type_t = 39
	IPC_OTYPE_UX_HANDLER           Ipc_info_object_type_t = 40
	IPC_OTYPE_UEXT_OBJECT          Ipc_info_object_type_t = 41
	IPC_OTYPE_ARCADE_REG           Ipc_info_object_type_t = 42
	IPC_OTYPE_EVENTLINK            Ipc_info_object_type_t = 43
	IPC_OTYPE_TASK_INSPECT         Ipc_info_object_type_t = 44
	IPC_OTYPE_TASK_READ            Ipc_info_object_type_t = 45
	IPC_OTYPE_THREAD_INSPECT       Ipc_info_object_type_t = 46
	IPC_OTYPE_THREAD_READ          Ipc_info_object_type_t = 47
	IPC_OTYPE_SUID_CRED            Ipc_info_object_type_t = 48
	IPC_OTYPE_HYPERVISOR           Ipc_info_object_type_t = 49
	IPC_OTYPE_TASK_ID_TOKEN        Ipc_info_object_type_t = 50
	IPC_OTYPE_TASK_FATAL           Ipc_info_object_type_t = 51
	IPC_OTYPE_KCDATA               Ipc_info_object_type_t = 52
	IPC_OTYPE_EXCLAVES_RESOURCE    Ipc_info_object_type_t = 53
	IPC_OTYPE_THREAD_RESUME        Ipc_info_object_type_t = 54
	IPC_OTYPE_UNKNOWN              Ipc_info_object_type_t = 4294967295
)

func (Ipc_info_object_type_t) String 

func (e Ipc_info_object_type_t) String() string

type Launch_data_type_t 

type Launch_data_type_t int64
const (
	LAUNCH_DATA_DICTIONARY Launch_data_type_t = 1
	LAUNCH_DATA_ARRAY      Launch_data_type_t = 2
	LAUNCH_DATA_FD         Launch_data_type_t = 3
	LAUNCH_DATA_INTEGER    Launch_data_type_t = 4
	LAUNCH_DATA_REAL       Launch_data_type_t = 5
	LAUNCH_DATA_BOOL       Launch_data_type_t = 6
	LAUNCH_DATA_STRING     Launch_data_type_t = 7
	LAUNCH_DATA_OPAQUE     Launch_data_type_t = 8
	LAUNCH_DATA_ERRNO      Launch_data_type_t = 9
	LAUNCH_DATA_MACHPORT   Launch_data_type_t = 10
)

func (Launch_data_type_t) String 

func (e Launch_data_type_t) String() string

type MDLabelDomain 

type MDLabelDomain int64

@typedef MDLabelDomain @abstract These constants are used to specify a domain to MDLabelCreate(). 

const (
	KMDLabelUserDomain  MDLabelDomain = 0
	KMDLabelLocalDomain MDLabelDomain = 1
)

func (MDLabelDomain) String 

func (e MDLabelDomain) String() string

type MDQueryOptionFlags 

type MDQueryOptionFlags int64
const (
	KMDQuerySynchronous        MDQueryOptionFlags = 1
	KMDQueryWantsUpdates       MDQueryOptionFlags = 4
	KMDQueryAllowFSTranslation MDQueryOptionFlags = 8
)

func (MDQueryOptionFlags) String 

func (e MDQueryOptionFlags) String() string

type MDQuerySortOptionFlags 

type MDQuerySortOptionFlags int64

@enum MDQuerySortOptionFlags @constant kMDQueryReverseSortOrderFlag Sort the attribute in reverse order. 

const (
	KMDQueryReverseSortOrderFlag MDQuerySortOptionFlags = 1
)

func (MDQuerySortOptionFlags) String 

func (e MDQuerySortOptionFlags) String() string

type Mach_vm_range_flags_t 

type Mach_vm_range_flags_t int64
const (
	MACH_VM_RANGE_NONE Mach_vm_range_flags_t = 0
)

func (Mach_vm_range_flags_t) String 

func (e Mach_vm_range_flags_t) String() string

type Mach_vm_range_flavor_t 

type Mach_vm_range_flavor_t int64
const (
	MACH_VM_RANGE_FLAVOR_INVALID Mach_vm_range_flavor_t = 0
	MACH_VM_RANGE_FLAVOR_V1      Mach_vm_range_flavor_t = 1
)

func (Mach_vm_range_flavor_t) String 

func (e Mach_vm_range_flavor_t) String() string

type Mach_vm_range_tag_t 

type Mach_vm_range_tag_t int64
const (
	MACH_VM_RANGE_DEFAULT Mach_vm_range_tag_t = 0
	MACH_VM_RANGE_DATA    Mach_vm_range_tag_t = 1
	MACH_VM_RANGE_FIXED   Mach_vm_range_tag_t = 2
)

func (Mach_vm_range_tag_t) String 

func (e Mach_vm_range_tag_t) String() string

type Mpo_flags_t 

type Mpo_flags_t int64
const (
	MPO_PORT                            Mpo_flags_t = 0
	MPO_SERVICE_PORT                    Mpo_flags_t = 1024
	MPO_CONNECTION_PORT                 Mpo_flags_t = 2048
	MPO_REPLY_PORT                      Mpo_flags_t = 4096
	MPO_WEAK_REPLY_PORT                 Mpo_flags_t = 16384
	MPO_NOTIFICATION_PORT               Mpo_flags_t = 17408
	MPO_EXCEPTION_PORT                  Mpo_flags_t = 32768
	MPO_CONNECTION_PORT_WITH_PORT_ARRAY Mpo_flags_t = 65536
)

func (Mpo_flags_t) String 

func (e Mpo_flags_t) String() string

type NXMouseButton 

type NXMouseButton int64
const (
	NX_OneButton   NXMouseButton = 0
	NX_LeftButton  NXMouseButton = 1
	NX_RightButton NXMouseButton = 2
)

func (NXMouseButton) String 

func (e NXMouseButton) String() string

type Os_clockid_t 

type Os_clockid_t int64
const (
	OS_CLOCK_MACH_ABSOLUTE_TIME Os_clockid_t = 32
)

func (Os_clockid_t) String 

func (e Os_clockid_t) String() string

type Os_unfair_lock_flags_t 

type Os_unfair_lock_flags_t int64
const (
	OS_UNFAIR_LOCK_FLAG_NONE          Os_unfair_lock_flags_t = 0
	OS_UNFAIR_LOCK_FLAG_ADAPTIVE_SPIN Os_unfair_lock_flags_t = 262144
)

func (Os_unfair_lock_flags_t) String 

func (e Os_unfair_lock_flags_t) String() string

type PMPageToPaperMappingType 

type PMPageToPaperMappingType int64
const (
	KPMPageToPaperMappingNone       PMPageToPaperMappingType = 1
	KPMPageToPaperMappingScaleToFit PMPageToPaperMappingType = 2
)

func (PMPageToPaperMappingType) String 

func (e PMPageToPaperMappingType) String() string

type Ptrauth_key 

type Ptrauth_key int64
const (
	Ptrauth_key_none                     Ptrauth_key = -1
	Ptrauth_key_asia                     Ptrauth_key = 0
	Ptrauth_key_asib                     Ptrauth_key = 1
	Ptrauth_key_asda                     Ptrauth_key = 2
	Ptrauth_key_asdb                     Ptrauth_key = 3
	Ptrauth_key_process_independent_code Ptrauth_key = 0
	Ptrauth_key_process_dependent_code   Ptrauth_key = 1
	Ptrauth_key_process_independent_data Ptrauth_key = 2
	Ptrauth_key_process_dependent_data   Ptrauth_key = 3
	Ptrauth_key_return_address           Ptrauth_key = 1
	Ptrauth_key_frame_pointer            Ptrauth_key = 3
	Ptrauth_key_function_pointer         Ptrauth_key = 0
	Ptrauth_key_block_function           Ptrauth_key = 0
	Ptrauth_key_cxx_vtable_pointer       Ptrauth_key = 2
	Ptrauth_key_method_list_pointer      Ptrauth_key = 2
	Ptrauth_key_objc_isa_pointer         Ptrauth_key = 2
	Ptrauth_key_objc_super_pointer       Ptrauth_key = 2
	Ptrauth_key_objc_sel_pointer         Ptrauth_key = 3
	Ptrauth_key_objc_class_ro_pointer    Ptrauth_key = 2
	Ptrauth_key_block_descriptor_pointer Ptrauth_key = 2
	Ptrauth_key_init_fini_pointer        Ptrauth_key = 0
)

func (Ptrauth_key) String 

func (e Ptrauth_key) String() string

type Qos_class_t 

type Qos_class_t uint32
const (
	QOS_CLASS_USER_INTERACTIVE Qos_class_t = 33
	QOS_CLASS_USER_INITIATED   Qos_class_t = 25
	QOS_CLASS_DEFAULT          Qos_class_t = 21
	QOS_CLASS_UTILITY          Qos_class_t = 17
	QOS_CLASS_BACKGROUND       Qos_class_t = 9
	QOS_CLASS_UNSPECIFIED      Qos_class_t = 0
)

func (Qos_class_t) String 

func (e Qos_class_t) String() string

type SK3DNode 

type SK3DNode struct {
	SKNode
}

Apple documentation: https://developer.apple.com/documentation/spritekit/sk3dnode

func SK3DNodeFromID 

func SK3DNodeFromID(id objc.ID) *SK3DNode

func SK3DNodeNodeWithViewportSize 

func SK3DNodeNodeWithViewportSize(viewportSize corefoundation.CGSize) *SK3DNode

Create a 3D Node with the viewport size the 3D content will be rendered with.

func (*SK3DNode) AutoenablesDefaultLighting 

func (o *SK3DNode) AutoenablesDefaultLighting() bool

@property autoenablesDefaultLighting @abstract Specifies whether the receiver should automatically light up scenes that have no light source. The default is NO. @discussion When enabled, a diffuse light is automatically added and placed while rendering scenes that have no light or only ambient lights.

func (*SK3DNode) HitTestOptions 

func (o *SK3DNode) HitTestOptions(point corefoundation.CGPoint, options *foundation.NSDictionary[*foundation.NSString, objc.ID]) *foundation.NSArray[*scenekit.SCNHitTestResult]

@method hitTest:options: @abstract Returns an array of SCNHitTestResult for each node that contains a specified point. @param point A point in the coordinate system of the receiver. @param options Optional parameters (see the "Hit test options" group for the available options).

func (*SK3DNode) InitWithCoder 

func (o *SK3DNode) InitWithCoder(aDecoder *foundation.NSCoder) *SK3DNode

Support coding and decoding via NSKeyedArchiver.

func (*SK3DNode) InitWithViewportSize 

func (o *SK3DNode) InitWithViewportSize(viewportSize corefoundation.CGSize) *SK3DNode

Designated initializer. Initialize a 3D Node with the viewport size the 3D content will be rendered with.

func (*SK3DNode) IsPlaying 

func (o *SK3DNode) IsPlaying() bool

@property playing @abstract Returns YES if the scene is playing, NO otherwise.

func (*SK3DNode) Loops 

func (o *SK3DNode) Loops() bool

@property loops @abstract Indicates whether the receiver restarts playback when it reaches the end of its content. Default: YES. @discussion YES when the receiver restarts playback when it finishes, NO otherwise.

func (*SK3DNode) PointOfView 

func (o *SK3DNode) PointOfView() *scenekit.SCNNode

@property pointOfView @abstract Specifies the point of view used to render the scene. @discussion A point of view must have either a camera or a spot light attached.

func (*SK3DNode) ProjectPoint 

func (o *SK3DNode) ProjectPoint(point unsafe.Pointer) unsafe.Pointer

@method projectPoint @abstract Projects a point in the world coordinate system using the receiver's current point of view and viewport. @param point The world position to be projected. @discussion A point projected from the near (resp. far) clip plane will have a z component of 0 (resp. 1).

func (*SK3DNode) SceneTime 

func (o *SK3DNode) SceneTime() float64

@property sceneTime @abstract Specifies the current time to display the scene.

func (*SK3DNode) ScnScene 

func (o *SK3DNode) ScnScene() *scenekit.SCNScene

A SceneKit scene

func (*SK3DNode) SetAutoenablesDefaultLighting 

func (o *SK3DNode) SetAutoenablesDefaultLighting(autoenablesDefaultLighting bool)

func (*SK3DNode) SetLoops 

func (o *SK3DNode) SetLoops(loops bool)

func (*SK3DNode) SetPlaying 

func (o *SK3DNode) SetPlaying(playing bool)

func (*SK3DNode) SetPointOfView 

func (o *SK3DNode) SetPointOfView(pointOfView *scenekit.SCNNode)

func (*SK3DNode) SetSceneTime 

func (o *SK3DNode) SetSceneTime(sceneTime float64)

func (*SK3DNode) SetScnScene 

func (o *SK3DNode) SetScnScene(scnScene *scenekit.SCNScene)

func (*SK3DNode) SetViewportSize 

func (o *SK3DNode) SetViewportSize(viewportSize corefoundation.CGSize)

func (*SK3DNode) UnprojectPoint 

func (o *SK3DNode) UnprojectPoint(point unsafe.Pointer) unsafe.Pointer

@method unprojectPoint @abstract Unprojects a screenspace 2D point with depth info using the receiver's current point of view and viewport. @param point The screenspace position to be unprojected. @discussion A point whose z component is 0 (resp. 1) is unprojected on the near (resp. far) clip plane.

func (*SK3DNode) ViewportSize 

func (o *SK3DNode) ViewportSize() corefoundation.CGSize

The viewport size that the 3D content will be rendered with

type SKAction 

type SKAction struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skaction

func SKActionActionNamed 

func SKActionActionNamed(name *foundation.NSString) *SKAction

Creates an action of the given name from an action file. @param name The name of the action

func SKActionActionNamedDuration 

func SKActionActionNamedDuration(name *foundation.NSString, duration float64) *SKAction

Creates an action of the given name from an action file with a new duration. @param name The name of the action @param duration The duration of the action

func SKActionActionNamedFromURL 

func SKActionActionNamedFromURL(name *foundation.NSString, url *foundation.NSURL) *SKAction

Creates an action of the given name from an action file. @param name The name of the action @param url The url of the file containing the action

func SKActionActionNamedFromURLDuration 

func SKActionActionNamedFromURLDuration(name *foundation.NSString, url *foundation.NSURL, duration float64) *SKAction

Creates an action of the given name from an action file with a new duration. @param name The name of the action @param url The url of the file containing the action @param duration The duration of the action

func SKActionAnimateWithNormalTexturesTimePerFrame 

func SKActionAnimateWithNormalTexturesTimePerFrame(textures *foundation.NSArray[*SKTexture], sec float64) *SKAction

func SKActionAnimateWithNormalTexturesTimePerFrameResizeRestore 

func SKActionAnimateWithNormalTexturesTimePerFrameResizeRestore(textures *foundation.NSArray[*SKTexture], sec float64, resize bool, restore bool) *SKAction

func SKActionAnimateWithTexturesTimePerFrame 

func SKActionAnimateWithTexturesTimePerFrame(textures *foundation.NSArray[*SKTexture], sec float64) *SKAction

Creates an action that animates changes to a sprite’s texture @param textures An array of textures to use when animating a sprite @param sec The amount of time that each texture is displayed

func SKActionAnimateWithTexturesTimePerFrameResizeRestore 

func SKActionAnimateWithTexturesTimePerFrameResizeRestore(textures *foundation.NSArray[*SKTexture], sec float64, resize bool, restore bool) *SKAction

Creates an action that animates changes to a sprite’s texture @param textures An array of textures to use when animating a sprite @param sec The amount of time that each texture is displayed @param resize If YES, the sprite is resized to match each new texture. If NO, the size of the sprite remains at a constant size. @param restore If YES, When the action completes, the sprite’s texture is restored to the texture it had before the action completed. (If the resize parameter is YES, the sprite is resized to match the size of the original texture. If NO, when the action completes the sprite’s texture remains set to the final texture in the array.

func SKActionAnimateWithWarpsTimes 

func SKActionAnimateWithWarpsTimes(warps *foundation.NSArray[*SKWarpGeometry], times *foundation.NSArray[*foundation.NSNumber]) *SKAction

func SKActionAnimateWithWarpsTimesRestore 

func SKActionAnimateWithWarpsTimesRestore(warps *foundation.NSArray[*SKWarpGeometry], times *foundation.NSArray[*foundation.NSNumber], restore bool) *SKAction

func SKActionApplyAngularImpulseDuration 

func SKActionApplyAngularImpulseDuration(impulse float64, duration float64) *SKAction

func SKActionApplyForceAtPointDuration 

func SKActionApplyForceAtPointDuration(force corefoundation.CGVector, point corefoundation.CGPoint, duration float64) *SKAction

func SKActionApplyForceDuration 

func SKActionApplyForceDuration(force corefoundation.CGVector, duration float64) *SKAction

func SKActionApplyImpulseAtPointDuration 

func SKActionApplyImpulseAtPointDuration(impulse corefoundation.CGVector, point corefoundation.CGPoint, duration float64) *SKAction

func SKActionApplyImpulseDuration 

func SKActionApplyImpulseDuration(impulse corefoundation.CGVector, duration float64) *SKAction

func SKActionApplyTorqueDuration 

func SKActionApplyTorqueDuration(torque float64, duration float64) *SKAction

func SKActionChangeChargeByDuration 

func SKActionChangeChargeByDuration(v float32, duration float64) *SKAction

func SKActionChangeChargeToDuration 

func SKActionChangeChargeToDuration(v float32, duration float64) *SKAction

func SKActionChangeMassByDuration 

func SKActionChangeMassByDuration(v float32, duration float64) *SKAction

func SKActionChangeMassToDuration 

func SKActionChangeMassToDuration(v float32, duration float64) *SKAction

func SKActionChangeObstructionByDuration 

func SKActionChangeObstructionByDuration(v float32, duration float64) *SKAction

func SKActionChangeObstructionToDuration 

func SKActionChangeObstructionToDuration(v float32, duration float64) *SKAction

func SKActionChangeOcclusionByDuration 

func SKActionChangeOcclusionByDuration(v float32, duration float64) *SKAction

func SKActionChangeOcclusionToDuration 

func SKActionChangeOcclusionToDuration(v float32, duration float64) *SKAction

func SKActionChangePlaybackRateByDuration 

func SKActionChangePlaybackRateByDuration(v float32, duration float64) *SKAction

func SKActionChangePlaybackRateToDuration 

func SKActionChangePlaybackRateToDuration(v float32, duration float64) *SKAction

func SKActionChangeReverbByDuration 

func SKActionChangeReverbByDuration(v float32, duration float64) *SKAction

func SKActionChangeReverbToDuration 

func SKActionChangeReverbToDuration(v float32, duration float64) *SKAction

func SKActionChangeVolumeByDuration 

func SKActionChangeVolumeByDuration(v float32, duration float64) *SKAction

func SKActionChangeVolumeToDuration 

func SKActionChangeVolumeToDuration(v float32, duration float64) *SKAction

func SKActionColorizeWithColorBlendFactorDuration 

func SKActionColorizeWithColorBlendFactorDuration(colorBlendFactor float64, sec float64) *SKAction

func SKActionColorizeWithColorColorBlendFactorDuration 

func SKActionColorizeWithColorColorBlendFactorDuration(color *appkit.NSColor, colorBlendFactor float64, duration float64) *SKAction

Creates an animation that animates a sprite’s color and blend factor @param color The new color for the sprite @param colorBlendFactor The new blend factor for the sprite @param duration The duration of the animation, in seconds

func SKActionCustomActionWithDurationActionBlock 

func SKActionCustomActionWithDurationActionBlock(duration float64, block func(*SKNode, float64)) *SKAction

Creates an action that executes a block over a duration @param duration The duration of the animation, in seconds @param block The block to run. The block takes the following parameters: node The node on which the action is running. elapsedTime The amount of time that has passed in the animation.

func SKActionFadeAlphaByDuration 

func SKActionFadeAlphaByDuration(factor float64, duration float64) *SKAction

Creates an action that adjusts the alpha value of a node by a relative value @param factor The amount to modify the node’s alpha value @param duration The duration of the animation, in seconds

func SKActionFadeAlphaToDuration 

func SKActionFadeAlphaToDuration(alpha float64, duration float64) *SKAction

Creates an action that adjusts the alpha value of a node to a new value @param alpha The new value of the node’s alpha @param duration The duration of the animation, in seconds

func SKActionFadeInWithDuration 

func SKActionFadeInWithDuration(duration float64) *SKAction

Creates an action that changes the alpha value of the node to 1.0 @param duration The duration of the animation, in seconds

func SKActionFadeOutWithDuration 

func SKActionFadeOutWithDuration(duration float64) *SKAction

Creates an action that changes the alpha value of the node to 0.0 @param duration The duration of the animation, in seconds

func SKActionFalloffByDuration 

func SKActionFalloffByDuration(falloff float32, duration float64) *SKAction

Creates an action that sets the falloff of a field @param falloff The value to modify falloff by @param duration The duration of the animation, in seconds @see SKFieldNode

func SKActionFalloffToDuration 

func SKActionFalloffToDuration(falloff float32, duration float64) *SKAction

Creates an action that sets the falloff of a field @param falloff The new value for falloff @param duration The duration of the animation, in seconds @see SKFieldNode

func SKActionFollowPathAsOffsetOrientToPathDuration 

func SKActionFollowPathAsOffsetOrientToPathDuration(path unsafe.Pointer, offset bool, orient bool, duration float64) *SKAction

Creates an action that moves the node along a path @param path A Core Graphics path whose coordinates are relative to the node’s current position @param offset If YES, the points in the path are relative offsets to the node’s starting position. If NO, the points in the node are absolute coordinate values. @param orient If YES, the node’s zRotation property animates so that the node turns to follow the path. If NO, the zRotation property of the node is unchanged. @param duration The duration of the animation

func SKActionFollowPathAsOffsetOrientToPathSpeed 

func SKActionFollowPathAsOffsetOrientToPathSpeed(path unsafe.Pointer, offset bool, orient bool, speed float64) *SKAction

func SKActionFollowPathDuration 

func SKActionFollowPathDuration(path unsafe.Pointer, duration float64) *SKAction

Creates an action that moves the node along a relative path, orienting the node to the path @param path A Core Graphics path whose coordinates are relative to the node’s current position @param duration The duration of the animation, in seconds

func SKActionFollowPathSpeed 

func SKActionFollowPathSpeed(path unsafe.Pointer, speed float64) *SKAction

Creates an action that moves the node along a relative path, orienting the node to the path @param path A Core Graphics path whose coordinates are relative to the node’s current position @param speed The speed in pixels per second to move along the path

func SKActionFromID 

func SKActionFromID(id objc.ID) *SKAction

func SKActionGroup 

func SKActionGroup(actions *foundation.NSArray[*SKAction]) *SKAction

Creates an action that runs a collection of actions concurrently @param actions An array of SKAction objects @discussion When the action executes, the actions that comprise the group all start immediately and run in parallel. The duration of the group action is the longest duration among the collection of actions. If an action in the group has a duration less than the group’s duration, the action completes, then idles until the group completes the remaining actions. This matters most when creating a repeating action that repeats a group.

func SKActionHide 

func SKActionHide() *SKAction

Creates an action that hides a node

func SKActionMoveByDuration 

func SKActionMoveByDuration(delta corefoundation.CGVector, duration float64) *SKAction

Creates an action that moves a node relative to its current position @param delta A vector that describes the change to apply to the node’s position @param duration The duration of the animation, in seconds

func SKActionMoveByXYDuration 

func SKActionMoveByXYDuration(deltaX float64, deltaY float64, duration float64) *SKAction

func SKActionMoveToDuration 

func SKActionMoveToDuration(location corefoundation.CGPoint, duration float64) *SKAction

Creates an action that moves a node to a new position @param location The coordinates for the node’s new position @param duration The duration of the animation, in seconds

func SKActionMoveToXDuration 

func SKActionMoveToXDuration(x float64, duration float64) *SKAction

func SKActionMoveToYDuration 

func SKActionMoveToYDuration(y float64, duration float64) *SKAction

func SKActionPause 

func SKActionPause() *SKAction

func SKActionPerformSelectorOnTarget 

func SKActionPerformSelectorOnTarget(selector objc.SEL, target objc.ID) *SKAction

Creates an action that calls a method on an object @param selector The selector of the method to call @param target The target object

func SKActionPlay 

func SKActionPlay() *SKAction

func SKActionPlaySoundFileNamedWaitForCompletion 

func SKActionPlaySoundFileNamedWaitForCompletion(soundFile *foundation.NSString, wait bool) *SKAction

Creates an action that plays a sound @param soundFile The name of a sound file in the app’s bundle @param wait If YES, then the duration of this action is the same as the length of the audio playback. If NO, the action is considered to have completed immediately. @discussion The file name must be the name or path of a file of a platform supported audio file format. Use a LinearPCM format audio file with 8 or 16 bits per channel for best performance

func SKActionReachToNodeRootNodeDuration 

func SKActionReachToNodeRootNodeDuration(node *SKNode, root *SKNode, sec float64) *SKAction

Creates an action that performs an inverse kinematic reach. This action must be run on a descendent of the rootNode for animation to occur. Running this action on the rootNode itself will not cause any animation to occur. @param node The node to reach for @param root Where to start the inverse kinematic operation from @param sec The duration of the animation, in seconds

func SKActionReachToNodeRootNodeVelocity 

func SKActionReachToNodeRootNodeVelocity(node *SKNode, root *SKNode, velocity float64) *SKAction

Creates an action that performs an inverse kinematic reach. This action must be run on a descendent of the rootNode for animation to occur. Running this action on the rootNode itself will not cause any animation to occur. @param node The node to reach for @param root Where to start the inverse kinematic operation from @param velocity The speed in points per second of the end node in the chain

func SKActionReachToRootNodeDuration 

func SKActionReachToRootNodeDuration(position corefoundation.CGPoint, root *SKNode, duration float64) *SKAction

Creates an action that performs an inverse kinematic reach. This action must be run on a descendent of the rootNode for animation to occur. Running this action on the rootNode itself will not cause any animation to occur. @param position The position (in screen space) to reach for @param root Where to start the inverse kinematic operation from @param duration The duration of the animation, in seconds

func SKActionReachToRootNodeVelocity 

func SKActionReachToRootNodeVelocity(position corefoundation.CGPoint, root *SKNode, velocity float64) *SKAction

Creates an action that performs an inverse kinematic reach. This action must be run on a descendent of the rootNode for animation to occur. Running this action on the rootNode itself will not cause any animation to occur. @param position The position (in screen space) to reach for @param root Where to start the inverse kinematic operation from @param velocity The speed in points per second of the end node in the chain

func SKActionRemoveFromParent 

func SKActionRemoveFromParent() *SKAction

Creates an action that removes the node from its parent

func SKActionRepeatActionCount 

func SKActionRepeatActionCount(action *SKAction, count uint) *SKAction

Creates an action that repeats another action a specified number of times @param action The action to execute @param count The number of times to execute the action

func SKActionRepeatActionForever 

func SKActionRepeatActionForever(action *SKAction) *SKAction

Creates an action that repeats forever @param action The action to execute

func SKActionResizeByWidthHeightDuration 

func SKActionResizeByWidthHeightDuration(width float64, height float64, duration float64) *SKAction

Creates an action that adjusts the size of a sprite @param width The amount to add to the sprite’s width @param height The amount to add to the sprite’s height @param duration The duration of the animation, in seconds

func SKActionResizeToHeightDuration 

func SKActionResizeToHeightDuration(height float64, duration float64) *SKAction

func SKActionResizeToWidthDuration 

func SKActionResizeToWidthDuration(width float64, duration float64) *SKAction

func SKActionResizeToWidthHeightDuration 

func SKActionResizeToWidthHeightDuration(width float64, height float64, duration float64) *SKAction

Creates an action that changes the width and height of a sprite to a new absolute value @param width The new width of the sprite @param height The new height of the sprite @param duration The duration of the animation, in seconds

func SKActionRotateByAngleDuration 

func SKActionRotateByAngleDuration(radians float64, duration float64) *SKAction

Creates an action that rotates the node by a relative value @param radians The amount to rotate the node, in radians @param duration The duration of the animation, in seconds

func SKActionRotateToAngleDuration 

func SKActionRotateToAngleDuration(radians float64, duration float64) *SKAction

Creates an action that rotates the node counterclockwise to an absolute angle @param radians The angle to rotate the node to, in radians @param duration The duration of the animation

func SKActionRotateToAngleDurationShortestUnitArc 

func SKActionRotateToAngleDurationShortestUnitArc(radians float64, duration float64, shortestUnitArc bool) *SKAction

Creates an action that rotates the node to an absolute value @param radians The angle to rotate the node to, in radians @param duration The duration of the animation, in seconds @param shortestUnitArc If YES, then the rotation is performed in whichever direction results in the smallest rotation. If NO, then the rotation is interpolated

func SKActionRunActionOnChildWithName 

func SKActionRunActionOnChildWithName(action *SKAction, name *foundation.NSString) *SKAction

Creates an action that runs an action on a named child object @param action the action to run @param name the name of a child object @see SKNode.name

func SKActionRunBlock 

func SKActionRunBlock(block func()) *SKAction

Creates an action that executes a block @param block The block to run

func SKActionRunBlockQueue 

func SKActionRunBlockQueue(block func(), queue *foundation.NSObject) *SKAction

Creates an action that executes a block @param block The block to run @param queue The queue to perform the action on

func SKActionScaleByDuration 

func SKActionScaleByDuration(scale float64, duration float64) *SKAction

Creates an action that changes the x and y scale values of a node by a relative value @param scale The amount to modify to the node’s x and y scale values @param duration The duration of the animation, in seconds

func SKActionScaleToDuration 

func SKActionScaleToDuration(scale float64, duration float64) *SKAction

Creates an action that changes the x and y scale values of a node by a relative value @param scale The new value for the node’s x and y scale values @param duration The duration of the animation, in seconds

func SKActionScaleToSizeDuration 

func SKActionScaleToSizeDuration(size corefoundation.CGSize, duration float64) *SKAction

Adjust the sprite's xScale & yScale to achieve the desired size (in parent's coordinate space) @param duration The duration of the animation, in seconds

func SKActionScaleXByYDuration 

func SKActionScaleXByYDuration(xScale float64, yScale float64, duration float64) *SKAction

func SKActionScaleXToDuration 

func SKActionScaleXToDuration(scale float64, duration float64) *SKAction

func SKActionScaleXToYDuration 

func SKActionScaleXToYDuration(xScale float64, yScale float64, duration float64) *SKAction

func SKActionScaleYToDuration 

func SKActionScaleYToDuration(scale float64, duration float64) *SKAction

func SKActionSequence 

func SKActionSequence(actions *foundation.NSArray[*SKAction]) *SKAction

Creates an action that runs a collection of actions sequentially @param actions An array of SKAction objects @discussion When the action executes, the first action in the sequence starts and runs to completion. Subsequent actions in the sequence run in a similar fashion until all of the actions in the sequence have executed. The duration of the sequence action is the sum of the durations of the actions in the sequence. This action is reversible; it creates a new sequence action that reverses the order of the actions. Each action in the reversed sequence is itself reversed. For example, if an action sequence is {1,2,3}, the reversed sequence would be {3R,2R,1R}.

func SKActionSetNormalTexture 

func SKActionSetNormalTexture(texture *SKTexture) *SKAction

func SKActionSetNormalTextureResize 

func SKActionSetNormalTextureResize(texture *SKTexture, resize bool) *SKAction

func SKActionSetTexture 

func SKActionSetTexture(texture *SKTexture) *SKAction

Creates an action that changes a sprite’s texture @param texture The new texture to use on the sprite

func SKActionSetTextureResize 

func SKActionSetTextureResize(texture *SKTexture, resize bool) *SKAction

Creates an action that changes a sprite’s texture, possibly resizing the sprite @param texture The new texture to use on the sprite @param resize If YES, the sprite is resized to match the new texture. If NO, the size of the sprite is unchanged.

func SKActionSpeedByDuration 

func SKActionSpeedByDuration(speed float64, duration float64) *SKAction

Creates an action that changes how fast the node executes actions by a relative value @param speed amount to modify the speed by @param duration The duration of the animation, in seconds

func SKActionSpeedToDuration 

func SKActionSpeedToDuration(speed float64, duration float64) *SKAction

Creates an action that changes how fast the node executes actions @param speed The new value for the node’s speed @param duration The duration of the animation, in seconds

func SKActionStereoPanByDuration 

func SKActionStereoPanByDuration(v float32, duration float64) *SKAction

func SKActionStereoPanToDuration 

func SKActionStereoPanToDuration(v float32, duration float64) *SKAction

func SKActionStop 

func SKActionStop() *SKAction

func SKActionStrengthByDuration 

func SKActionStrengthByDuration(strength float32, duration float64) *SKAction

Creates an action that sets the strength of a field @param strength The value to modify strength by @param duration The duration of the animation, in seconds @see SKFieldNode

func SKActionStrengthToDuration 

func SKActionStrengthToDuration(strength float32, duration float64) *SKAction

Creates an action that sets the strength of a field @param strength The new value for strength @param duration The duration of the animation, in seconds @see SKFieldNode

func SKActionUnhide 

func SKActionUnhide() *SKAction

Creates an action that unhides a node

func SKActionWaitForDuration 

func SKActionWaitForDuration(duration float64) *SKAction

Creates an action that idles for a specified period of time @param duration The duration of the idle, in seconds

func SKActionWaitForDurationWithRange 

func SKActionWaitForDurationWithRange(duration float64, durationRange float64) *SKAction

Creates an action that idles for a randomized period of time @param duration The duration of the idle, in seconds @param durationRange The range of possible values for the duration

func SKActionWarpToDuration 

func SKActionWarpToDuration(warp *SKWarpGeometry, duration float64) *SKAction

func (*SKAction) Duration 

func (o *SKAction) Duration() float64

The duration required to complete an action, in seconds.

func (*SKAction) ReversedAction 

func (o *SKAction) ReversedAction() *SKAction

Creates an action that reverses the behavior of another action @return This method always returns an action object; however, not all actions are reversible

func (*SKAction) SetDuration 

func (o *SKAction) SetDuration(duration float64)

func (*SKAction) SetSpeed 

func (o *SKAction) SetSpeed(speed float64)

func (*SKAction) SetTimingFunction 

func (o *SKAction) SetTimingFunction(timingFunction objc.Block)

func (*SKAction) SetTimingMode 

func (o *SKAction) SetTimingMode(timingMode SKActionTimingMode)

func (*SKAction) Speed 

func (o *SKAction) Speed() float64

A speed factor that modifies how fast an action runs. Default value is 1.0

func (*SKAction) TimingFunction 

func (o *SKAction) TimingFunction() objc.Block

When set, prodives a custom timing via a block. Applies after the 'timingMode' property is taken into account, defaults to nil @see SKActionTimingFunction

func (*SKAction) TimingMode 

func (o *SKAction) TimingMode() SKActionTimingMode

The timing mode used to execute an action @see SKActionTimingMode

type SKActionTimingMode 

type SKActionTimingMode int64
const (
	SKActionTimingLinear        SKActionTimingMode = 0
	SKActionTimingEaseIn        SKActionTimingMode = 1
	SKActionTimingEaseOut       SKActionTimingMode = 2
	SKActionTimingEaseInEaseOut SKActionTimingMode = 3
)

func (SKActionTimingMode) String 

func (e SKActionTimingMode) String() string

type SKAttribute 

type SKAttribute struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skattribute

func SKAttributeAttributeWithNameType 

func SKAttributeAttributeWithNameType(name *foundation.NSString, type_ SKAttributeType) *SKAttribute

func SKAttributeFromID 

func SKAttributeFromID(id objc.ID) *SKAttribute

func (*SKAttribute) InitWithNameType 

func (o *SKAttribute) InitWithNameType(name *foundation.NSString, type_ SKAttributeType) *SKAttribute

func (*SKAttribute) Name 

func (o *SKAttribute) Name() *foundation.NSString

func (*SKAttribute) Type 

func (o *SKAttribute) Type() SKAttributeType

type SKAttributeType 

type SKAttributeType int64
const (
	SKAttributeTypeNone             SKAttributeType = 0
	SKAttributeTypeFloat            SKAttributeType = 1
	SKAttributeTypeVectorFloat2     SKAttributeType = 2
	SKAttributeTypeVectorFloat3     SKAttributeType = 3
	SKAttributeTypeVectorFloat4     SKAttributeType = 4
	SKAttributeTypeHalfFloat        SKAttributeType = 5
	SKAttributeTypeVectorHalfFloat2 SKAttributeType = 6
	SKAttributeTypeVectorHalfFloat3 SKAttributeType = 7
	SKAttributeTypeVectorHalfFloat4 SKAttributeType = 8
)

func (SKAttributeType) String 

func (e SKAttributeType) String() string

type SKAttributeValue 

type SKAttributeValue struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skattributevalue

func SKAttributeValueFromID 

func SKAttributeValueFromID(id objc.ID) *SKAttributeValue

func SKAttributeValueValueWithFloat 

func SKAttributeValueValueWithFloat(value float32) *SKAttributeValue

func SKAttributeValueValueWithVectorFloat2 

func SKAttributeValueValueWithVectorFloat2(value unsafe.Pointer) *SKAttributeValue

func SKAttributeValueValueWithVectorFloat3 

func SKAttributeValueValueWithVectorFloat3(value unsafe.Pointer) *SKAttributeValue

func SKAttributeValueValueWithVectorFloat4 

func SKAttributeValueValueWithVectorFloat4(value unsafe.Pointer) *SKAttributeValue

func (*SKAttributeValue) FloatValue 

func (o *SKAttributeValue) FloatValue() float32

func (*SKAttributeValue) Init 

func (o *SKAttributeValue) Init() *SKAttributeValue

func (*SKAttributeValue) SetFloatValue 

func (o *SKAttributeValue) SetFloatValue(floatValue float32)

func (*SKAttributeValue) SetVectorFloat2Value 

func (o *SKAttributeValue) SetVectorFloat2Value(vectorFloat2Value unsafe.Pointer)

func (*SKAttributeValue) SetVectorFloat3Value 

func (o *SKAttributeValue) SetVectorFloat3Value(vectorFloat3Value unsafe.Pointer)

func (*SKAttributeValue) SetVectorFloat4Value 

func (o *SKAttributeValue) SetVectorFloat4Value(vectorFloat4Value unsafe.Pointer)

func (*SKAttributeValue) VectorFloat2Value 

func (o *SKAttributeValue) VectorFloat2Value() unsafe.Pointer

func (*SKAttributeValue) VectorFloat3Value 

func (o *SKAttributeValue) VectorFloat3Value() unsafe.Pointer

func (*SKAttributeValue) VectorFloat4Value 

func (o *SKAttributeValue) VectorFloat4Value() unsafe.Pointer

type SKAudioNode 

type SKAudioNode struct {
	SKNode
}

A SpriteKit scene graph audio node that provides a way to link audio graphs to a SpriteKit scene. The currently presented scene is responsible for mixing the audio from nodes in the scene. Positional sounds will use their relative location and velocity to the scene's listener to apply distance attenuation, doppler shift and pan. @see AVAudio3DMixing @see SKScene.listener

Apple documentation: https://developer.apple.com/documentation/spritekit/skaudionode

func SKAudioNodeFromID 

func SKAudioNodeFromID(id objc.ID) *SKAudioNode

func (*SKAudioNode) AutoplayLooped 

func (o *SKAudioNode) AutoplayLooped() bool

Specifies whether the node is to automatically play sound when added to a scene. If autoplaysLooped is NO, the node and its sound must be explicitly scheduled and played using the scene's engine. If YES, the node will automatically play sound when added to a scene. Defaults to YES. @see SKView.paused

func (*SKAudioNode) AvAudioNode 

func (o *SKAudioNode) AvAudioNode() *avfaudio.AVAudioNode

Sets or gets the current AVAudioNode used by this instance.

func (*SKAudioNode) InitWithAVAudioNode 

func (o *SKAudioNode) InitWithAVAudioNode(node *avfaudio.AVAudioNode) *SKAudioNode

Creates a SpriteKit scene graph audio node from the given AVAudioNode. @see AVAudioNode

func (*SKAudioNode) InitWithCoder 

func (o *SKAudioNode) InitWithCoder(aDecoder *foundation.NSCoder) *SKAudioNode

func (*SKAudioNode) InitWithFileNamed 

func (o *SKAudioNode) InitWithFileNamed(name *foundation.NSString) *SKAudioNode

Convenience initializer that creates an AVAudioNode from the named audio asset in the main bundle. @see initWithAVAudioNode

func (*SKAudioNode) InitWithURL 

func (o *SKAudioNode) InitWithURL(url *foundation.NSURL) *SKAudioNode

Convenience initializer that creates an AVAudioNode from the URL that contain a audio asset. @see initWithAVAudioNode

func (*SKAudioNode) IsPositional 

func (o *SKAudioNode) IsPositional() bool

Marks the audio source as positional so that the audio mix considers relative position and velocity with regards to the scene's current listener node. @see AVAudio3DMixing @see SKScene.listener

func (*SKAudioNode) SetAutoplayLooped 

func (o *SKAudioNode) SetAutoplayLooped(autoplayLooped bool)

func (*SKAudioNode) SetAvAudioNode 

func (o *SKAudioNode) SetAvAudioNode(avAudioNode *avfaudio.AVAudioNode)

func (*SKAudioNode) SetPositional 

func (o *SKAudioNode) SetPositional(positional bool)

type SKBlendMode 

type SKBlendMode int64
const (
	SKBlendModeAlpha         SKBlendMode = 0
	SKBlendModeAdd           SKBlendMode = 1
	SKBlendModeSubtract      SKBlendMode = 2
	SKBlendModeMultiply      SKBlendMode = 3
	SKBlendModeMultiplyX2    SKBlendMode = 4
	SKBlendModeScreen        SKBlendMode = 5
	SKBlendModeReplace       SKBlendMode = 6
	SKBlendModeMultiplyAlpha SKBlendMode = 7
)

func (SKBlendMode) String 

func (e SKBlendMode) String() string

type SKCameraNode 

type SKCameraNode struct {
	SKNode
}

A Camera node is a full fledged SKNode that can have actions and physics applied to it. It also uses the standard SKNode transform system so modifying the camera node's position is how you translate the camera's viewport. Applying a scale to the node would zoom the viewport in or out etc. As an added benefit you can now rotate the viewport by applying a zRotation to the camera node, just as you would with any other SKNode. The camera viewport is centered on the camera's position. It uses the scene's frame and scale mode along with the node transforms to determine the size, origin and rotation of the viewport. There are some convenience functions included for testing if nodes are contained within the camera viewport. It can be used to determine if objects are no longer visible on the display. In order to use a camera; set it on the scene that contains the camera. @see SKScene.camera

Apple documentation: https://developer.apple.com/documentation/spritekit/skcameranode

func SKCameraNodeFromID 

func SKCameraNodeFromID(id objc.ID) *SKCameraNode

func (*SKCameraNode) ContainedNodeSet 

func (o *SKCameraNode) ContainedNodeSet() *foundation.NSSet[*SKNode]

Returns the set of nodes in the same scene as the camera that are contained within its viewport. @return the set of nodes contained

func (*SKCameraNode) ContainsNode 

func (o *SKCameraNode) ContainsNode(node *SKNode) bool

Checks if the node is contained inside the viewport of the camera. The camera and node must both be in the same scene and presented on a view in order to determine if the node is inside the camera viewport rectangle. @return YES if the node is inside the viewport. NO if node is nil or the node is outside the viewport.

type SKConstraint 

type SKConstraint struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skconstraint

func SKConstraintDistanceToNode 

func SKConstraintDistanceToNode(range_ *SKRange, node *SKNode) *SKConstraint

Constrain the node's position to be within a distance of a point or node

func SKConstraintDistanceToPoint 

func SKConstraintDistanceToPoint(range_ *SKRange, point corefoundation.CGPoint) *SKConstraint

func SKConstraintDistanceToPointInNode 

func SKConstraintDistanceToPointInNode(range_ *SKRange, point corefoundation.CGPoint, node *SKNode) *SKConstraint

func SKConstraintFromID 

func SKConstraintFromID(id objc.ID) *SKConstraint

func SKConstraintOrientToNodeOffset 

func SKConstraintOrientToNodeOffset(node *SKNode, radians *SKRange) *SKConstraint

Constrain the node's rotation to orient to a point or node

func SKConstraintOrientToPointInNodeOffset 

func SKConstraintOrientToPointInNodeOffset(point corefoundation.CGPoint, node *SKNode, radians *SKRange) *SKConstraint

func SKConstraintOrientToPointOffset 

func SKConstraintOrientToPointOffset(point corefoundation.CGPoint, radians *SKRange) *SKConstraint

func SKConstraintPositionX 

func SKConstraintPositionX(range_ *SKRange) *SKConstraint

Constrain the node's position to a range

func SKConstraintPositionXY 

func SKConstraintPositionXY(xRange *SKRange, yRange *SKRange) *SKConstraint

func SKConstraintPositionY 

func SKConstraintPositionY(range_ *SKRange) *SKConstraint

func SKConstraintZRotation 

func SKConstraintZRotation(zRange *SKRange) *SKConstraint

Constrain the node's rotation to a range

func (*SKConstraint) Enabled 

func (o *SKConstraint) Enabled() bool

func (*SKConstraint) ReferenceNode 

func (o *SKConstraint) ReferenceNode() *SKNode

func (*SKConstraint) SetEnabled 

func (o *SKConstraint) SetEnabled(enabled bool)

func (*SKConstraint) SetReferenceNode 

func (o *SKConstraint) SetReferenceNode(referenceNode *SKNode)

type SKCropNode 

type SKCropNode struct {
	SKNode
}

A SpriteKit node that masks child nodes using another node's alpha component

Apple documentation: https://developer.apple.com/documentation/spritekit/skcropnode

func SKCropNodeFromID 

func SKCropNodeFromID(id objc.ID) *SKCropNode

func (*SKCropNode) MaskNode 

func (o *SKCropNode) MaskNode() *SKNode

func (*SKCropNode) SetMaskNode 

func (o *SKCropNode) SetMaskNode(maskNode *SKNode)

type SKEffectNode 

type SKEffectNode struct {
	SKNode
}

A SpriteKit node that applies frame buffer effects to the rendered results of its child nodes. This is done continuously on live content and is not a simple snapshot of the rendered result at one instant of time.

Apple documentation: https://developer.apple.com/documentation/spritekit/skeffectnode

func SKEffectNodeFromID 

func SKEffectNodeFromID(id objc.ID) *SKEffectNode

func (*SKEffectNode) BlendMode 

func (o *SKEffectNode) BlendMode() SKBlendMode

Sets the blend mode to use when composing the effect with the final framebuffer. @see SKNode.SKBlendMode

func (*SKEffectNode) Filter 

func (o *SKEffectNode) Filter() *coreimage.CIFilter

A CIFilter to be used as an effect Any CIFilter that requires only a single "inputImage" and produces an "outputImage" is allowed. The filter is applied to all children of the SKEffectNode. If the filter is nil, the children of this node is flattened before being drawn as long as the SKEffectNode is enabled.

func (*SKEffectNode) SetBlendMode 

func (o *SKEffectNode) SetBlendMode(blendMode SKBlendMode)

func (*SKEffectNode) SetFilter 

func (o *SKEffectNode) SetFilter(filter *coreimage.CIFilter)

func (*SKEffectNode) SetShader 

func (o *SKEffectNode) SetShader(shader *SKShader)

func (*SKEffectNode) SetShouldCenterFilter 

func (o *SKEffectNode) SetShouldCenterFilter(shouldCenterFilter bool)

func (*SKEffectNode) SetShouldEnableEffects 

func (o *SKEffectNode) SetShouldEnableEffects(shouldEnableEffects bool)

func (*SKEffectNode) SetShouldRasterize 

func (o *SKEffectNode) SetShouldRasterize(shouldRasterize bool)

func (*SKEffectNode) Shader 

func (o *SKEffectNode) Shader() *SKShader

func (*SKEffectNode) ShouldCenterFilter 

func (o *SKEffectNode) ShouldCenterFilter() bool

func (*SKEffectNode) ShouldEnableEffects 

func (o *SKEffectNode) ShouldEnableEffects() bool

Enable the SKEffectNode. The SKEffectNode has no effect when appliesEffects is not enabled, this is useful for setting up an effect to use later on. Defaults to YES.

func (*SKEffectNode) ShouldRasterize 

func (o *SKEffectNode) ShouldRasterize() bool

Enable the rasterization on the SKEffectNode. The SKEffectNode's output is rasterized and cached internally. This cache is reused when rendering. When the SKEffectNode's children change, the cache is updated, but changing properties on the CIFilter does *not* cause an update (you must disable rasterization and then re-enable it for the changes to apply). This is more expensive than not rasterizing if the node's children change frequently, only enable this option if you know the children is largely static.

type SKEmitterNode 

type SKEmitterNode struct {
	SKNode
}

An emitter of particle sprites.

Apple documentation: https://developer.apple.com/documentation/spritekit/skemitternode

func SKEmitterNodeFromID 

func SKEmitterNodeFromID(id objc.ID) *SKEmitterNode

func (*SKEmitterNode) AdvanceSimulationTime 

func (o *SKEmitterNode) AdvanceSimulationTime(sec float64)

func (*SKEmitterNode) EmissionAngle 

func (o *SKEmitterNode) EmissionAngle() float64

The angle at which to emit each new particle, in radians. Defaults to 0.0.

func (*SKEmitterNode) EmissionAngleRange 

func (o *SKEmitterNode) EmissionAngleRange() float64

The random variance about the angle at which to emit each new particle, in radians. Defaults to 0.0.

func (*SKEmitterNode) FieldBitMask 

func (o *SKEmitterNode) FieldBitMask() uint32

Defines what logical 'categories' of fields this particles emitted respond to. Defaults to all bits set (all categories). Can be forced off via affectedByGravity.

func (*SKEmitterNode) NumParticlesToEmit 

func (o *SKEmitterNode) NumParticlesToEmit() uint

The number of particles that will be emitted. If set to 0, there is no limit. Defaults to 0.

func (*SKEmitterNode) ParticleAction 

func (o *SKEmitterNode) ParticleAction() *SKAction

Specifies an action executed by new particles.

func (*SKEmitterNode) ParticleAlpha 

func (o *SKEmitterNode) ParticleAlpha() float64

The starting alpha for each particle. Defaults to 1.0.

func (*SKEmitterNode) ParticleAlphaRange 

func (o *SKEmitterNode) ParticleAlphaRange() float64

The random variance about the starting alpha for each particle. Defaults to 1.0.

func (*SKEmitterNode) ParticleAlphaSequence 

func (o *SKEmitterNode) ParticleAlphaSequence() *SKKeyframeSequence

func (*SKEmitterNode) ParticleAlphaSpeed 

func (o *SKEmitterNode) ParticleAlphaSpeed() float64

The rate at which to modify the alpha for each particle. Defaults to 1.0.

func (*SKEmitterNode) ParticleBirthRate 

func (o *SKEmitterNode) ParticleBirthRate() float64

The rate at which new particles are generated, in particles per second. Defaults to 0.0.

func (*SKEmitterNode) ParticleBlendMode 

func (o *SKEmitterNode) ParticleBlendMode() SKBlendMode

The blend mode for each particle. Defaults to SKBlendModeAlpha.

func (*SKEmitterNode) ParticleColor 

func (o *SKEmitterNode) ParticleColor() *appkit.NSColor

The starting color for each particle. Defaults to clear.

func (*SKEmitterNode) ParticleColorAlphaRange 

func (o *SKEmitterNode) ParticleColorAlphaRange() float64

func (*SKEmitterNode) ParticleColorAlphaSpeed 

func (o *SKEmitterNode) ParticleColorAlphaSpeed() float64

func (*SKEmitterNode) ParticleColorBlendFactor 

func (o *SKEmitterNode) ParticleColorBlendFactor() float64

The starting color blend for each particle. Behaves the same as SKSpriteNode. Defaults to 0.0.

func (*SKEmitterNode) ParticleColorBlendFactorRange 

func (o *SKEmitterNode) ParticleColorBlendFactorRange() float64

The random variance about the starting color blend for each particle. Defaults to 0.0.

func (*SKEmitterNode) ParticleColorBlendFactorSequence 

func (o *SKEmitterNode) ParticleColorBlendFactorSequence() *SKKeyframeSequence

func (*SKEmitterNode) ParticleColorBlendFactorSpeed 

func (o *SKEmitterNode) ParticleColorBlendFactorSpeed() float64

The rate at which to modify the color blend for each particle. Defaults to 0.0.

func (*SKEmitterNode) ParticleColorBlueRange 

func (o *SKEmitterNode) ParticleColorBlueRange() float64

func (*SKEmitterNode) ParticleColorBlueSpeed 

func (o *SKEmitterNode) ParticleColorBlueSpeed() float64

func (*SKEmitterNode) ParticleColorGreenRange 

func (o *SKEmitterNode) ParticleColorGreenRange() float64

func (*SKEmitterNode) ParticleColorGreenSpeed 

func (o *SKEmitterNode) ParticleColorGreenSpeed() float64

func (*SKEmitterNode) ParticleColorRedRange 

func (o *SKEmitterNode) ParticleColorRedRange() float64

The random variance about each color component for each particle. Defaults to 0.0.

func (*SKEmitterNode) ParticleColorRedSpeed 

func (o *SKEmitterNode) ParticleColorRedSpeed() float64

The rate at which to modify each color component for each particle (per second).

func (*SKEmitterNode) ParticleColorSequence 

func (o *SKEmitterNode) ParticleColorSequence() *SKKeyframeSequence

func (*SKEmitterNode) ParticleLifetime 

func (o *SKEmitterNode) ParticleLifetime() float64

The lifetime of each particle, in seconds. Defaults to 0.0.

func (*SKEmitterNode) ParticleLifetimeRange 

func (o *SKEmitterNode) ParticleLifetimeRange() float64

The random variance about the lifetime of each particle, in seconds. Defaults to 0.0.

func (*SKEmitterNode) ParticlePosition 

func (o *SKEmitterNode) ParticlePosition() corefoundation.CGPoint

The starting position for each particle in the emitter's coordinate space. Defaults to (0.0, 0,0).

func (*SKEmitterNode) ParticlePositionRange 

func (o *SKEmitterNode) ParticlePositionRange() corefoundation.CGVector

The random variance about the starting position for each particle in the emitter's coordinate space. Defaults to (0.0, 0,0).

func (*SKEmitterNode) ParticleRenderOrder 

func (o *SKEmitterNode) ParticleRenderOrder() SKParticleRenderOrder

The order in which particles will be rendered. Defaults to SKParticleRenderOrderOldestLast.

func (*SKEmitterNode) ParticleRotation 

func (o *SKEmitterNode) ParticleRotation() float64

The starting z-rotation for each particle. Defaults to 0.0.

func (*SKEmitterNode) ParticleRotationRange 

func (o *SKEmitterNode) ParticleRotationRange() float64

The random variance about the starting z-rotation for each particle. Defaults to 0.0.

func (*SKEmitterNode) ParticleRotationSpeed 

func (o *SKEmitterNode) ParticleRotationSpeed() float64

The rate at which to modify the z-rotation for each particle. Defaults to 0.0.

func (*SKEmitterNode) ParticleScale 

func (o *SKEmitterNode) ParticleScale() float64

The starting scale for each particle. Defaults to 1.0.

func (*SKEmitterNode) ParticleScaleRange 

func (o *SKEmitterNode) ParticleScaleRange() float64

The random variance about the starting scale for each particle. Defaults to 0.0.

func (*SKEmitterNode) ParticleScaleSequence 

func (o *SKEmitterNode) ParticleScaleSequence() *SKKeyframeSequence

func (*SKEmitterNode) ParticleScaleSpeed 

func (o *SKEmitterNode) ParticleScaleSpeed() float64

The rate at which to modify the scale for each particle. Defaults to 0.0.

func (*SKEmitterNode) ParticleSize 

func (o *SKEmitterNode) ParticleSize() corefoundation.CGSize

The starting size for each particle. If set to CGSizeZero (the default) the particles will start at the size of the texture assigned to particleTexture. Note that particleScale and particleScaleRange will also have an effect on the effective size of each new particle.

func (*SKEmitterNode) ParticleSpeed 

func (o *SKEmitterNode) ParticleSpeed() float64

The starting speed for each particle along its emission vector. Defaults to 0.0.

func (*SKEmitterNode) ParticleSpeedRange 

func (o *SKEmitterNode) ParticleSpeedRange() float64

The random variance about the starting speed for each particle along its emission vector. Defaults to 0.0.

func (*SKEmitterNode) ParticleTexture 

func (o *SKEmitterNode) ParticleTexture() *SKTexture

The texture to be used for the particles.

func (*SKEmitterNode) ParticleZPosition 

func (o *SKEmitterNode) ParticleZPosition() float64

The starting z-position for each particle. Defaults to 0.0.

func (*SKEmitterNode) ParticleZPositionRange 

func (o *SKEmitterNode) ParticleZPositionRange() float64

The random variance about the starting z-position for each particle. Defaults to 0.0. Deprecated: since macOS 10.10.

func (*SKEmitterNode) ParticleZPositionSpeed 

func (o *SKEmitterNode) ParticleZPositionSpeed() float64

The rate at which to modify the z-position for each particle. Defaults to 0.0. Deprecated: since macOS 10.10.

func (*SKEmitterNode) ResetSimulation 

func (o *SKEmitterNode) ResetSimulation()

func (*SKEmitterNode) SetEmissionAngle 

func (o *SKEmitterNode) SetEmissionAngle(emissionAngle float64)

func (*SKEmitterNode) SetEmissionAngleRange 

func (o *SKEmitterNode) SetEmissionAngleRange(emissionAngleRange float64)

func (*SKEmitterNode) SetFieldBitMask 

func (o *SKEmitterNode) SetFieldBitMask(fieldBitMask uint32)

func (*SKEmitterNode) SetNumParticlesToEmit 

func (o *SKEmitterNode) SetNumParticlesToEmit(numParticlesToEmit uint)

func (*SKEmitterNode) SetParticleAction 

func (o *SKEmitterNode) SetParticleAction(particleAction *SKAction)

func (*SKEmitterNode) SetParticleAlpha 

func (o *SKEmitterNode) SetParticleAlpha(particleAlpha float64)

func (*SKEmitterNode) SetParticleAlphaRange 

func (o *SKEmitterNode) SetParticleAlphaRange(particleAlphaRange float64)

func (*SKEmitterNode) SetParticleAlphaSequence 

func (o *SKEmitterNode) SetParticleAlphaSequence(particleAlphaSequence *SKKeyframeSequence)

func (*SKEmitterNode) SetParticleAlphaSpeed 

func (o *SKEmitterNode) SetParticleAlphaSpeed(particleAlphaSpeed float64)

func (*SKEmitterNode) SetParticleBirthRate 

func (o *SKEmitterNode) SetParticleBirthRate(particleBirthRate float64)

func (*SKEmitterNode) SetParticleBlendMode 

func (o *SKEmitterNode) SetParticleBlendMode(particleBlendMode SKBlendMode)

func (*SKEmitterNode) SetParticleColor 

func (o *SKEmitterNode) SetParticleColor(particleColor *appkit.NSColor)

func (*SKEmitterNode) SetParticleColorAlphaRange 

func (o *SKEmitterNode) SetParticleColorAlphaRange(particleColorAlphaRange float64)

func (*SKEmitterNode) SetParticleColorAlphaSpeed 

func (o *SKEmitterNode) SetParticleColorAlphaSpeed(particleColorAlphaSpeed float64)

func (*SKEmitterNode) SetParticleColorBlendFactor 

func (o *SKEmitterNode) SetParticleColorBlendFactor(particleColorBlendFactor float64)

func (*SKEmitterNode) SetParticleColorBlendFactorRange 

func (o *SKEmitterNode) SetParticleColorBlendFactorRange(particleColorBlendFactorRange float64)

func (*SKEmitterNode) SetParticleColorBlendFactorSequence 

func (o *SKEmitterNode) SetParticleColorBlendFactorSequence(particleColorBlendFactorSequence *SKKeyframeSequence)

func (*SKEmitterNode) SetParticleColorBlendFactorSpeed 

func (o *SKEmitterNode) SetParticleColorBlendFactorSpeed(particleColorBlendFactorSpeed float64)

func (*SKEmitterNode) SetParticleColorBlueRange 

func (o *SKEmitterNode) SetParticleColorBlueRange(particleColorBlueRange float64)

func (*SKEmitterNode) SetParticleColorBlueSpeed 

func (o *SKEmitterNode) SetParticleColorBlueSpeed(particleColorBlueSpeed float64)

func (*SKEmitterNode) SetParticleColorGreenRange 

func (o *SKEmitterNode) SetParticleColorGreenRange(particleColorGreenRange float64)

func (*SKEmitterNode) SetParticleColorGreenSpeed 

func (o *SKEmitterNode) SetParticleColorGreenSpeed(particleColorGreenSpeed float64)

func (*SKEmitterNode) SetParticleColorRedRange 

func (o *SKEmitterNode) SetParticleColorRedRange(particleColorRedRange float64)

func (*SKEmitterNode) SetParticleColorRedSpeed 

func (o *SKEmitterNode) SetParticleColorRedSpeed(particleColorRedSpeed float64)

func (*SKEmitterNode) SetParticleColorSequence 

func (o *SKEmitterNode) SetParticleColorSequence(particleColorSequence *SKKeyframeSequence)

func (*SKEmitterNode) SetParticleLifetime 

func (o *SKEmitterNode) SetParticleLifetime(particleLifetime float64)

func (*SKEmitterNode) SetParticleLifetimeRange 

func (o *SKEmitterNode) SetParticleLifetimeRange(particleLifetimeRange float64)

func (*SKEmitterNode) SetParticlePosition 

func (o *SKEmitterNode) SetParticlePosition(particlePosition corefoundation.CGPoint)

func (*SKEmitterNode) SetParticlePositionRange 

func (o *SKEmitterNode) SetParticlePositionRange(particlePositionRange corefoundation.CGVector)

func (*SKEmitterNode) SetParticleRenderOrder 

func (o *SKEmitterNode) SetParticleRenderOrder(particleRenderOrder SKParticleRenderOrder)

func (*SKEmitterNode) SetParticleRotation 

func (o *SKEmitterNode) SetParticleRotation(particleRotation float64)

func (*SKEmitterNode) SetParticleRotationRange 

func (o *SKEmitterNode) SetParticleRotationRange(particleRotationRange float64)

func (*SKEmitterNode) SetParticleRotationSpeed 

func (o *SKEmitterNode) SetParticleRotationSpeed(particleRotationSpeed float64)

func (*SKEmitterNode) SetParticleScale 

func (o *SKEmitterNode) SetParticleScale(particleScale float64)

func (*SKEmitterNode) SetParticleScaleRange 

func (o *SKEmitterNode) SetParticleScaleRange(particleScaleRange float64)

func (*SKEmitterNode) SetParticleScaleSequence 

func (o *SKEmitterNode) SetParticleScaleSequence(particleScaleSequence *SKKeyframeSequence)

func (*SKEmitterNode) SetParticleScaleSpeed 

func (o *SKEmitterNode) SetParticleScaleSpeed(particleScaleSpeed float64)

func (*SKEmitterNode) SetParticleSize 

func (o *SKEmitterNode) SetParticleSize(particleSize corefoundation.CGSize)

func (*SKEmitterNode) SetParticleSpeed 

func (o *SKEmitterNode) SetParticleSpeed(particleSpeed float64)

func (*SKEmitterNode) SetParticleSpeedRange 

func (o *SKEmitterNode) SetParticleSpeedRange(particleSpeedRange float64)

func (*SKEmitterNode) SetParticleTexture 

func (o *SKEmitterNode) SetParticleTexture(particleTexture *SKTexture)

func (*SKEmitterNode) SetParticleZPosition 

func (o *SKEmitterNode) SetParticleZPosition(particleZPosition float64)

func (*SKEmitterNode) SetParticleZPositionRange deprecated 

func (o *SKEmitterNode) SetParticleZPositionRange(particleZPositionRange float64)

Deprecated: since macOS 10.10.

func (*SKEmitterNode) SetParticleZPositionSpeed deprecated 

func (o *SKEmitterNode) SetParticleZPositionSpeed(particleZPositionSpeed float64)

Deprecated: since macOS 10.10.

func (*SKEmitterNode) SetShader 

func (o *SKEmitterNode) SetShader(shader *SKShader)

func (*SKEmitterNode) SetTargetNode 

func (o *SKEmitterNode) SetTargetNode(targetNode *SKNode)

func (*SKEmitterNode) SetXAcceleration 

func (o *SKEmitterNode) SetXAcceleration(xAcceleration float64)

func (*SKEmitterNode) SetYAcceleration 

func (o *SKEmitterNode) SetYAcceleration(yAcceleration float64)

func (*SKEmitterNode) Shader 

func (o *SKEmitterNode) Shader() *SKShader

func (*SKEmitterNode) TargetNode 

func (o *SKEmitterNode) TargetNode() *SKNode

Normally the particles are rendered as if they were a child of the SKEmitterNode, they can also be rendered as if they were a child of any other node in the scene by setting the targetNode property. Defaults to nil (standard behavior).

func (*SKEmitterNode) XAcceleration 

func (o *SKEmitterNode) XAcceleration() float64

The acceleration to apply to each particles velocity. Useful for simulating effects such as wind or gravity. Defaults to 0.0.

func (*SKEmitterNode) YAcceleration 

func (o *SKEmitterNode) YAcceleration() float64

type SKFieldNode 

type SKFieldNode struct {
	SKNode
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skfieldnode

func SKFieldNodeCustomFieldWithEvaluationBlock 

func SKFieldNodeCustomFieldWithEvaluationBlock(block func(unsafe.Pointer, unsafe.Pointer, float32, float32, float64) unsafe.Pointer) *SKFieldNode

func SKFieldNodeDragField 

func SKFieldNodeDragField() *SKFieldNode

Slows an object proportionally to the object’s velocity. Use this to simulate effects such as friction from motion through the air.

func SKFieldNodeElectricField 

func SKFieldNodeElectricField() *SKFieldNode

A force proportional to the charge on the object. A charge property has been added to SKPhysicsBodies to accomplish this. An example use of this field is to make objects behavior differently from one another when they enter a region, or to make an object's behavior different than its mass based behavior This field models the first part of the Lorentz equation, F = qE

func SKFieldNodeFromID 

func SKFieldNodeFromID(id objc.ID) *SKFieldNode

func SKFieldNodeLinearGravityFieldWithVector 

func SKFieldNodeLinearGravityFieldWithVector(direction unsafe.Pointer) *SKFieldNode

Applies a force in the direction of the vector in the local space. To repel objects, use a negative strength. The force is the same everywhere in the field. Varies with the mass of the object according to F = ma The field node's rotation property can be used to orient the gravity in a particular direction. @param direction The direction the force is applied in the x,y plane. The length of the direction vector is multiplied by the field's strength property to get the final calculated force. All three components of the direction vector are used to calculate the length. @see direction

func SKFieldNodeMagneticField 

func SKFieldNodeMagneticField() *SKFieldNode

A force proportional to the charge on the object and the object’s velocity. A charge property has been added to SKPhysicsBodies to accomplish this. An example use of this field is to make objects behavior differently from one another when they enter a region, or to make an object's behavior different than its mass based behavior This field models the second part of the Lorentz equation, F = qvB

func SKFieldNodeNoiseFieldWithSmoothnessAnimationSpeed 

func SKFieldNodeNoiseFieldWithSmoothnessAnimationSpeed(smoothness float64, speed float64) *SKFieldNode

A time varying differentiable Perlin simplex noise field. By default a smooth noise is calculated, and the field is time varying. Use this to simulate such effects as fireflies, or snow. To freeze the noise in place, set animationSpeed to 0.0. Mass is ignored. @param smoothness value of 0 means as noisy as possible, 1 means as smooth as possible @param speed is the general rate in Hz that any particular texel changes to a different value @see smoothness @see animationSpeed

func SKFieldNodeRadialGravityField 

func SKFieldNodeRadialGravityField() *SKFieldNode

Applies a force in the direction of the origin of the field in local space. To repel objects, use a negative strength. The force is proportional to the distance from the field origin. Varies with the mass of the object according to F = ma The field node's rotation property can be used to orient the gravity in a particular direction.

func SKFieldNodeSpringField 

func SKFieldNodeSpringField() *SKFieldNode

A Hooke’s law force - a force linearly proportional to distance from the center of the field. An object in this field will oscillate with a period proportional to the inverse of the mass. An example use is to keep objects confined to a particular region.

func SKFieldNodeTurbulenceFieldWithSmoothnessAnimationSpeed 

func SKFieldNodeTurbulenceFieldWithSmoothnessAnimationSpeed(smoothness float64, speed float64) *SKFieldNode

Just like Noise, except the strength of the noise is proportional to the velocity of the object in the field. @param smoothness value of 0 means as noisy as possible, 1 means as smooth as possible @param speed is the general rate in Hz that any particular texel changes to a different value @see smoothness @see animationSpeed

func SKFieldNodeVelocityFieldWithTexture 

func SKFieldNodeVelocityFieldWithTexture(velocityTexture *SKTexture) *SKFieldNode

The supplied texture contains velocity values for any object entering the field’s area of effect. If no texture is supplied, the direction property is used instead. Velocity fields override the effect of any other acceleration applied to the body. Velocity fields are typically used for such effects as advection, for example, a velocity field might describe the velocity on the surface of a river. An object placed in the river would then follow the river. @param velocityTexture The R and G channels of the supplied texture become x and y components of velocity. B and A, if present in the SKTexture, are ignored. @see texture

func SKFieldNodeVelocityFieldWithVector 

func SKFieldNodeVelocityFieldWithVector(direction unsafe.Pointer) *SKFieldNode

Uses the supplied velocity vector for any object entering the field’s area of effect. Velocity fields override the effect of any other acceleration applied to the body. Velocity fields are typically used for such effects as advection, for example, a velocity field might describe the velocity on the surface of a river. An object placed in the river would then follow the river. @param direction The directed velocity that will be applied to the body. The z component is ignored. @see direction

func SKFieldNodeVortexField 

func SKFieldNodeVortexField() *SKFieldNode

Applies a force tangential to the direction from the sample point to the field's position. The force will be CCW to the direction. Make the strength negative to apply force in the CW direction. Amount is proportional to distance from center and the object's mass. Use this to create effects such as tornadoes.

func (*SKFieldNode) AnimationSpeed 

func (o *SKFieldNode) AnimationSpeed() float32

fields that can be animated can have non zero values. A value of 2 will animated twice as fast as a value of 1. @see noiseFieldWithSmoothness:smoothness:animationSpeed @see turbulenceFieldWithSmoothness:smoothness:animationSpeed

func (*SKFieldNode) CategoryBitMask 

func (o *SKFieldNode) CategoryBitMask() uint32

Logical categories the field belongs to. Default is all categories. These categories correspond to fieldBitMasks, and can be used to enforce that a particular field applies to a particular category of objects. @see SKPhysicsBody.fieldBitMask @see SKEmitterNode.fieldBitMask

func (*SKFieldNode) Direction 

func (o *SKFieldNode) Direction() unsafe.Pointer

directed fields' directions can be accessed here. If the field is non-directional, a zero vector will be returned @see linearGravityFieldWithVector:direction @see velocityFieldWithVector:direction

func (*SKFieldNode) Falloff 

func (o *SKFieldNode) Falloff() float32

The falloff exponent used to calculate field strength at a distance. Falloff starts at the minimum radius. The default exponent is zero, which results in a uniform field with no falloff. @see minimumRadius

func (*SKFieldNode) IsEnabled 

func (o *SKFieldNode) IsEnabled() bool

If enabled, a field has an effect. default YES

func (*SKFieldNode) IsExclusive 

func (o *SKFieldNode) IsExclusive() bool

If a field is exclusive, it suppresses any other field in its region of effect. If two or more exclusive fields overlap, it is undefined which one of them will take effect @see region

func (*SKFieldNode) MinimumRadius 

func (o *SKFieldNode) MinimumRadius() float32

minimum radius of effect. Default is very small.

func (*SKFieldNode) Region 

func (o *SKFieldNode) Region() *SKRegion

The region property is the domain of the field's effect. No force is applied to objects outside the region.

func (*SKFieldNode) SetAnimationSpeed 

func (o *SKFieldNode) SetAnimationSpeed(animationSpeed float32)

func (*SKFieldNode) SetCategoryBitMask 

func (o *SKFieldNode) SetCategoryBitMask(categoryBitMask uint32)

func (*SKFieldNode) SetDirection 

func (o *SKFieldNode) SetDirection(direction unsafe.Pointer)

func (*SKFieldNode) SetEnabled 

func (o *SKFieldNode) SetEnabled(enabled bool)

func (*SKFieldNode) SetExclusive 

func (o *SKFieldNode) SetExclusive(exclusive bool)

func (*SKFieldNode) SetFalloff 

func (o *SKFieldNode) SetFalloff(falloff float32)

func (*SKFieldNode) SetMinimumRadius 

func (o *SKFieldNode) SetMinimumRadius(minimumRadius float32)

func (*SKFieldNode) SetRegion 

func (o *SKFieldNode) SetRegion(region *SKRegion)

func (*SKFieldNode) SetSmoothness 

func (o *SKFieldNode) SetSmoothness(smoothness float32)

func (*SKFieldNode) SetStrength 

func (o *SKFieldNode) SetStrength(strength float32)

func (*SKFieldNode) SetTexture 

func (o *SKFieldNode) SetTexture(texture *SKTexture)

func (*SKFieldNode) Smoothness 

func (o *SKFieldNode) Smoothness() float32

fields without a smoothness component will return 0 @see noiseFieldWithSmoothness:smoothness:animationSpeed @see turbulenceFieldWithSmoothness:smoothness:animationSpeed

func (*SKFieldNode) Strength 

func (o *SKFieldNode) Strength() float32

strength scaling value. default 1.0

func (*SKFieldNode) Texture 

func (o *SKFieldNode) Texture() *SKTexture

fields constructed with a texture can be uppdated by assigning a new texture @see velocityFieldWithTexture:velocityTexture

type SKInterpolationMode 

type SKInterpolationMode int64
const (
	SKInterpolationModeLinear SKInterpolationMode = 1
	SKInterpolationModeSpline SKInterpolationMode = 2
	SKInterpolationModeStep   SKInterpolationMode = 3
)

func (SKInterpolationMode) String 

func (e SKInterpolationMode) String() string

type SKKeyframeSequence 

type SKKeyframeSequence struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skkeyframesequence

func SKKeyframeSequenceFromID 

func SKKeyframeSequenceFromID(id objc.ID) *SKKeyframeSequence

func (*SKKeyframeSequence) AddKeyframeValueTime 

func (o *SKKeyframeSequence) AddKeyframeValueTime(value objc.ID, time_ float64)

func (*SKKeyframeSequence) Count 

func (o *SKKeyframeSequence) Count() uint

func (*SKKeyframeSequence) GetKeyframeTimeForIndex 

func (o *SKKeyframeSequence) GetKeyframeTimeForIndex(index uint) float64

func (*SKKeyframeSequence) GetKeyframeValueForIndex 

func (o *SKKeyframeSequence) GetKeyframeValueForIndex(index uint) objc.ID

func (*SKKeyframeSequence) InitWithCapacity 

func (o *SKKeyframeSequence) InitWithCapacity(numItems uint) *SKKeyframeSequence

func (*SKKeyframeSequence) InitWithCoder 

func (o *SKKeyframeSequence) InitWithCoder(aDecoder *foundation.NSCoder) *SKKeyframeSequence

Support coding and decoding via NSKeyedArchiver.

func (*SKKeyframeSequence) InitWithKeyframeValuesTimes 

func (o *SKKeyframeSequence) InitWithKeyframeValuesTimes(values *foundation.NSArray[objc.ID], times *foundation.NSArray[*foundation.NSNumber]) *SKKeyframeSequence

func (*SKKeyframeSequence) InterpolationMode 

func (o *SKKeyframeSequence) InterpolationMode() SKInterpolationMode

func (*SKKeyframeSequence) RemoveKeyframeAtIndex 

func (o *SKKeyframeSequence) RemoveKeyframeAtIndex(index uint)

func (*SKKeyframeSequence) RemoveLastKeyframe 

func (o *SKKeyframeSequence) RemoveLastKeyframe()

func (*SKKeyframeSequence) RepeatMode 

func (o *SKKeyframeSequence) RepeatMode() SKRepeatMode

func (*SKKeyframeSequence) SampleAtTime 

func (o *SKKeyframeSequence) SampleAtTime(time_ float64) objc.ID

func (*SKKeyframeSequence) SetInterpolationMode 

func (o *SKKeyframeSequence) SetInterpolationMode(interpolationMode SKInterpolationMode)

func (*SKKeyframeSequence) SetKeyframeTimeForIndex 

func (o *SKKeyframeSequence) SetKeyframeTimeForIndex(time_ float64, index uint)

func (*SKKeyframeSequence) SetKeyframeValueForIndex 

func (o *SKKeyframeSequence) SetKeyframeValueForIndex(value objc.ID, index uint)

func (*SKKeyframeSequence) SetKeyframeValueTimeForIndex 

func (o *SKKeyframeSequence) SetKeyframeValueTimeForIndex(value objc.ID, time_ float64, index uint)

func (*SKKeyframeSequence) SetRepeatMode 

func (o *SKKeyframeSequence) SetRepeatMode(repeatMode SKRepeatMode)

type SKLabelHorizontalAlignmentMode 

type SKLabelHorizontalAlignmentMode int64
const (
	SKLabelHorizontalAlignmentModeCenter SKLabelHorizontalAlignmentMode = 0
	SKLabelHorizontalAlignmentModeLeft   SKLabelHorizontalAlignmentMode = 1
	SKLabelHorizontalAlignmentModeRight  SKLabelHorizontalAlignmentMode = 2
)

func (SKLabelHorizontalAlignmentMode) String 

func (e SKLabelHorizontalAlignmentMode) String() string

type SKLabelNode 

type SKLabelNode struct {
	SKNode
}

A node that displays a text label with a given font.

Apple documentation: https://developer.apple.com/documentation/spritekit/sklabelnode

func SKLabelNodeFromID 

func SKLabelNodeFromID(id objc.ID) *SKLabelNode

func SKLabelNodeLabelNodeWithAttributedText 

func SKLabelNodeLabelNodeWithAttributedText(attributedText *foundation.NSAttributedString) *SKLabelNode

func SKLabelNodeLabelNodeWithFontNamed 

func SKLabelNodeLabelNodeWithFontNamed(fontName *foundation.NSString) *SKLabelNode

func SKLabelNodeLabelNodeWithText 

func SKLabelNodeLabelNodeWithText(text *foundation.NSString) *SKLabelNode

func (*SKLabelNode) AttributedText 

func (o *SKLabelNode) AttributedText() *foundation.NSAttributedString

func (*SKLabelNode) BlendMode 

func (o *SKLabelNode) BlendMode() SKBlendMode

Sets the blend mode to use when composing the sprite with the final framebuffer. @see SKNode.SKBlendMode

func (*SKLabelNode) Color 

func (o *SKLabelNode) Color() *appkit.NSColor

Color to be blended with the text based on the colorBlendFactor

func (*SKLabelNode) ColorBlendFactor 

func (o *SKLabelNode) ColorBlendFactor() float64

Controls the blending between the rendered text and a color. The valid interval of values is from 0.0 up to and including 1.0. A value above or below that interval is clamped to the minimum (0.0) if below or the maximum (1.0) if above.

func (*SKLabelNode) FontColor 

func (o *SKLabelNode) FontColor() *appkit.NSColor

Base color that the text is rendered with (if supported by the font)

func (*SKLabelNode) FontName 

func (o *SKLabelNode) FontName() *foundation.NSString

func (*SKLabelNode) FontSize 

func (o *SKLabelNode) FontSize() float64

func (*SKLabelNode) HorizontalAlignmentMode 

func (o *SKLabelNode) HorizontalAlignmentMode() SKLabelHorizontalAlignmentMode

func (*SKLabelNode) InitWithFontNamed 

func (o *SKLabelNode) InitWithFontNamed(fontName *foundation.NSString) *SKLabelNode

func (*SKLabelNode) LineBreakMode 

func (o *SKLabelNode) LineBreakMode() appkit.NSLineBreakMode

Determines the line break mode for multiple lines. Default is NSLineBreakByTruncatingTail

func (*SKLabelNode) NumberOfLines 

func (o *SKLabelNode) NumberOfLines() int

Determines the number of lines to draw. The default value is 1 (single line). A value of 0 means no limit. If the height of the text reaches the # of lines the text will be truncated using the line break mode.

func (*SKLabelNode) PreferredMaxLayoutWidth 

func (o *SKLabelNode) PreferredMaxLayoutWidth() float64

If nonzero, this is used when determining layout width for multiline labels. Default is zero.

func (*SKLabelNode) SetAttributedText 

func (o *SKLabelNode) SetAttributedText(attributedText *foundation.NSAttributedString)

func (*SKLabelNode) SetBlendMode 

func (o *SKLabelNode) SetBlendMode(blendMode SKBlendMode)

func (*SKLabelNode) SetColor 

func (o *SKLabelNode) SetColor(color *appkit.NSColor)

func (*SKLabelNode) SetColorBlendFactor 

func (o *SKLabelNode) SetColorBlendFactor(colorBlendFactor float64)

func (*SKLabelNode) SetFontColor 

func (o *SKLabelNode) SetFontColor(fontColor *appkit.NSColor)

func (*SKLabelNode) SetFontName 

func (o *SKLabelNode) SetFontName(fontName *foundation.NSString)

func (*SKLabelNode) SetFontSize 

func (o *SKLabelNode) SetFontSize(fontSize float64)

func (*SKLabelNode) SetHorizontalAlignmentMode 

func (o *SKLabelNode) SetHorizontalAlignmentMode(horizontalAlignmentMode SKLabelHorizontalAlignmentMode)

func (*SKLabelNode) SetLineBreakMode 

func (o *SKLabelNode) SetLineBreakMode(lineBreakMode appkit.NSLineBreakMode)

func (*SKLabelNode) SetNumberOfLines 

func (o *SKLabelNode) SetNumberOfLines(numberOfLines int)

func (*SKLabelNode) SetPreferredMaxLayoutWidth 

func (o *SKLabelNode) SetPreferredMaxLayoutWidth(preferredMaxLayoutWidth float64)

func (*SKLabelNode) SetText 

func (o *SKLabelNode) SetText(text *foundation.NSString)

func (*SKLabelNode) SetVerticalAlignmentMode 

func (o *SKLabelNode) SetVerticalAlignmentMode(verticalAlignmentMode SKLabelVerticalAlignmentMode)

func (*SKLabelNode) Text 

func (o *SKLabelNode) Text() *foundation.NSString

func (*SKLabelNode) VerticalAlignmentMode 

func (o *SKLabelNode) VerticalAlignmentMode() SKLabelVerticalAlignmentMode

type SKLabelVerticalAlignmentMode 

type SKLabelVerticalAlignmentMode int64
const (
	SKLabelVerticalAlignmentModeBaseline SKLabelVerticalAlignmentMode = 0
	SKLabelVerticalAlignmentModeCenter   SKLabelVerticalAlignmentMode = 1
	SKLabelVerticalAlignmentModeTop      SKLabelVerticalAlignmentMode = 2
	SKLabelVerticalAlignmentModeBottom   SKLabelVerticalAlignmentMode = 3
)

func (SKLabelVerticalAlignmentMode) String 

func (e SKLabelVerticalAlignmentMode) String() string

type SKLightNode 

type SKLightNode struct {
	SKNode
}

Apple documentation: https://developer.apple.com/documentation/spritekit/sklightnode

func SKLightNodeFromID 

func SKLightNodeFromID(id objc.ID) *SKLightNode

func (*SKLightNode) AmbientColor 

func (o *SKLightNode) AmbientColor() *appkit.NSColor

Ambient color of the light source, defaults to black. If you had only a single light in the scene with an ambient color of opaque white and a light color of black, it would appear as if the scene was rendered without lighting. The alpha component of the color is ignored. The color is not affected by falloff or surface normals. @see lightColor

func (*SKLightNode) CategoryBitMask 

func (o *SKLightNode) CategoryBitMask() uint32

The category of the light, which determines the group(s) a light belongs to. Any node that has its corresponding light and shadow bitmasks set to an overlapping value will be lit, shadow casting or shadowed by this light. @see SKSpriteNode.lightingBitMask @see SKSpriteNode.shadowCastBitMask @see SKSpriteNode.shadowedBitMask

func (*SKLightNode) Falloff 

func (o *SKLightNode) Falloff() float64

Falloff in intensity of the light over distance, defaults to 1. The falloff does not affect the ambient color nor the shadow color. @see lightColor

func (*SKLightNode) IsEnabled 

func (o *SKLightNode) IsEnabled() bool

Enables or disables lighting contribution from this light node. Set to YES; sprites using this light will be lit with the ambient color and the light color, with a falloff in intensity according to the falloff property. Set to NO; this light does not contribute any lighting. If no lights are active on a sprite it will be drawn normally, as if not lit. The default value is YES. @see lightColor @see falloff @see categoryBitMask

func (*SKLightNode) LightColor 

func (o *SKLightNode) LightColor() *appkit.NSColor

Diffuse and Specular color of the light source, defaults to opaque white. The alpha component of the color is ignored. If using shaders bind a uniform to this property to use scene based custom lighting. @see SKUniform @see falloff

func (*SKLightNode) SetAmbientColor 

func (o *SKLightNode) SetAmbientColor(ambientColor *appkit.NSColor)

func (*SKLightNode) SetCategoryBitMask 

func (o *SKLightNode) SetCategoryBitMask(categoryBitMask uint32)

func (*SKLightNode) SetEnabled 

func (o *SKLightNode) SetEnabled(enabled bool)

func (*SKLightNode) SetFalloff 

func (o *SKLightNode) SetFalloff(falloff float64)

func (*SKLightNode) SetLightColor 

func (o *SKLightNode) SetLightColor(lightColor *appkit.NSColor)

func (*SKLightNode) SetShadowColor 

func (o *SKLightNode) SetShadowColor(shadowColor *appkit.NSColor)

func (*SKLightNode) ShadowColor 

func (o *SKLightNode) ShadowColor() *appkit.NSColor

Color of the shadow casted on occluded objects, defaults to half opacity black. The alpha component of the color is used for blending with the regions that are in shadow. @see SKSpriteNode.shadowCastBitMask @see SKSpriteNode.shadowedBitMask

type SKMutableTexture 

type SKMutableTexture struct {
	SKTexture
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skmutabletexture

func SKMutableTextureFromID 

func SKMutableTextureFromID(id objc.ID) *SKMutableTexture

func SKMutableTextureMutableTextureWithSize 

func SKMutableTextureMutableTextureWithSize(size corefoundation.CGSize) *SKMutableTexture

func (*SKMutableTexture) InitWithSize 

func (o *SKMutableTexture) InitWithSize(size corefoundation.CGSize) *SKMutableTexture

Create a mutable texture with a specfic size. @param size the dimension to use when creating the given texture.

func (*SKMutableTexture) InitWithSizePixelFormat 

func (o *SKMutableTexture) InitWithSizePixelFormat(size corefoundation.CGSize, format int) *SKMutableTexture

Create a mutable texture with a specfic size and type. @param size the dimension to use when creating the given texture. @param format the CoreVideo format type. supported types include 'RGBA', 'RGhA', and 'RGfA' for byte, half-float, and float components.

func (*SKMutableTexture) ModifyPixelDataWith 

func (o *SKMutableTexture) ModifyPixelDataWith(block func(unsafe.Pointer, uint))

Modify the created mutable texture.

type SKNode 

type SKNode struct {
	appkit.NSResponder
}

Apple documentation: https://developer.apple.com/documentation/spritekit/sknode

func SKNodeFromID 

func SKNodeFromID(id objc.ID) *SKNode

func SKNodeNode 

func SKNodeNode() *SKNode

func SKNodeNodeWithFileNamed 

func SKNodeNodeWithFileNamed(filename *foundation.NSString) *SKNode

func SKNodeNodeWithFileNamedSecurelyWithClassesAndError 

func SKNodeNodeWithFileNamedSecurelyWithClassesAndError(filename *foundation.NSString, classes *foundation.NSSet[objc.Class]) (*SKNode, error)

func (*SKNode) AccessibilityChildren 

func (o *SKNode) AccessibilityChildren() *foundation.NSArray[objc.ID]

func (*SKNode) AccessibilityFrame 

func (o *SKNode) AccessibilityFrame() corefoundation.CGRect

func (*SKNode) AccessibilityHelp 

func (o *SKNode) AccessibilityHelp() *foundation.NSString

func (*SKNode) AccessibilityHitTest 

func (o *SKNode) AccessibilityHitTest(point corefoundation.CGPoint) objc.ID

func (*SKNode) AccessibilityLabel 

func (o *SKNode) AccessibilityLabel() *foundation.NSString

func (*SKNode) AccessibilityParent 

func (o *SKNode) AccessibilityParent() objc.ID

func (*SKNode) AccessibilityRole 

func (o *SKNode) AccessibilityRole() *foundation.NSString

func (*SKNode) AccessibilityRoleDescription 

func (o *SKNode) AccessibilityRoleDescription() *foundation.NSString

func (*SKNode) AccessibilitySubrole 

func (o *SKNode) AccessibilitySubrole() *foundation.NSString

func (*SKNode) ActionForKey 

func (o *SKNode) ActionForKey(key *foundation.NSString) *SKAction

func (*SKNode) AddChild 

func (o *SKNode) AddChild(node *SKNode)

Adds a node as a child node of this node The added node must not have a parent. @param node the child node to add.

func (*SKNode) Alpha 

func (o *SKNode) Alpha() float64

Alpha of this node (multiplied by the output color to give the final result)

func (*SKNode) AttributeValues 

func (o *SKNode) AttributeValues() *foundation.NSDictionary[*foundation.NSString, *SKAttributeValue]

Optional dictionary of SKAttributeValues Attributes can be used with custom SKShaders. DEPRECATED: Attributes are only available for node classes supporting SKShader (see SKSpriteNode etc.). Deprecated: since macOS 10.12.

func (*SKNode) CalculateAccumulatedFrame 

func (o *SKNode) CalculateAccumulatedFrame() corefoundation.CGRect

Calculates the bounding box including all child nodes in parents coordinate system.

func (*SKNode) ChildNodeWithName 

func (o *SKNode) ChildNodeWithName(name *foundation.NSString) *SKNode

func (*SKNode) Children 

func (o *SKNode) Children() *foundation.NSArray[*SKNode]

The children of this node.

func (*SKNode) Constraints 

func (o *SKNode) Constraints() *foundation.NSArray[*SKConstraint]

Optional array of SKConstraints Constraints are evaluated each frame after actions and physics. The node's transform will be changed to satisfy the constraint.

func (*SKNode) ContainsPoint 

func (o *SKNode) ContainsPoint(p corefoundation.CGPoint) bool

func (*SKNode) ConvertPointFromNode 

func (o *SKNode) ConvertPointFromNode(point corefoundation.CGPoint, node *SKNode) corefoundation.CGPoint

func (*SKNode) ConvertPointToNode 

func (o *SKNode) ConvertPointToNode(point corefoundation.CGPoint, node *SKNode) corefoundation.CGPoint

func (*SKNode) EnumerateChildNodesWithNameUsing 

func (o *SKNode) EnumerateChildNodesWithNameUsing(name *foundation.NSString, block func(*SKNode, *bool))

func (*SKNode) Frame 

func (o *SKNode) Frame() corefoundation.CGRect

func (*SKNode) HasActions 

func (o *SKNode) HasActions() bool

func (*SKNode) InParentHierarchy 

func (o *SKNode) InParentHierarchy(parent *SKNode) bool

func (*SKNode) Init 

func (o *SKNode) Init() *SKNode

func (*SKNode) InitWithCoder 

func (o *SKNode) InitWithCoder(aDecoder *foundation.NSCoder) *SKNode

Support coding and decoding via NSKeyedArchiver.

func (*SKNode) InsertChildAtIndex 

func (o *SKNode) InsertChildAtIndex(node *SKNode, index int)

func (*SKNode) IntersectsNode 

func (o *SKNode) IntersectsNode(node *SKNode) bool

func (*SKNode) IsAccessibilityElement 

func (o *SKNode) IsAccessibilityElement() bool

func (*SKNode) IsAccessibilityEnabled 

func (o *SKNode) IsAccessibilityEnabled() bool

func (*SKNode) IsEqualToNode 

func (o *SKNode) IsEqualToNode(node *SKNode) bool

func (*SKNode) IsHidden 

func (o *SKNode) IsHidden() bool

Controls whether or not the node and its children are rendered.

func (*SKNode) IsPaused 

func (o *SKNode) IsPaused() bool

Controls whether or not the node's actions is updated or paused.

func (*SKNode) IsUserInteractionEnabled 

func (o *SKNode) IsUserInteractionEnabled() bool

Controls whether or not the node receives touch events

func (*SKNode) MoveToParent 

func (o *SKNode) MoveToParent(parent *SKNode)

func (*SKNode) Name 

func (o *SKNode) Name() *foundation.NSString

The client assignable name. In general, this should be unique among peers in the scene graph.

func (*SKNode) NodeAtPoint 

func (o *SKNode) NodeAtPoint(p corefoundation.CGPoint) *SKNode

Returns the node itself or a child node at the point given. If the receiver is returned there is no child node at the given point. @return a child node or self at the given location.

func (*SKNode) NodesAtPoint 

func (o *SKNode) NodesAtPoint(p corefoundation.CGPoint) *foundation.NSArray[*SKNode]

func (*SKNode) ObjectForKeyedSubscript 

func (o *SKNode) ObjectForKeyedSubscript(name *foundation.NSString) *foundation.NSArray[*SKNode]

Simplified shorthand for enumerateChildNodesWithName that returns an array of the matching nodes. This allows subscripting of the form: NSArray *childrenMatchingName = node[@"name"] or even complex like: NSArray *siblingsBeginningWithA = node[@"../a*"] @param name An Xpath style path that can include simple regular expressions for matching node names. @see enumerateChildNodesWithName:usingBlock:

func (*SKNode) Parent 

func (o *SKNode) Parent() *SKNode

The parent of the node. If this is nil the node has not been added to another group and is thus the root node of its own graph.

func (*SKNode) PhysicsBody 

func (o *SKNode) PhysicsBody() *SKPhysicsBody

Physics body attached to the node, with synchronized scale, rotation, and position

func (*SKNode) Position 

func (o *SKNode) Position() corefoundation.CGPoint

The position of the node in the parent's coordinate system

func (*SKNode) ReachConstraints 

func (o *SKNode) ReachConstraints() *SKReachConstraints

Kinematic constraints, used in IK solving

func (*SKNode) RemoveActionForKey 

func (o *SKNode) RemoveActionForKey(key *foundation.NSString)

func (*SKNode) RemoveAllActions 

func (o *SKNode) RemoveAllActions()

func (*SKNode) RemoveAllChildren 

func (o *SKNode) RemoveAllChildren()

func (*SKNode) RemoveChildrenInArray 

func (o *SKNode) RemoveChildrenInArray(nodes *foundation.NSArray[*SKNode])

func (*SKNode) RemoveFromParent 

func (o *SKNode) RemoveFromParent()

func (*SKNode) RunAction 

func (o *SKNode) RunAction(action *SKAction)

func (*SKNode) RunActionCompletion 

func (o *SKNode) RunActionCompletion(action *SKAction, block func())

func (*SKNode) RunActionWithKey 

func (o *SKNode) RunActionWithKey(action *SKAction, key *foundation.NSString)

func (*SKNode) Scene 

func (o *SKNode) Scene() *SKScene

The scene that the node is currently in.

func (*SKNode) SetAccessibilityChildren 

func (o *SKNode) SetAccessibilityChildren(accessibilityChildren *foundation.NSArray[objc.ID])

func (*SKNode) SetAccessibilityElement 

func (o *SKNode) SetAccessibilityElement(accessibilityElement bool)

func (*SKNode) SetAccessibilityEnabled 

func (o *SKNode) SetAccessibilityEnabled(accessibilityEnabled bool)

func (*SKNode) SetAccessibilityFrame 

func (o *SKNode) SetAccessibilityFrame(accessibilityFrame corefoundation.CGRect)

func (*SKNode) SetAccessibilityHelp 

func (o *SKNode) SetAccessibilityHelp(accessibilityHelp *foundation.NSString)

func (*SKNode) SetAccessibilityLabel 

func (o *SKNode) SetAccessibilityLabel(accessibilityLabel *foundation.NSString)

func (*SKNode) SetAccessibilityParent 

func (o *SKNode) SetAccessibilityParent(accessibilityParent objc.ID)

func (*SKNode) SetAccessibilityRole 

func (o *SKNode) SetAccessibilityRole(accessibilityRole *foundation.NSString)

func (*SKNode) SetAccessibilityRoleDescription 

func (o *SKNode) SetAccessibilityRoleDescription(accessibilityRoleDescription *foundation.NSString)

func (*SKNode) SetAccessibilitySubrole 

func (o *SKNode) SetAccessibilitySubrole(accessibilitySubrole *foundation.NSString)

func (*SKNode) SetAlpha 

func (o *SKNode) SetAlpha(alpha float64)

func (*SKNode) SetAttributeValues deprecated 

func (o *SKNode) SetAttributeValues(attributeValues *foundation.NSDictionary[*foundation.NSString, *SKAttributeValue])

Deprecated: since macOS 10.12.

func (*SKNode) SetConstraints 

func (o *SKNode) SetConstraints(constraints *foundation.NSArray[*SKConstraint])

func (*SKNode) SetHidden 

func (o *SKNode) SetHidden(hidden bool)

func (*SKNode) SetName 

func (o *SKNode) SetName(name *foundation.NSString)

func (*SKNode) SetPaused 

func (o *SKNode) SetPaused(paused bool)

func (*SKNode) SetPhysicsBody 

func (o *SKNode) SetPhysicsBody(physicsBody *SKPhysicsBody)

func (*SKNode) SetPosition 

func (o *SKNode) SetPosition(position corefoundation.CGPoint)

func (*SKNode) SetReachConstraints 

func (o *SKNode) SetReachConstraints(reachConstraints *SKReachConstraints)

func (*SKNode) SetScale 

func (o *SKNode) SetScale(scale float64)

Sets both the x & y scale @param scale the uniform scale to set.

func (*SKNode) SetSpeed 

func (o *SKNode) SetSpeed(speed float64)

func (*SKNode) SetUserData 

func (o *SKNode) SetUserData(userData *foundation.NSMutableDictionary[objc.ID, objc.ID])

func (*SKNode) SetUserInteractionEnabled 

func (o *SKNode) SetUserInteractionEnabled(userInteractionEnabled bool)

func (*SKNode) SetValueForAttributeNamed deprecated 

func (o *SKNode) SetValueForAttributeNamed(value *SKAttributeValue, key *foundation.NSString)

Deprecated: since macOS 10.12.

func (*SKNode) SetXScale 

func (o *SKNode) SetXScale(xScale float64)

func (*SKNode) SetYScale 

func (o *SKNode) SetYScale(yScale float64)

func (*SKNode) SetZPosition 

func (o *SKNode) SetZPosition(zPosition float64)

func (*SKNode) SetZRotation 

func (o *SKNode) SetZRotation(zRotation float64)

func (*SKNode) Speed 

func (o *SKNode) Speed() float64

The speed multiplier applied to all actions run on this node. Inherited by its children.

func (*SKNode) UserData 

func (o *SKNode) UserData() *foundation.NSMutableDictionary[objc.ID, objc.ID]

An optional dictionary that can be used to store your own data in a node. Defaults to nil.

func (*SKNode) ValueForAttributeNamed deprecated 

func (o *SKNode) ValueForAttributeNamed(key *foundation.NSString) *SKAttributeValue

Deprecated: since macOS 10.12.

func (*SKNode) XScale 

func (o *SKNode) XScale() float64

The scaling in the X axis

func (*SKNode) YScale 

func (o *SKNode) YScale() float64

The scaling in the Y axis

func (*SKNode) ZPosition 

func (o *SKNode) ZPosition() float64

The z-order of the node (used for ordering). Negative z is "into" the screen, Positive z is "out" of the screen. A greater zPosition will sort in front of a lesser zPosition.

func (*SKNode) ZRotation 

func (o *SKNode) ZRotation() float64

The Euler rotation about the z axis (in radians)

type SKParticleRenderOrder 

type SKParticleRenderOrder uint64
const (
	SKParticleRenderOrderOldestLast  SKParticleRenderOrder = 0
	SKParticleRenderOrderOldestFirst SKParticleRenderOrder = 1
	SKParticleRenderOrderDontCare    SKParticleRenderOrder = 2
)

func (SKParticleRenderOrder) String 

func (e SKParticleRenderOrder) String() string

type SKPhysicsBody 

type SKPhysicsBody struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skphysicsbody

func SKPhysicsBodyBodyWithBodies 

func SKPhysicsBodyBodyWithBodies(bodies *foundation.NSArray[*SKPhysicsBody]) *SKPhysicsBody

Creates an compound body that is the union of the bodies used to create it.

func SKPhysicsBodyBodyWithCircleOfRadius 

func SKPhysicsBodyBodyWithCircleOfRadius(r float64) *SKPhysicsBody

Creates a circle of radius r centered at the node's origin. @param r the radius in points

func SKPhysicsBodyBodyWithCircleOfRadiusCenter 

func SKPhysicsBodyBodyWithCircleOfRadiusCenter(r float64, center corefoundation.CGPoint) *SKPhysicsBody

Creates a circle of radius r centered at a point in the node's coordinate space. @param r the radius in points

func SKPhysicsBodyBodyWithEdgeChainFromPath 

func SKPhysicsBodyBodyWithEdgeChainFromPath(path unsafe.Pointer) *SKPhysicsBody

Creates an edge chain from a path. The path must have no self intersection. Edges have no volume and are intended to be used to create static environments. Edges can collide with bodies of volume, but not with each other. @param path the path to use

func SKPhysicsBodyBodyWithEdgeFromPointToPoint 

func SKPhysicsBodyBodyWithEdgeFromPointToPoint(p1 corefoundation.CGPoint, p2 corefoundation.CGPoint) *SKPhysicsBody

Creates an edge from p1 to p2. Edges have no volume and are intended to be used to create static environments. Edges can collide with bodies of volume, but not with each other. @param p1 start point @param p2 end point

func SKPhysicsBodyBodyWithEdgeLoopFromPath 

func SKPhysicsBodyBodyWithEdgeLoopFromPath(path unsafe.Pointer) *SKPhysicsBody

Creates an edge loop from a path. A loop is automatically created by joining the last point to the first. The path must have no self intersection. Edges have no volume and are intended to be used to create static environments. Edges can collide with body's of volume, but not with each other. @param path the path to use

func SKPhysicsBodyBodyWithEdgeLoopFromRect 

func SKPhysicsBodyBodyWithEdgeLoopFromRect(rect corefoundation.CGRect) *SKPhysicsBody

Creates an edge loop from a CGRect. Edges have no volume and are intended to be used to create static environments. Edges can collide with body's of volume, but not with each other. @param rect the CGRect to use

func SKPhysicsBodyBodyWithPolygonFromPath 

func SKPhysicsBodyBodyWithPolygonFromPath(path unsafe.Pointer) *SKPhysicsBody

The path must represent a convex or concave polygon with counter clockwise winding and no self intersection. Positions are relative to the node's origin. @param path the path to use

func SKPhysicsBodyBodyWithRectangleOfSize 

func SKPhysicsBodyBodyWithRectangleOfSize(s corefoundation.CGSize) *SKPhysicsBody

Creates a rectangle of the specified size centered at the node's origin. @param s the size in points

func SKPhysicsBodyBodyWithRectangleOfSizeCenter 

func SKPhysicsBodyBodyWithRectangleOfSizeCenter(s corefoundation.CGSize, center corefoundation.CGPoint) *SKPhysicsBody

Creates a rectangle of the specified size centered at a point in the node's coordinate space. @param s the size in points

func SKPhysicsBodyBodyWithTextureAlphaThresholdSize 

func SKPhysicsBodyBodyWithTextureAlphaThresholdSize(texture *SKTexture, alphaThreshold float32, size corefoundation.CGSize) *SKPhysicsBody

Creates a body from the alpha values in the supplied texture. @param texture the texture to be interpreted @param alphaThreshold the alpha value above which a pixel is interpreted as opaque @param size of the generated physics body

func SKPhysicsBodyBodyWithTextureSize 

func SKPhysicsBodyBodyWithTextureSize(texture *SKTexture, size corefoundation.CGSize) *SKPhysicsBody

Creates a body from the alpha values in the supplied texture. @param texture the texture to be interpreted @param size of the generated physics body

func SKPhysicsBodyFromID 

func SKPhysicsBodyFromID(id objc.ID) *SKPhysicsBody

func (*SKPhysicsBody) AffectedByGravity 

func (o *SKPhysicsBody) AffectedByGravity() bool

Bodies are affected by field forces such as gravity if this property is set and the field's category mask is set appropriately. The default value is YES. @discussion If this is set a force is applied to the object based on the mass. Set the field force vector in the scene to modify the strength of the force.

func (*SKPhysicsBody) AllContactedBodies 

func (o *SKPhysicsBody) AllContactedBodies() *foundation.NSArray[*SKPhysicsBody]

func (*SKPhysicsBody) AllowsRotation 

func (o *SKPhysicsBody) AllowsRotation() bool

func (*SKPhysicsBody) AngularDamping 

func (o *SKPhysicsBody) AngularDamping() float64

Optionally reduce the body's angular velocity each frame to simulate rotational friction. (0.0 - 1.0). Defaults to 0.1

func (*SKPhysicsBody) AngularVelocity 

func (o *SKPhysicsBody) AngularVelocity() float64

func (*SKPhysicsBody) ApplyAngularImpulse 

func (o *SKPhysicsBody) ApplyAngularImpulse(impulse float64)

func (*SKPhysicsBody) ApplyForce 

func (o *SKPhysicsBody) ApplyForce(force corefoundation.CGVector)

func (*SKPhysicsBody) ApplyForceAtPoint 

func (o *SKPhysicsBody) ApplyForceAtPoint(force corefoundation.CGVector, point corefoundation.CGPoint)

func (*SKPhysicsBody) ApplyImpulse 

func (o *SKPhysicsBody) ApplyImpulse(impulse corefoundation.CGVector)

func (*SKPhysicsBody) ApplyImpulseAtPoint 

func (o *SKPhysicsBody) ApplyImpulseAtPoint(impulse corefoundation.CGVector, point corefoundation.CGPoint)

func (*SKPhysicsBody) ApplyTorque 

func (o *SKPhysicsBody) ApplyTorque(torque float64)

func (*SKPhysicsBody) Area 

func (o *SKPhysicsBody) Area() float64

The area of the body. @discussion The unit is arbitrary, as long as the relative areas are consistent throughout the application.

func (*SKPhysicsBody) CategoryBitMask 

func (o *SKPhysicsBody) CategoryBitMask() uint32

Defines what logical 'categories' this body belongs to. Defaults to all bits set (all categories).

func (*SKPhysicsBody) Charge 

func (o *SKPhysicsBody) Charge() float64

Specifies the charge on the body. Charge determines the degree to which a body is affected by electric and magnetic fields. Note that this is a unitless quantity, it is up to the developer to set charge and field strength appropriately. Defaults to 0.0

func (*SKPhysicsBody) CollisionBitMask 

func (o *SKPhysicsBody) CollisionBitMask() uint32

Defines what logical 'categories' of bodies this body responds to collisions with. Defaults to all bits set (all categories).

func (*SKPhysicsBody) ContactTestBitMask 

func (o *SKPhysicsBody) ContactTestBitMask() uint32

Defines what logical 'categories' of bodies this body generates intersection notifications with. Defaults to all bits cleared (no categories).

func (*SKPhysicsBody) Density 

func (o *SKPhysicsBody) Density() float64

The density of the body. @discussion The unit is arbitrary, as long as the relative densities are consistent throughout the application. Note that density and mass are inherently related (they are directly proportional), so changing one also changes the other. Both are provided so either can be used depending on what is more relevant to your usage.

func (*SKPhysicsBody) FieldBitMask 

func (o *SKPhysicsBody) FieldBitMask() uint32

Defines what logical 'categories' of fields this body responds to. Defaults to all bits set (all categories). Can be forced off via affectedByGravity.

func (*SKPhysicsBody) Friction 

func (o *SKPhysicsBody) Friction() float64

Determines the 'roughness' for the surface of the physics body (0.0 - 1.0). Defaults to 0.2

func (*SKPhysicsBody) IsDynamic 

func (o *SKPhysicsBody) IsDynamic() bool

func (*SKPhysicsBody) IsResting 

func (o *SKPhysicsBody) IsResting() bool

If the physics simulation has determined that this body is at rest it may set the resting property to YES. Resting bodies do not participate in the simulation until some collision with a non-resting object, or an impulse is applied, that unrests it. If all bodies in the world are resting then the simulation as a whole is "at rest".

func (*SKPhysicsBody) Joints 

func (o *SKPhysicsBody) Joints() *foundation.NSArray[*SKPhysicsJoint]

func (*SKPhysicsBody) LinearDamping 

func (o *SKPhysicsBody) LinearDamping() float64

Optionally reduce the body's linear velocity each frame to simulate fluid/air friction. Value should be zero or greater. Defaults to 0.1. Used in conjunction with per frame impulses, an object can be made to move at a constant speed. For example, if an object 64 points in size and default density and a linearDamping of 25 will slide across the screen in a few seconds if an impulse of magnitude 10 is applied every update.

func (*SKPhysicsBody) Mass 

func (o *SKPhysicsBody) Mass() float64

The mass of the body. @discussion The unit is arbitrary, as long as the relative masses are consistent throughout the application. Note that density and mass are inherently related (they are directly proportional), so changing one also changes the other. Both are provided so either can be used depending on what is more relevant to your usage.

func (*SKPhysicsBody) Node 

func (o *SKPhysicsBody) Node() *SKNode

The representedObject this physicsBody is currently bound to, or nil if it is not.

func (*SKPhysicsBody) Pinned 

func (o *SKPhysicsBody) Pinned() bool

func (*SKPhysicsBody) Restitution 

func (o *SKPhysicsBody) Restitution() float64

Determines the 'bounciness' of the physics body (0.0 - 1.0). Defaults to 0.2

func (*SKPhysicsBody) SetAffectedByGravity 

func (o *SKPhysicsBody) SetAffectedByGravity(affectedByGravity bool)

func (*SKPhysicsBody) SetAllowsRotation 

func (o *SKPhysicsBody) SetAllowsRotation(allowsRotation bool)

func (*SKPhysicsBody) SetAngularDamping 

func (o *SKPhysicsBody) SetAngularDamping(angularDamping float64)

func (*SKPhysicsBody) SetAngularVelocity 

func (o *SKPhysicsBody) SetAngularVelocity(angularVelocity float64)

func (*SKPhysicsBody) SetCategoryBitMask 

func (o *SKPhysicsBody) SetCategoryBitMask(categoryBitMask uint32)

func (*SKPhysicsBody) SetCharge 

func (o *SKPhysicsBody) SetCharge(charge float64)

func (*SKPhysicsBody) SetCollisionBitMask 

func (o *SKPhysicsBody) SetCollisionBitMask(collisionBitMask uint32)

func (*SKPhysicsBody) SetContactTestBitMask 

func (o *SKPhysicsBody) SetContactTestBitMask(contactTestBitMask uint32)

func (*SKPhysicsBody) SetDensity 

func (o *SKPhysicsBody) SetDensity(density float64)

func (*SKPhysicsBody) SetDynamic 

func (o *SKPhysicsBody) SetDynamic(dynamic bool)

func (*SKPhysicsBody) SetFieldBitMask 

func (o *SKPhysicsBody) SetFieldBitMask(fieldBitMask uint32)

func (*SKPhysicsBody) SetFriction 

func (o *SKPhysicsBody) SetFriction(friction float64)

func (*SKPhysicsBody) SetLinearDamping 

func (o *SKPhysicsBody) SetLinearDamping(linearDamping float64)

func (*SKPhysicsBody) SetMass 

func (o *SKPhysicsBody) SetMass(mass float64)

func (*SKPhysicsBody) SetPinned 

func (o *SKPhysicsBody) SetPinned(pinned bool)

func (*SKPhysicsBody) SetResting 

func (o *SKPhysicsBody) SetResting(resting bool)

func (*SKPhysicsBody) SetRestitution 

func (o *SKPhysicsBody) SetRestitution(restitution float64)

func (*SKPhysicsBody) SetUsesPreciseCollisionDetection 

func (o *SKPhysicsBody) SetUsesPreciseCollisionDetection(usesPreciseCollisionDetection bool)

func (*SKPhysicsBody) SetVelocity 

func (o *SKPhysicsBody) SetVelocity(velocity corefoundation.CGVector)

func (*SKPhysicsBody) UsesPreciseCollisionDetection 

func (o *SKPhysicsBody) UsesPreciseCollisionDetection() bool

func (*SKPhysicsBody) Velocity 

func (o *SKPhysicsBody) Velocity() corefoundation.CGVector

type SKPhysicsContact 

type SKPhysicsContact struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skphysicscontact

func SKPhysicsContactFromID 

func SKPhysicsContactFromID(id objc.ID) *SKPhysicsContact

func (*SKPhysicsContact) BodyA 

func (o *SKPhysicsContact) BodyA() *SKPhysicsBody

func (*SKPhysicsContact) BodyB 

func (o *SKPhysicsContact) BodyB() *SKPhysicsBody

func (*SKPhysicsContact) CollisionImpulse 

func (o *SKPhysicsContact) CollisionImpulse() float64

func (*SKPhysicsContact) ContactNormal 

func (o *SKPhysicsContact) ContactNormal() corefoundation.CGVector

func (*SKPhysicsContact) ContactPoint 

func (o *SKPhysicsContact) ContactPoint() corefoundation.CGPoint

type SKPhysicsContactDelegate 

type SKPhysicsContactDelegate interface {
}

SKPhysicsContactDelegate wraps the ObjC protocol SKPhysicsContactDelegate.

type SKPhysicsJoint 

type SKPhysicsJoint struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skphysicsjoint

func SKPhysicsJointFromID 

func SKPhysicsJointFromID(id objc.ID) *SKPhysicsJoint

func (*SKPhysicsJoint) BodyA 

func (o *SKPhysicsJoint) BodyA() *SKPhysicsBody

func (*SKPhysicsJoint) BodyB 

func (o *SKPhysicsJoint) BodyB() *SKPhysicsBody

func (*SKPhysicsJoint) ReactionForce 

func (o *SKPhysicsJoint) ReactionForce() corefoundation.CGVector

func (*SKPhysicsJoint) ReactionTorque 

func (o *SKPhysicsJoint) ReactionTorque() float64

func (*SKPhysicsJoint) SetBodyA 

func (o *SKPhysicsJoint) SetBodyA(bodyA *SKPhysicsBody)

func (*SKPhysicsJoint) SetBodyB 

func (o *SKPhysicsJoint) SetBodyB(bodyB *SKPhysicsBody)

type SKPhysicsJointFixed 

type SKPhysicsJointFixed struct {
	SKPhysicsJoint
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skphysicsjointfixed

func SKPhysicsJointFixedFromID 

func SKPhysicsJointFixedFromID(id objc.ID) *SKPhysicsJointFixed

func SKPhysicsJointFixedJointWithBodyABodyBAnchor 

func SKPhysicsJointFixedJointWithBodyABodyBAnchor(bodyA *SKPhysicsBody, bodyB *SKPhysicsBody, anchor corefoundation.CGPoint) *SKPhysicsJointFixed

type SKPhysicsJointLimit 

type SKPhysicsJointLimit struct {
	SKPhysicsJoint
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skphysicsjointlimit

func SKPhysicsJointLimitFromID 

func SKPhysicsJointLimitFromID(id objc.ID) *SKPhysicsJointLimit

func SKPhysicsJointLimitJointWithBodyABodyBAnchorAAnchorB 

func SKPhysicsJointLimitJointWithBodyABodyBAnchorAAnchorB(bodyA *SKPhysicsBody, bodyB *SKPhysicsBody, anchorA corefoundation.CGPoint, anchorB corefoundation.CGPoint) *SKPhysicsJointLimit

func (*SKPhysicsJointLimit) MaxLength 

func (o *SKPhysicsJointLimit) MaxLength() float64

func (*SKPhysicsJointLimit) SetMaxLength 

func (o *SKPhysicsJointLimit) SetMaxLength(maxLength float64)

type SKPhysicsJointPin 

type SKPhysicsJointPin struct {
	SKPhysicsJoint
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skphysicsjointpin

func SKPhysicsJointPinFromID 

func SKPhysicsJointPinFromID(id objc.ID) *SKPhysicsJointPin

func SKPhysicsJointPinJointWithBodyABodyBAnchor 

func SKPhysicsJointPinJointWithBodyABodyBAnchor(bodyA *SKPhysicsBody, bodyB *SKPhysicsBody, anchor corefoundation.CGPoint) *SKPhysicsJointPin

func (*SKPhysicsJointPin) FrictionTorque 

func (o *SKPhysicsJointPin) FrictionTorque() float64

func (*SKPhysicsJointPin) LowerAngleLimit 

func (o *SKPhysicsJointPin) LowerAngleLimit() float64

func (*SKPhysicsJointPin) RotationSpeed 

func (o *SKPhysicsJointPin) RotationSpeed() float64

func (*SKPhysicsJointPin) SetFrictionTorque 

func (o *SKPhysicsJointPin) SetFrictionTorque(frictionTorque float64)

func (*SKPhysicsJointPin) SetLowerAngleLimit 

func (o *SKPhysicsJointPin) SetLowerAngleLimit(lowerAngleLimit float64)

func (*SKPhysicsJointPin) SetRotationSpeed 

func (o *SKPhysicsJointPin) SetRotationSpeed(rotationSpeed float64)

func (*SKPhysicsJointPin) SetShouldEnableLimits 

func (o *SKPhysicsJointPin) SetShouldEnableLimits(shouldEnableLimits bool)

func (*SKPhysicsJointPin) SetUpperAngleLimit 

func (o *SKPhysicsJointPin) SetUpperAngleLimit(upperAngleLimit float64)

func (*SKPhysicsJointPin) ShouldEnableLimits 

func (o *SKPhysicsJointPin) ShouldEnableLimits() bool

func (*SKPhysicsJointPin) UpperAngleLimit 

func (o *SKPhysicsJointPin) UpperAngleLimit() float64

type SKPhysicsJointSliding 

type SKPhysicsJointSliding struct {
	SKPhysicsJoint
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skphysicsjointsliding

func SKPhysicsJointSlidingFromID 

func SKPhysicsJointSlidingFromID(id objc.ID) *SKPhysicsJointSliding

func SKPhysicsJointSlidingJointWithBodyABodyBAnchorAxis 

func SKPhysicsJointSlidingJointWithBodyABodyBAnchorAxis(bodyA *SKPhysicsBody, bodyB *SKPhysicsBody, anchor corefoundation.CGPoint, axis corefoundation.CGVector) *SKPhysicsJointSliding

func (*SKPhysicsJointSliding) LowerDistanceLimit 

func (o *SKPhysicsJointSliding) LowerDistanceLimit() float64

func (*SKPhysicsJointSliding) SetLowerDistanceLimit 

func (o *SKPhysicsJointSliding) SetLowerDistanceLimit(lowerDistanceLimit float64)

func (*SKPhysicsJointSliding) SetShouldEnableLimits 

func (o *SKPhysicsJointSliding) SetShouldEnableLimits(shouldEnableLimits bool)

func (*SKPhysicsJointSliding) SetUpperDistanceLimit 

func (o *SKPhysicsJointSliding) SetUpperDistanceLimit(upperDistanceLimit float64)

func (*SKPhysicsJointSliding) ShouldEnableLimits 

func (o *SKPhysicsJointSliding) ShouldEnableLimits() bool

func (*SKPhysicsJointSliding) UpperDistanceLimit 

func (o *SKPhysicsJointSliding) UpperDistanceLimit() float64

type SKPhysicsJointSpring 

type SKPhysicsJointSpring struct {
	SKPhysicsJoint
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skphysicsjointspring

func SKPhysicsJointSpringFromID 

func SKPhysicsJointSpringFromID(id objc.ID) *SKPhysicsJointSpring

func SKPhysicsJointSpringJointWithBodyABodyBAnchorAAnchorB 

func SKPhysicsJointSpringJointWithBodyABodyBAnchorAAnchorB(bodyA *SKPhysicsBody, bodyB *SKPhysicsBody, anchorA corefoundation.CGPoint, anchorB corefoundation.CGPoint) *SKPhysicsJointSpring

func (*SKPhysicsJointSpring) Damping 

func (o *SKPhysicsJointSpring) Damping() float64

func (*SKPhysicsJointSpring) Frequency 

func (o *SKPhysicsJointSpring) Frequency() float64

func (*SKPhysicsJointSpring) SetDamping 

func (o *SKPhysicsJointSpring) SetDamping(damping float64)

func (*SKPhysicsJointSpring) SetFrequency 

func (o *SKPhysicsJointSpring) SetFrequency(frequency float64)

type SKPhysicsWorld 

type SKPhysicsWorld struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skphysicsworld

func SKPhysicsWorldFromID 

func SKPhysicsWorldFromID(id objc.ID) *SKPhysicsWorld

func (*SKPhysicsWorld) AddJoint 

func (o *SKPhysicsWorld) AddJoint(joint *SKPhysicsJoint)

func (*SKPhysicsWorld) BodyAlongRayStartEnd 

func (o *SKPhysicsWorld) BodyAlongRayStartEnd(start corefoundation.CGPoint, end corefoundation.CGPoint) *SKPhysicsBody

func (*SKPhysicsWorld) BodyAtPoint 

func (o *SKPhysicsWorld) BodyAtPoint(point corefoundation.CGPoint) *SKPhysicsBody

func (*SKPhysicsWorld) BodyInRect 

func (o *SKPhysicsWorld) BodyInRect(rect corefoundation.CGRect) *SKPhysicsBody

func (*SKPhysicsWorld) ContactDelegate 

func (o *SKPhysicsWorld) ContactDelegate() SKPhysicsContactDelegate

func (*SKPhysicsWorld) EnumerateBodiesAlongRayStartEndUsing 

func (o *SKPhysicsWorld) EnumerateBodiesAlongRayStartEndUsing(start corefoundation.CGPoint, end corefoundation.CGPoint, block objc.Block)

func (*SKPhysicsWorld) EnumerateBodiesAtPointUsing 

func (o *SKPhysicsWorld) EnumerateBodiesAtPointUsing(point corefoundation.CGPoint, block func(*SKPhysicsBody, *bool))

func (*SKPhysicsWorld) EnumerateBodiesInRectUsing 

func (o *SKPhysicsWorld) EnumerateBodiesInRectUsing(rect corefoundation.CGRect, block func(*SKPhysicsBody, *bool))

func (*SKPhysicsWorld) Gravity 

func (o *SKPhysicsWorld) Gravity() corefoundation.CGVector

A global 2D vector specifying the field force acceleration due to gravity. The unit is meters per second so standard earth gravity would be { 0.0, +/-9.8 }.

func (*SKPhysicsWorld) RemoveAllJoints 

func (o *SKPhysicsWorld) RemoveAllJoints()

func (*SKPhysicsWorld) RemoveJoint 

func (o *SKPhysicsWorld) RemoveJoint(joint *SKPhysicsJoint)

func (*SKPhysicsWorld) SampleFieldsAt 

func (o *SKPhysicsWorld) SampleFieldsAt(position unsafe.Pointer) unsafe.Pointer

func (*SKPhysicsWorld) SetContactDelegate 

func (o *SKPhysicsWorld) SetContactDelegate(contactDelegate SKPhysicsContactDelegate)

func (*SKPhysicsWorld) SetGravity 

func (o *SKPhysicsWorld) SetGravity(gravity corefoundation.CGVector)

func (*SKPhysicsWorld) SetSpeed 

func (o *SKPhysicsWorld) SetSpeed(speed float64)

func (*SKPhysicsWorld) Speed 

func (o *SKPhysicsWorld) Speed() float64

type SKRange 

type SKRange struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skrange

func SKRangeFromID 

func SKRangeFromID(id objc.ID) *SKRange

func SKRangeRangeWithConstantValue 

func SKRangeRangeWithConstantValue(value float64) *SKRange

func SKRangeRangeWithLowerLimit 

func SKRangeRangeWithLowerLimit(lower float64) *SKRange

func SKRangeRangeWithLowerLimitUpperLimit 

func SKRangeRangeWithLowerLimitUpperLimit(lower float64, upper float64) *SKRange

func SKRangeRangeWithNoLimits 

func SKRangeRangeWithNoLimits() *SKRange

func SKRangeRangeWithUpperLimit 

func SKRangeRangeWithUpperLimit(upper float64) *SKRange

func SKRangeRangeWithValueVariance 

func SKRangeRangeWithValueVariance(value float64, variance float64) *SKRange

func (*SKRange) InitWithLowerLimitUpperLimit 

func (o *SKRange) InitWithLowerLimitUpperLimit(lower float64, upper float64) *SKRange

func (*SKRange) LowerLimit 

func (o *SKRange) LowerLimit() float64

func (*SKRange) SetLowerLimit 

func (o *SKRange) SetLowerLimit(lowerLimit float64)

func (*SKRange) SetUpperLimit 

func (o *SKRange) SetUpperLimit(upperLimit float64)

func (*SKRange) UpperLimit 

func (o *SKRange) UpperLimit() float64

type SKReachConstraints 

type SKReachConstraints struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skreachconstraints

func SKReachConstraintsFromID 

func SKReachConstraintsFromID(id objc.ID) *SKReachConstraints

func (*SKReachConstraints) InitWithLowerAngleLimitUpperAngleLimit 

func (o *SKReachConstraints) InitWithLowerAngleLimitUpperAngleLimit(lowerAngleLimit float64, upperAngleLimit float64) *SKReachConstraints

func (*SKReachConstraints) LowerAngleLimit 

func (o *SKReachConstraints) LowerAngleLimit() float64

Lower angle limit in radians

func (*SKReachConstraints) SetLowerAngleLimit 

func (o *SKReachConstraints) SetLowerAngleLimit(lowerAngleLimit float64)

func (*SKReachConstraints) SetUpperAngleLimit 

func (o *SKReachConstraints) SetUpperAngleLimit(upperAngleLimit float64)

func (*SKReachConstraints) UpperAngleLimit 

func (o *SKReachConstraints) UpperAngleLimit() float64

Upper angle limit in radians

type SKReferenceNode 

type SKReferenceNode struct {
	SKNode
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skreferencenode

func SKReferenceNodeFromID 

func SKReferenceNodeFromID(id objc.ID) *SKReferenceNode

func SKReferenceNodeReferenceNodeWithFileNamed 

func SKReferenceNodeReferenceNodeWithFileNamed(fileName *foundation.NSString) *SKReferenceNode

Create a reference node with a url

func SKReferenceNodeReferenceNodeWithURL 

func SKReferenceNodeReferenceNodeWithURL(referenceURL *foundation.NSURL) *SKReferenceNode

Create a reference node with a url

func (*SKReferenceNode) DidLoadReferenceNode 

func (o *SKReferenceNode) DidLoadReferenceNode(node *SKNode)

called each time the url is loaded, after it has been added as a child

func (*SKReferenceNode) InitWithCoder 

func (o *SKReferenceNode) InitWithCoder(aDecoder *foundation.NSCoder) *SKReferenceNode

Support coding and decoding via NSKeyedArchiver.

func (*SKReferenceNode) InitWithFileNamed 

func (o *SKReferenceNode) InitWithFileNamed(fileName *foundation.NSString) *SKReferenceNode

Create a reference node with a url

func (*SKReferenceNode) InitWithURL 

func (o *SKReferenceNode) InitWithURL(url *foundation.NSURL) *SKReferenceNode

Create a reference node with a url

func (*SKReferenceNode) ResolveReferenceNode 

func (o *SKReferenceNode) ResolveReferenceNode()

Force the reference to be reloaded. The resolved node will added as a child of this node. If the resolved node has not yet been loaded, it will be automatically loaded when the resolved node is queryed or the refenece node is rendered.

type SKRegion 

type SKRegion struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skregion

func SKRegionFromID 

func SKRegionFromID(id objc.ID) *SKRegion

func SKRegionInfiniteRegion 

func SKRegionInfiniteRegion() *SKRegion

A shared infinite region

func (*SKRegion) ContainsPoint 

func (o *SKRegion) ContainsPoint(point corefoundation.CGPoint) bool

Test for containment

func (*SKRegion) InitWithPath 

func (o *SKRegion) InitWithPath(path unsafe.Pointer) *SKRegion

Create a region bounded by a CGPath. Note that this option can be costly to evaluate.

func (*SKRegion) InitWithRadius 

func (o *SKRegion) InitWithRadius(radius float32) *SKRegion

Create a circular region with radius

func (*SKRegion) InitWithSize 

func (o *SKRegion) InitWithSize(size corefoundation.CGSize) *SKRegion

Create a rectangular region of size

func (*SKRegion) InverseRegion 

func (o *SKRegion) InverseRegion() *SKRegion

Create a new region that is the inverse of the current region. The inverse of the infiniteRegion is an empty region. Subclasses of SKRegion need to provide an implementation of inverseRegion.

func (*SKRegion) Path 

func (o *SKRegion) Path() unsafe.Pointer

func (*SKRegion) RegionByDifferenceFromRegion 

func (o *SKRegion) RegionByDifferenceFromRegion(region *SKRegion) *SKRegion

Create a new region that is the original region minus the supplied region

func (*SKRegion) RegionByIntersectionWithRegion 

func (o *SKRegion) RegionByIntersectionWithRegion(region *SKRegion) *SKRegion

Create a new region that is the region covered by the original region and the supplied region

func (*SKRegion) RegionByUnionWithRegion 

func (o *SKRegion) RegionByUnionWithRegion(region *SKRegion) *SKRegion

Create a new region that is the original region plus the supplied region

type SKRenderer 

type SKRenderer struct {
	foundation.NSObject
}

A renderer for displaying a SpriteKit scene in an existing Metal workflow.

Apple documentation: https://developer.apple.com/documentation/spritekit/skrenderer

func SKRendererFromID 

func SKRendererFromID(id objc.ID) *SKRenderer

func SKRendererRendererWithDevice 

func SKRendererRendererWithDevice(device metal.MTLDevice) *SKRenderer

Creates a renderer with the specified Metal device. @param device A Metal device. @return A new renderer object.

func (*SKRenderer) IgnoresSiblingOrder 

func (o *SKRenderer) IgnoresSiblingOrder() bool

Ignores sibling and traversal order to sort the rendered contents of a scene into the most efficient batching possible. This will require zPosition to be used in the scenes to properly guarantee elements are in front or behind each other. This defaults to NO, meaning that sibling order overrides efficiency heuristics in the rendering of the scenes in the view. Setting this to YES for a complex scene may substantially increase performance, but care must be taken as only zPosition determines render order before the efficiency heuristics are used.

func (*SKRenderer) RenderWithViewportCommandBufferRenderPassDescriptor 

func (o *SKRenderer) RenderWithViewportCommandBufferRenderPassDescriptor(viewport corefoundation.CGRect, commandBuffer metal.MTLCommandBuffer, renderPassDescriptor *metal.MTLRenderPassDescriptor)

Render the scene content in the specified Metal command buffer. @param viewport The pixel dimensions in which to render. @param commandBuffer The Metal command buffer in which SpriteKit should schedule rendering commands. @param renderPassDescriptor The Metal render pass descriptor describing the rendering target.

func (*SKRenderer) RenderWithViewportRenderCommandEncoderRenderPassDescriptorCommandQueue 

func (o *SKRenderer) RenderWithViewportRenderCommandEncoderRenderPassDescriptorCommandQueue(viewport corefoundation.CGRect, renderCommandEncoder metal.MTLRenderCommandEncoder, renderPassDescriptor *metal.MTLRenderPassDescriptor, commandQueue metal.MTLCommandQueue)

Render the scene content using a specific Metal command encoder. @param viewport The pixel dimensions in which to render. @param renderCommandEncoder The Metal render command encoder that SpriteKit will use to encode rendering commands. This method will not call endEncoding. @param renderPassDescriptor The Metal render pass descriptor describing the rendering target. @param commandQueue The Metal command queue.

func (*SKRenderer) Scene 

func (o *SKRenderer) Scene() *SKScene

The currently presented scene, otherwise nil. If in a transition, the 'incoming' scene is returned.

func (*SKRenderer) SetIgnoresSiblingOrder 

func (o *SKRenderer) SetIgnoresSiblingOrder(ignoresSiblingOrder bool)

func (*SKRenderer) SetScene 

func (o *SKRenderer) SetScene(scene *SKScene)

func (*SKRenderer) SetShouldCullNonVisibleNodes 

func (o *SKRenderer) SetShouldCullNonVisibleNodes(shouldCullNonVisibleNodes bool)

func (*SKRenderer) SetShowsDrawCount 

func (o *SKRenderer) SetShowsDrawCount(showsDrawCount bool)

func (*SKRenderer) SetShowsFields 

func (o *SKRenderer) SetShowsFields(showsFields bool)

func (*SKRenderer) SetShowsNodeCount 

func (o *SKRenderer) SetShowsNodeCount(showsNodeCount bool)

func (*SKRenderer) SetShowsPhysics 

func (o *SKRenderer) SetShowsPhysics(showsPhysics bool)

func (*SKRenderer) SetShowsQuadCount 

func (o *SKRenderer) SetShowsQuadCount(showsQuadCount bool)

func (*SKRenderer) ShouldCullNonVisibleNodes 

func (o *SKRenderer) ShouldCullNonVisibleNodes() bool

A boolean that indicated whether non-visible nodes should be automatically culled when rendering.

func (*SKRenderer) ShowsDrawCount 

func (o *SKRenderer) ShowsDrawCount() bool

Toggles display of performance stats when rendering. All default to false.

func (*SKRenderer) ShowsFields 

func (o *SKRenderer) ShowsFields() bool

func (*SKRenderer) ShowsNodeCount 

func (o *SKRenderer) ShowsNodeCount() bool

func (*SKRenderer) ShowsPhysics 

func (o *SKRenderer) ShowsPhysics() bool

func (*SKRenderer) ShowsQuadCount 

func (o *SKRenderer) ShowsQuadCount() bool

func (*SKRenderer) UpdateAtTime 

func (o *SKRenderer) UpdateAtTime(currentTime float64)

Update the scene at the specified system time. @param currentTime The timestamp in seconds.

type SKRepeatMode 

type SKRepeatMode int64
const (
	SKRepeatModeClamp SKRepeatMode = 1
	SKRepeatModeLoop  SKRepeatMode = 2
)

func (SKRepeatMode) String 

func (e SKRepeatMode) String() string

type SKScene 

type SKScene struct {
	SKEffectNode
}

A scene is the root node of your content. It is used to display SpriteKit content on an SKView. @see SKView

Apple documentation: https://developer.apple.com/documentation/spritekit/skscene

func SKSceneFromID 

func SKSceneFromID(id objc.ID) *SKScene

func SKSceneSceneWithSize 

func SKSceneSceneWithSize(size corefoundation.CGSize) *SKScene

func (*SKScene) AnchorPoint 

func (o *SKScene) AnchorPoint() corefoundation.CGPoint

Used to choose the origin of the scene's coordinate system

func (*SKScene) AudioEngine 

func (o *SKScene) AudioEngine() *avfaudio.AVAudioEngine

func (*SKScene) BackgroundColor 

func (o *SKScene) BackgroundColor() *appkit.NSColor

Background color, defaults to gray

func (*SKScene) Camera 

func (o *SKScene) Camera() *SKCameraNode

The camera that is used to obtain the view scale and translation based on where the camera is in relation to the scene.

func (*SKScene) ConvertPointFromView 

func (o *SKScene) ConvertPointFromView(point corefoundation.CGPoint) corefoundation.CGPoint

func (*SKScene) ConvertPointToView 

func (o *SKScene) ConvertPointToView(point corefoundation.CGPoint) corefoundation.CGPoint

func (*SKScene) Delegate 

func (o *SKScene) Delegate() SKSceneDelegate

func (*SKScene) DidApplyConstraints 

func (o *SKScene) DidApplyConstraints()

Override this to perform game logic. Called exactly once per frame after any enabled constraints have been applied. Any additional actions applied is not evaluated until the next update. Any changes to physics bodies is not simulated until the next update. Any changes to constraints will not be applied until the next update.

func (*SKScene) DidChangeSize 

func (o *SKScene) DidChangeSize(oldSize corefoundation.CGSize)

func (*SKScene) DidEvaluateActions 

func (o *SKScene) DidEvaluateActions()

Override this to perform game logic. Called exactly once per frame after any actions have been evaluated but before any physics are simulated. Any additional actions applied is not evaluated until the next update.

func (*SKScene) DidFinishUpdate 

func (o *SKScene) DidFinishUpdate()

Override this to perform game logic. Called after all update logic has been completed. Any additional actions applied are not evaluated until the next update. Any changes to physics bodies are not simulated until the next update. Any changes to constraints will not be applied until the next update. No futher update logic will be applied to the scene after this call. Any values set on nodes here will be used when the scene is rendered for the current frame.

func (*SKScene) DidMoveToView 

func (o *SKScene) DidMoveToView(view *SKView)

func (*SKScene) DidSimulatePhysics 

func (o *SKScene) DidSimulatePhysics()

Override this to perform game logic. Called exactly once per frame after any actions have been evaluated and any physics have been simulated. Any additional actions applied is not evaluated until the next update. Any changes to physics bodies is not simulated until the next update.

func (*SKScene) InitWithSize 

func (o *SKScene) InitWithSize(size corefoundation.CGSize) *SKScene

A scene is infinitely large, but it has a viewport that is the frame through which you present the content of the scene. The passed in size defines the size of this viewport that you use to present the scene. @param size a size in points that signifies the viewport into the scene that defines your framing of the scene.

func (*SKScene) Listener 

func (o *SKScene) Listener() *SKNode

The node that is currently the listener for positional audio coming from SKAudioNodes @see SKAudioNode

func (*SKScene) PhysicsWorld 

func (o *SKScene) PhysicsWorld() *SKPhysicsWorld

Physics simulation functionality

func (*SKScene) ScaleMode 

func (o *SKScene) ScaleMode() SKSceneScaleMode

Used to determine how to scale the scene to match the SKView it is being displayed in.

func (*SKScene) SceneDidLoad 

func (o *SKScene) SceneDidLoad()

func (*SKScene) SetAnchorPoint 

func (o *SKScene) SetAnchorPoint(anchorPoint corefoundation.CGPoint)

func (*SKScene) SetBackgroundColor 

func (o *SKScene) SetBackgroundColor(backgroundColor *appkit.NSColor)

func (*SKScene) SetCamera 

func (o *SKScene) SetCamera(camera *SKCameraNode)

func (*SKScene) SetDelegate 

func (o *SKScene) SetDelegate(delegate SKSceneDelegate)

func (*SKScene) SetListener 

func (o *SKScene) SetListener(listener *SKNode)

func (*SKScene) SetScaleMode 

func (o *SKScene) SetScaleMode(scaleMode SKSceneScaleMode)

func (*SKScene) SetSize 

func (o *SKScene) SetSize(size corefoundation.CGSize)

func (*SKScene) Size 

func (o *SKScene) Size() corefoundation.CGSize

func (*SKScene) Update 

func (o *SKScene) Update(currentTime float64)

Override this to perform per-frame game logic. Called exactly once per frame before any actions are evaluated and any physics are simulated. @param currentTime the current time in the app. This must be monotonically increasing.

func (*SKScene) View 

func (o *SKScene) View() *SKView

The SKView this scene is currently presented in, or nil if it is not being presented.

func (*SKScene) WillMoveFromView 

func (o *SKScene) WillMoveFromView(view *SKView)

type SKSceneDelegate 

type SKSceneDelegate interface {
}

SKSceneDelegate wraps the ObjC protocol SKSceneDelegate.

type SKSceneScaleMode 

type SKSceneScaleMode int64
const (
	SKSceneScaleModeFill       SKSceneScaleMode = 0
	SKSceneScaleModeAspectFill SKSceneScaleMode = 1
	SKSceneScaleModeAspectFit  SKSceneScaleMode = 2
	SKSceneScaleModeResizeFill SKSceneScaleMode = 3
)

func (SKSceneScaleMode) String 

func (e SKSceneScaleMode) String() string

type SKShader 

type SKShader struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skshader

func SKShaderFromID 

func SKShaderFromID(id objc.ID) *SKShader

func SKShaderShader 

func SKShaderShader() *SKShader

func SKShaderShaderWithFileNamed 

func SKShaderShaderWithFileNamed(name *foundation.NSString) *SKShader

Loads a shader source file named 'name' from the main bundle. This is simpler yet functionally equivalent to the following code [SKShader shaderWithSource:[NSString stringWithContentsOfFile:[[NSBundle mainBundle] pathForResource:name ofType:@"fsh"] encoding:NSUTF8StringEncoding error:NULL]]; The encoding is assumed to be NSUTF8StringEncoding.

func SKShaderShaderWithSource 

func SKShaderShaderWithSource(source *foundation.NSString) *SKShader

func SKShaderShaderWithSourceUniforms 

func SKShaderShaderWithSourceUniforms(source *foundation.NSString, uniforms *foundation.NSArray[*SKUniform]) *SKShader

func (*SKShader) AddUniform 

func (o *SKShader) AddUniform(uniform *SKUniform)

func (*SKShader) Attributes 

func (o *SKShader) Attributes() *foundation.NSArray[*SKAttribute]

func (*SKShader) InitWithSource 

func (o *SKShader) InitWithSource(source *foundation.NSString) *SKShader

Create a custom shader with source code. @param source the source code for the custom fragment shader.

func (*SKShader) InitWithSourceUniforms 

func (o *SKShader) InitWithSourceUniforms(source *foundation.NSString, uniforms *foundation.NSArray[*SKUniform]) *SKShader

Create a custom shader with source code and uniforms. @param source the source code for the custom fragment shader. @param uniforms the array of uniforms supplied to this shader

func (*SKShader) RemoveUniformNamed 

func (o *SKShader) RemoveUniformNamed(name *foundation.NSString)

func (*SKShader) SetAttributes 

func (o *SKShader) SetAttributes(attributes *foundation.NSArray[*SKAttribute])

func (*SKShader) SetSource 

func (o *SKShader) SetSource(source *foundation.NSString)

func (*SKShader) SetUniforms 

func (o *SKShader) SetUniforms(uniforms *foundation.NSArray[*SKUniform])

func (*SKShader) Source 

func (o *SKShader) Source() *foundation.NSString

func (*SKShader) UniformNamed 

func (o *SKShader) UniformNamed(name *foundation.NSString) *SKUniform

func (*SKShader) Uniforms 

func (o *SKShader) Uniforms() *foundation.NSArray[*SKUniform]

You may define additional uniforms to be used in your shader here. There is no need to declare them in you source, just use them by name. All uniforms declared must be used within the source.

type SKShapeNode 

type SKShapeNode struct {
	SKNode
}

A SpriteKit Node used to stroke or fill a shape. CGPaths are used to supply the path. See CGPath <a href="http://developer.apple.com/library/mac/#documentation/GraphicsImaging/Reference/CGPath/Reference/reference.html">reference pages</a> for details on how to construct a CGPath.

Apple documentation: https://developer.apple.com/documentation/spritekit/skshapenode

func SKShapeNodeFromID 

func SKShapeNodeFromID(id objc.ID) *SKShapeNode

func SKShapeNodeShapeNodeWithCircleOfRadius 

func SKShapeNodeShapeNodeWithCircleOfRadius(radius float64) *SKShapeNode

func SKShapeNodeShapeNodeWithEllipseInRect 

func SKShapeNodeShapeNodeWithEllipseInRect(rect corefoundation.CGRect) *SKShapeNode

func SKShapeNodeShapeNodeWithEllipseOfSize 

func SKShapeNodeShapeNodeWithEllipseOfSize(size corefoundation.CGSize) *SKShapeNode

func SKShapeNodeShapeNodeWithPath 

func SKShapeNodeShapeNodeWithPath(path unsafe.Pointer) *SKShapeNode

func SKShapeNodeShapeNodeWithPathCentered 

func SKShapeNodeShapeNodeWithPathCentered(path unsafe.Pointer, centered bool) *SKShapeNode

func SKShapeNodeShapeNodeWithPointsCount 

func SKShapeNodeShapeNodeWithPointsCount(points *corefoundation.CGPoint, numPoints uint) *SKShapeNode

func SKShapeNodeShapeNodeWithRect 

func SKShapeNodeShapeNodeWithRect(rect corefoundation.CGRect) *SKShapeNode

func SKShapeNodeShapeNodeWithRectCornerRadius 

func SKShapeNodeShapeNodeWithRectCornerRadius(rect corefoundation.CGRect, cornerRadius float64) *SKShapeNode

func SKShapeNodeShapeNodeWithRectOfSize 

func SKShapeNodeShapeNodeWithRectOfSize(size corefoundation.CGSize) *SKShapeNode

func SKShapeNodeShapeNodeWithRectOfSizeCornerRadius 

func SKShapeNodeShapeNodeWithRectOfSizeCornerRadius(size corefoundation.CGSize, cornerRadius float64) *SKShapeNode

func SKShapeNodeShapeNodeWithSplinePointsCount 

func SKShapeNodeShapeNodeWithSplinePointsCount(points *corefoundation.CGPoint, numPoints uint) *SKShapeNode

func (*SKShapeNode) BlendMode 

func (o *SKShapeNode) BlendMode() SKBlendMode

Sets the blend mode to use when composing the shape with the final framebuffer. @see SKNode.SKBlendMode

func (*SKShapeNode) FillColor 

func (o *SKShapeNode) FillColor() *appkit.NSColor

The color to fill the path with. Defaults to [SKColor clearColor] (no fill).

func (*SKShapeNode) FillShader 

func (o *SKShapeNode) FillShader() *SKShader

func (*SKShapeNode) FillTexture 

func (o *SKShapeNode) FillTexture() *SKTexture

func (*SKShapeNode) GlowWidth 

func (o *SKShapeNode) GlowWidth() float64

Add a glow to the path stroke of the specified width. Defaults to 0.0 (no glow)

func (*SKShapeNode) IsAntialiased 

func (o *SKShapeNode) IsAntialiased() bool

If set to YES, the path stroke edges and caps is smoothed (antialiased) when drawn.

func (*SKShapeNode) LineCap 

func (o *SKShapeNode) LineCap() coregraphics.CGLineCap

The cap type that should be used when stroking a non-closed path

func (*SKShapeNode) LineJoin 

func (o *SKShapeNode) LineJoin() coregraphics.CGLineJoin

The join type that should be used when stroking a path

func (*SKShapeNode) LineLength 

func (o *SKShapeNode) LineLength() float64

The length of the node's path if it were to be stroked

func (*SKShapeNode) LineWidth 

func (o *SKShapeNode) LineWidth() float64

The width used to stroke the path. Widths larger than 2.0 may result in artifacts. Defaults to 1.0.

func (*SKShapeNode) MiterLimit 

func (o *SKShapeNode) MiterLimit() float64

When a miter join is used, the maximum ratio of miter length to line with to be used

func (*SKShapeNode) Path 

func (o *SKShapeNode) Path() unsafe.Pointer

The CGPath to be drawn (in the Node's coordinate space)

func (*SKShapeNode) SetAntialiased 

func (o *SKShapeNode) SetAntialiased(antialiased bool)

func (*SKShapeNode) SetBlendMode 

func (o *SKShapeNode) SetBlendMode(blendMode SKBlendMode)

func (*SKShapeNode) SetFillColor 

func (o *SKShapeNode) SetFillColor(fillColor *appkit.NSColor)

func (*SKShapeNode) SetFillShader 

func (o *SKShapeNode) SetFillShader(fillShader *SKShader)

func (*SKShapeNode) SetFillTexture 

func (o *SKShapeNode) SetFillTexture(fillTexture *SKTexture)

func (*SKShapeNode) SetGlowWidth 

func (o *SKShapeNode) SetGlowWidth(glowWidth float64)

func (*SKShapeNode) SetLineCap 

func (o *SKShapeNode) SetLineCap(lineCap coregraphics.CGLineCap)

func (*SKShapeNode) SetLineJoin 

func (o *SKShapeNode) SetLineJoin(lineJoin coregraphics.CGLineJoin)

func (*SKShapeNode) SetLineWidth 

func (o *SKShapeNode) SetLineWidth(lineWidth float64)

func (*SKShapeNode) SetMiterLimit 

func (o *SKShapeNode) SetMiterLimit(miterLimit float64)

func (*SKShapeNode) SetPath 

func (o *SKShapeNode) SetPath(path unsafe.Pointer)

func (*SKShapeNode) SetStrokeColor 

func (o *SKShapeNode) SetStrokeColor(strokeColor *appkit.NSColor)

func (*SKShapeNode) SetStrokeShader 

func (o *SKShapeNode) SetStrokeShader(strokeShader *SKShader)

func (*SKShapeNode) SetStrokeTexture 

func (o *SKShapeNode) SetStrokeTexture(strokeTexture *SKTexture)

func (*SKShapeNode) StrokeColor 

func (o *SKShapeNode) StrokeColor() *appkit.NSColor

The color to draw the path with. (for no stroke use [SKColor clearColor]). Defaults to [SKColor whiteColor].

func (*SKShapeNode) StrokeShader 

func (o *SKShapeNode) StrokeShader() *SKShader

func (*SKShapeNode) StrokeTexture 

func (o *SKShapeNode) StrokeTexture() *SKTexture

type SKSpriteNode 

type SKSpriteNode struct {
	SKNode
}

A Sprite is a textured 2D node. It can be placed, rotated, scaled and animated like any other node except it draws a textured rectangle specified by the bounds and anchor point. Sprites are used to define quad primitives with color and/or textures applied to them. See <a href="http://en.wikipedia.org/wiki/Sprite_(computer_graphics)">wiki</a> for a definition of a Sprite.

Apple documentation: https://developer.apple.com/documentation/spritekit/skspritenode

func SKSpriteNodeFromID 

func SKSpriteNodeFromID(id objc.ID) *SKSpriteNode

func SKSpriteNodeSpriteNodeWithColorSize 

func SKSpriteNodeSpriteNodeWithColorSize(color *appkit.NSColor, size corefoundation.CGSize) *SKSpriteNode

Create a sprite with a color and the specified bounds. @param color the color to use for tinting the sprite. @param size the size of the sprite in points

func SKSpriteNodeSpriteNodeWithImageNamed 

func SKSpriteNodeSpriteNodeWithImageNamed(name *foundation.NSString) *SKSpriteNode

Create a sprite with an image from your app bundle (An SKTexture is created for the image and set on the sprite. Its size is set to the SKTexture's pixel width/height) The position of the sprite is (0, 0) and the texture anchored at (0.5, 0.5), so that it is offset by half the width and half the height. Thus the sprite has the texture centered about the position. If you wish to have the texture anchored at a different offset set the anchorPoint to another pair of values in the interval from 0.0 up to and including 1.0. @param name is the name of an image file stored in the app bundle.

func SKSpriteNodeSpriteNodeWithImageNamedNormalMapped 

func SKSpriteNodeSpriteNodeWithImageNamedNormalMapped(name *foundation.NSString, generateNormalMap bool) *SKSpriteNode

func SKSpriteNodeSpriteNodeWithTexture 

func SKSpriteNodeSpriteNodeWithTexture(texture *SKTexture) *SKSpriteNode

Create a sprite with an SKTexture and set its size to the SKTexture's pixel width/height. @param texture the texture to reference for size and content

func SKSpriteNodeSpriteNodeWithTextureNormalMap 

func SKSpriteNodeSpriteNodeWithTextureNormalMap(texture *SKTexture, normalMap *SKTexture) *SKSpriteNode

func SKSpriteNodeSpriteNodeWithTextureSize 

func SKSpriteNodeSpriteNodeWithTextureSize(texture *SKTexture, size corefoundation.CGSize) *SKSpriteNode

Create a sprite with an SKTexture and the specified size. @param texture the texture to reference for size and content @param size the size of the sprite in points

func (*SKSpriteNode) AnchorPoint 

func (o *SKSpriteNode) AnchorPoint() corefoundation.CGPoint

Used to choose the location in the sprite that maps to its 'position' in the parent's coordinate space. The valid interval for each input is from 0.0 up to and including 1.0.

func (*SKSpriteNode) BlendMode 

func (o *SKSpriteNode) BlendMode() SKBlendMode

Sets the blend mode to use when composing the sprite with the final framebuffer. @see SKNode.SKBlendMode

func (*SKSpriteNode) CenterRect 

func (o *SKSpriteNode) CenterRect() corefoundation.CGRect

Controls how the texture is stretched to fill the SKSpriteNode. Stretching is performed via a 9-part algorithm where the upper & lower middle parts are scaled horizontally, the left and right middle parts are scaled vertically, the center is scaled in both directions, and the corners are preserved. The centerRect defines the center region in a (0.0 - 1.0) coordinate space. Defaults to {(0,0) (1,1)} (the entire texture is stretched).

func (*SKSpriteNode) Color 

func (o *SKSpriteNode) Color() *appkit.NSColor

Base color for the sprite (If no texture is present, the color still is drawn)

func (*SKSpriteNode) ColorBlendFactor 

func (o *SKSpriteNode) ColorBlendFactor() float64

Controls the blending between the texture and the sprite's color. The valid interval of values is from 0.0 up to and including 1.0. A value above or below that interval is clamped to the minimum (0.0) if below or the maximum (1.0) if above.

func (*SKSpriteNode) InitWithCoder 

func (o *SKSpriteNode) InitWithCoder(aDecoder *foundation.NSCoder) *SKSpriteNode

Support coding and decoding via NSKeyedArchiver.

func (*SKSpriteNode) InitWithColorSize 

func (o *SKSpriteNode) InitWithColorSize(color *appkit.NSColor, size corefoundation.CGSize) *SKSpriteNode

Initialize a sprite with a color and the specified bounds. @param color the color to use for tinting the sprite. @param size the size of the sprite in points

func (*SKSpriteNode) InitWithImageNamed 

func (o *SKSpriteNode) InitWithImageNamed(name *foundation.NSString) *SKSpriteNode

Initialize a sprite with an image from your app bundle (An SKTexture is created for the image and set on the sprite. Its size is set to the SKTexture's pixel width/height) The position of the sprite is (0, 0) and the texture anchored at (0.5, 0.5), so that it is offset by half the width and half the height. Thus the sprite has the texture centered about the position. If you wish to have the texture anchored at a different offset set the anchorPoint to another pair of values in the interval from 0.0 up to and including 1.0. @param name the name or path of the image to load.

func (*SKSpriteNode) InitWithTexture 

func (o *SKSpriteNode) InitWithTexture(texture *SKTexture) *SKSpriteNode

Initialize a sprite with an SKTexture and set its size to the SKTexture's width/height. @param texture the texture to reference for size and content

func (*SKSpriteNode) InitWithTextureColorSize 

func (o *SKSpriteNode) InitWithTextureColorSize(texture *SKTexture, color *appkit.NSColor, size corefoundation.CGSize) *SKSpriteNode

Designated Initializer Initialize a sprite with a color and the specified bounds. @param texture the texture to use (can be nil for colored sprite) @param color the color to use for tinting the sprite. @param size the size of the sprite in points

func (*SKSpriteNode) LightingBitMask 

func (o *SKSpriteNode) LightingBitMask() uint32

Bitmask to indicate being lit by a set of lights using overlapping lighting categories. A light whose category is set to a value that masks to non-zero using this mask will apply light to this sprite. When used together with a normal texture, complex lighting effects can be used.

func (*SKSpriteNode) NormalTexture 

func (o *SKSpriteNode) NormalTexture() *SKTexture

Texture to use for generating normals that lights use to light this sprite. This will only be used if the sprite is lit by at least one light. @see SKLightNode @see lightingBitMask

func (*SKSpriteNode) ScaleToSize 

func (o *SKSpriteNode) ScaleToSize(size corefoundation.CGSize)

Adjust the sprite's xScale & yScale to achieve the desired size (in parent's coordinate space)

func (*SKSpriteNode) SetAnchorPoint 

func (o *SKSpriteNode) SetAnchorPoint(anchorPoint corefoundation.CGPoint)

func (*SKSpriteNode) SetBlendMode 

func (o *SKSpriteNode) SetBlendMode(blendMode SKBlendMode)

func (*SKSpriteNode) SetCenterRect 

func (o *SKSpriteNode) SetCenterRect(centerRect corefoundation.CGRect)

func (*SKSpriteNode) SetColor 

func (o *SKSpriteNode) SetColor(color *appkit.NSColor)

func (*SKSpriteNode) SetColorBlendFactor 

func (o *SKSpriteNode) SetColorBlendFactor(colorBlendFactor float64)

func (*SKSpriteNode) SetLightingBitMask 

func (o *SKSpriteNode) SetLightingBitMask(lightingBitMask uint32)

func (*SKSpriteNode) SetNormalTexture 

func (o *SKSpriteNode) SetNormalTexture(normalTexture *SKTexture)

func (*SKSpriteNode) SetShader 

func (o *SKSpriteNode) SetShader(shader *SKShader)

func (*SKSpriteNode) SetShadowCastBitMask 

func (o *SKSpriteNode) SetShadowCastBitMask(shadowCastBitMask uint32)

func (*SKSpriteNode) SetShadowedBitMask 

func (o *SKSpriteNode) SetShadowedBitMask(shadowedBitMask uint32)

func (*SKSpriteNode) SetSize 

func (o *SKSpriteNode) SetSize(size corefoundation.CGSize)

func (*SKSpriteNode) SetTexture 

func (o *SKSpriteNode) SetTexture(texture *SKTexture)

func (*SKSpriteNode) Shader 

func (o *SKSpriteNode) Shader() *SKShader

func (*SKSpriteNode) ShadowCastBitMask 

func (o *SKSpriteNode) ShadowCastBitMask() uint32

func (*SKSpriteNode) ShadowedBitMask 

func (o *SKSpriteNode) ShadowedBitMask() uint32

func (*SKSpriteNode) Size 

func (o *SKSpriteNode) Size() corefoundation.CGSize

Set the size of the sprite (in parent's coordinate space)

func (*SKSpriteNode) Texture 

func (o *SKSpriteNode) Texture() *SKTexture

Texture to be drawn (is stretched to fill the sprite)

type SKTexture 

type SKTexture struct {
	foundation.NSObject
}

A texture to be mapped onto SKSpriteNode instances.

Apple documentation: https://developer.apple.com/documentation/spritekit/sktexture

func SKTextureFromID 

func SKTextureFromID(id objc.ID) *SKTexture

func SKTextureTextureNoiseWithSmoothnessSizeGrayscale 

func SKTextureTextureNoiseWithSmoothnessSizeGrayscale(smoothness float64, size corefoundation.CGSize, grayscale bool) *SKTexture

Create a texture containing colored noise. The noise texture is tileable with itself. @param size the size of the resulting texture. @param smoothness how similar neighboring pixels are. A value of zero is like static, one is smooth. @param grayscale if YES, RGB and A will all be the same. If no, RGB and A will all be different. A is not pre-multiplied, because the intent is that if you read a texel in a shader, all four values will be exactly the same value if grayscale, or four different, uncorrelated values if not grayscale.

func SKTextureTextureVectorNoiseWithSmoothnessSize 

func SKTextureTextureVectorNoiseWithSmoothnessSize(smoothness float64, size corefoundation.CGSize) *SKTexture

Create a texture containing directional noise. The RGBA values in this texture can be used as a normal map or as direction possibly with length. XYZ are a three dimensional direction, and A is a magnitude. @param size the size of the resulting texture. @param smoothness how similar neighboring pixels are. A value of zero is like static, one is smooth.

func SKTextureTextureWithCGImage 

func SKTextureTextureWithCGImage(image unsafe.Pointer) *SKTexture

Create a texture from a CGImageRef. @param image the CGImageRef to create the texture from

func SKTextureTextureWithDataSize 

func SKTextureTextureWithDataSize(pixelData *foundation.NSData, size corefoundation.CGSize) *SKTexture

Create new texture with bitmap RGBA data in unsigned bytes. Data is copied once, additional changes to the data does not affect the texture. All pixel data is assumed to be premultiplied alpha. @param pixelData the pixelData to read in creating the texture. @param size the dimensions of the pixelData given.

func SKTextureTextureWithDataSizeFlipped 

func SKTextureTextureWithDataSizeFlipped(pixelData *foundation.NSData, size corefoundation.CGSize, flipped bool) *SKTexture

func SKTextureTextureWithDataSizeRowLengthAlignment 

func SKTextureTextureWithDataSizeRowLengthAlignment(pixelData *foundation.NSData, size corefoundation.CGSize, rowLength uint, alignment uint) *SKTexture

Create new texture with bitmap RGBA data in unsigned bytes using a custom row length and row alignment. Data is copied once, additional changes to the data does not affect the texture. All pixel data is assumed to be premultiplied alpha. @param pixelData the data to use @param size the size in texels @param rowLength the length of each row in pixels (allows byte row pitches greater than the width for aligned data) @param alignment the byte alignment of the data, provide 0 for tightly packed data.

func SKTextureTextureWithImage 

func SKTextureTextureWithImage(image *appkit.NSImage) *SKTexture

func SKTextureTextureWithImageNamed 

func SKTextureTextureWithImageNamed(name *foundation.NSString) *SKTexture

Create a texture from an image file. Behaves similar to imageNamed: in UIImage or NSImage @param name the name or path of the image to load.

func SKTextureTextureWithRectInTexture 

func SKTextureTextureWithRectInTexture(rect corefoundation.CGRect, texture *SKTexture) *SKTexture

Create a texture that is a subrect of an existing texture. See textureRect property for details. @param rect the source rectangle to use in creating a logical copy of the given texture. @param texture the existing texture to reference in the copy.

func (*SKTexture) CGImage 

func (o *SKTexture) CGImage() unsafe.Pointer

Convert the current SKTexture into a CGImageRef object

func (*SKTexture) FilteringMode 

func (o *SKTexture) FilteringMode() SKTextureFilteringMode

The filtering mode the texture should use when not drawn at native size. Defaults to SKTextureFilteringLinear.

func (*SKTexture) PreloadWithCompletionHandler 

func (o *SKTexture) PreloadWithCompletionHandler(completionHandler func())

Request that this texture be loaded into vram on the next render update, with a callback handler.

func (*SKTexture) SetFilteringMode 

func (o *SKTexture) SetFilteringMode(filteringMode SKTextureFilteringMode)

func (*SKTexture) SetUsesMipmaps 

func (o *SKTexture) SetUsesMipmaps(usesMipmaps bool)

func (*SKTexture) Size 

func (o *SKTexture) Size() corefoundation.CGSize

The size of the texture's bitmap data in points.

func (*SKTexture) TextureByApplyingCIFilter 

func (o *SKTexture) TextureByApplyingCIFilter(filter *coreimage.CIFilter) *SKTexture

Create new texture by applying a CIFilter to an existing one. Any CIFilter that requires only a single "inputImage" and produces an "outputImage" is allowed. @param filter the CI filter to apply in the copy.

func (*SKTexture) TextureByGeneratingNormalMap 

func (o *SKTexture) TextureByGeneratingNormalMap() *SKTexture

Create new texture by generating a normal map texture.

func (*SKTexture) TextureByGeneratingNormalMapWithSmoothnessContrast 

func (o *SKTexture) TextureByGeneratingNormalMapWithSmoothnessContrast(smoothness float64, contrast float64) *SKTexture

Create new texture by generating a normal map texture. @param smoothness the smooth level of the generated normal map. @param contrast the scale applied to the generated normal map.

func (*SKTexture) TextureRect 

func (o *SKTexture) TextureRect() corefoundation.CGRect

Used to choose the area of the texture you want to display. The origin and size should both be in the range 0.0 - 1.0, values outside of this range produces unpredictable results. Defaults to the entire texture {(0,0) (1,1)}.

func (*SKTexture) UsesMipmaps 

func (o *SKTexture) UsesMipmaps() bool

Request that the texture have mipmaps generated if possible. Only supported for power of 2 texture sizes.

type SKTextureAtlas 

type SKTextureAtlas struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/sktextureatlas

func SKTextureAtlasAtlasNamed 

func SKTextureAtlasAtlasNamed(name *foundation.NSString) *SKTextureAtlas

func SKTextureAtlasAtlasWithDictionary 

func SKTextureAtlasAtlasWithDictionary(properties *foundation.NSDictionary[*foundation.NSString, objc.ID]) *SKTextureAtlas

func SKTextureAtlasFromID 

func SKTextureAtlasFromID(id objc.ID) *SKTextureAtlas

func (*SKTextureAtlas) PreloadWithCompletionHandler 

func (o *SKTextureAtlas) PreloadWithCompletionHandler(completionHandler func())

Request that this texture atlas be loaded into vram on the next render update, with a callback handler.

func (*SKTextureAtlas) TextureNamed 

func (o *SKTextureAtlas) TextureNamed(name *foundation.NSString) *SKTexture

func (*SKTextureAtlas) TextureNames 

func (o *SKTextureAtlas) TextureNames() *foundation.NSArray[*foundation.NSString]

type SKTextureFilteringMode 

type SKTextureFilteringMode int64
const (
	SKTextureFilteringNearest SKTextureFilteringMode = 0
	SKTextureFilteringLinear  SKTextureFilteringMode = 1
)

func (SKTextureFilteringMode) String 

func (e SKTextureFilteringMode) String() string

type SKTileAdjacencyMask 

type SKTileAdjacencyMask uint64
const (
	SKTileAdjacencyUp                  SKTileAdjacencyMask = 1
	SKTileAdjacencyUpperRight          SKTileAdjacencyMask = 2
	SKTileAdjacencyRight               SKTileAdjacencyMask = 4
	SKTileAdjacencyLowerRight          SKTileAdjacencyMask = 8
	SKTileAdjacencyDown                SKTileAdjacencyMask = 16
	SKTileAdjacencyLowerLeft           SKTileAdjacencyMask = 32
	SKTileAdjacencyLeft                SKTileAdjacencyMask = 64
	SKTileAdjacencyUpperLeft           SKTileAdjacencyMask = 128
	SKTileAdjacencyAll                 SKTileAdjacencyMask = 255
	SKTileHexFlatAdjacencyUp           SKTileAdjacencyMask = 1
	SKTileHexFlatAdjacencyUpperRight   SKTileAdjacencyMask = 2
	SKTileHexFlatAdjacencyLowerRight   SKTileAdjacencyMask = 4
	SKTileHexFlatAdjacencyDown         SKTileAdjacencyMask = 8
	SKTileHexFlatAdjacencyLowerLeft    SKTileAdjacencyMask = 16
	SKTileHexFlatAdjacencyUpperLeft    SKTileAdjacencyMask = 32
	SKTileHexFlatAdjacencyAll          SKTileAdjacencyMask = 63
	SKTileHexPointyAdjacencyUpperLeft  SKTileAdjacencyMask = 1
	SKTileHexPointyAdjacencyUpperRight SKTileAdjacencyMask = 2
	SKTileHexPointyAdjacencyRight      SKTileAdjacencyMask = 4
	SKTileHexPointyAdjacencyLowerRight SKTileAdjacencyMask = 8
	SKTileHexPointyAdjacencyLowerLeft  SKTileAdjacencyMask = 16
	SKTileHexPointyAdjacencyLeft       SKTileAdjacencyMask = 32
	SKTileHexPointyAdjacencyAdd        SKTileAdjacencyMask = 63
	SKTileAdjacencyUpEdge              SKTileAdjacencyMask = 124
	SKTileAdjacencyUpperRightEdge      SKTileAdjacencyMask = 112
	SKTileAdjacencyRightEdge           SKTileAdjacencyMask = 241
	SKTileAdjacencyLowerRightEdge      SKTileAdjacencyMask = 193
	SKTileAdjacencyDownEdge            SKTileAdjacencyMask = 199
	SKTileAdjacencyLowerLeftEdge       SKTileAdjacencyMask = 7
	SKTileAdjacencyLeftEdge            SKTileAdjacencyMask = 31
	SKTileAdjacencyUpperLeftEdge       SKTileAdjacencyMask = 28
	SKTileAdjacencyUpperRightCorner    SKTileAdjacencyMask = 223
	SKTileAdjacencyLowerRightCorner    SKTileAdjacencyMask = 127
	SKTileAdjacencyLowerLeftCorner     SKTileAdjacencyMask = 253
	SKTileAdjacencyUpperLeftCorner     SKTileAdjacencyMask = 247
)

func (SKTileAdjacencyMask) String 

func (e SKTileAdjacencyMask) String() string

type SKTileDefinition 

type SKTileDefinition struct {
	foundation.NSObject
}

A tile definition contains the information needed to represent a single type of tile within a tile map.

Apple documentation: https://developer.apple.com/documentation/spritekit/sktiledefinition

func SKTileDefinitionFromID 

func SKTileDefinitionFromID(id objc.ID) *SKTileDefinition

func SKTileDefinitionTileDefinitionWithTexture 

func SKTileDefinitionTileDefinitionWithTexture(texture *SKTexture) *SKTileDefinition

Create a tile definition with an SKTexture, and set its size to the SKTexture's width/height. @param texture the texture to reference for size and content

func SKTileDefinitionTileDefinitionWithTextureNormalTextureSize 

func SKTileDefinitionTileDefinitionWithTextureNormalTextureSize(texture *SKTexture, normalTexture *SKTexture, size corefoundation.CGSize) *SKTileDefinition

Create a tile definition with an SKTexture and the specified size. @param texture the texture to reference for content @param normalTexture the normal texture to use for generating normals for lighting @param size the size of the tile in points

func SKTileDefinitionTileDefinitionWithTextureSize 

func SKTileDefinitionTileDefinitionWithTextureSize(texture *SKTexture, size corefoundation.CGSize) *SKTileDefinition

Create a tile definition with an SKTexture and the specified size. @param texture the texture to reference for content @param size the size of the tile in points

func SKTileDefinitionTileDefinitionWithTexturesNormalTexturesSizeTimePerFrame 

func SKTileDefinitionTileDefinitionWithTexturesNormalTexturesSizeTimePerFrame(textures *foundation.NSArray[*SKTexture], normalTextures *foundation.NSArray[*SKTexture], size corefoundation.CGSize, timePerFrame float64) *SKTileDefinition

Create an animated tile definition with an array of SKTextures, the specified size, and the length of time each texture should be displayed for in the animation. @param textures the textures to reference for animated content @param normalTextures the normal textures to use for generating normals for lighting @param size the size of the tile in points @param timePerFrame the duration, in seconds, that each texture in the textures array is displayed before switching to the next texture in the sequence

func SKTileDefinitionTileDefinitionWithTexturesSizeTimePerFrame 

func SKTileDefinitionTileDefinitionWithTexturesSizeTimePerFrame(textures *foundation.NSArray[*SKTexture], size corefoundation.CGSize, timePerFrame float64) *SKTileDefinition

Create an animated tile definition with an array of SKTextures, the specified size, and the length of time each texture should be displayed for in the animation. @param textures the textures to reference for animated content @param size the size of the tile in points @param timePerFrame the duration, in seconds, that each texture in the textures array is displayed before switching to the next texture in the sequence

func (*SKTileDefinition) FlipHorizontally 

func (o *SKTileDefinition) FlipHorizontally() bool

When set to YES, the tile definition's images will be flipped horizontally (i.e., the left of the image becomes the right). Defaults to NO.

func (*SKTileDefinition) FlipVertically 

func (o *SKTileDefinition) FlipVertically() bool

When set to YES, the tile definition's images will be flipped vertically (i.e., the top of the image becomes the bottom). Defaults to NO.

func (*SKTileDefinition) InitWithTexture 

func (o *SKTileDefinition) InitWithTexture(texture *SKTexture) *SKTileDefinition

Initilize a tile definition with an SKTexture, and set its size to the SKTexture's width/height. @param texture the texture to reference for size and content

func (*SKTileDefinition) InitWithTextureNormalTextureSize 

func (o *SKTileDefinition) InitWithTextureNormalTextureSize(texture *SKTexture, normalTexture *SKTexture, size corefoundation.CGSize) *SKTileDefinition

Initilize a tile definition with an SKTexture and the specified size. @param texture the texture to reference for content @param normalTexture the normal texture to use for generating normals for lighting @param size the size of the tile in points

func (*SKTileDefinition) InitWithTextureSize 

func (o *SKTileDefinition) InitWithTextureSize(texture *SKTexture, size corefoundation.CGSize) *SKTileDefinition

Initilize a tile definition with an SKTexture and the specified size. @param texture the texture to reference for content @param size the size of the tile in points

func (*SKTileDefinition) InitWithTexturesNormalTexturesSizeTimePerFrame 

func (o *SKTileDefinition) InitWithTexturesNormalTexturesSizeTimePerFrame(textures *foundation.NSArray[*SKTexture], normalTextures *foundation.NSArray[*SKTexture], size corefoundation.CGSize, timePerFrame float64) *SKTileDefinition

Initilize an animated tile definition with an array of SKTextures, the specified size, and the length of time each texture should be displayed for in the animation. @param textures the textures to reference for animated content @param normalTextures the normal textures to use for generating normals for lighting @param size the size of the tile in points @param timePerFrame the duration, in seconds, that each texture in the textures array is displayed before switching to the next texture in the sequence

func (*SKTileDefinition) InitWithTexturesSizeTimePerFrame 

func (o *SKTileDefinition) InitWithTexturesSizeTimePerFrame(textures *foundation.NSArray[*SKTexture], size corefoundation.CGSize, timePerFrame float64) *SKTileDefinition

Initilize an animated tile definition with an array of SKTextures, the specified size, and the length of time each texture should be displayed for in the animation. @param textures the textures to reference for animated content @param size the size of the tile in points @param timePerFrame the duration, in seconds, that each texture in the textures array is displayed before switching to the next texture in the sequence

func (*SKTileDefinition) Name 

func (o *SKTileDefinition) Name() *foundation.NSString

Client-assignable name for the tile definition. Defaults to nil.

func (*SKTileDefinition) NormalTextures 

func (o *SKTileDefinition) NormalTextures() *foundation.NSArray[*SKTexture]

The textures to use for generating normals that lights use to light this tile. These will only be used if the tile is lit by at least one light. Each normal texture corresponds to a texture in the textures property.

func (*SKTileDefinition) PlacementWeight 

func (o *SKTileDefinition) PlacementWeight() uint

This value is used to determine how likely this tile definition is to be chosen for placement when a SKTileGroupRule has mulitple tile definitions assigned to it. A higher value relative to the other definitions assigned to the rule make it more likely for this definition to be selected; lower values make it less likely. Defaults to 1. When set to 0, the definition will never be chosen as long as there is at least one other definition with a placementWeight above 0.

func (*SKTileDefinition) Rotation 

func (o *SKTileDefinition) Rotation() SKTileDefinitionRotation

The rotation of the tile definition's images can be set in 90 degree increments. Defaults to SKTileDefinitionRotation0.

func (*SKTileDefinition) SetFlipHorizontally 

func (o *SKTileDefinition) SetFlipHorizontally(flipHorizontally bool)

func (*SKTileDefinition) SetFlipVertically 

func (o *SKTileDefinition) SetFlipVertically(flipVertically bool)

func (*SKTileDefinition) SetName 

func (o *SKTileDefinition) SetName(name *foundation.NSString)

func (*SKTileDefinition) SetNormalTextures 

func (o *SKTileDefinition) SetNormalTextures(normalTextures *foundation.NSArray[*SKTexture])

func (*SKTileDefinition) SetPlacementWeight 

func (o *SKTileDefinition) SetPlacementWeight(placementWeight uint)

func (*SKTileDefinition) SetRotation 

func (o *SKTileDefinition) SetRotation(rotation SKTileDefinitionRotation)

func (*SKTileDefinition) SetSize 

func (o *SKTileDefinition) SetSize(size corefoundation.CGSize)

func (*SKTileDefinition) SetTextures 

func (o *SKTileDefinition) SetTextures(textures *foundation.NSArray[*SKTexture])

func (*SKTileDefinition) SetTimePerFrame 

func (o *SKTileDefinition) SetTimePerFrame(timePerFrame float64)

func (*SKTileDefinition) SetUserData 

func (o *SKTileDefinition) SetUserData(userData *foundation.NSMutableDictionary[objc.ID, objc.ID])

func (*SKTileDefinition) Size 

func (o *SKTileDefinition) Size() corefoundation.CGSize

The size of the tile in points.

func (*SKTileDefinition) Textures 

func (o *SKTileDefinition) Textures() *foundation.NSArray[*SKTexture]

The textures used to draw the tile. Non-animated tiles use only one texture. When more than one texture is present, the tile will swap through them in sequence, showing each for the duration specified in the timePerFrame property. After displaying the last texture in the array, the sequence is repeated from the first texture.

func (*SKTileDefinition) TimePerFrame 

func (o *SKTileDefinition) TimePerFrame() float64

The duration, in seconds, that each texture in the textures array is displayed before switching to the next texture in the sequence. Only used when there is more than one texture available.

func (*SKTileDefinition) UserData 

func (o *SKTileDefinition) UserData() *foundation.NSMutableDictionary[objc.ID, objc.ID]

An optional dictionary that can be used to store your own data for each tile definition. Defaults to nil.

type SKTileDefinitionRotation 

type SKTileDefinitionRotation uint64
const (
	SKTileDefinitionRotation0   SKTileDefinitionRotation = 0
	SKTileDefinitionRotation90  SKTileDefinitionRotation = 1
	SKTileDefinitionRotation180 SKTileDefinitionRotation = 2
	SKTileDefinitionRotation270 SKTileDefinitionRotation = 3
)

func (SKTileDefinitionRotation) String 

func (e SKTileDefinitionRotation) String() string

type SKTileGroup 

type SKTileGroup struct {
	foundation.NSObject
}

A tile group encapsulates a collection of related tile definitions that are designed to be pieced together within a tile map. How those tiles are pieced together is governed by the set of rules. When a tile group is placed in a tile map, the map evaluates the rules to determine which tiles should be placed to achieve the desired outcome.

Apple documentation: https://developer.apple.com/documentation/spritekit/sktilegroup

func SKTileGroupEmptyTileGroup 

func SKTileGroupEmptyTileGroup() *SKTileGroup

Create an empty tile group. Placing this in a tile map will erase the existing tile at that location.

func SKTileGroupFromID 

func SKTileGroupFromID(id objc.ID) *SKTileGroup

func SKTileGroupTileGroupWithRules 

func SKTileGroupTileGroupWithRules(rules *foundation.NSArray[*SKTileGroupRule]) *SKTileGroup

Create a tile group with the specified rules. @param rules the rules the group will use to determine tile placement

func SKTileGroupTileGroupWithTileDefinition 

func SKTileGroupTileGroupWithTileDefinition(tileDefinition *SKTileDefinition) *SKTileGroup

Create a simple tile group for a single tile definition. This creates and initializes the SKTileGroupRule necessary to place the provided tile definition in a tile map. @param tileDefinition the tile definition we wish to place in a tile map

func (*SKTileGroup) InitWithRules 

func (o *SKTileGroup) InitWithRules(rules *foundation.NSArray[*SKTileGroupRule]) *SKTileGroup

Initilize a tile group with the specified rules. @param rules the rules the group will use to determine tile placement

func (*SKTileGroup) InitWithTileDefinition 

func (o *SKTileGroup) InitWithTileDefinition(tileDefinition *SKTileDefinition) *SKTileGroup

Initilize a simple tile group for a single tile definition. This creates and initializes the SKTileGroupRule necessary to place the provided tile definition in a tile map. @param tileDefinition tile definition we wish to place in a tile map

func (*SKTileGroup) Name 

func (o *SKTileGroup) Name() *foundation.NSString

Client-assignable name for the tile group. Defaults to nil.

func (*SKTileGroup) Rules 

func (o *SKTileGroup) Rules() *foundation.NSArray[*SKTileGroupRule]

The rules that govern which tiles are placed when this group is used, and where in the map they'll be placed.

func (*SKTileGroup) SetName 

func (o *SKTileGroup) SetName(name *foundation.NSString)

func (*SKTileGroup) SetRules 

func (o *SKTileGroup) SetRules(rules *foundation.NSArray[*SKTileGroupRule])

type SKTileGroupRule 

type SKTileGroupRule struct {
	foundation.NSObject
}

A tile group rule defines how a certain type of tile should be placed on the map. These tiles are like puzzle pieces, and the rules define how they should be pieced together. This is accomplished by defining which neighboring spaces need to be filled with tiles that belong to the same group, and which tiles are required to be empty. The required pattern of neighboring tiles is defined using the SKTileAdjacencyMask.

Apple documentation: https://developer.apple.com/documentation/spritekit/sktilegrouprule

func SKTileGroupRuleFromID 

func SKTileGroupRuleFromID(id objc.ID) *SKTileGroupRule

func SKTileGroupRuleTileGroupRuleWithAdjacencyTileDefinitions 

func SKTileGroupRuleTileGroupRuleWithAdjacencyTileDefinitions(adjacency SKTileAdjacencyMask, tileDefinitions *foundation.NSArray[*SKTileDefinition]) *SKTileGroupRule

Create a tile group rule with the specified adjacency and tile definitions. @param adjacency the adjacency requirements for this rule; use the mask that covers the adjacent spaces that must be filled with tiles belonging to the same group; tiles not masked out must be empty @param tileDefinitions the tile definitions used for this rule

func (*SKTileGroupRule) Adjacency 

func (o *SKTileGroupRule) Adjacency() SKTileAdjacencyMask

The adjacency mask used by this rule. Set this to the mask that covers the adjacent spaces that must be filled with tiles belonging to the same group for this rule met.

func (*SKTileGroupRule) InitWithAdjacencyTileDefinitions 

func (o *SKTileGroupRule) InitWithAdjacencyTileDefinitions(adjacency SKTileAdjacencyMask, tileDefinitions *foundation.NSArray[*SKTileDefinition]) *SKTileGroupRule

Initilize a tile group rule with the specified adjacency and tile definitions. @param adjacency the adjacency requirements for this rule; use the mask that covers the adjacent spaces that must be filled with tiles belonging to the same group; tiles not masked out must be empty @param tileDefinitions the tile definitions used for this rule

func (*SKTileGroupRule) Name 

func (o *SKTileGroupRule) Name() *foundation.NSString

Client-assignable name for the tile group rule. Defaults to nil.

func (*SKTileGroupRule) SetAdjacency 

func (o *SKTileGroupRule) SetAdjacency(adjacency SKTileAdjacencyMask)

func (*SKTileGroupRule) SetName 

func (o *SKTileGroupRule) SetName(name *foundation.NSString)

func (*SKTileGroupRule) SetTileDefinitions 

func (o *SKTileGroupRule) SetTileDefinitions(tileDefinitions *foundation.NSArray[*SKTileDefinition])

func (*SKTileGroupRule) TileDefinitions 

func (o *SKTileGroupRule) TileDefinitions() *foundation.NSArray[*SKTileDefinition]

The tile definitions used by this rule. If the rule is evaluated and its conditions are met, one of the tile definitions within this array will be randomly selected for placement within the tile map. Each tile definitions' placement weight is taken into consideration to determine how likely each is to be selected; tile definitions with higher placement weights will be selected more frequently than those with lower placement weights.

type SKTileMapNode 

type SKTileMapNode struct {
	SKNode
}

A SpriteKit node used to render a 2D array of textured sprites. Uses SKTileSet to determine what textures it can use to render. Separate tile map nodes can be layered on top of one another to achieve various effects, such as parallax scrolling.

Apple documentation: https://developer.apple.com/documentation/spritekit/sktilemapnode

func SKTileMapNodeFromID 

func SKTileMapNodeFromID(id objc.ID) *SKTileMapNode

func SKTileMapNodeTileMapNodeWithTileSetColumnsRowsTileSize 

func SKTileMapNodeTileMapNodeWithTileSetColumnsRowsTileSize(tileSet *SKTileSet, columns uint, rows uint, tileSize corefoundation.CGSize) *SKTileMapNode

Create a tile map node with the specified tile set and dimensions. The tiles of the map will be empty, equivalent to the nil tile definition/group. @param tileSet the tile set that is used to render the tiles @param columns the number of columns in the map that can hold tiles @param rows the number of rows in the map that can hold tiles @param tileSize the size of each tile in points

func SKTileMapNodeTileMapNodeWithTileSetColumnsRowsTileSizeFillWithTileGroup 

func SKTileMapNodeTileMapNodeWithTileSetColumnsRowsTileSizeFillWithTileGroup(tileSet *SKTileSet, columns uint, rows uint, tileSize corefoundation.CGSize, tileGroup *SKTileGroup) *SKTileMapNode

Create a tile map node with the specified tile set and dimensions, and fill it with the specified tile group. @param tileSet the tile set that is used to render the tiles @param columns the number of columns in the map that can hold tiles @param rows the number of rows in the map that can hold tiles @param tileSize the size of each tile in points @param tileGroup the tile group we wish to fill the tile map with

func SKTileMapNodeTileMapNodeWithTileSetColumnsRowsTileSizeTileGroupLayout 

func SKTileMapNodeTileMapNodeWithTileSetColumnsRowsTileSizeTileGroupLayout(tileSet *SKTileSet, columns uint, rows uint, tileSize corefoundation.CGSize, tileGroupLayout *foundation.NSArray[*SKTileGroup]) *SKTileMapNode

Create a tile map node with the specified tile set and dimensions, and fill it with a specific layout of tile groups that belong to the provided tile set. The tileGroupLayout array should match the dimensions of the tile map (i.e., the number of elements should be equal to columns * rows). Index 0 of the array maps to column 0, row 0 of the tile map. Index 1 is column 1, row 0, and so on, wrapping around to the next row once the index passes the number of columns in the tile map. If the array has fewer elements than the number of tiles in the map, the remaining tiles are initialized with the nil tile group. If the array has more elements than the number of tiles in the map, the extra tile groups are ignored. @param tileSet the tile set that is used to render the tiles @param columns the number of columns in the map that can hold tiles @param rows the number of rows in the map that can hold tiles @param tileSize the size of each tile in points @param tileGroupLayout an array of tile groups that we want to use to fill the tile map

func (*SKTileMapNode) AnchorPoint 

func (o *SKTileMapNode) AnchorPoint() corefoundation.CGPoint

Used to choose the location in the tile map that maps to its 'position' in the parent's coordinate space. The valid interval for each input is from 0.0 up to and including 1.0.

func (*SKTileMapNode) BlendMode 

func (o *SKTileMapNode) BlendMode() SKBlendMode

Sets the blend mode to use when composing the tile map with the final framebuffer. @see SKNode.SKBlendMode

func (*SKTileMapNode) CenterOfTileAtColumnRow 

func (o *SKTileMapNode) CenterOfTileAtColumnRow(column uint, row uint) corefoundation.CGPoint

Returns the position of the center of the tile at the specified column and row. @param column the column index of the tile @param row the row index of the tile

func (*SKTileMapNode) Color 

func (o *SKTileMapNode) Color() *appkit.NSColor

Base color for the tile map (If no texture is present, the color still is drawn).

func (*SKTileMapNode) ColorBlendFactor 

func (o *SKTileMapNode) ColorBlendFactor() float64

Controls the blending between the texture and the tile map color. The valid interval of values is from 0.0 up to and including 1.0. A value above or below that interval is clamped to the minimum (0.0) if below or the maximum (1.0) if above.

func (*SKTileMapNode) EnableAutomapping 

func (o *SKTileMapNode) EnableAutomapping() bool

func (*SKTileMapNode) FillWithTileGroup 

func (o *SKTileMapNode) FillWithTileGroup(tileGroup *SKTileGroup)

Fill the entire tile map with the provided tile group. @param tileGroup the tile group that will be used to fill the map

func (*SKTileMapNode) InitWithTileSetColumnsRowsTileSize 

func (o *SKTileMapNode) InitWithTileSetColumnsRowsTileSize(tileSet *SKTileSet, columns uint, rows uint, tileSize corefoundation.CGSize) *SKTileMapNode

Initialize a tile map node with the specified tile set and dimensions. The tiles of the map will be empty, equivalent to the nil tile definition/group. @param tileSet the tile set that is used to render the tiles @param columns the number of columns in the map that can hold tiles @param rows the number of rows in the map that can hold tiles @param tileSize the size of each tile in points

func (*SKTileMapNode) InitWithTileSetColumnsRowsTileSizeFillWithTileGroup 

func (o *SKTileMapNode) InitWithTileSetColumnsRowsTileSizeFillWithTileGroup(tileSet *SKTileSet, columns uint, rows uint, tileSize corefoundation.CGSize, tileGroup *SKTileGroup) *SKTileMapNode

Initialize a tile map node with the specified tile set and dimensions, and fill it with the specified tile group. @param tileSet the tile set that is used to render the tiles @param columns the number of columns in the map that can hold tiles @param rows the number of rows in the map that can hold tiles @param tileSize the size of each tile in points @param tileGroup the tile group we wish to fill the tile map with

func (*SKTileMapNode) InitWithTileSetColumnsRowsTileSizeTileGroupLayout 

func (o *SKTileMapNode) InitWithTileSetColumnsRowsTileSizeTileGroupLayout(tileSet *SKTileSet, columns uint, rows uint, tileSize corefoundation.CGSize, tileGroupLayout *foundation.NSArray[*SKTileGroup]) *SKTileMapNode

Initialize a tile map node with the specified tile set and dimensions, and fill it with a specific layout of tile groups that belong to the provided tile set. The tileGroupLayout array should match the dimensions of the tile map (i.e., the number of elements should be equal to columns * rows). Index 0 of the array maps to column 0, row 0 of the tile map. Index 1 is column 1, row 0, and so on, wrapping around to the next row once the index passes the number of columns in the tile map. If the array has fewer elements than the number of tiles in the map, the remaining tiles are initialized with the nil tile group. If the array has more elements than the number of tiles in the map, the extra tile groups are ignored. @param tileSet the tile set that is used to render the tiles @param columns the number of columns in the map that can hold tiles @param rows the number of rows in the map that can hold tiles @param tileSize the size of each tile in points @param tileGroupLayout an array of tile groups that we want to use to fill the tile map

func (*SKTileMapNode) LightingBitMask 

func (o *SKTileMapNode) LightingBitMask() uint32

Bitmask to indicate being lit by a set of lights using overlapping lighting categories. A light whose category is set to a value that masks to non-zero using this mask will apply light to this sprite. When used together with a normal texture, complex lighting effects can be used.

func (*SKTileMapNode) MapSize 

func (o *SKTileMapNode) MapSize() corefoundation.CGSize

The size of the tile map. This is dependent on the tileSize, the number of columns and rows in the map, and the tile set type.

func (*SKTileMapNode) NumberOfColumns 

func (o *SKTileMapNode) NumberOfColumns() uint

The number of columns in the tile map.

func (*SKTileMapNode) NumberOfRows 

func (o *SKTileMapNode) NumberOfRows() uint

The number of rows in the tile map.

func (*SKTileMapNode) SetAnchorPoint 

func (o *SKTileMapNode) SetAnchorPoint(anchorPoint corefoundation.CGPoint)

func (*SKTileMapNode) SetBlendMode 

func (o *SKTileMapNode) SetBlendMode(blendMode SKBlendMode)

func (*SKTileMapNode) SetColor 

func (o *SKTileMapNode) SetColor(color *appkit.NSColor)

func (*SKTileMapNode) SetColorBlendFactor 

func (o *SKTileMapNode) SetColorBlendFactor(colorBlendFactor float64)

func (*SKTileMapNode) SetEnableAutomapping 

func (o *SKTileMapNode) SetEnableAutomapping(enableAutomapping bool)

func (*SKTileMapNode) SetLightingBitMask 

func (o *SKTileMapNode) SetLightingBitMask(lightingBitMask uint32)

func (*SKTileMapNode) SetNumberOfColumns 

func (o *SKTileMapNode) SetNumberOfColumns(numberOfColumns uint)

func (*SKTileMapNode) SetNumberOfRows 

func (o *SKTileMapNode) SetNumberOfRows(numberOfRows uint)

func (*SKTileMapNode) SetShader 

func (o *SKTileMapNode) SetShader(shader *SKShader)

func (*SKTileMapNode) SetTileGroupAndTileDefinitionForColumnRow 

func (o *SKTileMapNode) SetTileGroupAndTileDefinitionForColumnRow(tileGroup *SKTileGroup, tileDefinition *SKTileDefinition, column uint, row uint)

Set the tile group and tile defintion at the specified tile index. When automapping is enabled, it will attempt to resolve the surrounding tiles to allow the specified tile definition to be placed. When automapping is disabled, it will simply place the tile definition and not modify any of the neighboring tiles. @param tileGroup the tile group we want to place in the map @param tileDefinition the tile definition we want to place in the map @param column the column index of the tile @param row the row index of the tile

func (*SKTileMapNode) SetTileGroupForColumnRow 

func (o *SKTileMapNode) SetTileGroupForColumnRow(tileGroup *SKTileGroup, column uint, row uint)

Set the tile group at the specified tile index. When automapping is enabled, the appropriate tile definitions will automatically be selected and placed, possibly modifying neighboring tiles. When automapping is disabled, it will simply place the default center tile definition for the group, and will not modify any of the neihboring tiles. @param tileGroup the tile group we want to place in the map @param column the column index of the tile @param row the row index of the tile

func (*SKTileMapNode) SetTileSet 

func (o *SKTileMapNode) SetTileSet(tileSet *SKTileSet)

func (*SKTileMapNode) SetTileSize 

func (o *SKTileMapNode) SetTileSize(tileSize corefoundation.CGSize)

func (*SKTileMapNode) Shader 

func (o *SKTileMapNode) Shader() *SKShader

A property that determines whether the tile map is rendered using a custom shader.

func (*SKTileMapNode) TileColumnIndexFromPosition 

func (o *SKTileMapNode) TileColumnIndexFromPosition(position corefoundation.CGPoint) uint

Returns the column index of the tile that lies under the specified position. Returns NSUIntegerMax if the position does not fall within the tile map. @param position the position we want to check against the tile map

func (*SKTileMapNode) TileDefinitionAtColumnRow 

func (o *SKTileMapNode) TileDefinitionAtColumnRow(column uint, row uint) *SKTileDefinition

Look up the tile definition at the specified tile index. @param column the column index of the tile @param row the row index of the tile

func (*SKTileMapNode) TileGroupAtColumnRow 

func (o *SKTileMapNode) TileGroupAtColumnRow(column uint, row uint) *SKTileGroup

Look up the tile group at the specified tile index. @param column the column index of the tile @param row the row index of the tile

func (*SKTileMapNode) TileRowIndexFromPosition 

func (o *SKTileMapNode) TileRowIndexFromPosition(position corefoundation.CGPoint) uint

Returns the row index of the tile that lies under the specified position. Returns NSUIntegerMax if the position does not fall within the tile map. @param position the position we want to check against the tile map

func (*SKTileMapNode) TileSet 

func (o *SKTileMapNode) TileSet() *SKTileSet

The tile set being used by this tile map.

func (*SKTileMapNode) TileSize 

func (o *SKTileMapNode) TileSize() corefoundation.CGSize

The size of each tile in the map.

type SKTileSet 

type SKTileSet struct {
	foundation.NSObject
}

A tile set contains all of the tile definitions that are available for use in a tile map. In addition, it also contains tile groups, which define collections of related tile definitions and the rules that govern their placement.

Apple documentation: https://developer.apple.com/documentation/spritekit/sktileset

func SKTileSetFromID 

func SKTileSetFromID(id objc.ID) *SKTileSet

func SKTileSetTileSetFromURL 

func SKTileSetTileSetFromURL(url *foundation.NSURL) *SKTileSet

Creates a tile set from the specified tile set file. Returns nil if the URL doesn't point to a valid tile set file. @param url the URL of the tile set file

func SKTileSetTileSetNamed 

func SKTileSetTileSetNamed(name *foundation.NSString) *SKTileSet

Gets the tile set with the specified name from the SpriteKit resource bundle. Returns nil if a tile set with a matching name cannot be found. @param name the name of the tile set to search for

func SKTileSetTileSetWithTileGroups 

func SKTileSetTileSetWithTileGroups(tileGroups *foundation.NSArray[*SKTileGroup]) *SKTileSet

Create a tile set with the specified tile groups. @param tileGroups the tile groups that will be available for use with this set

func SKTileSetTileSetWithTileGroupsTileSetType 

func SKTileSetTileSetWithTileGroupsTileSetType(tileGroups *foundation.NSArray[*SKTileGroup], tileSetType SKTileSetType) *SKTileSet

Create a tile set with the specified tile groups and tile set type. @param tileGroups the tile groups that will be available for use with this set @param tileSetType the type of tile set this will be

func (*SKTileSet) DefaultTileGroup 

func (o *SKTileSet) DefaultTileGroup() *SKTileGroup

func (*SKTileSet) DefaultTileSize 

func (o *SKTileSet) DefaultTileSize() corefoundation.CGSize

The default tile size is the value an SKTileMapNode will use for it's tiles when the tile set is assigned to it.

func (*SKTileSet) InitWithTileGroups 

func (o *SKTileSet) InitWithTileGroups(tileGroups *foundation.NSArray[*SKTileGroup]) *SKTileSet

Initilize a tile set with the specified tile groups. @param tileGroups the tile groups that will be available for use with this set

func (*SKTileSet) InitWithTileGroupsTileSetType 

func (o *SKTileSet) InitWithTileGroupsTileSetType(tileGroups *foundation.NSArray[*SKTileGroup], tileSetType SKTileSetType) *SKTileSet

Initilize a tile set with the specified tile groups and tile set type. @param tileGroups the tile groups that will be available for use with this set @param tileSetType the type of tile set this will be

func (*SKTileSet) Name 

func (o *SKTileSet) Name() *foundation.NSString

Client-assignable name for the tile set. Defaults to nil.

func (*SKTileSet) SetDefaultTileGroup 

func (o *SKTileSet) SetDefaultTileGroup(defaultTileGroup *SKTileGroup)

func (*SKTileSet) SetDefaultTileSize 

func (o *SKTileSet) SetDefaultTileSize(defaultTileSize corefoundation.CGSize)

func (*SKTileSet) SetName 

func (o *SKTileSet) SetName(name *foundation.NSString)

func (*SKTileSet) SetTileGroups 

func (o *SKTileSet) SetTileGroups(tileGroups *foundation.NSArray[*SKTileGroup])

func (*SKTileSet) SetType 

func (o *SKTileSet) SetType(type_ SKTileSetType)

func (*SKTileSet) TileGroups 

func (o *SKTileSet) TileGroups() *foundation.NSArray[*SKTileGroup]

The tile groups that this set provides for use.

func (*SKTileSet) Type 

func (o *SKTileSet) Type() SKTileSetType

The tile set type specifies how the tiles in the set will be arranged when placed in a tile map. Defaults to SKTileSetTypeGrid.

type SKTileSetType 

type SKTileSetType uint64
const (
	SKTileSetTypeGrid            SKTileSetType = 0
	SKTileSetTypeIsometric       SKTileSetType = 1
	SKTileSetTypeHexagonalFlat   SKTileSetType = 2
	SKTileSetTypeHexagonalPointy SKTileSetType = 3
)

func (SKTileSetType) String 

func (e SKTileSetType) String() string

type SKTransformNode 

type SKTransformNode struct {
	SKNode
}

An SKTransformNode can be applied a 3D rotation that will affect the visual aspect of its children. The physics and constraints of the children will behave as if none of them were transformed.

Apple documentation: https://developer.apple.com/documentation/spritekit/sktransformnode

func SKTransformNodeFromID 

func SKTransformNodeFromID(id objc.ID) *SKTransformNode

func (*SKTransformNode) EulerAngles 

func (o *SKTransformNode) EulerAngles() unsafe.Pointer

func (*SKTransformNode) Quaternion 

func (o *SKTransformNode) Quaternion() unsafe.Pointer

func (*SKTransformNode) RotationMatrix 

func (o *SKTransformNode) RotationMatrix() unsafe.Pointer

func (*SKTransformNode) SetEulerAngles 

func (o *SKTransformNode) SetEulerAngles(euler unsafe.Pointer)

func (*SKTransformNode) SetQuaternion 

func (o *SKTransformNode) SetQuaternion(quaternion unsafe.Pointer)

func (*SKTransformNode) SetRotationMatrix 

func (o *SKTransformNode) SetRotationMatrix(rotationMatrix unsafe.Pointer)

func (*SKTransformNode) SetXRotation 

func (o *SKTransformNode) SetXRotation(xRotation float64)

func (*SKTransformNode) SetYRotation 

func (o *SKTransformNode) SetYRotation(yRotation float64)

func (*SKTransformNode) XRotation 

func (o *SKTransformNode) XRotation() float64

func (*SKTransformNode) YRotation 

func (o *SKTransformNode) YRotation() float64

type SKTransition 

type SKTransition struct {
	foundation.NSObject
}

A transition style from one scene to another.

Apple documentation: https://developer.apple.com/documentation/spritekit/sktransition

func SKTransitionCrossFadeWithDuration 

func SKTransitionCrossFadeWithDuration(sec float64) *SKTransition

func SKTransitionDoorsCloseHorizontalWithDuration 

func SKTransitionDoorsCloseHorizontalWithDuration(sec float64) *SKTransition

func SKTransitionDoorsCloseVerticalWithDuration 

func SKTransitionDoorsCloseVerticalWithDuration(sec float64) *SKTransition

func SKTransitionDoorsOpenHorizontalWithDuration 

func SKTransitionDoorsOpenHorizontalWithDuration(sec float64) *SKTransition

func SKTransitionDoorsOpenVerticalWithDuration 

func SKTransitionDoorsOpenVerticalWithDuration(sec float64) *SKTransition

func SKTransitionDoorwayWithDuration 

func SKTransitionDoorwayWithDuration(sec float64) *SKTransition

func SKTransitionFadeWithColorDuration 

func SKTransitionFadeWithColorDuration(color *appkit.NSColor, sec float64) *SKTransition

func SKTransitionFadeWithDuration 

func SKTransitionFadeWithDuration(sec float64) *SKTransition

func SKTransitionFlipHorizontalWithDuration 

func SKTransitionFlipHorizontalWithDuration(sec float64) *SKTransition

func SKTransitionFlipVerticalWithDuration 

func SKTransitionFlipVerticalWithDuration(sec float64) *SKTransition

func SKTransitionFromID 

func SKTransitionFromID(id objc.ID) *SKTransition

func SKTransitionMoveInWithDirectionDuration 

func SKTransitionMoveInWithDirectionDuration(direction SKTransitionDirection, sec float64) *SKTransition

func SKTransitionPushWithDirectionDuration 

func SKTransitionPushWithDirectionDuration(direction SKTransitionDirection, sec float64) *SKTransition

func SKTransitionRevealWithDirectionDuration 

func SKTransitionRevealWithDirectionDuration(direction SKTransitionDirection, sec float64) *SKTransition

func SKTransitionTransitionWithCIFilterDuration 

func SKTransitionTransitionWithCIFilterDuration(filter *coreimage.CIFilter, sec float64) *SKTransition

func (*SKTransition) PausesIncomingScene 

func (o *SKTransition) PausesIncomingScene() bool

Pause the incoming Scene during the transition, defaults to YES.

func (*SKTransition) PausesOutgoingScene 

func (o *SKTransition) PausesOutgoingScene() bool

Pause the outgoing Scene during the transition, defaults to YES.

func (*SKTransition) SetPausesIncomingScene 

func (o *SKTransition) SetPausesIncomingScene(pausesIncomingScene bool)

func (*SKTransition) SetPausesOutgoingScene 

func (o *SKTransition) SetPausesOutgoingScene(pausesOutgoingScene bool)

type SKTransitionDirection 

type SKTransitionDirection int64
const (
	SKTransitionDirectionUp    SKTransitionDirection = 0
	SKTransitionDirectionDown  SKTransitionDirection = 1
	SKTransitionDirectionRight SKTransitionDirection = 2
	SKTransitionDirectionLeft  SKTransitionDirection = 3
)

func (SKTransitionDirection) String 

func (e SKTransitionDirection) String() string

type SKUniform 

type SKUniform struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skuniform

func SKUniformFromID 

func SKUniformFromID(id objc.ID) *SKUniform

func SKUniformUniformWithName 

func SKUniformUniformWithName(name *foundation.NSString) *SKUniform

Create a shader uniform with a given name. @param name the name of the shader uniform.

func SKUniformUniformWithNameFloat 

func SKUniformUniformWithNameFloat(name *foundation.NSString, value float32) *SKUniform

Create a shader uniform with a given name, and a float value @param name the name of the shader uniform. @param value the floating point value associated with this uniform.

func SKUniformUniformWithNameFloatMatrix2 deprecated 

func SKUniformUniformWithNameFloatMatrix2(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func SKUniformUniformWithNameFloatMatrix3 deprecated 

func SKUniformUniformWithNameFloatMatrix3(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func SKUniformUniformWithNameFloatMatrix4 deprecated 

func SKUniformUniformWithNameFloatMatrix4(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func SKUniformUniformWithNameFloatVector2 deprecated 

func SKUniformUniformWithNameFloatVector2(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func SKUniformUniformWithNameFloatVector3 deprecated 

func SKUniformUniformWithNameFloatVector3(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func SKUniformUniformWithNameFloatVector4 deprecated 

func SKUniformUniformWithNameFloatVector4(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func SKUniformUniformWithNameMatrixFloat2x2 

func SKUniformUniformWithNameMatrixFloat2x2(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Create a shader uniform with a given name, and a 2x2 matrix value @param name the name of the shader uniform. @param value the 2x2 matrix value associated with this uniform.

func SKUniformUniformWithNameMatrixFloat3x3 

func SKUniformUniformWithNameMatrixFloat3x3(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Create a shader uniform with a given name, and a 3x3 matrix value @param name the name of the shader uniform. @param value the 3x3 matrix value associated with this uniform.

func SKUniformUniformWithNameMatrixFloat4x4 

func SKUniformUniformWithNameMatrixFloat4x4(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Create a shader uniform with a given name, and a 4x4 matrix value @param name the name of the shader uniform. @param value the 4x4 matrix value associated with this uniform.

func SKUniformUniformWithNameTexture 

func SKUniformUniformWithNameTexture(name *foundation.NSString, texture *SKTexture) *SKUniform

Create a shader uniform with a given name, and texture data @param name the name of the shader uniform. @param texture the texture data associated with this uniform.

func SKUniformUniformWithNameVectorFloat2 

func SKUniformUniformWithNameVectorFloat2(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Create a shader uniform with a given name, and a float vector2 value @param name the name of the shader uniform. @param value the float vector2 value associated with this uniform.

func SKUniformUniformWithNameVectorFloat3 

func SKUniformUniformWithNameVectorFloat3(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Create a shader uniform with a given name, and a float vector3 value @param name the name of the shader uniform. @param value the float vector3 value associated with this uniform.

func SKUniformUniformWithNameVectorFloat4 

func SKUniformUniformWithNameVectorFloat4(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Create a shader uniform with a given name, and a float vector4 value @param name the name of the shader uniform. @param value the float vector4 value associated with this uniform.

func (*SKUniform) FloatMatrix2Value deprecated 

func (o *SKUniform) FloatMatrix2Value() unsafe.Pointer

Deprecated: since macOS 10.12.

func (*SKUniform) FloatMatrix3Value deprecated 

func (o *SKUniform) FloatMatrix3Value() unsafe.Pointer

Deprecated: since macOS 10.12.

func (*SKUniform) FloatMatrix4Value deprecated 

func (o *SKUniform) FloatMatrix4Value() unsafe.Pointer

Deprecated: since macOS 10.12.

func (*SKUniform) FloatValue 

func (o *SKUniform) FloatValue() float32

func (*SKUniform) FloatVector2Value deprecated 

func (o *SKUniform) FloatVector2Value() unsafe.Pointer

Deprecated: since macOS 10.12.

func (*SKUniform) FloatVector3Value deprecated 

func (o *SKUniform) FloatVector3Value() unsafe.Pointer

Deprecated: since macOS 10.12.

func (*SKUniform) FloatVector4Value deprecated 

func (o *SKUniform) FloatVector4Value() unsafe.Pointer

Deprecated: since macOS 10.12.

func (*SKUniform) InitWithName 

func (o *SKUniform) InitWithName(name *foundation.NSString) *SKUniform

func (*SKUniform) InitWithNameFloat 

func (o *SKUniform) InitWithNameFloat(name *foundation.NSString, value float32) *SKUniform

func (*SKUniform) InitWithNameFloatMatrix2 deprecated 

func (o *SKUniform) InitWithNameFloatMatrix2(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func (*SKUniform) InitWithNameFloatMatrix3 deprecated 

func (o *SKUniform) InitWithNameFloatMatrix3(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func (*SKUniform) InitWithNameFloatMatrix4 deprecated 

func (o *SKUniform) InitWithNameFloatMatrix4(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func (*SKUniform) InitWithNameFloatVector2 deprecated 

func (o *SKUniform) InitWithNameFloatVector2(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func (*SKUniform) InitWithNameFloatVector3 deprecated 

func (o *SKUniform) InitWithNameFloatVector3(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func (*SKUniform) InitWithNameFloatVector4 deprecated 

func (o *SKUniform) InitWithNameFloatVector4(name *foundation.NSString, value unsafe.Pointer) *SKUniform

Deprecated: since macOS 10.12.

func (*SKUniform) InitWithNameMatrixFloat2x2 

func (o *SKUniform) InitWithNameMatrixFloat2x2(name *foundation.NSString, value unsafe.Pointer) *SKUniform

func (*SKUniform) InitWithNameMatrixFloat3x3 

func (o *SKUniform) InitWithNameMatrixFloat3x3(name *foundation.NSString, value unsafe.Pointer) *SKUniform

func (*SKUniform) InitWithNameMatrixFloat4x4 

func (o *SKUniform) InitWithNameMatrixFloat4x4(name *foundation.NSString, value unsafe.Pointer) *SKUniform

func (*SKUniform) InitWithNameTexture 

func (o *SKUniform) InitWithNameTexture(name *foundation.NSString, texture *SKTexture) *SKUniform

func (*SKUniform) InitWithNameVectorFloat2 

func (o *SKUniform) InitWithNameVectorFloat2(name *foundation.NSString, value unsafe.Pointer) *SKUniform

func (*SKUniform) InitWithNameVectorFloat3 

func (o *SKUniform) InitWithNameVectorFloat3(name *foundation.NSString, value unsafe.Pointer) *SKUniform

func (*SKUniform) InitWithNameVectorFloat4 

func (o *SKUniform) InitWithNameVectorFloat4(name *foundation.NSString, value unsafe.Pointer) *SKUniform

func (*SKUniform) MatrixFloat2x2Value 

func (o *SKUniform) MatrixFloat2x2Value() unsafe.Pointer

func (*SKUniform) MatrixFloat3x3Value 

func (o *SKUniform) MatrixFloat3x3Value() unsafe.Pointer

func (*SKUniform) MatrixFloat4x4Value 

func (o *SKUniform) MatrixFloat4x4Value() unsafe.Pointer

func (*SKUniform) Name 

func (o *SKUniform) Name() *foundation.NSString

func (*SKUniform) SetFloatMatrix2Value deprecated 

func (o *SKUniform) SetFloatMatrix2Value(floatMatrix2Value unsafe.Pointer)

Deprecated: since macOS 10.12.

func (*SKUniform) SetFloatMatrix3Value deprecated 

func (o *SKUniform) SetFloatMatrix3Value(floatMatrix3Value unsafe.Pointer)

Deprecated: since macOS 10.12.

func (*SKUniform) SetFloatMatrix4Value deprecated 

func (o *SKUniform) SetFloatMatrix4Value(floatMatrix4Value unsafe.Pointer)

Deprecated: since macOS 10.12.

func (*SKUniform) SetFloatValue 

func (o *SKUniform) SetFloatValue(floatValue float32)

func (*SKUniform) SetFloatVector2Value deprecated 

func (o *SKUniform) SetFloatVector2Value(floatVector2Value unsafe.Pointer)

Deprecated: since macOS 10.12.

func (*SKUniform) SetFloatVector3Value deprecated 

func (o *SKUniform) SetFloatVector3Value(floatVector3Value unsafe.Pointer)

Deprecated: since macOS 10.12.

func (*SKUniform) SetFloatVector4Value deprecated 

func (o *SKUniform) SetFloatVector4Value(floatVector4Value unsafe.Pointer)

Deprecated: since macOS 10.12.

func (*SKUniform) SetMatrixFloat2x2Value 

func (o *SKUniform) SetMatrixFloat2x2Value(matrixFloat2x2Value unsafe.Pointer)

func (*SKUniform) SetMatrixFloat3x3Value 

func (o *SKUniform) SetMatrixFloat3x3Value(matrixFloat3x3Value unsafe.Pointer)

func (*SKUniform) SetMatrixFloat4x4Value 

func (o *SKUniform) SetMatrixFloat4x4Value(matrixFloat4x4Value unsafe.Pointer)

func (*SKUniform) SetTextureValue 

func (o *SKUniform) SetTextureValue(textureValue *SKTexture)

func (*SKUniform) SetVectorFloat2Value 

func (o *SKUniform) SetVectorFloat2Value(vectorFloat2Value unsafe.Pointer)

func (*SKUniform) SetVectorFloat3Value 

func (o *SKUniform) SetVectorFloat3Value(vectorFloat3Value unsafe.Pointer)

func (*SKUniform) SetVectorFloat4Value 

func (o *SKUniform) SetVectorFloat4Value(vectorFloat4Value unsafe.Pointer)

func (*SKUniform) TextureValue 

func (o *SKUniform) TextureValue() *SKTexture

func (*SKUniform) UniformType 

func (o *SKUniform) UniformType() SKUniformType

func (*SKUniform) VectorFloat2Value 

func (o *SKUniform) VectorFloat2Value() unsafe.Pointer

func (*SKUniform) VectorFloat3Value 

func (o *SKUniform) VectorFloat3Value() unsafe.Pointer

func (*SKUniform) VectorFloat4Value 

func (o *SKUniform) VectorFloat4Value() unsafe.Pointer

type SKUniformType 

type SKUniformType int64
const (
	SKUniformTypeNone         SKUniformType = 0
	SKUniformTypeFloat        SKUniformType = 1
	SKUniformTypeFloatVector2 SKUniformType = 2
	SKUniformTypeFloatVector3 SKUniformType = 3
	SKUniformTypeFloatVector4 SKUniformType = 4
	SKUniformTypeFloatMatrix2 SKUniformType = 5
	SKUniformTypeFloatMatrix3 SKUniformType = 6
	SKUniformTypeFloatMatrix4 SKUniformType = 7
	SKUniformTypeTexture      SKUniformType = 8
)

func (SKUniformType) String 

func (e SKUniformType) String() string

type SKVideoNode 

type SKVideoNode struct {
	SKNode
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skvideonode

func SKVideoNodeFromID 

func SKVideoNodeFromID(id objc.ID) *SKVideoNode

func SKVideoNodeVideoNodeWithAVPlayer 

func SKVideoNodeVideoNodeWithAVPlayer(player *avfoundation.AVPlayer) *SKVideoNode

Create a video node from an AVPlayer. You can use the AVPlayer to control playback.

func SKVideoNodeVideoNodeWithFileNamed 

func SKVideoNodeVideoNodeWithFileNamed(videoFile *foundation.NSString) *SKVideoNode

func SKVideoNodeVideoNodeWithURL 

func SKVideoNodeVideoNodeWithURL(videoURL *foundation.NSURL) *SKVideoNode

func SKVideoNodeVideoNodeWithVideoFileNamed 

func SKVideoNodeVideoNodeWithVideoFileNamed(videoFile *foundation.NSString) *SKVideoNode

Create a video node from a file. Deprecated: since macOS 10.11.

func SKVideoNodeVideoNodeWithVideoURL 

func SKVideoNodeVideoNodeWithVideoURL(videoURL *foundation.NSURL) *SKVideoNode

Create a video node from a URL. Deprecated: since macOS 10.11.

func (*SKVideoNode) AnchorPoint 

func (o *SKVideoNode) AnchorPoint() corefoundation.CGPoint

The location in the video that maps to its 'position' in the parent's coordinate space. (0.0-1.0)

func (*SKVideoNode) InitWithAVPlayer 

func (o *SKVideoNode) InitWithAVPlayer(player *avfoundation.AVPlayer) *SKVideoNode

Designated Initializer. Initialize a video node from an AVPlayer. You can use the AVPlayer to control playback.

func (*SKVideoNode) InitWithCoder 

func (o *SKVideoNode) InitWithCoder(aDecoder *foundation.NSCoder) *SKVideoNode

Support coding and decoding via NSKeyedArchiver.

func (*SKVideoNode) InitWithFileNamed 

func (o *SKVideoNode) InitWithFileNamed(videoFile *foundation.NSString) *SKVideoNode

func (*SKVideoNode) InitWithURL 

func (o *SKVideoNode) InitWithURL(url *foundation.NSURL) *SKVideoNode

func (*SKVideoNode) InitWithVideoFileNamed 

func (o *SKVideoNode) InitWithVideoFileNamed(videoFile *foundation.NSString) *SKVideoNode

Initialize a video node from a file. Deprecated: since macOS 10.10.

func (*SKVideoNode) InitWithVideoURL deprecated 

func (o *SKVideoNode) InitWithVideoURL(url *foundation.NSURL) *SKVideoNode

Deprecated: since macOS 10.10.

func (*SKVideoNode) Pause 

func (o *SKVideoNode) Pause()

func (*SKVideoNode) Play 

func (o *SKVideoNode) Play()

func (*SKVideoNode) SetAnchorPoint 

func (o *SKVideoNode) SetAnchorPoint(anchorPoint corefoundation.CGPoint)

func (*SKVideoNode) SetSize 

func (o *SKVideoNode) SetSize(size corefoundation.CGSize)

func (*SKVideoNode) Size 

func (o *SKVideoNode) Size() corefoundation.CGSize

The display size of the video (in parent's coordinate space)

type SKView 

type SKView struct {
	appkit.NSView
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skview

func SKViewFromID 

func SKViewFromID(id objc.ID) *SKView

func (*SKView) AllowsTransparency 

func (o *SKView) AllowsTransparency() bool

Toggles whether the view allows transparent rendering. This allows content under the view to show through if a non-opaque backgroundColor is set on the scene. Defaults to NO.

func (*SKView) ConvertPointFromScene 

func (o *SKView) ConvertPointFromScene(point corefoundation.CGPoint, scene *SKScene) corefoundation.CGPoint

Converts a point from scene space to view space. @param point the point to convert. @param scene the scene to convert the point into.

func (*SKView) ConvertPointToScene 

func (o *SKView) ConvertPointToScene(point corefoundation.CGPoint, scene *SKScene) corefoundation.CGPoint

Converts a point from view space to scene space. @param point the point to convert. @param scene the scene to convert the point into.

func (*SKView) Delegate 

func (o *SKView) Delegate() *foundation.NSObject

Optional view delegate, see SKViewDelegate.

func (*SKView) DisableDepthStencilBuffer 

func (o *SKView) DisableDepthStencilBuffer() bool

func (*SKView) FrameInterval deprecated 

func (o *SKView) FrameInterval() int

Deprecated: since macOS 10.12.

func (*SKView) IgnoresSiblingOrder 

func (o *SKView) IgnoresSiblingOrder() bool

Ignores sibling and traversal order to sort the rendered contents of a scene into the most efficient batching possible. This will require zPosition to be used in the scenes to properly guarantee elements are in front or behind each other. This defaults to NO, meaning that sibling order overrides efficiency heuristics in the rendering of the scenes in the view. Setting this to YES for a complex scene may substantially increase performance, but care must be taken as only zPosition determines render order before the efficiency heuristics are used.

func (*SKView) IsAsynchronous 

func (o *SKView) IsAsynchronous() bool

Toggles whether the view updates is rendered asynchronously or aligned with Core Animation updates. Defaults to YES.

func (*SKView) IsPaused 

func (o *SKView) IsPaused() bool

Pause the entire view

func (*SKView) PreferredFrameRate deprecated 

func (o *SKView) PreferredFrameRate() float32

Deprecated: since macOS 10.12.

func (*SKView) PreferredFramesPerSecond 

func (o *SKView) PreferredFramesPerSecond() int

func (*SKView) PresentScene 

func (o *SKView) PresentScene(scene *SKScene)

Present an SKScene in the view, replacing the current scene. @param scene the scene to present.

func (*SKView) PresentSceneTransition 

func (o *SKView) PresentSceneTransition(scene *SKScene, transition *SKTransition)

Present an SKScene in the view, replacing the current scene. If there is currently a scene being presented in the view, the transition is used to swap between them. @param scene the scene to present. @param transition the transition to use when presenting the scene.

func (*SKView) Scene 

func (o *SKView) Scene() *SKScene

The currently presented scene, otherwise nil. If in a transition, the 'incoming' scene is returned.

func (*SKView) SetAllowsTransparency 

func (o *SKView) SetAllowsTransparency(allowsTransparency bool)

func (*SKView) SetAsynchronous 

func (o *SKView) SetAsynchronous(asynchronous bool)

func (*SKView) SetDelegate 

func (o *SKView) SetDelegate(delegate *foundation.NSObject)

func (*SKView) SetDisableDepthStencilBuffer 

func (o *SKView) SetDisableDepthStencilBuffer(disableDepthStencilBuffer bool)

func (*SKView) SetFrameInterval deprecated 

func (o *SKView) SetFrameInterval(frameInterval int)

Deprecated: since macOS 10.12.

func (*SKView) SetIgnoresSiblingOrder 

func (o *SKView) SetIgnoresSiblingOrder(ignoresSiblingOrder bool)

func (*SKView) SetPaused 

func (o *SKView) SetPaused(paused bool)

func (*SKView) SetPreferredFrameRate deprecated 

func (o *SKView) SetPreferredFrameRate(preferredFrameRate float32)

Deprecated: since macOS 10.12.

func (*SKView) SetPreferredFramesPerSecond 

func (o *SKView) SetPreferredFramesPerSecond(preferredFramesPerSecond int)

func (*SKView) SetShouldCullNonVisibleNodes 

func (o *SKView) SetShouldCullNonVisibleNodes(shouldCullNonVisibleNodes bool)

func (*SKView) SetShowsDrawCount 

func (o *SKView) SetShowsDrawCount(showsDrawCount bool)

func (*SKView) SetShowsFPS 

func (o *SKView) SetShowsFPS(showsFPS bool)

func (*SKView) SetShowsFields 

func (o *SKView) SetShowsFields(showsFields bool)

func (*SKView) SetShowsNodeCount 

func (o *SKView) SetShowsNodeCount(showsNodeCount bool)

func (*SKView) SetShowsPhysics 

func (o *SKView) SetShowsPhysics(showsPhysics bool)

func (*SKView) SetShowsQuadCount 

func (o *SKView) SetShowsQuadCount(showsQuadCount bool)

func (*SKView) ShouldCullNonVisibleNodes 

func (o *SKView) ShouldCullNonVisibleNodes() bool

func (*SKView) ShowsDrawCount 

func (o *SKView) ShowsDrawCount() bool

func (*SKView) ShowsFPS 

func (o *SKView) ShowsFPS() bool

Toggles display of performance stats in the view. All default to false.

func (*SKView) ShowsFields 

func (o *SKView) ShowsFields() bool

func (*SKView) ShowsNodeCount 

func (o *SKView) ShowsNodeCount() bool

func (*SKView) ShowsPhysics 

func (o *SKView) ShowsPhysics() bool

func (*SKView) ShowsQuadCount 

func (o *SKView) ShowsQuadCount() bool

func (*SKView) TextureFromNode 

func (o *SKView) TextureFromNode(node *SKNode) *SKTexture

Create an SKTexture containing a snapshot of how it would have been rendered in this view. The texture is tightly cropped to the size of the node. @param node the node subtree to render to the texture.

func (*SKView) TextureFromNodeCrop 

func (o *SKView) TextureFromNodeCrop(node *SKNode, crop corefoundation.CGRect) *SKTexture

Create an SKTexture containing a snapshot of how it would have been rendered in this view. The texture is cropped to the specified rectangle @param node the node subtree to render to the texture. @param crop the crop

type SKViewDelegate 

type SKViewDelegate interface {
}

SKViewDelegate wraps the ObjC protocol SKViewDelegate.

type SKWarpGeometry 

type SKWarpGeometry struct {
	foundation.NSObject
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skwarpgeometry

func SKWarpGeometryFromID 

func SKWarpGeometryFromID(id objc.ID) *SKWarpGeometry

type SKWarpGeometryGrid 

type SKWarpGeometryGrid struct {
	SKWarpGeometry
}

Apple documentation: https://developer.apple.com/documentation/spritekit/skwarpgeometrygrid

func SKWarpGeometryGridFromID 

func SKWarpGeometryGridFromID(id objc.ID) *SKWarpGeometryGrid

func SKWarpGeometryGridGrid 

func SKWarpGeometryGridGrid() *SKWarpGeometryGrid

func SKWarpGeometryGridGridWithColumnsRows 

func SKWarpGeometryGridGridWithColumnsRows(cols int, rows int) *SKWarpGeometryGrid

func SKWarpGeometryGridGridWithColumnsRowsSourcePositionsDestPositions 

func SKWarpGeometryGridGridWithColumnsRowsSourcePositionsDestPositions(cols int, rows int, sourcePositions unsafe.Pointer, destPositions unsafe.Pointer) *SKWarpGeometryGrid

func (*SKWarpGeometryGrid) DestPositionAtIndex 

func (o *SKWarpGeometryGrid) DestPositionAtIndex(index int) unsafe.Pointer

func (*SKWarpGeometryGrid) GridByReplacingDestPositions 

func (o *SKWarpGeometryGrid) GridByReplacingDestPositions(destPositions unsafe.Pointer) *SKWarpGeometryGrid

func (*SKWarpGeometryGrid) GridByReplacingSourcePositions 

func (o *SKWarpGeometryGrid) GridByReplacingSourcePositions(sourcePositions unsafe.Pointer) *SKWarpGeometryGrid

func (*SKWarpGeometryGrid) InitWithCoder 

func (o *SKWarpGeometryGrid) InitWithCoder(aDecoder *foundation.NSCoder) *SKWarpGeometryGrid

func (*SKWarpGeometryGrid) InitWithColumnsRowsSourcePositionsDestPositions 

func (o *SKWarpGeometryGrid) InitWithColumnsRowsSourcePositionsDestPositions(cols int, rows int, sourcePositions unsafe.Pointer, destPositions unsafe.Pointer) *SKWarpGeometryGrid

func (*SKWarpGeometryGrid) NumberOfColumns 

func (o *SKWarpGeometryGrid) NumberOfColumns() int

func (*SKWarpGeometryGrid) NumberOfRows 

func (o *SKWarpGeometryGrid) NumberOfRows() int

func (*SKWarpGeometryGrid) SourcePositionAtIndex 

func (o *SKWarpGeometryGrid) SourcePositionAtIndex(index int) unsafe.Pointer

func (*SKWarpGeometryGrid) VertexCount 

func (o *SKWarpGeometryGrid) VertexCount() int

type SKWarpable 

type SKWarpable interface {
	WarpGeometry() *SKWarpGeometry
	SetWarpGeometry(warpGeometry *SKWarpGeometry)
	SubdivisionLevels() int
	SetSubdivisionLevels(subdivisionLevels int)
}

SKWarpable wraps the ObjC protocol SKWarpable.

type UIFocusItem 

type UIFocusItem interface {
}

UIFocusItem wraps the ObjC protocol UIFocusItem.

type Virtual_memory_guard_exception_code_t 

type Virtual_memory_guard_exception_code_t int64
const (
	KGUARD_EXC_DEALLOC_GAP                   Virtual_memory_guard_exception_code_t = 1
	KGUARD_EXC_RECLAIM_COPYIO_FAILURE        Virtual_memory_guard_exception_code_t = 2
	KGUARD_EXC_RECLAIM_INDEX_FAILURE         Virtual_memory_guard_exception_code_t = 4
	KGUARD_EXC_RECLAIM_DEALLOCATE_FAILURE    Virtual_memory_guard_exception_code_t = 8
	KGUARD_EXC_RECLAIM_ACCOUNTING_FAILURE    Virtual_memory_guard_exception_code_t = 9
	KGUARD_EXC_SEC_IOPL_ON_EXEC_PAGE         Virtual_memory_guard_exception_code_t = 10
	KGUARD_EXC_SEC_EXEC_ON_IOPL_PAGE         Virtual_memory_guard_exception_code_t = 11
	KGUARD_EXC_SEC_UPL_WRITE_ON_EXEC_REGION  Virtual_memory_guard_exception_code_t = 12
	KGUARD_EXC_LARGE_ALLOCATION_TELEMETRY    Virtual_memory_guard_exception_code_t = 13
	KGUARD_EXC_SEC_ACCESS_FAULT              Virtual_memory_guard_exception_code_t = 98
	KGUARD_EXC_SEC_ASYNC_ACCESS_FAULT        Virtual_memory_guard_exception_code_t = 99
	KGUARD_EXC_SEC_COPY_DENIED               Virtual_memory_guard_exception_code_t = 100
	KGUARD_EXC_SEC_SHARING_DENIED            Virtual_memory_guard_exception_code_t = 101
	KGUARD_EXC_MTE_SYNC_FAULT                Virtual_memory_guard_exception_code_t = 200
	KGUARD_EXC_MTE_ASYNC_USER_FAULT          Virtual_memory_guard_exception_code_t = 201
	KGUARD_EXC_MTE_ASYNC_KERN_FAULT          Virtual_memory_guard_exception_code_t = 202
	KGUARD_EXC_GUARD_OBJECT_ASYNC_USER_FAULT Virtual_memory_guard_exception_code_t = 203
	KGUARD_EXC_GUARD_OBJECT_ASYNC_KERN_FAULT Virtual_memory_guard_exception_code_t = 204
)

func (Virtual_memory_guard_exception_code_t) String 

func (e Virtual_memory_guard_exception_code_t) String() string

type Xpc_listener_create_flags_t 

type Xpc_listener_create_flags_t int64
const (
	XPC_LISTENER_CREATE_NONE             Xpc_listener_create_flags_t = 0
	XPC_LISTENER_CREATE_INACTIVE         Xpc_listener_create_flags_t = 1
	XPC_LISTENER_CREATE_FORCE_MACH       Xpc_listener_create_flags_t = 2
	XPC_LISTENER_CREATE_FORCE_XPCSERVICE Xpc_listener_create_flags_t = 4
)

func (Xpc_listener_create_flags_t) String 

func (e Xpc_listener_create_flags_t) String() string

type Xpc_session_create_flags_t 

type Xpc_session_create_flags_t int64
const (
	XPC_SESSION_CREATE_NONE            Xpc_session_create_flags_t = 0
	XPC_SESSION_CREATE_INACTIVE        Xpc_session_create_flags_t = 1
	XPC_SESSION_CREATE_MACH_PRIVILEGED Xpc_session_create_flags_t = 2
)

func (Xpc_session_create_flags_t) String 

func (e Xpc_session_create_flags_t) String() 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.