gdnative-go/gdnative/pool_arrays.gen.go

// Copyright © 2019 - 2020 Oscar Campos <oscar.campos@thepimpam.com>
// Copyright © 2017 - William Edwards
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package gdnative

// ==================================================================
// This file was autogenerated by PimPam GDNative-Go binding tools
// Please do not modify this file, any change will be lost
// ==================================================================

/*
#include "gdnative.gen.h"
#include <gdnative/pool_arrays.h>
// Include all headers for now. TODO: Look up all the required
// headers we need to import based on the method arguments and return types.
#include <gdnative/aabb.h>
#include <gdnative/array.h>
#include <gdnative/basis.h>
#include <gdnative/color.h>
#include <gdnative/dictionary.h>
#include <gdnative/gdnative.h>
#include <gdnative/node_path.h>
#include <gdnative/plane.h>
#include <gdnative/pool_arrays.h>
#include <gdnative/quat.h>
#include <gdnative/rect2.h>
#include <gdnative/rid.h>
#include <gdnative/string.h>
#include <gdnative/string_name.h>
#include <gdnative/transform.h>
#include <gdnative/transform2d.h>
#include <gdnative/variant.h>
#include <gdnative/vector2.h>
#include <gdnative/vector3.h>
#include <gdnative_api_struct.gen.h>
*/
import "C"
import "unsafe"

// NewEmptyPoolArrayReadAccess will return a pointer to an empty
// initialized PoolArrayReadAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolArrayReadAccess() Pointer {
	var obj C.godot_pool_array_read_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolArrayReadAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolArrayReadAccess(obj PoolArrayReadAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolArrayReadAccessFromPointer will return a PoolArrayReadAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolArrayReadAccessFromPointer(ptr Pointer) PoolArrayReadAccess {

	return PoolArrayReadAccess{base: (*C.godot_pool_array_read_access)(ptr.getBase())}
}

// PoolArrayReadAccess data structure wrapper
type PoolArrayReadAccess struct {
	base *C.godot_pool_array_read_access
}

// returns the wrapped C base data type for this type
func (gdt PoolArrayReadAccess) getBase() *C.godot_pool_array_read_access {
	return gdt.base
}

// NewEmptyPoolByteArrayReadAccess will return a pointer to an empty
// initialized PoolByteArrayReadAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolByteArrayReadAccess() Pointer {
	var obj C.godot_pool_byte_array_read_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolByteArrayReadAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolByteArrayReadAccess(obj PoolByteArrayReadAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolByteArrayReadAccessFromPointer will return a PoolByteArrayReadAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolByteArrayReadAccessFromPointer(ptr Pointer) PoolByteArrayReadAccess {
	obj := (*C.godot_pool_byte_array_read_access)(ptr.getBase())
	return PoolByteArrayReadAccess{base: obj}
}

type PoolByteArrayReadAccess struct {
	base *C.godot_pool_byte_array_read_access
}

func (gdt PoolByteArrayReadAccess) getBase() *C.godot_pool_byte_array_read_access {
	return gdt.base
}

// NewEmptyPoolIntArrayReadAccess will return a pointer to an empty
// initialized PoolIntArrayReadAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolIntArrayReadAccess() Pointer {
	var obj C.godot_pool_int_array_read_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolIntArrayReadAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolIntArrayReadAccess(obj PoolIntArrayReadAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolIntArrayReadAccessFromPointer will return a PoolIntArrayReadAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolIntArrayReadAccessFromPointer(ptr Pointer) PoolIntArrayReadAccess {
	obj := (*C.godot_pool_int_array_read_access)(ptr.getBase())
	return PoolIntArrayReadAccess{base: obj}
}

type PoolIntArrayReadAccess struct {
	base *C.godot_pool_int_array_read_access
}

func (gdt PoolIntArrayReadAccess) getBase() *C.godot_pool_int_array_read_access {
	return gdt.base
}

// NewEmptyPoolRealArrayReadAccess will return a pointer to an empty
// initialized PoolRealArrayReadAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolRealArrayReadAccess() Pointer {
	var obj C.godot_pool_real_array_read_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolRealArrayReadAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolRealArrayReadAccess(obj PoolRealArrayReadAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolRealArrayReadAccessFromPointer will return a PoolRealArrayReadAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolRealArrayReadAccessFromPointer(ptr Pointer) PoolRealArrayReadAccess {
	obj := (*C.godot_pool_real_array_read_access)(ptr.getBase())
	return PoolRealArrayReadAccess{base: obj}
}

type PoolRealArrayReadAccess struct {
	base *C.godot_pool_real_array_read_access
}

func (gdt PoolRealArrayReadAccess) getBase() *C.godot_pool_real_array_read_access {
	return gdt.base
}

// NewEmptyPoolStringArrayReadAccess will return a pointer to an empty
// initialized PoolStringArrayReadAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolStringArrayReadAccess() Pointer {
	var obj C.godot_pool_string_array_read_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolStringArrayReadAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolStringArrayReadAccess(obj PoolStringArrayReadAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolStringArrayReadAccessFromPointer will return a PoolStringArrayReadAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolStringArrayReadAccessFromPointer(ptr Pointer) PoolStringArrayReadAccess {
	obj := (*C.godot_pool_string_array_read_access)(ptr.getBase())
	return PoolStringArrayReadAccess{base: obj}
}

type PoolStringArrayReadAccess struct {
	base *C.godot_pool_string_array_read_access
}

func (gdt PoolStringArrayReadAccess) getBase() *C.godot_pool_string_array_read_access {
	return gdt.base
}

// NewEmptyPoolVector2ArrayReadAccess will return a pointer to an empty
// initialized PoolVector2ArrayReadAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolVector2ArrayReadAccess() Pointer {
	var obj C.godot_pool_vector2_array_read_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolVector2ArrayReadAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolVector2ArrayReadAccess(obj PoolVector2ArrayReadAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolVector2ArrayReadAccessFromPointer will return a PoolVector2ArrayReadAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolVector2ArrayReadAccessFromPointer(ptr Pointer) PoolVector2ArrayReadAccess {
	obj := (*C.godot_pool_vector2_array_read_access)(ptr.getBase())
	return PoolVector2ArrayReadAccess{base: obj}
}

type PoolVector2ArrayReadAccess struct {
	base *C.godot_pool_vector2_array_read_access
}

func (gdt PoolVector2ArrayReadAccess) getBase() *C.godot_pool_vector2_array_read_access {
	return gdt.base
}

// NewEmptyPoolVector3ArrayReadAccess will return a pointer to an empty
// initialized PoolVector3ArrayReadAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolVector3ArrayReadAccess() Pointer {
	var obj C.godot_pool_vector3_array_read_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolVector3ArrayReadAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolVector3ArrayReadAccess(obj PoolVector3ArrayReadAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolVector3ArrayReadAccessFromPointer will return a PoolVector3ArrayReadAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolVector3ArrayReadAccessFromPointer(ptr Pointer) PoolVector3ArrayReadAccess {
	obj := (*C.godot_pool_vector3_array_read_access)(ptr.getBase())
	return PoolVector3ArrayReadAccess{base: obj}
}

type PoolVector3ArrayReadAccess struct {
	base *C.godot_pool_vector3_array_read_access
}

func (gdt PoolVector3ArrayReadAccess) getBase() *C.godot_pool_vector3_array_read_access {
	return gdt.base
}

// NewEmptyPoolColorArrayReadAccess will return a pointer to an empty
// initialized PoolColorArrayReadAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolColorArrayReadAccess() Pointer {
	var obj C.godot_pool_color_array_read_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolColorArrayReadAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolColorArrayReadAccess(obj PoolColorArrayReadAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolColorArrayReadAccessFromPointer will return a PoolColorArrayReadAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolColorArrayReadAccessFromPointer(ptr Pointer) PoolColorArrayReadAccess {
	obj := (*C.godot_pool_color_array_read_access)(ptr.getBase())
	return PoolColorArrayReadAccess{base: obj}
}

type PoolColorArrayReadAccess struct {
	base *C.godot_pool_color_array_read_access
}

func (gdt PoolColorArrayReadAccess) getBase() *C.godot_pool_color_array_read_access {
	return gdt.base
}

// NewEmptyPoolArrayWriteAccess will return a pointer to an empty
// initialized PoolArrayWriteAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolArrayWriteAccess() Pointer {
	var obj C.godot_pool_array_write_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolArrayWriteAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolArrayWriteAccess(obj PoolArrayWriteAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolArrayWriteAccessFromPointer will return a PoolArrayWriteAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolArrayWriteAccessFromPointer(ptr Pointer) PoolArrayWriteAccess {

	return PoolArrayWriteAccess{base: (*C.godot_pool_array_write_access)(ptr.getBase())}
}

// PoolArrayWriteAccess data structure wrapper
type PoolArrayWriteAccess struct {
	base *C.godot_pool_array_write_access
}

// returns the wrapped C base data type for this type
func (gdt PoolArrayWriteAccess) getBase() *C.godot_pool_array_write_access {
	return gdt.base
}

// NewEmptyPoolByteArrayWriteAccess will return a pointer to an empty
// initialized PoolByteArrayWriteAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolByteArrayWriteAccess() Pointer {
	var obj C.godot_pool_byte_array_write_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolByteArrayWriteAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolByteArrayWriteAccess(obj PoolByteArrayWriteAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolByteArrayWriteAccessFromPointer will return a PoolByteArrayWriteAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolByteArrayWriteAccessFromPointer(ptr Pointer) PoolByteArrayWriteAccess {
	obj := (*C.godot_pool_byte_array_write_access)(ptr.getBase())
	return PoolByteArrayWriteAccess{base: obj}
}

type PoolByteArrayWriteAccess struct {
	base *C.godot_pool_byte_array_write_access
}

func (gdt PoolByteArrayWriteAccess) getBase() *C.godot_pool_byte_array_write_access {
	return gdt.base
}

// NewEmptyPoolIntArrayWriteAccess will return a pointer to an empty
// initialized PoolIntArrayWriteAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolIntArrayWriteAccess() Pointer {
	var obj C.godot_pool_int_array_write_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolIntArrayWriteAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolIntArrayWriteAccess(obj PoolIntArrayWriteAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolIntArrayWriteAccessFromPointer will return a PoolIntArrayWriteAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolIntArrayWriteAccessFromPointer(ptr Pointer) PoolIntArrayWriteAccess {
	obj := (*C.godot_pool_int_array_write_access)(ptr.getBase())
	return PoolIntArrayWriteAccess{base: obj}
}

type PoolIntArrayWriteAccess struct {
	base *C.godot_pool_int_array_write_access
}

func (gdt PoolIntArrayWriteAccess) getBase() *C.godot_pool_int_array_write_access {
	return gdt.base
}

// NewEmptyPoolRealArrayWriteAccess will return a pointer to an empty
// initialized PoolRealArrayWriteAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolRealArrayWriteAccess() Pointer {
	var obj C.godot_pool_real_array_write_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolRealArrayWriteAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolRealArrayWriteAccess(obj PoolRealArrayWriteAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolRealArrayWriteAccessFromPointer will return a PoolRealArrayWriteAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolRealArrayWriteAccessFromPointer(ptr Pointer) PoolRealArrayWriteAccess {
	obj := (*C.godot_pool_real_array_write_access)(ptr.getBase())
	return PoolRealArrayWriteAccess{base: obj}
}

type PoolRealArrayWriteAccess struct {
	base *C.godot_pool_real_array_write_access
}

func (gdt PoolRealArrayWriteAccess) getBase() *C.godot_pool_real_array_write_access {
	return gdt.base
}

// NewEmptyPoolStringArrayWriteAccess will return a pointer to an empty
// initialized PoolStringArrayWriteAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolStringArrayWriteAccess() Pointer {
	var obj C.godot_pool_string_array_write_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolStringArrayWriteAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolStringArrayWriteAccess(obj PoolStringArrayWriteAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolStringArrayWriteAccessFromPointer will return a PoolStringArrayWriteAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolStringArrayWriteAccessFromPointer(ptr Pointer) PoolStringArrayWriteAccess {
	obj := (*C.godot_pool_string_array_write_access)(ptr.getBase())
	return PoolStringArrayWriteAccess{base: obj}
}

type PoolStringArrayWriteAccess struct {
	base *C.godot_pool_string_array_write_access
}

func (gdt PoolStringArrayWriteAccess) getBase() *C.godot_pool_string_array_write_access {
	return gdt.base
}

// NewEmptyPoolVector2ArrayWriteAccess will return a pointer to an empty
// initialized PoolVector2ArrayWriteAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolVector2ArrayWriteAccess() Pointer {
	var obj C.godot_pool_vector2_array_write_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolVector2ArrayWriteAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolVector2ArrayWriteAccess(obj PoolVector2ArrayWriteAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolVector2ArrayWriteAccessFromPointer will return a PoolVector2ArrayWriteAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolVector2ArrayWriteAccessFromPointer(ptr Pointer) PoolVector2ArrayWriteAccess {
	obj := (*C.godot_pool_vector2_array_write_access)(ptr.getBase())
	return PoolVector2ArrayWriteAccess{base: obj}
}

type PoolVector2ArrayWriteAccess struct {
	base *C.godot_pool_vector2_array_write_access
}

func (gdt PoolVector2ArrayWriteAccess) getBase() *C.godot_pool_vector2_array_write_access {
	return gdt.base
}

// NewEmptyPoolVector3ArrayWriteAccess will return a pointer to an empty
// initialized PoolVector3ArrayWriteAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolVector3ArrayWriteAccess() Pointer {
	var obj C.godot_pool_vector3_array_write_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolVector3ArrayWriteAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolVector3ArrayWriteAccess(obj PoolVector3ArrayWriteAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolVector3ArrayWriteAccessFromPointer will return a PoolVector3ArrayWriteAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolVector3ArrayWriteAccessFromPointer(ptr Pointer) PoolVector3ArrayWriteAccess {
	obj := (*C.godot_pool_vector3_array_write_access)(ptr.getBase())
	return PoolVector3ArrayWriteAccess{base: obj}
}

type PoolVector3ArrayWriteAccess struct {
	base *C.godot_pool_vector3_array_write_access
}

func (gdt PoolVector3ArrayWriteAccess) getBase() *C.godot_pool_vector3_array_write_access {
	return gdt.base
}

// NewEmptyPoolColorArrayWriteAccess will return a pointer to an empty
// initialized PoolColorArrayWriteAccess. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolColorArrayWriteAccess() Pointer {
	var obj C.godot_pool_color_array_write_access
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolColorArrayWriteAccess will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolColorArrayWriteAccess(obj PoolColorArrayWriteAccess) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolColorArrayWriteAccessFromPointer will return a PoolColorArrayWriteAccess from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolColorArrayWriteAccessFromPointer(ptr Pointer) PoolColorArrayWriteAccess {
	obj := (*C.godot_pool_color_array_write_access)(ptr.getBase())
	return PoolColorArrayWriteAccess{base: obj}
}

type PoolColorArrayWriteAccess struct {
	base *C.godot_pool_color_array_write_access
}

func (gdt PoolColorArrayWriteAccess) getBase() *C.godot_pool_color_array_write_access {
	return gdt.base
}

// NewEmptyPoolByteArray will return a pointer to an empty
// initialized PoolByteArray. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolByteArray() Pointer {
	var obj C.godot_pool_byte_array
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolByteArray will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolByteArray(obj PoolByteArray) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolByteArrayFromPointer will return a PoolByteArray from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolByteArrayFromPointer(ptr Pointer) PoolByteArray {

	return PoolByteArray{base: (*C.godot_pool_byte_array)(ptr.getBase())}
}

// PoolByteArray data structure wrapper
type PoolByteArray struct {
	base *C.godot_pool_byte_array
}

// returns the wrapped C base data type for this type
func (gdt PoolByteArray) getBase() *C.godot_pool_byte_array {
	return gdt.base
}

// NewPoolByteArray godot_pool_byte_array_new [[godot_pool_byte_array * r_dest]] void
func NewPoolByteArray() PoolByteArray {
	var dest C.godot_pool_byte_array
	C.go_godot_pool_byte_array_new(GDNative.api, &dest)
	return PoolByteArray{base: &dest}
}

// NewPoolByteArrayCopy godot_pool_byte_array_new_copy [[godot_pool_byte_array * r_dest] [const godot_pool_byte_array * p_src]] void
func NewPoolByteArrayCopy(src PoolByteArray) PoolByteArray {
	var dest C.godot_pool_byte_array
	arg1 := src.getBase()
	C.go_godot_pool_byte_array_new_copy(GDNative.api, &dest, arg1)
	return PoolByteArray{base: &dest}
}

// NewPoolByteArrayWithArray godot_pool_byte_array_new_with_array [[godot_pool_byte_array * r_dest] [const godot_array * p_a]] void
func NewPoolByteArrayWithArray(a Array) PoolByteArray {
	var dest C.godot_pool_byte_array
	arg1 := a.getBase()
	C.go_godot_pool_byte_array_new_with_array(GDNative.api, &dest, arg1)
	return PoolByteArray{base: &dest}
}

// Append godot_pool_byte_array_append [[godot_pool_byte_array * p_self] [const uint8_t p_data]] void
func (gdt *PoolByteArray) Append(data Uint8T) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_byte_array_append(GDNative.api, arg0, arg1)
}

// AppendArray godot_pool_byte_array_append_array [[godot_pool_byte_array * p_self] [const godot_pool_byte_array * p_array]] void
func (gdt *PoolByteArray) AppendArray(array PoolByteArray) {
	arg0 := gdt.getBase()
	arg1 := array.getBase()

	C.go_godot_pool_byte_array_append_array(GDNative.api, arg0, arg1)
}

// Insert godot_pool_byte_array_insert [[godot_pool_byte_array * p_self] [const godot_int p_idx] [const uint8_t p_data]] godot_error
func (gdt *PoolByteArray) Insert(idx Int, data Uint8T) Error {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	ret := C.go_godot_pool_byte_array_insert(GDNative.api, arg0, arg1, arg2)

	return Error(ret)
}

// Invert godot_pool_byte_array_invert [[godot_pool_byte_array * p_self]] void
func (gdt *PoolByteArray) Invert() {
	arg0 := gdt.getBase()

	C.go_godot_pool_byte_array_invert(GDNative.api, arg0)
}

// PushBack godot_pool_byte_array_push_back [[godot_pool_byte_array * p_self] [const uint8_t p_data]] void
func (gdt *PoolByteArray) PushBack(data Uint8T) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_byte_array_push_back(GDNative.api, arg0, arg1)
}

// Remove godot_pool_byte_array_remove [[godot_pool_byte_array * p_self] [const godot_int p_idx]] void
func (gdt *PoolByteArray) Remove(idx Int) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	C.go_godot_pool_byte_array_remove(GDNative.api, arg0, arg1)
}

// Resize godot_pool_byte_array_resize [[godot_pool_byte_array * p_self] [const godot_int p_size]] void
func (gdt *PoolByteArray) Resize(size Int) {
	arg0 := gdt.getBase()
	arg1 := size.getBase()

	C.go_godot_pool_byte_array_resize(GDNative.api, arg0, arg1)
}

// Read godot_pool_byte_array_read [[const godot_pool_byte_array * p_self]] godot_pool_byte_array_read_access *
func (gdt *PoolByteArray) Read() PoolByteArrayReadAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_byte_array_read(GDNative.api, arg0)

	return PoolByteArrayReadAccess{base: ret}

}

// Write godot_pool_byte_array_write [[godot_pool_byte_array * p_self]] godot_pool_byte_array_write_access *
func (gdt *PoolByteArray) Write() PoolByteArrayWriteAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_byte_array_write(GDNative.api, arg0)

	return PoolByteArrayWriteAccess{base: ret}

}

// Set godot_pool_byte_array_set [[godot_pool_byte_array * p_self] [const godot_int p_idx] [const uint8_t p_data]] void
func (gdt *PoolByteArray) Set(idx Int, data Uint8T) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	C.go_godot_pool_byte_array_set(GDNative.api, arg0, arg1, arg2)
}

// Get godot_pool_byte_array_get [[const godot_pool_byte_array * p_self] [const godot_int p_idx]] uint8_t
func (gdt *PoolByteArray) Get(idx Int) Uint8T {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	ret := C.go_godot_pool_byte_array_get(GDNative.api, arg0, arg1)

	return Uint8T(ret)
}

// Size godot_pool_byte_array_size [[const godot_pool_byte_array * p_self]] godot_int
func (gdt *PoolByteArray) Size() Int {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_byte_array_size(GDNative.api, arg0)

	return Int(ret)
}

// Destroy godot_pool_byte_array_destroy [[godot_pool_byte_array * p_self]] void
func (gdt *PoolByteArray) Destroy() {
	arg0 := gdt.getBase()

	C.go_godot_pool_byte_array_destroy(GDNative.api, arg0)
}

// NewEmptyPoolIntArray will return a pointer to an empty
// initialized PoolIntArray. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolIntArray() Pointer {
	var obj C.godot_pool_int_array
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolIntArray will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolIntArray(obj PoolIntArray) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolIntArrayFromPointer will return a PoolIntArray from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolIntArrayFromPointer(ptr Pointer) PoolIntArray {

	return PoolIntArray{base: (*C.godot_pool_int_array)(ptr.getBase())}
}

// PoolIntArray data structure wrapper
type PoolIntArray struct {
	base *C.godot_pool_int_array
}

// returns the wrapped C base data type for this type
func (gdt PoolIntArray) getBase() *C.godot_pool_int_array {
	return gdt.base
}

// NewPoolIntArray godot_pool_int_array_new [[godot_pool_int_array * r_dest]] void
func NewPoolIntArray() PoolIntArray {
	var dest C.godot_pool_int_array
	C.go_godot_pool_int_array_new(GDNative.api, &dest)
	return PoolIntArray{base: &dest}
}

// NewPoolIntArrayCopy godot_pool_int_array_new_copy [[godot_pool_int_array * r_dest] [const godot_pool_int_array * p_src]] void
func NewPoolIntArrayCopy(src PoolIntArray) PoolIntArray {
	var dest C.godot_pool_int_array
	arg1 := src.getBase()
	C.go_godot_pool_int_array_new_copy(GDNative.api, &dest, arg1)
	return PoolIntArray{base: &dest}
}

// NewPoolIntArrayWithArray godot_pool_int_array_new_with_array [[godot_pool_int_array * r_dest] [const godot_array * p_a]] void
func NewPoolIntArrayWithArray(a Array) PoolIntArray {
	var dest C.godot_pool_int_array
	arg1 := a.getBase()
	C.go_godot_pool_int_array_new_with_array(GDNative.api, &dest, arg1)
	return PoolIntArray{base: &dest}
}

// Append godot_pool_int_array_append [[godot_pool_int_array * p_self] [const godot_int p_data]] void
func (gdt *PoolIntArray) Append(data Int) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_int_array_append(GDNative.api, arg0, arg1)
}

// AppendArray godot_pool_int_array_append_array [[godot_pool_int_array * p_self] [const godot_pool_int_array * p_array]] void
func (gdt *PoolIntArray) AppendArray(array PoolIntArray) {
	arg0 := gdt.getBase()
	arg1 := array.getBase()

	C.go_godot_pool_int_array_append_array(GDNative.api, arg0, arg1)
}

// Insert godot_pool_int_array_insert [[godot_pool_int_array * p_self] [const godot_int p_idx] [const godot_int p_data]] godot_error
func (gdt *PoolIntArray) Insert(idx Int, data Int) Error {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	ret := C.go_godot_pool_int_array_insert(GDNative.api, arg0, arg1, arg2)

	return Error(ret)
}

// Invert godot_pool_int_array_invert [[godot_pool_int_array * p_self]] void
func (gdt *PoolIntArray) Invert() {
	arg0 := gdt.getBase()

	C.go_godot_pool_int_array_invert(GDNative.api, arg0)
}

// PushBack godot_pool_int_array_push_back [[godot_pool_int_array * p_self] [const godot_int p_data]] void
func (gdt *PoolIntArray) PushBack(data Int) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_int_array_push_back(GDNative.api, arg0, arg1)
}

// Remove godot_pool_int_array_remove [[godot_pool_int_array * p_self] [const godot_int p_idx]] void
func (gdt *PoolIntArray) Remove(idx Int) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	C.go_godot_pool_int_array_remove(GDNative.api, arg0, arg1)
}

// Resize godot_pool_int_array_resize [[godot_pool_int_array * p_self] [const godot_int p_size]] void
func (gdt *PoolIntArray) Resize(size Int) {
	arg0 := gdt.getBase()
	arg1 := size.getBase()

	C.go_godot_pool_int_array_resize(GDNative.api, arg0, arg1)
}

// Read godot_pool_int_array_read [[const godot_pool_int_array * p_self]] godot_pool_int_array_read_access *
func (gdt *PoolIntArray) Read() PoolIntArrayReadAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_int_array_read(GDNative.api, arg0)

	return PoolIntArrayReadAccess{base: ret}

}

// Write godot_pool_int_array_write [[godot_pool_int_array * p_self]] godot_pool_int_array_write_access *
func (gdt *PoolIntArray) Write() PoolIntArrayWriteAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_int_array_write(GDNative.api, arg0)

	return PoolIntArrayWriteAccess{base: ret}

}

// Set godot_pool_int_array_set [[godot_pool_int_array * p_self] [const godot_int p_idx] [const godot_int p_data]] void
func (gdt *PoolIntArray) Set(idx Int, data Int) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	C.go_godot_pool_int_array_set(GDNative.api, arg0, arg1, arg2)
}

// Get godot_pool_int_array_get [[const godot_pool_int_array * p_self] [const godot_int p_idx]] godot_int
func (gdt *PoolIntArray) Get(idx Int) Int {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	ret := C.go_godot_pool_int_array_get(GDNative.api, arg0, arg1)

	return Int(ret)
}

// Size godot_pool_int_array_size [[const godot_pool_int_array * p_self]] godot_int
func (gdt *PoolIntArray) Size() Int {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_int_array_size(GDNative.api, arg0)

	return Int(ret)
}

// Destroy godot_pool_int_array_destroy [[godot_pool_int_array * p_self]] void
func (gdt *PoolIntArray) Destroy() {
	arg0 := gdt.getBase()

	C.go_godot_pool_int_array_destroy(GDNative.api, arg0)
}

// NewEmptyPoolRealArray will return a pointer to an empty
// initialized PoolRealArray. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolRealArray() Pointer {
	var obj C.godot_pool_real_array
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolRealArray will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolRealArray(obj PoolRealArray) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolRealArrayFromPointer will return a PoolRealArray from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolRealArrayFromPointer(ptr Pointer) PoolRealArray {

	return PoolRealArray{base: (*C.godot_pool_real_array)(ptr.getBase())}
}

// PoolRealArray data structure wrapper
type PoolRealArray struct {
	base *C.godot_pool_real_array
}

// returns the wrapped C base data type for this type
func (gdt PoolRealArray) getBase() *C.godot_pool_real_array {
	return gdt.base
}

// NewPoolRealArray godot_pool_real_array_new [[godot_pool_real_array * r_dest]] void
func NewPoolRealArray() PoolRealArray {
	var dest C.godot_pool_real_array
	C.go_godot_pool_real_array_new(GDNative.api, &dest)
	return PoolRealArray{base: &dest}
}

// NewPoolRealArrayCopy godot_pool_real_array_new_copy [[godot_pool_real_array * r_dest] [const godot_pool_real_array * p_src]] void
func NewPoolRealArrayCopy(src PoolRealArray) PoolRealArray {
	var dest C.godot_pool_real_array
	arg1 := src.getBase()
	C.go_godot_pool_real_array_new_copy(GDNative.api, &dest, arg1)
	return PoolRealArray{base: &dest}
}

// NewPoolRealArrayWithArray godot_pool_real_array_new_with_array [[godot_pool_real_array * r_dest] [const godot_array * p_a]] void
func NewPoolRealArrayWithArray(a Array) PoolRealArray {
	var dest C.godot_pool_real_array
	arg1 := a.getBase()
	C.go_godot_pool_real_array_new_with_array(GDNative.api, &dest, arg1)
	return PoolRealArray{base: &dest}
}

// Append godot_pool_real_array_append [[godot_pool_real_array * p_self] [const godot_real p_data]] void
func (gdt *PoolRealArray) Append(data Real) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_real_array_append(GDNative.api, arg0, arg1)
}

// AppendArray godot_pool_real_array_append_array [[godot_pool_real_array * p_self] [const godot_pool_real_array * p_array]] void
func (gdt *PoolRealArray) AppendArray(array PoolRealArray) {
	arg0 := gdt.getBase()
	arg1 := array.getBase()

	C.go_godot_pool_real_array_append_array(GDNative.api, arg0, arg1)
}

// Insert godot_pool_real_array_insert [[godot_pool_real_array * p_self] [const godot_int p_idx] [const godot_real p_data]] godot_error
func (gdt *PoolRealArray) Insert(idx Int, data Real) Error {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	ret := C.go_godot_pool_real_array_insert(GDNative.api, arg0, arg1, arg2)

	return Error(ret)
}

// Invert godot_pool_real_array_invert [[godot_pool_real_array * p_self]] void
func (gdt *PoolRealArray) Invert() {
	arg0 := gdt.getBase()

	C.go_godot_pool_real_array_invert(GDNative.api, arg0)
}

// PushBack godot_pool_real_array_push_back [[godot_pool_real_array * p_self] [const godot_real p_data]] void
func (gdt *PoolRealArray) PushBack(data Real) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_real_array_push_back(GDNative.api, arg0, arg1)
}

// Remove godot_pool_real_array_remove [[godot_pool_real_array * p_self] [const godot_int p_idx]] void
func (gdt *PoolRealArray) Remove(idx Int) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	C.go_godot_pool_real_array_remove(GDNative.api, arg0, arg1)
}

// Resize godot_pool_real_array_resize [[godot_pool_real_array * p_self] [const godot_int p_size]] void
func (gdt *PoolRealArray) Resize(size Int) {
	arg0 := gdt.getBase()
	arg1 := size.getBase()

	C.go_godot_pool_real_array_resize(GDNative.api, arg0, arg1)
}

// Read godot_pool_real_array_read [[const godot_pool_real_array * p_self]] godot_pool_real_array_read_access *
func (gdt *PoolRealArray) Read() PoolRealArrayReadAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_real_array_read(GDNative.api, arg0)

	return PoolRealArrayReadAccess{base: ret}

}

// Write godot_pool_real_array_write [[godot_pool_real_array * p_self]] godot_pool_real_array_write_access *
func (gdt *PoolRealArray) Write() PoolRealArrayWriteAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_real_array_write(GDNative.api, arg0)

	return PoolRealArrayWriteAccess{base: ret}

}

// Set godot_pool_real_array_set [[godot_pool_real_array * p_self] [const godot_int p_idx] [const godot_real p_data]] void
func (gdt *PoolRealArray) Set(idx Int, data Real) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	C.go_godot_pool_real_array_set(GDNative.api, arg0, arg1, arg2)
}

// Get godot_pool_real_array_get [[const godot_pool_real_array * p_self] [const godot_int p_idx]] godot_real
func (gdt *PoolRealArray) Get(idx Int) Real {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	ret := C.go_godot_pool_real_array_get(GDNative.api, arg0, arg1)

	return Real(ret)
}

// Size godot_pool_real_array_size [[const godot_pool_real_array * p_self]] godot_int
func (gdt *PoolRealArray) Size() Int {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_real_array_size(GDNative.api, arg0)

	return Int(ret)
}

// Destroy godot_pool_real_array_destroy [[godot_pool_real_array * p_self]] void
func (gdt *PoolRealArray) Destroy() {
	arg0 := gdt.getBase()

	C.go_godot_pool_real_array_destroy(GDNative.api, arg0)
}

// NewEmptyPoolStringArray will return a pointer to an empty
// initialized PoolStringArray. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolStringArray() Pointer {
	var obj C.godot_pool_string_array
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolStringArray will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolStringArray(obj PoolStringArray) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolStringArrayFromPointer will return a PoolStringArray from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolStringArrayFromPointer(ptr Pointer) PoolStringArray {

	return PoolStringArray{base: (*C.godot_pool_string_array)(ptr.getBase())}
}

// PoolStringArray data structure wrapper
type PoolStringArray struct {
	base *C.godot_pool_string_array
}

// returns the wrapped C base data type for this type
func (gdt PoolStringArray) getBase() *C.godot_pool_string_array {
	return gdt.base
}

// NewPoolStringArray godot_pool_string_array_new [[godot_pool_string_array * r_dest]] void
func NewPoolStringArray() PoolStringArray {
	var dest C.godot_pool_string_array
	C.go_godot_pool_string_array_new(GDNative.api, &dest)
	return PoolStringArray{base: &dest}
}

// NewPoolStringArrayCopy godot_pool_string_array_new_copy [[godot_pool_string_array * r_dest] [const godot_pool_string_array * p_src]] void
func NewPoolStringArrayCopy(src PoolStringArray) PoolStringArray {
	var dest C.godot_pool_string_array
	arg1 := src.getBase()
	C.go_godot_pool_string_array_new_copy(GDNative.api, &dest, arg1)
	return PoolStringArray{base: &dest}
}

// NewPoolStringArrayWithArray godot_pool_string_array_new_with_array [[godot_pool_string_array * r_dest] [const godot_array * p_a]] void
func NewPoolStringArrayWithArray(a Array) PoolStringArray {
	var dest C.godot_pool_string_array
	arg1 := a.getBase()
	C.go_godot_pool_string_array_new_with_array(GDNative.api, &dest, arg1)
	return PoolStringArray{base: &dest}
}

// Append godot_pool_string_array_append [[godot_pool_string_array * p_self] [const godot_string * p_data]] void
func (gdt *PoolStringArray) Append(data String) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_string_array_append(GDNative.api, arg0, arg1)
}

// AppendArray godot_pool_string_array_append_array [[godot_pool_string_array * p_self] [const godot_pool_string_array * p_array]] void
func (gdt *PoolStringArray) AppendArray(array PoolStringArray) {
	arg0 := gdt.getBase()
	arg1 := array.getBase()

	C.go_godot_pool_string_array_append_array(GDNative.api, arg0, arg1)
}

// Insert godot_pool_string_array_insert [[godot_pool_string_array * p_self] [const godot_int p_idx] [const godot_string * p_data]] godot_error
func (gdt *PoolStringArray) Insert(idx Int, data String) Error {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	ret := C.go_godot_pool_string_array_insert(GDNative.api, arg0, arg1, arg2)

	return Error(ret)
}

// Invert godot_pool_string_array_invert [[godot_pool_string_array * p_self]] void
func (gdt *PoolStringArray) Invert() {
	arg0 := gdt.getBase()

	C.go_godot_pool_string_array_invert(GDNative.api, arg0)
}

// PushBack godot_pool_string_array_push_back [[godot_pool_string_array * p_self] [const godot_string * p_data]] void
func (gdt *PoolStringArray) PushBack(data String) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_string_array_push_back(GDNative.api, arg0, arg1)
}

// Remove godot_pool_string_array_remove [[godot_pool_string_array * p_self] [const godot_int p_idx]] void
func (gdt *PoolStringArray) Remove(idx Int) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	C.go_godot_pool_string_array_remove(GDNative.api, arg0, arg1)
}

// Resize godot_pool_string_array_resize [[godot_pool_string_array * p_self] [const godot_int p_size]] void
func (gdt *PoolStringArray) Resize(size Int) {
	arg0 := gdt.getBase()
	arg1 := size.getBase()

	C.go_godot_pool_string_array_resize(GDNative.api, arg0, arg1)
}

// Read godot_pool_string_array_read [[const godot_pool_string_array * p_self]] godot_pool_string_array_read_access *
func (gdt *PoolStringArray) Read() PoolStringArrayReadAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_string_array_read(GDNative.api, arg0)

	return PoolStringArrayReadAccess{base: ret}

}

// Write godot_pool_string_array_write [[godot_pool_string_array * p_self]] godot_pool_string_array_write_access *
func (gdt *PoolStringArray) Write() PoolStringArrayWriteAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_string_array_write(GDNative.api, arg0)

	return PoolStringArrayWriteAccess{base: ret}

}

// Set godot_pool_string_array_set [[godot_pool_string_array * p_self] [const godot_int p_idx] [const godot_string * p_data]] void
func (gdt *PoolStringArray) Set(idx Int, data String) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	C.go_godot_pool_string_array_set(GDNative.api, arg0, arg1, arg2)
}

// Get godot_pool_string_array_get [[const godot_pool_string_array * p_self] [const godot_int p_idx]] godot_string
func (gdt *PoolStringArray) Get(idx Int) String {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	ret := C.go_godot_pool_string_array_get(GDNative.api, arg0, arg1)

	utfStr := C.go_godot_string_utf8(GDNative.api, &ret)
	char := C.go_godot_char_string_get_data(GDNative.api, &utfStr)
	goStr := C.GoString(char)
	C.go_godot_char_string_destroy(GDNative.api, &utfStr)

	return String(goStr)

}

// Size godot_pool_string_array_size [[const godot_pool_string_array * p_self]] godot_int
func (gdt *PoolStringArray) Size() Int {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_string_array_size(GDNative.api, arg0)

	return Int(ret)
}

// Destroy godot_pool_string_array_destroy [[godot_pool_string_array * p_self]] void
func (gdt *PoolStringArray) Destroy() {
	arg0 := gdt.getBase()

	C.go_godot_pool_string_array_destroy(GDNative.api, arg0)
}

// NewEmptyPoolVector2Array will return a pointer to an empty
// initialized PoolVector2Array. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolVector2Array() Pointer {
	var obj C.godot_pool_vector2_array
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolVector2Array will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolVector2Array(obj PoolVector2Array) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolVector2ArrayFromPointer will return a PoolVector2Array from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolVector2ArrayFromPointer(ptr Pointer) PoolVector2Array {

	return PoolVector2Array{base: (*C.godot_pool_vector2_array)(ptr.getBase())}
}

// PoolVector2Array data structure wrapper
type PoolVector2Array struct {
	base *C.godot_pool_vector2_array
}

// returns the wrapped C base data type for this type
func (gdt PoolVector2Array) getBase() *C.godot_pool_vector2_array {
	return gdt.base
}

// NewPoolVector2Array godot_pool_vector2_array_new [[godot_pool_vector2_array * r_dest]] void
func NewPoolVector2Array() PoolVector2Array {
	var dest C.godot_pool_vector2_array
	C.go_godot_pool_vector2_array_new(GDNative.api, &dest)
	return PoolVector2Array{base: &dest}
}

// NewPoolVector2ArrayCopy godot_pool_vector2_array_new_copy [[godot_pool_vector2_array * r_dest] [const godot_pool_vector2_array * p_src]] void
func NewPoolVector2ArrayCopy(src PoolVector2Array) PoolVector2Array {
	var dest C.godot_pool_vector2_array
	arg1 := src.getBase()
	C.go_godot_pool_vector2_array_new_copy(GDNative.api, &dest, arg1)
	return PoolVector2Array{base: &dest}
}

// NewPoolVector2ArrayWithArray godot_pool_vector2_array_new_with_array [[godot_pool_vector2_array * r_dest] [const godot_array * p_a]] void
func NewPoolVector2ArrayWithArray(a Array) PoolVector2Array {
	var dest C.godot_pool_vector2_array
	arg1 := a.getBase()
	C.go_godot_pool_vector2_array_new_with_array(GDNative.api, &dest, arg1)
	return PoolVector2Array{base: &dest}
}

// Append godot_pool_vector2_array_append [[godot_pool_vector2_array * p_self] [const godot_vector2 * p_data]] void
func (gdt *PoolVector2Array) Append(data Vector2) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_vector2_array_append(GDNative.api, arg0, arg1)
}

// AppendArray godot_pool_vector2_array_append_array [[godot_pool_vector2_array * p_self] [const godot_pool_vector2_array * p_array]] void
func (gdt *PoolVector2Array) AppendArray(array PoolVector2Array) {
	arg0 := gdt.getBase()
	arg1 := array.getBase()

	C.go_godot_pool_vector2_array_append_array(GDNative.api, arg0, arg1)
}

// Insert godot_pool_vector2_array_insert [[godot_pool_vector2_array * p_self] [const godot_int p_idx] [const godot_vector2 * p_data]] godot_error
func (gdt *PoolVector2Array) Insert(idx Int, data Vector2) Error {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	ret := C.go_godot_pool_vector2_array_insert(GDNative.api, arg0, arg1, arg2)

	return Error(ret)
}

// Invert godot_pool_vector2_array_invert [[godot_pool_vector2_array * p_self]] void
func (gdt *PoolVector2Array) Invert() {
	arg0 := gdt.getBase()

	C.go_godot_pool_vector2_array_invert(GDNative.api, arg0)
}

// PushBack godot_pool_vector2_array_push_back [[godot_pool_vector2_array * p_self] [const godot_vector2 * p_data]] void
func (gdt *PoolVector2Array) PushBack(data Vector2) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_vector2_array_push_back(GDNative.api, arg0, arg1)
}

// Remove godot_pool_vector2_array_remove [[godot_pool_vector2_array * p_self] [const godot_int p_idx]] void
func (gdt *PoolVector2Array) Remove(idx Int) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	C.go_godot_pool_vector2_array_remove(GDNative.api, arg0, arg1)
}

// Resize godot_pool_vector2_array_resize [[godot_pool_vector2_array * p_self] [const godot_int p_size]] void
func (gdt *PoolVector2Array) Resize(size Int) {
	arg0 := gdt.getBase()
	arg1 := size.getBase()

	C.go_godot_pool_vector2_array_resize(GDNative.api, arg0, arg1)
}

// Read godot_pool_vector2_array_read [[const godot_pool_vector2_array * p_self]] godot_pool_vector2_array_read_access *
func (gdt *PoolVector2Array) Read() PoolVector2ArrayReadAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_vector2_array_read(GDNative.api, arg0)

	return PoolVector2ArrayReadAccess{base: ret}

}

// Write godot_pool_vector2_array_write [[godot_pool_vector2_array * p_self]] godot_pool_vector2_array_write_access *
func (gdt *PoolVector2Array) Write() PoolVector2ArrayWriteAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_vector2_array_write(GDNative.api, arg0)

	return PoolVector2ArrayWriteAccess{base: ret}

}

// Set godot_pool_vector2_array_set [[godot_pool_vector2_array * p_self] [const godot_int p_idx] [const godot_vector2 * p_data]] void
func (gdt *PoolVector2Array) Set(idx Int, data Vector2) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	C.go_godot_pool_vector2_array_set(GDNative.api, arg0, arg1, arg2)
}

// Get godot_pool_vector2_array_get [[const godot_pool_vector2_array * p_self] [const godot_int p_idx]] godot_vector2
func (gdt *PoolVector2Array) Get(idx Int) Vector2 {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	ret := C.go_godot_pool_vector2_array_get(GDNative.api, arg0, arg1)

	return Vector2{base: &ret}

}

// Size godot_pool_vector2_array_size [[const godot_pool_vector2_array * p_self]] godot_int
func (gdt *PoolVector2Array) Size() Int {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_vector2_array_size(GDNative.api, arg0)

	return Int(ret)
}

// Destroy godot_pool_vector2_array_destroy [[godot_pool_vector2_array * p_self]] void
func (gdt *PoolVector2Array) Destroy() {
	arg0 := gdt.getBase()

	C.go_godot_pool_vector2_array_destroy(GDNative.api, arg0)
}

// NewEmptyPoolVector3Array will return a pointer to an empty
// initialized PoolVector3Array. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolVector3Array() Pointer {
	var obj C.godot_pool_vector3_array
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolVector3Array will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolVector3Array(obj PoolVector3Array) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolVector3ArrayFromPointer will return a PoolVector3Array from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolVector3ArrayFromPointer(ptr Pointer) PoolVector3Array {

	return PoolVector3Array{base: (*C.godot_pool_vector3_array)(ptr.getBase())}
}

// PoolVector3Array data structure wrapper
type PoolVector3Array struct {
	base *C.godot_pool_vector3_array
}

// returns the wrapped C base data type for this type
func (gdt PoolVector3Array) getBase() *C.godot_pool_vector3_array {
	return gdt.base
}

// NewPoolVector3Array godot_pool_vector3_array_new [[godot_pool_vector3_array * r_dest]] void
func NewPoolVector3Array() PoolVector3Array {
	var dest C.godot_pool_vector3_array
	C.go_godot_pool_vector3_array_new(GDNative.api, &dest)
	return PoolVector3Array{base: &dest}
}

// NewPoolVector3ArrayCopy godot_pool_vector3_array_new_copy [[godot_pool_vector3_array * r_dest] [const godot_pool_vector3_array * p_src]] void
func NewPoolVector3ArrayCopy(src PoolVector3Array) PoolVector3Array {
	var dest C.godot_pool_vector3_array
	arg1 := src.getBase()
	C.go_godot_pool_vector3_array_new_copy(GDNative.api, &dest, arg1)
	return PoolVector3Array{base: &dest}
}

// NewPoolVector3ArrayWithArray godot_pool_vector3_array_new_with_array [[godot_pool_vector3_array * r_dest] [const godot_array * p_a]] void
func NewPoolVector3ArrayWithArray(a Array) PoolVector3Array {
	var dest C.godot_pool_vector3_array
	arg1 := a.getBase()
	C.go_godot_pool_vector3_array_new_with_array(GDNative.api, &dest, arg1)
	return PoolVector3Array{base: &dest}
}

// Append godot_pool_vector3_array_append [[godot_pool_vector3_array * p_self] [const godot_vector3 * p_data]] void
func (gdt *PoolVector3Array) Append(data Vector3) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_vector3_array_append(GDNative.api, arg0, arg1)
}

// AppendArray godot_pool_vector3_array_append_array [[godot_pool_vector3_array * p_self] [const godot_pool_vector3_array * p_array]] void
func (gdt *PoolVector3Array) AppendArray(array PoolVector3Array) {
	arg0 := gdt.getBase()
	arg1 := array.getBase()

	C.go_godot_pool_vector3_array_append_array(GDNative.api, arg0, arg1)
}

// Insert godot_pool_vector3_array_insert [[godot_pool_vector3_array * p_self] [const godot_int p_idx] [const godot_vector3 * p_data]] godot_error
func (gdt *PoolVector3Array) Insert(idx Int, data Vector3) Error {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	ret := C.go_godot_pool_vector3_array_insert(GDNative.api, arg0, arg1, arg2)

	return Error(ret)
}

// Invert godot_pool_vector3_array_invert [[godot_pool_vector3_array * p_self]] void
func (gdt *PoolVector3Array) Invert() {
	arg0 := gdt.getBase()

	C.go_godot_pool_vector3_array_invert(GDNative.api, arg0)
}

// PushBack godot_pool_vector3_array_push_back [[godot_pool_vector3_array * p_self] [const godot_vector3 * p_data]] void
func (gdt *PoolVector3Array) PushBack(data Vector3) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_vector3_array_push_back(GDNative.api, arg0, arg1)
}

// Remove godot_pool_vector3_array_remove [[godot_pool_vector3_array * p_self] [const godot_int p_idx]] void
func (gdt *PoolVector3Array) Remove(idx Int) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	C.go_godot_pool_vector3_array_remove(GDNative.api, arg0, arg1)
}

// Resize godot_pool_vector3_array_resize [[godot_pool_vector3_array * p_self] [const godot_int p_size]] void
func (gdt *PoolVector3Array) Resize(size Int) {
	arg0 := gdt.getBase()
	arg1 := size.getBase()

	C.go_godot_pool_vector3_array_resize(GDNative.api, arg0, arg1)
}

// Read godot_pool_vector3_array_read [[const godot_pool_vector3_array * p_self]] godot_pool_vector3_array_read_access *
func (gdt *PoolVector3Array) Read() PoolVector3ArrayReadAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_vector3_array_read(GDNative.api, arg0)

	return PoolVector3ArrayReadAccess{base: ret}

}

// Write godot_pool_vector3_array_write [[godot_pool_vector3_array * p_self]] godot_pool_vector3_array_write_access *
func (gdt *PoolVector3Array) Write() PoolVector3ArrayWriteAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_vector3_array_write(GDNative.api, arg0)

	return PoolVector3ArrayWriteAccess{base: ret}

}

// Set godot_pool_vector3_array_set [[godot_pool_vector3_array * p_self] [const godot_int p_idx] [const godot_vector3 * p_data]] void
func (gdt *PoolVector3Array) Set(idx Int, data Vector3) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	C.go_godot_pool_vector3_array_set(GDNative.api, arg0, arg1, arg2)
}

// Get godot_pool_vector3_array_get [[const godot_pool_vector3_array * p_self] [const godot_int p_idx]] godot_vector3
func (gdt *PoolVector3Array) Get(idx Int) Vector3 {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	ret := C.go_godot_pool_vector3_array_get(GDNative.api, arg0, arg1)

	return Vector3{base: &ret}

}

// Size godot_pool_vector3_array_size [[const godot_pool_vector3_array * p_self]] godot_int
func (gdt *PoolVector3Array) Size() Int {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_vector3_array_size(GDNative.api, arg0)

	return Int(ret)
}

// Destroy godot_pool_vector3_array_destroy [[godot_pool_vector3_array * p_self]] void
func (gdt *PoolVector3Array) Destroy() {
	arg0 := gdt.getBase()

	C.go_godot_pool_vector3_array_destroy(GDNative.api, arg0)
}

// NewEmptyPoolColorArray will return a pointer to an empty
// initialized PoolColorArray. This is primarily used in
// conjunction with MethodBindPtrCall.
func NewEmptyPoolColorArray() Pointer {
	var obj C.godot_pool_color_array
	return Pointer{base: unsafe.Pointer(&obj)}
}

// NewPointerFromPoolColorArray will return an unsafe pointer to the given
// object. This is primarily used in conjunction with MethodBindPtrCall.
func NewPointerFromPoolColorArray(obj PoolColorArray) Pointer {
	return Pointer{base: unsafe.Pointer(obj.getBase())}
}

// NewPoolColorArrayFromPointer will return a PoolColorArray from the
// given unsafe pointer. This is primarily used in conjunction with MethodBindPtrCall.
func NewPoolColorArrayFromPointer(ptr Pointer) PoolColorArray {

	return PoolColorArray{base: (*C.godot_pool_color_array)(ptr.getBase())}
}

// PoolColorArray data structure wrapper
type PoolColorArray struct {
	base *C.godot_pool_color_array
}

// returns the wrapped C base data type for this type
func (gdt PoolColorArray) getBase() *C.godot_pool_color_array {
	return gdt.base
}

// NewPoolColorArray godot_pool_color_array_new [[godot_pool_color_array * r_dest]] void
func NewPoolColorArray() PoolColorArray {
	var dest C.godot_pool_color_array
	C.go_godot_pool_color_array_new(GDNative.api, &dest)
	return PoolColorArray{base: &dest}
}

// NewPoolColorArrayCopy godot_pool_color_array_new_copy [[godot_pool_color_array * r_dest] [const godot_pool_color_array * p_src]] void
func NewPoolColorArrayCopy(src PoolColorArray) PoolColorArray {
	var dest C.godot_pool_color_array
	arg1 := src.getBase()
	C.go_godot_pool_color_array_new_copy(GDNative.api, &dest, arg1)
	return PoolColorArray{base: &dest}
}

// NewPoolColorArrayWithArray godot_pool_color_array_new_with_array [[godot_pool_color_array * r_dest] [const godot_array * p_a]] void
func NewPoolColorArrayWithArray(a Array) PoolColorArray {
	var dest C.godot_pool_color_array
	arg1 := a.getBase()
	C.go_godot_pool_color_array_new_with_array(GDNative.api, &dest, arg1)
	return PoolColorArray{base: &dest}
}

// Append godot_pool_color_array_append [[godot_pool_color_array * p_self] [const godot_color * p_data]] void
func (gdt *PoolColorArray) Append(data Color) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_color_array_append(GDNative.api, arg0, arg1)
}

// AppendArray godot_pool_color_array_append_array [[godot_pool_color_array * p_self] [const godot_pool_color_array * p_array]] void
func (gdt *PoolColorArray) AppendArray(array PoolColorArray) {
	arg0 := gdt.getBase()
	arg1 := array.getBase()

	C.go_godot_pool_color_array_append_array(GDNative.api, arg0, arg1)
}

// Insert godot_pool_color_array_insert [[godot_pool_color_array * p_self] [const godot_int p_idx] [const godot_color * p_data]] godot_error
func (gdt *PoolColorArray) Insert(idx Int, data Color) Error {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	ret := C.go_godot_pool_color_array_insert(GDNative.api, arg0, arg1, arg2)

	return Error(ret)
}

// Invert godot_pool_color_array_invert [[godot_pool_color_array * p_self]] void
func (gdt *PoolColorArray) Invert() {
	arg0 := gdt.getBase()

	C.go_godot_pool_color_array_invert(GDNative.api, arg0)
}

// PushBack godot_pool_color_array_push_back [[godot_pool_color_array * p_self] [const godot_color * p_data]] void
func (gdt *PoolColorArray) PushBack(data Color) {
	arg0 := gdt.getBase()
	arg1 := data.getBase()

	C.go_godot_pool_color_array_push_back(GDNative.api, arg0, arg1)
}

// Remove godot_pool_color_array_remove [[godot_pool_color_array * p_self] [const godot_int p_idx]] void
func (gdt *PoolColorArray) Remove(idx Int) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	C.go_godot_pool_color_array_remove(GDNative.api, arg0, arg1)
}

// Resize godot_pool_color_array_resize [[godot_pool_color_array * p_self] [const godot_int p_size]] void
func (gdt *PoolColorArray) Resize(size Int) {
	arg0 := gdt.getBase()
	arg1 := size.getBase()

	C.go_godot_pool_color_array_resize(GDNative.api, arg0, arg1)
}

// Read godot_pool_color_array_read [[const godot_pool_color_array * p_self]] godot_pool_color_array_read_access *
func (gdt *PoolColorArray) Read() PoolColorArrayReadAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_color_array_read(GDNative.api, arg0)

	return PoolColorArrayReadAccess{base: ret}

}

// Write godot_pool_color_array_write [[godot_pool_color_array * p_self]] godot_pool_color_array_write_access *
func (gdt *PoolColorArray) Write() PoolColorArrayWriteAccess {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_color_array_write(GDNative.api, arg0)

	return PoolColorArrayWriteAccess{base: ret}

}

// Set godot_pool_color_array_set [[godot_pool_color_array * p_self] [const godot_int p_idx] [const godot_color * p_data]] void
func (gdt *PoolColorArray) Set(idx Int, data Color) {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()
	arg2 := data.getBase()

	C.go_godot_pool_color_array_set(GDNative.api, arg0, arg1, arg2)
}

// Get godot_pool_color_array_get [[const godot_pool_color_array * p_self] [const godot_int p_idx]] godot_color
func (gdt *PoolColorArray) Get(idx Int) Color {
	arg0 := gdt.getBase()
	arg1 := idx.getBase()

	ret := C.go_godot_pool_color_array_get(GDNative.api, arg0, arg1)

	return Color{base: &ret}

}

// Size godot_pool_color_array_size [[const godot_pool_color_array * p_self]] godot_int
func (gdt *PoolColorArray) Size() Int {
	arg0 := gdt.getBase()

	ret := C.go_godot_pool_color_array_size(GDNative.api, arg0)

	return Int(ret)
}

// Destroy godot_pool_color_array_destroy [[godot_pool_color_array * p_self]] void
func (gdt *PoolColorArray) Destroy() {
	arg0 := gdt.getBase()

	C.go_godot_pool_color_array_destroy(GDNative.api, arg0)
}