// Copyright (C) 2018-2024, Tellusim Technologies Inc. All rights reserved
// https://tellusim.com/

#include <TellusimApp.h>
#include <TellusimFormat.h>
#include <core/TellusimCore.h>
#include <core/TellusimSystem.h>
#include <core/TellusimDirectory.h>
#include <math/TellusimMath.h>
#include <format/TellusimFormats.h>
#include <platform/TellusimPlatforms.h>
#include <interface/TellusimFont.h>
#include <interface/TellusimControls.h>
#include <interface/TellusimDialogs.h>
#include <geometry/TellusimGeometry.h>
#include <graphics/TellusimGraphics.h>
#include <parallel/TellusimParallels.h>
#include <system/TellusimDesktop.h>

#define TS_OBJCPP 1

#include "../include/TellusimObjCAPI.h"

/*
 */
namespace Tellusim {
	
	// Tellusim::Vendor
	TS_STATIC_ASSERT(TS_VendorARM == (uint32_t)VendorARM);
	TS_STATIC_ASSERT(TS_VendorAMD == (uint32_t)VendorAMD);
	TS_STATIC_ASSERT(TS_VendorApple == (uint32_t)VendorApple);
	TS_STATIC_ASSERT(TS_VendorIntel == (uint32_t)VendorIntel);
	TS_STATIC_ASSERT(TS_VendorNvidia == (uint32_t)VendorNvidia);
	TS_STATIC_ASSERT(TS_VendorQualcomm == (uint32_t)VendorQualcomm);
	
	// Tellusim::Platform
	TS_STATIC_ASSERT(TS_PlatformUnknown == (uint32_t)PlatformUnknown);
	TS_STATIC_ASSERT(TS_PlatformFusion == (uint32_t)PlatformFusion);
	TS_STATIC_ASSERT(TS_PlatformD3D12 == (uint32_t)PlatformD3D12);
	TS_STATIC_ASSERT(TS_PlatformD3D11 == (uint32_t)PlatformD3D11);
	TS_STATIC_ASSERT(TS_PlatformMTL == (uint32_t)PlatformMTL);
	TS_STATIC_ASSERT(TS_PlatformVK == (uint32_t)PlatformVK);
	TS_STATIC_ASSERT(TS_PlatformGL == (uint32_t)PlatformGL);
	TS_STATIC_ASSERT(TS_PlatformGLES == (uint32_t)PlatformGLES);
	TS_STATIC_ASSERT(TS_PlatformWG == (uint32_t)PlatformWG);
	TS_STATIC_ASSERT(TS_PlatformCU == (uint32_t)PlatformCU);
	TS_STATIC_ASSERT(TS_PlatformHIP == (uint32_t)PlatformHIP);
	TS_STATIC_ASSERT(TS_PlatformAny == (uint32_t)PlatformAny);
	TS_STATIC_ASSERT(TS_PlatformNumPlatforms == (uint32_t)NumPlatforms);
	
	// Tellusim::BindFlags
	TS_STATIC_ASSERT(TS_BindFlagsBindFlagNone == (uint32_t)BindFlagNone);
	TS_STATIC_ASSERT(TS_BindFlagsBindFlagFixed == (uint32_t)BindFlagFixed);
	TS_STATIC_ASSERT(TS_BindFlagsBindFlagRead == (uint32_t)BindFlagRead);
	
	// Tellusim::TableType
	TS_STATIC_ASSERT(TS_TableTypeTexture == (uint32_t)TableTypeTexture);
	TS_STATIC_ASSERT(TS_TableTypeStorage == (uint32_t)TableTypeStorage);
	TS_STATIC_ASSERT(TS_TableTypeNumTableTypes == (uint32_t)NumTableTypes);
	
	// Tellusim::Format
	TS_STATIC_ASSERT(TS_FormatUnknown == (uint32_t)FormatUnknown);
	TS_STATIC_ASSERT(TS_FormatRi8 == (uint32_t)FormatRi8);
	TS_STATIC_ASSERT(TS_FormatRu8 == (uint32_t)FormatRu8);
	TS_STATIC_ASSERT(TS_FormatRi8n == (uint32_t)FormatRi8n);
	TS_STATIC_ASSERT(TS_FormatRu8n == (uint32_t)FormatRu8n);
	TS_STATIC_ASSERT(TS_FormatRGi8 == (uint32_t)FormatRGi8);
	TS_STATIC_ASSERT(TS_FormatRGu8 == (uint32_t)FormatRGu8);
	TS_STATIC_ASSERT(TS_FormatRGi8n == (uint32_t)FormatRGi8n);
	TS_STATIC_ASSERT(TS_FormatRGu8n == (uint32_t)FormatRGu8n);
	TS_STATIC_ASSERT(TS_FormatRGBi8 == (uint32_t)FormatRGBi8);
	TS_STATIC_ASSERT(TS_FormatRGBu8 == (uint32_t)FormatRGBu8);
	TS_STATIC_ASSERT(TS_FormatRGBi8n == (uint32_t)FormatRGBi8n);
	TS_STATIC_ASSERT(TS_FormatRGBu8n == (uint32_t)FormatRGBu8n);
	TS_STATIC_ASSERT(TS_FormatRGBu8ns == (uint32_t)FormatRGBu8ns);
	TS_STATIC_ASSERT(TS_FormatRGBAi8 == (uint32_t)FormatRGBAi8);
	TS_STATIC_ASSERT(TS_FormatRGBAu8 == (uint32_t)FormatRGBAu8);
	TS_STATIC_ASSERT(TS_FormatRGBAi8n == (uint32_t)FormatRGBAi8n);
	TS_STATIC_ASSERT(TS_FormatRGBAu8n == (uint32_t)FormatRGBAu8n);
	TS_STATIC_ASSERT(TS_FormatRGBAu8ns == (uint32_t)FormatRGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatBGRAu8n == (uint32_t)FormatBGRAu8n);
	TS_STATIC_ASSERT(TS_FormatBGRAu8ns == (uint32_t)FormatBGRAu8ns);
	TS_STATIC_ASSERT(TS_FormatRi16 == (uint32_t)FormatRi16);
	TS_STATIC_ASSERT(TS_FormatRu16 == (uint32_t)FormatRu16);
	TS_STATIC_ASSERT(TS_FormatRi16n == (uint32_t)FormatRi16n);
	TS_STATIC_ASSERT(TS_FormatRu16n == (uint32_t)FormatRu16n);
	TS_STATIC_ASSERT(TS_FormatRf16 == (uint32_t)FormatRf16);
	TS_STATIC_ASSERT(TS_FormatRGi16 == (uint32_t)FormatRGi16);
	TS_STATIC_ASSERT(TS_FormatRGu16 == (uint32_t)FormatRGu16);
	TS_STATIC_ASSERT(TS_FormatRGi16n == (uint32_t)FormatRGi16n);
	TS_STATIC_ASSERT(TS_FormatRGu16n == (uint32_t)FormatRGu16n);
	TS_STATIC_ASSERT(TS_FormatRGf16 == (uint32_t)FormatRGf16);
	TS_STATIC_ASSERT(TS_FormatRGBi16 == (uint32_t)FormatRGBi16);
	TS_STATIC_ASSERT(TS_FormatRGBu16 == (uint32_t)FormatRGBu16);
	TS_STATIC_ASSERT(TS_FormatRGBi16n == (uint32_t)FormatRGBi16n);
	TS_STATIC_ASSERT(TS_FormatRGBu16n == (uint32_t)FormatRGBu16n);
	TS_STATIC_ASSERT(TS_FormatRGBf16 == (uint32_t)FormatRGBf16);
	TS_STATIC_ASSERT(TS_FormatRGBAi16 == (uint32_t)FormatRGBAi16);
	TS_STATIC_ASSERT(TS_FormatRGBAu16 == (uint32_t)FormatRGBAu16);
	TS_STATIC_ASSERT(TS_FormatRGBAi16n == (uint32_t)FormatRGBAi16n);
	TS_STATIC_ASSERT(TS_FormatRGBAu16n == (uint32_t)FormatRGBAu16n);
	TS_STATIC_ASSERT(TS_FormatRGBAf16 == (uint32_t)FormatRGBAf16);
	TS_STATIC_ASSERT(TS_FormatRi32 == (uint32_t)FormatRi32);
	TS_STATIC_ASSERT(TS_FormatRu32 == (uint32_t)FormatRu32);
	TS_STATIC_ASSERT(TS_FormatRf32 == (uint32_t)FormatRf32);
	TS_STATIC_ASSERT(TS_FormatRGi32 == (uint32_t)FormatRGi32);
	TS_STATIC_ASSERT(TS_FormatRGu32 == (uint32_t)FormatRGu32);
	TS_STATIC_ASSERT(TS_FormatRGf32 == (uint32_t)FormatRGf32);
	TS_STATIC_ASSERT(TS_FormatRGBi32 == (uint32_t)FormatRGBi32);
	TS_STATIC_ASSERT(TS_FormatRGBu32 == (uint32_t)FormatRGBu32);
	TS_STATIC_ASSERT(TS_FormatRGBf32 == (uint32_t)FormatRGBf32);
	TS_STATIC_ASSERT(TS_FormatRGBAi32 == (uint32_t)FormatRGBAi32);
	TS_STATIC_ASSERT(TS_FormatRGBAu32 == (uint32_t)FormatRGBAu32);
	TS_STATIC_ASSERT(TS_FormatRGBAf32 == (uint32_t)FormatRGBAf32);
	TS_STATIC_ASSERT(TS_FormatRi64 == (uint32_t)FormatRi64);
	TS_STATIC_ASSERT(TS_FormatRu64 == (uint32_t)FormatRu64);
	TS_STATIC_ASSERT(TS_FormatRf64 == (uint32_t)FormatRf64);
	TS_STATIC_ASSERT(TS_FormatRGi64 == (uint32_t)FormatRGi64);
	TS_STATIC_ASSERT(TS_FormatRGu64 == (uint32_t)FormatRGu64);
	TS_STATIC_ASSERT(TS_FormatRGf64 == (uint32_t)FormatRGf64);
	TS_STATIC_ASSERT(TS_FormatRGBi64 == (uint32_t)FormatRGBi64);
	TS_STATIC_ASSERT(TS_FormatRGBu64 == (uint32_t)FormatRGBu64);
	TS_STATIC_ASSERT(TS_FormatRGBf64 == (uint32_t)FormatRGBf64);
	TS_STATIC_ASSERT(TS_FormatRGBAi64 == (uint32_t)FormatRGBAi64);
	TS_STATIC_ASSERT(TS_FormatRGBAu64 == (uint32_t)FormatRGBAu64);
	TS_STATIC_ASSERT(TS_FormatRGBAf64 == (uint32_t)FormatRGBAf64);
	TS_STATIC_ASSERT(TS_FormatRGBAu4n == (uint32_t)FormatRGBAu4n);
	TS_STATIC_ASSERT(TS_FormatRGBu5Au1n == (uint32_t)FormatRGBu5Au1n);
	TS_STATIC_ASSERT(TS_FormatRu5Gu6Bu5n == (uint32_t)FormatRu5Gu6Bu5n);
	TS_STATIC_ASSERT(TS_FormatRGBu10Au2 == (uint32_t)FormatRGBu10Au2);
	TS_STATIC_ASSERT(TS_FormatRGBu10Au2n == (uint32_t)FormatRGBu10Au2n);
	TS_STATIC_ASSERT(TS_FormatRGf11Bf10 == (uint32_t)FormatRGf11Bf10);
	TS_STATIC_ASSERT(TS_FormatRGBf21 == (uint32_t)FormatRGBf21);
	TS_STATIC_ASSERT(TS_FormatBC1RGBu8n == (uint32_t)FormatBC1RGBu8n);
	TS_STATIC_ASSERT(TS_FormatBC1RGBu8ns == (uint32_t)FormatBC1RGBu8ns);
	TS_STATIC_ASSERT(TS_FormatBC1RGBAu8n == (uint32_t)FormatBC1RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatBC1RGBAu8ns == (uint32_t)FormatBC1RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatBC2RGBAu8n == (uint32_t)FormatBC2RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatBC2RGBAu8ns == (uint32_t)FormatBC2RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatBC3RGBAu8n == (uint32_t)FormatBC3RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatBC3RGBAu8ns == (uint32_t)FormatBC3RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatBC4Ri8n == (uint32_t)FormatBC4Ri8n);
	TS_STATIC_ASSERT(TS_FormatBC4Ru8n == (uint32_t)FormatBC4Ru8n);
	TS_STATIC_ASSERT(TS_FormatBC5RGi8n == (uint32_t)FormatBC5RGi8n);
	TS_STATIC_ASSERT(TS_FormatBC5RGu8n == (uint32_t)FormatBC5RGu8n);
	TS_STATIC_ASSERT(TS_FormatBC6RGBf16s == (uint32_t)FormatBC6RGBf16s);
	TS_STATIC_ASSERT(TS_FormatBC6RGBf16u == (uint32_t)FormatBC6RGBf16u);
	TS_STATIC_ASSERT(TS_FormatBC7RGBAu8n == (uint32_t)FormatBC7RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatBC7RGBAu8ns == (uint32_t)FormatBC7RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatEACRi8n == (uint32_t)FormatEACRi8n);
	TS_STATIC_ASSERT(TS_FormatEACRu8n == (uint32_t)FormatEACRu8n);
	TS_STATIC_ASSERT(TS_FormatEACRGi8n == (uint32_t)FormatEACRGi8n);
	TS_STATIC_ASSERT(TS_FormatEACRGu8n == (uint32_t)FormatEACRGu8n);
	TS_STATIC_ASSERT(TS_FormatETC2RGBu8n == (uint32_t)FormatETC2RGBu8n);
	TS_STATIC_ASSERT(TS_FormatETC2RGBu8ns == (uint32_t)FormatETC2RGBu8ns);
	TS_STATIC_ASSERT(TS_FormatETC2RGBAu8n == (uint32_t)FormatETC2RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatETC2RGBAu8ns == (uint32_t)FormatETC2RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatETC2RGBu8Au1n == (uint32_t)FormatETC2RGBu8Au1n);
	TS_STATIC_ASSERT(TS_FormatETC2RGBu8Au1ns == (uint32_t)FormatETC2RGBu8Au1ns);
	TS_STATIC_ASSERT(TS_FormatASTC44RGBAu8n == (uint32_t)FormatASTC44RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatASTC44RGBAu8ns == (uint32_t)FormatASTC44RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatASTC44RGBAf16 == (uint32_t)FormatASTC44RGBAf16);
	TS_STATIC_ASSERT(TS_FormatASTC54RGBAu8n == (uint32_t)FormatASTC54RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatASTC54RGBAu8ns == (uint32_t)FormatASTC54RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatASTC54RGBAf16 == (uint32_t)FormatASTC54RGBAf16);
	TS_STATIC_ASSERT(TS_FormatASTC55RGBAu8n == (uint32_t)FormatASTC55RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatASTC55RGBAu8ns == (uint32_t)FormatASTC55RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatASTC55RGBAf16 == (uint32_t)FormatASTC55RGBAf16);
	TS_STATIC_ASSERT(TS_FormatASTC65RGBAu8n == (uint32_t)FormatASTC65RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatASTC65RGBAu8ns == (uint32_t)FormatASTC65RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatASTC65RGBAf16 == (uint32_t)FormatASTC65RGBAf16);
	TS_STATIC_ASSERT(TS_FormatASTC66RGBAu8n == (uint32_t)FormatASTC66RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatASTC66RGBAu8ns == (uint32_t)FormatASTC66RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatASTC66RGBAf16 == (uint32_t)FormatASTC66RGBAf16);
	TS_STATIC_ASSERT(TS_FormatASTC85RGBAu8n == (uint32_t)FormatASTC85RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatASTC85RGBAu8ns == (uint32_t)FormatASTC85RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatASTC85RGBAf16 == (uint32_t)FormatASTC85RGBAf16);
	TS_STATIC_ASSERT(TS_FormatASTC86RGBAu8n == (uint32_t)FormatASTC86RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatASTC86RGBAu8ns == (uint32_t)FormatASTC86RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatASTC86RGBAf16 == (uint32_t)FormatASTC86RGBAf16);
	TS_STATIC_ASSERT(TS_FormatASTC88RGBAu8n == (uint32_t)FormatASTC88RGBAu8n);
	TS_STATIC_ASSERT(TS_FormatASTC88RGBAu8ns == (uint32_t)FormatASTC88RGBAu8ns);
	TS_STATIC_ASSERT(TS_FormatASTC88RGBAf16 == (uint32_t)FormatASTC88RGBAf16);
	TS_STATIC_ASSERT(TS_FormatDu16 == (uint32_t)FormatDu16);
	TS_STATIC_ASSERT(TS_FormatDu16Su8 == (uint32_t)FormatDu16Su8);
	TS_STATIC_ASSERT(TS_FormatDu24 == (uint32_t)FormatDu24);
	TS_STATIC_ASSERT(TS_FormatDu24Su8 == (uint32_t)FormatDu24Su8);
	TS_STATIC_ASSERT(TS_FormatDf32 == (uint32_t)FormatDf32);
	TS_STATIC_ASSERT(TS_FormatDf32Su8 == (uint32_t)FormatDf32Su8);
	TS_STATIC_ASSERT(TS_FormatNumFormats == (uint32_t)NumFormats);
	
	// Tellusim::App::
	TS_STATIC_ASSERT(TS_AppVersion_19 == (uint32_t)App::Version_19);
	TS_STATIC_ASSERT(TS_AppVersion_20 == (uint32_t)App::Version_20);
	TS_STATIC_ASSERT(TS_AppVersion_21 == (uint32_t)App::Version_21);
	TS_STATIC_ASSERT(TS_AppVersion_22 == (uint32_t)App::Version_22);
	TS_STATIC_ASSERT(TS_AppVersion_23 == (uint32_t)App::Version_23);
	TS_STATIC_ASSERT(TS_AppVersion_24 == (uint32_t)App::Version_24);
	TS_STATIC_ASSERT(TS_AppVersion_25 == (uint32_t)App::Version_25);
	TS_STATIC_ASSERT(TS_AppVersion_26 == (uint32_t)App::Version_26);
	TS_STATIC_ASSERT(TS_AppVersion_27 == (uint32_t)App::Version_27);
	TS_STATIC_ASSERT(TS_AppVersion_28 == (uint32_t)App::Version_28);
	TS_STATIC_ASSERT(TS_AppVersion_29 == (uint32_t)App::Version_29);
	TS_STATIC_ASSERT(TS_AppVersion_30 == (uint32_t)App::Version_30);
	TS_STATIC_ASSERT(TS_AppVersion_31 == (uint32_t)App::Version_31);
	TS_STATIC_ASSERT(TS_AppVersion_32 == (uint32_t)App::Version_32);
	TS_STATIC_ASSERT(TS_AppVersion_33 == (uint32_t)App::Version_33);
	TS_STATIC_ASSERT(TS_AppVersion_34 == (uint32_t)App::Version_34);
	TS_STATIC_ASSERT(TS_AppVersion_35 == (uint32_t)App::Version_35);
	TS_STATIC_ASSERT(TS_AppVersion_36 == (uint32_t)App::Version_36);
	TS_STATIC_ASSERT(TS_AppVersion_37 == (uint32_t)App::Version_37);
	TS_STATIC_ASSERT(TS_AppVersion == (uint32_t)App::Version);
	
	// Tellusim::Socket::Type
	TS_STATIC_ASSERT(TS_SocketTypeStream == (uint32_t)Socket::TypeStream);
	TS_STATIC_ASSERT(TS_SocketTypeDatagram == (uint32_t)Socket::TypeDatagram);
	TS_STATIC_ASSERT(TS_SocketTypeNumTypes == (uint32_t)Socket::NumTypes);
	
	// Tellusim::Directory::Attributes
	TS_STATIC_ASSERT(TS_DirectoryAttributesNone == (uint32_t)Directory::AttributeNone);
	TS_STATIC_ASSERT(TS_DirectoryAttributesRead == (uint32_t)Directory::AttributeRead);
	TS_STATIC_ASSERT(TS_DirectoryAttributesWrite == (uint32_t)Directory::AttributeWrite);
	TS_STATIC_ASSERT(TS_DirectoryAttributesHidden == (uint32_t)Directory::AttributeHidden);
	TS_STATIC_ASSERT(TS_DirectoryAttributesExecute == (uint32_t)Directory::AttributeExecute);
	TS_STATIC_ASSERT(TS_DirectoryAttributesTemporary == (uint32_t)Directory::AttributeTemporary);
	TS_STATIC_ASSERT(TS_DirectoryAttributesNumAttributes == (uint32_t)Directory::NumAttributes);
	
	// Tellusim::Image::Type
	TS_STATIC_ASSERT(TS_ImageTypeUnknown == (uint32_t)Image::TypeUnknown);
	TS_STATIC_ASSERT(TS_ImageType2D == (uint32_t)Image::Type2D);
	TS_STATIC_ASSERT(TS_ImageType3D == (uint32_t)Image::Type3D);
	TS_STATIC_ASSERT(TS_ImageTypeCube == (uint32_t)Image::TypeCube);
	TS_STATIC_ASSERT(TS_ImageTypeNumTypes == (uint32_t)Image::NumTypes);
	
	// Tellusim::Image::Flags
	TS_STATIC_ASSERT(TS_ImageFlagsNone == (uint32_t)Image::FlagNone);
	TS_STATIC_ASSERT(TS_ImageFlagsMipmaps == (uint32_t)Image::FlagMipmaps);
	TS_STATIC_ASSERT(TS_ImageFlagsNoClear == (uint32_t)Image::FlagNoClear);
	TS_STATIC_ASSERT(TS_ImageFlagsNoAllocate == (uint32_t)Image::FlagNoAllocate);
	TS_STATIC_ASSERT(TS_ImageFlagsFast == (uint32_t)Image::FlagFast);
	TS_STATIC_ASSERT(TS_ImageFlagsBest == (uint32_t)Image::FlagBest);
	TS_STATIC_ASSERT(TS_ImageFlagsPerceptual == (uint32_t)Image::FlagPerceptual);
	TS_STATIC_ASSERT(TS_ImageFlagsPanorama == (uint32_t)Image::FlagPanorama);
	TS_STATIC_ASSERT(TS_ImageFlagsNormalize == (uint32_t)Image::FlagNormalize);
	TS_STATIC_ASSERT(TS_ImageFlagsGamma == (uint32_t)Image::FlagGamma);
	TS_STATIC_ASSERT(TS_ImageFlagsSRGB == (uint32_t)Image::FlagSRGB);
	TS_STATIC_ASSERT(TS_ImageFlagsNumFlags == (uint32_t)Image::NumFlags);
	
	// Tellusim::Image::Filter
	TS_STATIC_ASSERT(TS_ImageFilterUnknown == (uint32_t)Image::FilterUnknown);
	TS_STATIC_ASSERT(TS_ImageFilterPoint == (uint32_t)Image::FilterPoint);
	TS_STATIC_ASSERT(TS_ImageFilterLinear == (uint32_t)Image::FilterLinear);
	TS_STATIC_ASSERT(TS_ImageFilterCubic == (uint32_t)Image::FilterCubic);
	TS_STATIC_ASSERT(TS_ImageFilterSinc == (uint32_t)Image::FilterSinc);
	TS_STATIC_ASSERT(TS_ImageFilterBox == (uint32_t)Image::FilterBox);
	TS_STATIC_ASSERT(TS_ImageFilterMax == (uint32_t)Image::FilterMax);
	TS_STATIC_ASSERT(TS_ImageFilterMin == (uint32_t)Image::FilterMin);
	TS_STATIC_ASSERT(TS_ImageFilterMip == (uint32_t)Image::FilterMip);
	TS_STATIC_ASSERT(TS_ImageFilterCR == (uint32_t)Image::FilterCR);
	TS_STATIC_ASSERT(TS_ImageFilterNumFilters == (uint32_t)Image::NumFilters);
	
	// Tellusim::MeshIndices::Type
	TS_STATIC_ASSERT(TS_MeshIndicesTypeUnknown == (uint32_t)MeshIndices::TypeUnknown);
	TS_STATIC_ASSERT(TS_MeshIndicesTypePoint == (uint32_t)MeshIndices::TypePoint);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeLine == (uint32_t)MeshIndices::TypeLine);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeTriangle == (uint32_t)MeshIndices::TypeTriangle);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeQuadrilateral == (uint32_t)MeshIndices::TypeQuadrilateral);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeTetrahedron == (uint32_t)MeshIndices::TypeTetrahedron);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeMaterial == (uint32_t)MeshIndices::TypeMaterial);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeIsland == (uint32_t)MeshIndices::TypeIsland);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeGroup == (uint32_t)MeshIndices::TypeGroup);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeJoint == (uint32_t)MeshIndices::TypeJoint);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeEdge == (uint32_t)MeshIndices::TypeEdge);
	TS_STATIC_ASSERT(TS_MeshIndicesTypeNumTypes == (uint32_t)MeshIndices::NumTypes);
	
	// Tellusim::MeshAttribute::Type
	TS_STATIC_ASSERT(TS_MeshAttributeTypeUnknown == (uint32_t)MeshAttribute::TypeUnknown);
	TS_STATIC_ASSERT(TS_MeshAttributeTypePosition == (uint32_t)MeshAttribute::TypePosition);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeBasis == (uint32_t)MeshAttribute::TypeBasis);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeNormal == (uint32_t)MeshAttribute::TypeNormal);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeTangent == (uint32_t)MeshAttribute::TypeTangent);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeBinormal == (uint32_t)MeshAttribute::TypeBinormal);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeTexCoord == (uint32_t)MeshAttribute::TypeTexCoord);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeWeights == (uint32_t)MeshAttribute::TypeWeights);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeJoints == (uint32_t)MeshAttribute::TypeJoints);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeColor == (uint32_t)MeshAttribute::TypeColor);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeCrease == (uint32_t)MeshAttribute::TypeCrease);
	TS_STATIC_ASSERT(TS_MeshAttributeTypeNumTypes == (uint32_t)MeshAttribute::NumTypes);
	
	// Tellusim::MeshMaterial::Flags
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsNone == (uint32_t)MeshMaterial::FlagNone);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsBool == (uint32_t)MeshMaterial::FlagBool);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsScalarf32 == (uint32_t)MeshMaterial::FlagScalarf32);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsVector4f == (uint32_t)MeshMaterial::FlagVector4f);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsMatrix3x2f == (uint32_t)MeshMaterial::FlagMatrix3x2f);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsColor == (uint32_t)MeshMaterial::FlagColor);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsName == (uint32_t)MeshMaterial::FlagName);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsLayout == (uint32_t)MeshMaterial::FlagLayout);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsBlob == (uint32_t)MeshMaterial::FlagBlob);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsImage == (uint32_t)MeshMaterial::FlagImage);
	TS_STATIC_ASSERT(TS_MeshMaterialFlagsTexture == (uint32_t)MeshMaterial::FlagTexture);
	
	// Tellusim::MeshAttachment::Type
	TS_STATIC_ASSERT(TS_MeshAttachmentTypeUnknown == (uint32_t)MeshAttachment::TypeUnknown);
	TS_STATIC_ASSERT(TS_MeshAttachmentTypeLightGlobal == (uint32_t)MeshAttachment::TypeLightGlobal);
	TS_STATIC_ASSERT(TS_MeshAttachmentTypeLightPoint == (uint32_t)MeshAttachment::TypeLightPoint);
	TS_STATIC_ASSERT(TS_MeshAttachmentTypeLightSpot == (uint32_t)MeshAttachment::TypeLightSpot);
	TS_STATIC_ASSERT(TS_MeshAttachmentTypeLightImage == (uint32_t)MeshAttachment::TypeLightImage);
	TS_STATIC_ASSERT(TS_MeshAttachmentTypeCameraPerspective == (uint32_t)MeshAttachment::TypeCameraPerspective);
	TS_STATIC_ASSERT(TS_MeshAttachmentTypeCameraOrthographic == (uint32_t)MeshAttachment::TypeCameraOrthographic);
	TS_STATIC_ASSERT(TS_MeshAttachmentTypeNumTypes == (uint32_t)MeshAttachment::NumTypes);
	
	// Tellusim::MeshAttachment::Flags
	TS_STATIC_ASSERT(TS_MeshAttachmentFlagsNone == (uint32_t)MeshAttachment::FlagNone);
	TS_STATIC_ASSERT(TS_MeshAttachmentFlagsBool == (uint32_t)MeshAttachment::FlagBool);
	TS_STATIC_ASSERT(TS_MeshAttachmentFlagsScalarf32 == (uint32_t)MeshAttachment::FlagScalarf32);
	TS_STATIC_ASSERT(TS_MeshAttachmentFlagsVector4f == (uint32_t)MeshAttachment::FlagVector4f);
	TS_STATIC_ASSERT(TS_MeshAttachmentFlagsColor == (uint32_t)MeshAttachment::FlagColor);
	TS_STATIC_ASSERT(TS_MeshAttachmentFlagsName == (uint32_t)MeshAttachment::FlagName);
	
	// Tellusim::Mesh::Flags
	TS_STATIC_ASSERT(TS_MeshFlagsNone == (uint32_t)Mesh::FlagNone);
	TS_STATIC_ASSERT(TS_MeshFlagsEmbed == (uint32_t)Mesh::FlagEmbed);
	TS_STATIC_ASSERT(TS_MeshFlags32Bit == (uint32_t)Mesh::Flag32Bit);
	
	// Tellusim::Mesh::Basis
	TS_STATIC_ASSERT(TS_MeshBasisUnknown == (uint32_t)Mesh::BasisUnknown);
	TS_STATIC_ASSERT(TS_MeshBasisXUpRight == (uint32_t)Mesh::BasisXUpRight);
	TS_STATIC_ASSERT(TS_MeshBasisYUpRight == (uint32_t)Mesh::BasisYUpRight);
	TS_STATIC_ASSERT(TS_MeshBasisZUpRight == (uint32_t)Mesh::BasisZUpRight);
	TS_STATIC_ASSERT(TS_MeshBasisXUpLeft == (uint32_t)Mesh::BasisXUpLeft);
	TS_STATIC_ASSERT(TS_MeshBasisYUpLeft == (uint32_t)Mesh::BasisYUpLeft);
	TS_STATIC_ASSERT(TS_MeshBasisZUpLeft == (uint32_t)Mesh::BasisZUpLeft);
	TS_STATIC_ASSERT(TS_MeshBasisZUpMaya == (uint32_t)Mesh::BasisZUpMaya);
	TS_STATIC_ASSERT(TS_MeshBasisNumBases == (uint32_t)Mesh::NumBases);
	
	// Tellusim::Mesh::Axis
	TS_STATIC_ASSERT(TS_MeshAxisUnknown == (uint32_t)Mesh::AxisUnknown);
	TS_STATIC_ASSERT(TS_MeshAxisPX == (uint32_t)Mesh::AxisPX);
	TS_STATIC_ASSERT(TS_MeshAxisPY == (uint32_t)Mesh::AxisPY);
	TS_STATIC_ASSERT(TS_MeshAxisPZ == (uint32_t)Mesh::AxisPZ);
	TS_STATIC_ASSERT(TS_MeshAxisNX == (uint32_t)Mesh::AxisNX);
	TS_STATIC_ASSERT(TS_MeshAxisNY == (uint32_t)Mesh::AxisNY);
	TS_STATIC_ASSERT(TS_MeshAxisNZ == (uint32_t)Mesh::AxisNZ);
	TS_STATIC_ASSERT(TS_MeshAxisNumAxes == (uint32_t)Mesh::NumAxes);
	
	// Tellusim::Json::Type
	TS_STATIC_ASSERT(TS_JsonTypeUnknown == (uint32_t)Json::TypeUnknown);
	TS_STATIC_ASSERT(TS_JsonTypeNull == (uint32_t)Json::TypeNull);
	TS_STATIC_ASSERT(TS_JsonTypeBool == (uint32_t)Json::TypeBool);
	TS_STATIC_ASSERT(TS_JsonTypeNumber == (uint32_t)Json::TypeNumber);
	TS_STATIC_ASSERT(TS_JsonTypeString == (uint32_t)Json::TypeString);
	TS_STATIC_ASSERT(TS_JsonTypeObject == (uint32_t)Json::TypeObject);
	TS_STATIC_ASSERT(TS_JsonTypeArray == (uint32_t)Json::TypeArray);
	TS_STATIC_ASSERT(TS_JsonTypeNumTypes == (uint32_t)Json::NumTypes);
	
	// Tellusim::Buffer::Flags
	TS_STATIC_ASSERT(TS_BufferFlagsNone == (uint32_t)Buffer::FlagNone);
	TS_STATIC_ASSERT(TS_BufferFlagsRead == (uint32_t)Buffer::FlagRead);
	TS_STATIC_ASSERT(TS_BufferFlagsWrite == (uint32_t)Buffer::FlagWrite);
	TS_STATIC_ASSERT(TS_BufferFlagsSource == (uint32_t)Buffer::FlagSource);
	TS_STATIC_ASSERT(TS_BufferFlagsSparse == (uint32_t)Buffer::FlagSparse);
	TS_STATIC_ASSERT(TS_BufferFlagsShared == (uint32_t)Buffer::FlagShared);
	TS_STATIC_ASSERT(TS_BufferFlagsMapped == (uint32_t)Buffer::FlagMapped);
	TS_STATIC_ASSERT(TS_BufferFlagsExtern == (uint32_t)Buffer::FlagExtern);
	TS_STATIC_ASSERT(TS_BufferFlagsInterop == (uint32_t)Buffer::FlagInterop);
	TS_STATIC_ASSERT(TS_BufferFlagsDynamic == (uint32_t)Buffer::FlagDynamic);
	TS_STATIC_ASSERT(TS_BufferFlagsUniform == (uint32_t)Buffer::FlagUniform);
	TS_STATIC_ASSERT(TS_BufferFlagsStorage == (uint32_t)Buffer::FlagStorage);
	TS_STATIC_ASSERT(TS_BufferFlagsAddress == (uint32_t)Buffer::FlagAddress);
	TS_STATIC_ASSERT(TS_BufferFlagsTracing == (uint32_t)Buffer::FlagTracing);
	TS_STATIC_ASSERT(TS_BufferFlagsScratch == (uint32_t)Buffer::FlagScratch);
	TS_STATIC_ASSERT(TS_BufferFlagsBinding == (uint32_t)Buffer::FlagBinding);
	TS_STATIC_ASSERT(TS_BufferFlagsIndirect == (uint32_t)Buffer::FlagIndirect);
	TS_STATIC_ASSERT(TS_BufferFlagsConditional == (uint32_t)Buffer::FlagConditional);
	TS_STATIC_ASSERT(TS_BufferFlagsVertex == (uint32_t)Buffer::FlagVertex);
	TS_STATIC_ASSERT(TS_BufferFlagsIndex == (uint32_t)Buffer::FlagIndex);
	TS_STATIC_ASSERT(TS_BufferFlagsTexel == (uint32_t)Buffer::FlagTexel);
	TS_STATIC_ASSERT(TS_BufferFlagsAccel == (uint32_t)Buffer::FlagAccel);
	TS_STATIC_ASSERT(TS_BufferFlagsDefaultFlags == (uint32_t)Buffer::DefaultFlags);
	TS_STATIC_ASSERT(TS_BufferFlagsNumFlags == (uint32_t)Buffer::NumFlags);
	
	// Tellusim::Query::Type
	TS_STATIC_ASSERT(TS_QueryTypeUnknown == (uint32_t)Query::TypeUnknown);
	TS_STATIC_ASSERT(TS_QueryTypeTime == (uint32_t)Query::TypeTime);
	TS_STATIC_ASSERT(TS_QueryTypeClock == (uint32_t)Query::TypeClock);
	TS_STATIC_ASSERT(TS_QueryTypeSamples == (uint32_t)Query::TypeSamples);
	TS_STATIC_ASSERT(TS_QueryTypeSamples1 == (uint32_t)Query::TypeSamples1);
	TS_STATIC_ASSERT(TS_QueryTypeStatistics == (uint32_t)Query::TypeStatistics);
	TS_STATIC_ASSERT(TS_QueryTypeNumTypes == (uint32_t)Query::NumTypes);
	
	// Tellusim::Fence::Flags
	TS_STATIC_ASSERT(TS_FenceFlagsNone == (uint32_t)Fence::FlagNone);
	TS_STATIC_ASSERT(TS_FenceFlagsSemaphore == (uint32_t)Fence::FlagSemaphore);
	TS_STATIC_ASSERT(TS_FenceFlagsSignaled == (uint32_t)Fence::FlagSignaled);
	TS_STATIC_ASSERT(TS_FenceFlagsShared == (uint32_t)Fence::FlagShared);
	TS_STATIC_ASSERT(TS_FenceFlagsExtern == (uint32_t)Fence::FlagExtern);
	TS_STATIC_ASSERT(TS_FenceFlagsDefaultFlags == (uint32_t)Fence::DefaultFlags);
	TS_STATIC_ASSERT(TS_FenceFlagsNumFlags == (uint32_t)Fence::NumFlags);
	
	// Tellusim::Shader::Type
	TS_STATIC_ASSERT(TS_ShaderTypeUnknown == (uint32_t)Shader::TypeUnknown);
	TS_STATIC_ASSERT(TS_ShaderTypeVertex == (uint32_t)Shader::TypeVertex);
	TS_STATIC_ASSERT(TS_ShaderTypeControl == (uint32_t)Shader::TypeControl);
	TS_STATIC_ASSERT(TS_ShaderTypeEvaluate == (uint32_t)Shader::TypeEvaluate);
	TS_STATIC_ASSERT(TS_ShaderTypeGeometry == (uint32_t)Shader::TypeGeometry);
	TS_STATIC_ASSERT(TS_ShaderTypeFragment == (uint32_t)Shader::TypeFragment);
	TS_STATIC_ASSERT(TS_ShaderTypeCompute == (uint32_t)Shader::TypeCompute);
	TS_STATIC_ASSERT(TS_ShaderTypeTask == (uint32_t)Shader::TypeTask);
	TS_STATIC_ASSERT(TS_ShaderTypeMesh == (uint32_t)Shader::TypeMesh);
	TS_STATIC_ASSERT(TS_ShaderTypeRayGen == (uint32_t)Shader::TypeRayGen);
	TS_STATIC_ASSERT(TS_ShaderTypeRayMiss == (uint32_t)Shader::TypeRayMiss);
	TS_STATIC_ASSERT(TS_ShaderTypeClosest == (uint32_t)Shader::TypeClosest);
	TS_STATIC_ASSERT(TS_ShaderTypeFirstHit == (uint32_t)Shader::TypeFirstHit);
	TS_STATIC_ASSERT(TS_ShaderTypeIntersection == (uint32_t)Shader::TypeIntersection);
	TS_STATIC_ASSERT(TS_ShaderTypeCallable == (uint32_t)Shader::TypeCallable);
	TS_STATIC_ASSERT(TS_ShaderTypeNumTypes == (uint32_t)Shader::NumTypes);
	
	// Tellusim::Shader::Mask
	TS_STATIC_ASSERT(TS_ShaderMaskNone == (uint32_t)Shader::MaskNone);
	TS_STATIC_ASSERT(TS_ShaderMaskVertex == (uint32_t)Shader::MaskVertex);
	TS_STATIC_ASSERT(TS_ShaderMaskControl == (uint32_t)Shader::MaskControl);
	TS_STATIC_ASSERT(TS_ShaderMaskEvaluate == (uint32_t)Shader::MaskEvaluate);
	TS_STATIC_ASSERT(TS_ShaderMaskGeometry == (uint32_t)Shader::MaskGeometry);
	TS_STATIC_ASSERT(TS_ShaderMaskFragment == (uint32_t)Shader::MaskFragment);
	TS_STATIC_ASSERT(TS_ShaderMaskCompute == (uint32_t)Shader::MaskCompute);
	TS_STATIC_ASSERT(TS_ShaderMaskTask == (uint32_t)Shader::MaskTask);
	TS_STATIC_ASSERT(TS_ShaderMaskMesh == (uint32_t)Shader::MaskMesh);
	TS_STATIC_ASSERT(TS_ShaderMaskRayGen == (uint32_t)Shader::MaskRayGen);
	TS_STATIC_ASSERT(TS_ShaderMaskRayMiss == (uint32_t)Shader::MaskRayMiss);
	TS_STATIC_ASSERT(TS_ShaderMaskClosest == (uint32_t)Shader::MaskClosest);
	TS_STATIC_ASSERT(TS_ShaderMaskFirstHit == (uint32_t)Shader::MaskFirstHit);
	TS_STATIC_ASSERT(TS_ShaderMaskIntersection == (uint32_t)Shader::MaskIntersection);
	TS_STATIC_ASSERT(TS_ShaderMaskCallable == (uint32_t)Shader::MaskCallable);
	TS_STATIC_ASSERT(TS_ShaderMaskVertexFragment == (uint32_t)Shader::MaskVertexFragment);
	TS_STATIC_ASSERT(TS_ShaderMaskGraphics == (uint32_t)Shader::MaskGraphics);
	TS_STATIC_ASSERT(TS_ShaderMaskTracing == (uint32_t)Shader::MaskTracing);
	TS_STATIC_ASSERT(TS_ShaderMaskAll == (uint32_t)Shader::MaskAll);
	
	// Tellusim::ShaderCompiler::Flags
	TS_STATIC_ASSERT(TS_ShaderCompilerFlagsNone == (uint32_t)ShaderCompiler::FlagNone);
	TS_STATIC_ASSERT(TS_ShaderCompilerFlagsMSLIndirect == (uint32_t)ShaderCompiler::FlagMSLIndirect);
	
	// Tellusim::Sampler::Filter
	TS_STATIC_ASSERT(TS_SamplerFilterPoint == (uint32_t)Sampler::FilterPoint);
	TS_STATIC_ASSERT(TS_SamplerFilterLinear == (uint32_t)Sampler::FilterLinear);
	TS_STATIC_ASSERT(TS_SamplerFilterBipoint == (uint32_t)Sampler::FilterBipoint);
	TS_STATIC_ASSERT(TS_SamplerFilterBilinear == (uint32_t)Sampler::FilterBilinear);
	TS_STATIC_ASSERT(TS_SamplerFilterTrilinear == (uint32_t)Sampler::FilterTrilinear);
	TS_STATIC_ASSERT(TS_SamplerFilterNumFilters == (uint32_t)Sampler::NumFilters);
	
	// Tellusim::Sampler::
	TS_STATIC_ASSERT(TS_SamplerMinAnisotropy == (uint32_t)Sampler::MinAnisotropy);
	TS_STATIC_ASSERT(TS_SamplerMaxAnisotropy == (uint32_t)Sampler::MaxAnisotropy);
	
	// Tellusim::Sampler::WrapMode
	TS_STATIC_ASSERT(TS_SamplerWrapModeClamp == (uint32_t)Sampler::WrapModeClamp);
	TS_STATIC_ASSERT(TS_SamplerWrapModeRepeat == (uint32_t)Sampler::WrapModeRepeat);
	TS_STATIC_ASSERT(TS_SamplerWrapModeMirror == (uint32_t)Sampler::WrapModeMirror);
	TS_STATIC_ASSERT(TS_SamplerWrapModeBorder == (uint32_t)Sampler::WrapModeBorder);
	TS_STATIC_ASSERT(TS_SamplerWrapModeNumWrapModes == (uint32_t)Sampler::NumWrapModes);
	
	// Tellusim::Sampler::CompareFunc
	TS_STATIC_ASSERT(TS_SamplerCompareFuncNone == (uint32_t)Sampler::CompareFuncNone);
	TS_STATIC_ASSERT(TS_SamplerCompareFuncEqual == (uint32_t)Sampler::CompareFuncEqual);
	TS_STATIC_ASSERT(TS_SamplerCompareFuncLess == (uint32_t)Sampler::CompareFuncLess);
	TS_STATIC_ASSERT(TS_SamplerCompareFuncGreater == (uint32_t)Sampler::CompareFuncGreater);
	TS_STATIC_ASSERT(TS_SamplerCompareFuncNotEqual == (uint32_t)Sampler::CompareFuncNotEqual);
	TS_STATIC_ASSERT(TS_SamplerCompareFuncLessEqual == (uint32_t)Sampler::CompareFuncLessEqual);
	TS_STATIC_ASSERT(TS_SamplerCompareFuncGreaterEqual == (uint32_t)Sampler::CompareFuncGreaterEqual);
	TS_STATIC_ASSERT(TS_SamplerCompareFuncNumCompareFunctions == (uint32_t)Sampler::NumCompareFunctions);
	
	// Tellusim::Sampler::ReductionMode
	TS_STATIC_ASSERT(TS_SamplerReductionModeAverage == (uint32_t)Sampler::ReductionModeAverage);
	TS_STATIC_ASSERT(TS_SamplerReductionModeMin == (uint32_t)Sampler::ReductionModeMin);
	TS_STATIC_ASSERT(TS_SamplerReductionModeMax == (uint32_t)Sampler::ReductionModeMax);
	TS_STATIC_ASSERT(TS_SamplerReductionModeNumReductionModes == (uint32_t)Sampler::NumReductionModes);
	
	// Tellusim::Texture::Type
	TS_STATIC_ASSERT(TS_TextureTypeUnknown == (uint32_t)Texture::TypeUnknown);
	TS_STATIC_ASSERT(TS_TextureType2D == (uint32_t)Texture::Type2D);
	TS_STATIC_ASSERT(TS_TextureType3D == (uint32_t)Texture::Type3D);
	TS_STATIC_ASSERT(TS_TextureTypeCube == (uint32_t)Texture::TypeCube);
	TS_STATIC_ASSERT(TS_TextureTypeNumTypes == (uint32_t)Texture::NumTypes);
	
	// Tellusim::Texture::Flags
	TS_STATIC_ASSERT(TS_TextureFlagsNone == (uint32_t)Texture::FlagNone);
	TS_STATIC_ASSERT(TS_TextureFlagsRead == (uint32_t)Texture::FlagRead);
	TS_STATIC_ASSERT(TS_TextureFlagsWrite == (uint32_t)Texture::FlagWrite);
	TS_STATIC_ASSERT(TS_TextureFlagsTarget == (uint32_t)Texture::FlagTarget);
	TS_STATIC_ASSERT(TS_TextureFlagsBuffer == (uint32_t)Texture::FlagBuffer);
	TS_STATIC_ASSERT(TS_TextureFlagsSource == (uint32_t)Texture::FlagSource);
	TS_STATIC_ASSERT(TS_TextureFlagsSparse == (uint32_t)Texture::FlagSparse);
	TS_STATIC_ASSERT(TS_TextureFlagsShared == (uint32_t)Texture::FlagShared);
	TS_STATIC_ASSERT(TS_TextureFlagsExtern == (uint32_t)Texture::FlagExtern);
	TS_STATIC_ASSERT(TS_TextureFlagsInterop == (uint32_t)Texture::FlagInterop);
	TS_STATIC_ASSERT(TS_TextureFlagsSurface == (uint32_t)Texture::FlagSurface);
	TS_STATIC_ASSERT(TS_TextureFlagsMutable == (uint32_t)Texture::FlagMutable);
	TS_STATIC_ASSERT(TS_TextureFlagsMipmaps == (uint32_t)Texture::FlagMipmaps);
	TS_STATIC_ASSERT(TS_TextureFlagsGenerate == (uint32_t)Texture::FlagGenerate);
	TS_STATIC_ASSERT(TS_TextureFlagsFormatNorm == (uint32_t)Texture::FlagFormatNorm);
	TS_STATIC_ASSERT(TS_TextureFlagsFormatSRGB == (uint32_t)Texture::FlagFormatSRGB);
	TS_STATIC_ASSERT(TS_TextureFlagsFormatSigned == (uint32_t)Texture::FlagFormatSigned);
	TS_STATIC_ASSERT(TS_TextureFlagsMultisample2 == (uint32_t)Texture::FlagMultisample2);
	TS_STATIC_ASSERT(TS_TextureFlagsMultisample4 == (uint32_t)Texture::FlagMultisample4);
	TS_STATIC_ASSERT(TS_TextureFlagsMultisample8 == (uint32_t)Texture::FlagMultisample8);
	TS_STATIC_ASSERT(TS_TextureFlagsClearOne == (uint32_t)Texture::FlagClearOne);
	TS_STATIC_ASSERT(TS_TextureFlagsClearZero == (uint32_t)Texture::FlagClearZero);
	TS_STATIC_ASSERT(TS_TextureFlagsClearNormal == (uint32_t)Texture::FlagClearNormal);
	TS_STATIC_ASSERT(TS_TextureFlagsMultisample == (uint32_t)Texture::FlagMultisample);
	TS_STATIC_ASSERT(TS_TextureFlagsDefaultFlags == (uint32_t)Texture::DefaultFlags);
	TS_STATIC_ASSERT(TS_TextureFlagsNumFlags == (uint32_t)Texture::NumFlags);
	
	// Tellusim::Tracing::Type
	TS_STATIC_ASSERT(TS_TracingTypeUnknown == (uint32_t)Tracing::TypeUnknown);
	TS_STATIC_ASSERT(TS_TracingTypeInstance == (uint32_t)Tracing::TypeInstance);
	TS_STATIC_ASSERT(TS_TracingTypeTriangle == (uint32_t)Tracing::TypeTriangle);
	TS_STATIC_ASSERT(TS_TracingTypeBound == (uint32_t)Tracing::TypeBound);
	TS_STATIC_ASSERT(TS_TracingTypeNumTypes == (uint32_t)Tracing::NumTypes);
	
	// Tellusim::Tracing::Flags
	TS_STATIC_ASSERT(TS_TracingFlagsNone == (uint32_t)Tracing::FlagNone);
	TS_STATIC_ASSERT(TS_TracingFlagsInfo == (uint32_t)Tracing::FlagInfo);
	TS_STATIC_ASSERT(TS_TracingFlagsUpdate == (uint32_t)Tracing::FlagUpdate);
	TS_STATIC_ASSERT(TS_TracingFlagsCompact == (uint32_t)Tracing::FlagCompact);
	TS_STATIC_ASSERT(TS_TracingFlagsTransparent == (uint32_t)Tracing::FlagTransparent);
	TS_STATIC_ASSERT(TS_TracingFlagsFastBuild == (uint32_t)Tracing::FlagFastBuild);
	TS_STATIC_ASSERT(TS_TracingFlagsFastTrace == (uint32_t)Tracing::FlagFastTrace);
	TS_STATIC_ASSERT(TS_TracingFlagsDefaultFlags == (uint32_t)Tracing::DefaultFlags);
	TS_STATIC_ASSERT(TS_TracingFlagsNumFlags == (uint32_t)Tracing::NumFlags);
	
	// Tellusim::Tracing::
	TS_STATIC_ASSERT(TS_TracingInstanceSize == (uint32_t)Tracing::InstanceSize);
	
	// Tellusim::Target::Operation
	TS_STATIC_ASSERT(TS_TargetOperationBeginLoad == (uint32_t)Target::BeginLoad);
	TS_STATIC_ASSERT(TS_TargetOperationBeginClear == (uint32_t)Target::BeginClear);
	TS_STATIC_ASSERT(TS_TargetOperationBeginDiscard == (uint32_t)Target::BeginDiscard);
	TS_STATIC_ASSERT(TS_TargetOperationBeginMask == (uint32_t)Target::BeginMask);
	TS_STATIC_ASSERT(TS_TargetOperationEndStore == (uint32_t)Target::EndStore);
	TS_STATIC_ASSERT(TS_TargetOperationEndResolve == (uint32_t)Target::EndResolve);
	TS_STATIC_ASSERT(TS_TargetOperationEndDiscard == (uint32_t)Target::EndDiscard);
	TS_STATIC_ASSERT(TS_TargetOperationEndMask == (uint32_t)Target::EndMask);
	TS_STATIC_ASSERT(TS_TargetOperationOpNone == (uint32_t)Target::OpNone);
	TS_STATIC_ASSERT(TS_TargetOperationOpLoad == (uint32_t)Target::OpLoad);
	TS_STATIC_ASSERT(TS_TargetOperationOpLoadStore == (uint32_t)Target::OpLoadStore);
	TS_STATIC_ASSERT(TS_TargetOperationOpClearStore == (uint32_t)Target::OpClearStore);
	TS_STATIC_ASSERT(TS_TargetOperationOpClearDiscard == (uint32_t)Target::OpClearDiscard);
	TS_STATIC_ASSERT(TS_TargetOperationOpDefault == (uint32_t)Target::OpDefault);
	
	// Tellusim::Pipeline::Primitive
	TS_STATIC_ASSERT(TS_PipelinePrimitivePoint == (uint32_t)Pipeline::PrimitivePoint);
	TS_STATIC_ASSERT(TS_PipelinePrimitivePointPatch == (uint32_t)Pipeline::PrimitivePointPatch);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveLine == (uint32_t)Pipeline::PrimitiveLine);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveLineAdj == (uint32_t)Pipeline::PrimitiveLineAdj);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveLineStrip == (uint32_t)Pipeline::PrimitiveLineStrip);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveLinePatch == (uint32_t)Pipeline::PrimitiveLinePatch);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveTriangle == (uint32_t)Pipeline::PrimitiveTriangle);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveTriangleAdj == (uint32_t)Pipeline::PrimitiveTriangleAdj);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveTriangleStrip == (uint32_t)Pipeline::PrimitiveTriangleStrip);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveTrianglePatch == (uint32_t)Pipeline::PrimitiveTrianglePatch);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveQuadrilateralPatch == (uint32_t)Pipeline::PrimitiveQuadrilateralPatch);
	TS_STATIC_ASSERT(TS_PipelinePrimitiveNumPrimitiveTypes == (uint32_t)Pipeline::NumPrimitiveTypes);
	
	// Tellusim::Pipeline::Attribute
	TS_STATIC_ASSERT(TS_PipelineAttributePosition == (uint32_t)Pipeline::AttributePosition);
	TS_STATIC_ASSERT(TS_PipelineAttributeBasis == (uint32_t)Pipeline::AttributeBasis);
	TS_STATIC_ASSERT(TS_PipelineAttributeNormal == (uint32_t)Pipeline::AttributeNormal);
	TS_STATIC_ASSERT(TS_PipelineAttributeTangent == (uint32_t)Pipeline::AttributeTangent);
	TS_STATIC_ASSERT(TS_PipelineAttributeBinormal == (uint32_t)Pipeline::AttributeBinormal);
	TS_STATIC_ASSERT(TS_PipelineAttributeTexCoord == (uint32_t)Pipeline::AttributeTexCoord);
	TS_STATIC_ASSERT(TS_PipelineAttributeWeights == (uint32_t)Pipeline::AttributeWeights);
	TS_STATIC_ASSERT(TS_PipelineAttributeJoints == (uint32_t)Pipeline::AttributeJoints);
	TS_STATIC_ASSERT(TS_PipelineAttributeColor == (uint32_t)Pipeline::AttributeColor);
	TS_STATIC_ASSERT(TS_PipelineAttributeNumAttributeTypes == (uint32_t)Pipeline::NumAttributeTypes);
	
	// Tellusim::Pipeline::FillMode
	TS_STATIC_ASSERT(TS_PipelineFillModeLine == (uint32_t)Pipeline::FillModeLine);
	TS_STATIC_ASSERT(TS_PipelineFillModeSolid == (uint32_t)Pipeline::FillModeSolid);
	TS_STATIC_ASSERT(TS_PipelineFillModeNumFillModes == (uint32_t)Pipeline::NumFillModes);
	
	// Tellusim::Pipeline::CullMode
	TS_STATIC_ASSERT(TS_PipelineCullModeNone == (uint32_t)Pipeline::CullModeNone);
	TS_STATIC_ASSERT(TS_PipelineCullModeBack == (uint32_t)Pipeline::CullModeBack);
	TS_STATIC_ASSERT(TS_PipelineCullModeFront == (uint32_t)Pipeline::CullModeFront);
	TS_STATIC_ASSERT(TS_PipelineCullModeNumCullModes == (uint32_t)Pipeline::NumCullModes);
	
	// Tellusim::Pipeline::FrontMode
	TS_STATIC_ASSERT(TS_PipelineFrontModeCCW == (uint32_t)Pipeline::FrontModeCCW);
	TS_STATIC_ASSERT(TS_PipelineFrontModeCW == (uint32_t)Pipeline::FrontModeCW);
	TS_STATIC_ASSERT(TS_PipelineFrontModeNumFrontModes == (uint32_t)Pipeline::NumFrontModes);
	
	// Tellusim::Pipeline::BlendOp
	TS_STATIC_ASSERT(TS_PipelineBlendOpAdd == (uint32_t)Pipeline::BlendOpAdd);
	TS_STATIC_ASSERT(TS_PipelineBlendOpSub == (uint32_t)Pipeline::BlendOpSub);
	TS_STATIC_ASSERT(TS_PipelineBlendOpMin == (uint32_t)Pipeline::BlendOpMin);
	TS_STATIC_ASSERT(TS_PipelineBlendOpMax == (uint32_t)Pipeline::BlendOpMax);
	TS_STATIC_ASSERT(TS_PipelineBlendOpNumBlendOperations == (uint32_t)Pipeline::NumBlendOperations);
	
	// Tellusim::Pipeline::BlendFunc
	TS_STATIC_ASSERT(TS_PipelineBlendFuncNone == (uint32_t)Pipeline::BlendFuncNone);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncZero == (uint32_t)Pipeline::BlendFuncZero);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncOne == (uint32_t)Pipeline::BlendFuncOne);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncSrcColor == (uint32_t)Pipeline::BlendFuncSrcColor);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncSrcAlpha == (uint32_t)Pipeline::BlendFuncSrcAlpha);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncSrc1Color == (uint32_t)Pipeline::BlendFuncSrc1Color);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncSrc1Alpha == (uint32_t)Pipeline::BlendFuncSrc1Alpha);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncDestColor == (uint32_t)Pipeline::BlendFuncDestColor);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncDestAlpha == (uint32_t)Pipeline::BlendFuncDestAlpha);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncFactorColor == (uint32_t)Pipeline::BlendFuncFactorColor);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncFactorAlpha == (uint32_t)Pipeline::BlendFuncFactorAlpha);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncInvSrcColor == (uint32_t)Pipeline::BlendFuncInvSrcColor);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncInvSrcAlpha == (uint32_t)Pipeline::BlendFuncInvSrcAlpha);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncInvSrc1Color == (uint32_t)Pipeline::BlendFuncInvSrc1Color);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncInvSrc1Alpha == (uint32_t)Pipeline::BlendFuncInvSrc1Alpha);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncInvDestColor == (uint32_t)Pipeline::BlendFuncInvDestColor);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncInvDestAlpha == (uint32_t)Pipeline::BlendFuncInvDestAlpha);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncInvFactorColor == (uint32_t)Pipeline::BlendFuncInvFactorColor);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncInvFactorAlpha == (uint32_t)Pipeline::BlendFuncInvFactorAlpha);
	TS_STATIC_ASSERT(TS_PipelineBlendFuncNumBlendFunctions == (uint32_t)Pipeline::NumBlendFunctions);
	
	// Tellusim::Pipeline::ColorMask
	TS_STATIC_ASSERT(TS_PipelineColorMaskNone == (uint32_t)Pipeline::ColorMaskNone);
	TS_STATIC_ASSERT(TS_PipelineColorMaskR == (uint32_t)Pipeline::ColorMaskR);
	TS_STATIC_ASSERT(TS_PipelineColorMaskG == (uint32_t)Pipeline::ColorMaskG);
	TS_STATIC_ASSERT(TS_PipelineColorMaskB == (uint32_t)Pipeline::ColorMaskB);
	TS_STATIC_ASSERT(TS_PipelineColorMaskA == (uint32_t)Pipeline::ColorMaskA);
	TS_STATIC_ASSERT(TS_PipelineColorMaskUnknown == (uint32_t)Pipeline::ColorMaskUnknown);
	TS_STATIC_ASSERT(TS_PipelineColorMaskRGB == (uint32_t)Pipeline::ColorMaskRGB);
	TS_STATIC_ASSERT(TS_PipelineColorMaskAll == (uint32_t)Pipeline::ColorMaskAll);
	
	// Tellusim::Pipeline::DepthMask
	TS_STATIC_ASSERT(TS_PipelineDepthMaskNone == (uint32_t)Pipeline::DepthMaskNone);
	TS_STATIC_ASSERT(TS_PipelineDepthMaskRead == (uint32_t)Pipeline::DepthMaskRead);
	TS_STATIC_ASSERT(TS_PipelineDepthMaskWrite == (uint32_t)Pipeline::DepthMaskWrite);
	TS_STATIC_ASSERT(TS_PipelineDepthMaskNumDepthMasks == (uint32_t)Pipeline::NumDepthMasks);
	
	// Tellusim::Pipeline::DepthFunc
	TS_STATIC_ASSERT(TS_PipelineDepthFuncNone == (uint32_t)Pipeline::DepthFuncNone);
	TS_STATIC_ASSERT(TS_PipelineDepthFuncNever == (uint32_t)Pipeline::DepthFuncNever);
	TS_STATIC_ASSERT(TS_PipelineDepthFuncAlways == (uint32_t)Pipeline::DepthFuncAlways);
	TS_STATIC_ASSERT(TS_PipelineDepthFuncEqual == (uint32_t)Pipeline::DepthFuncEqual);
	TS_STATIC_ASSERT(TS_PipelineDepthFuncLess == (uint32_t)Pipeline::DepthFuncLess);
	TS_STATIC_ASSERT(TS_PipelineDepthFuncGreater == (uint32_t)Pipeline::DepthFuncGreater);
	TS_STATIC_ASSERT(TS_PipelineDepthFuncNotEqual == (uint32_t)Pipeline::DepthFuncNotEqual);
	TS_STATIC_ASSERT(TS_PipelineDepthFuncLessEqual == (uint32_t)Pipeline::DepthFuncLessEqual);
	TS_STATIC_ASSERT(TS_PipelineDepthFuncGreaterEqual == (uint32_t)Pipeline::DepthFuncGreaterEqual);
	TS_STATIC_ASSERT(TS_PipelineDepthFuncNumDepthFunctions == (uint32_t)Pipeline::NumDepthFunctions);
	
	// Tellusim::Pipeline::StencilOp
	TS_STATIC_ASSERT(TS_PipelineStencilOpKeep == (uint32_t)Pipeline::StencilOpKeep);
	TS_STATIC_ASSERT(TS_PipelineStencilOpInvert == (uint32_t)Pipeline::StencilOpInvert);
	TS_STATIC_ASSERT(TS_PipelineStencilOpReplace == (uint32_t)Pipeline::StencilOpReplace);
	TS_STATIC_ASSERT(TS_PipelineStencilOpIncrWrap == (uint32_t)Pipeline::StencilOpIncrWrap);
	TS_STATIC_ASSERT(TS_PipelineStencilOpDecrWrap == (uint32_t)Pipeline::StencilOpDecrWrap);
	TS_STATIC_ASSERT(TS_PipelineStencilOpIncrSat == (uint32_t)Pipeline::StencilOpIncrSat);
	TS_STATIC_ASSERT(TS_PipelineStencilOpDecrSat == (uint32_t)Pipeline::StencilOpDecrSat);
	TS_STATIC_ASSERT(TS_PipelineStencilOpNumStencilOperations == (uint32_t)Pipeline::NumStencilOperations);
	
	// Tellusim::Pipeline::StencilFunc
	TS_STATIC_ASSERT(TS_PipelineStencilFuncNone == (uint32_t)Pipeline::StencilFuncNone);
	TS_STATIC_ASSERT(TS_PipelineStencilFuncNever == (uint32_t)Pipeline::StencilFuncNever);
	TS_STATIC_ASSERT(TS_PipelineStencilFuncAlways == (uint32_t)Pipeline::StencilFuncAlways);
	TS_STATIC_ASSERT(TS_PipelineStencilFuncEqual == (uint32_t)Pipeline::StencilFuncEqual);
	TS_STATIC_ASSERT(TS_PipelineStencilFuncLess == (uint32_t)Pipeline::StencilFuncLess);
	TS_STATIC_ASSERT(TS_PipelineStencilFuncGreater == (uint32_t)Pipeline::StencilFuncGreater);
	TS_STATIC_ASSERT(TS_PipelineStencilFuncNotEqual == (uint32_t)Pipeline::StencilFuncNotEqual);
	TS_STATIC_ASSERT(TS_PipelineStencilFuncLessEqual == (uint32_t)Pipeline::StencilFuncLessEqual);
	TS_STATIC_ASSERT(TS_PipelineStencilFuncGreaterEqual == (uint32_t)Pipeline::StencilFuncGreaterEqual);
	TS_STATIC_ASSERT(TS_PipelineStencilFuncNumStencilFunctions == (uint32_t)Pipeline::NumStencilFunctions);
	
	// Tellusim::Window::Flags
	TS_STATIC_ASSERT(TS_WindowFlagsNone == (uint32_t)Window::FlagNone);
	TS_STATIC_ASSERT(TS_WindowFlagsTitle == (uint32_t)Window::FlagTitle);
	TS_STATIC_ASSERT(TS_WindowFlagsClose == (uint32_t)Window::FlagClose);
	TS_STATIC_ASSERT(TS_WindowFlagsFrame == (uint32_t)Window::FlagFrame);
	TS_STATIC_ASSERT(TS_WindowFlagsResize == (uint32_t)Window::FlagResize);
	TS_STATIC_ASSERT(TS_WindowFlagsMinimize == (uint32_t)Window::FlagMinimize);
	TS_STATIC_ASSERT(TS_WindowFlagsMaximize == (uint32_t)Window::FlagMaximize);
	TS_STATIC_ASSERT(TS_WindowFlagsTransient == (uint32_t)Window::FlagTransient);
	TS_STATIC_ASSERT(TS_WindowFlagsFullscreen == (uint32_t)Window::FlagFullscreen);
	TS_STATIC_ASSERT(TS_WindowFlagsTransparent == (uint32_t)Window::FlagTransparent);
	TS_STATIC_ASSERT(TS_WindowFlagsFileDropped == (uint32_t)Window::FlagFileDropped);
	TS_STATIC_ASSERT(TS_WindowFlagsMultisample2 == (uint32_t)Window::FlagMultisample2);
	TS_STATIC_ASSERT(TS_WindowFlagsMultisample4 == (uint32_t)Window::FlagMultisample4);
	TS_STATIC_ASSERT(TS_WindowFlagsMultisample8 == (uint32_t)Window::FlagMultisample8);
	TS_STATIC_ASSERT(TS_WindowFlagsVerticalSync == (uint32_t)Window::FlagVerticalSync);
	TS_STATIC_ASSERT(TS_WindowFlagsRefreshSync == (uint32_t)Window::FlagRefreshSync);
	TS_STATIC_ASSERT(TS_WindowFlagsColorRGBAu8ns == (uint32_t)Window::FlagColorRGBAu8ns);
	TS_STATIC_ASSERT(TS_WindowFlagsColorRGBu10Au2n == (uint32_t)Window::FlagColorRGBu10Au2n);
	TS_STATIC_ASSERT(TS_WindowFlagsColorRGBAf16 == (uint32_t)Window::FlagColorRGBAf16);
	TS_STATIC_ASSERT(TS_WindowFlagsMultisample == (uint32_t)Window::FlagMultisample);
	TS_STATIC_ASSERT(TS_WindowFlagsDefaultFlags == (uint32_t)Window::DefaultFlags);
	TS_STATIC_ASSERT(TS_WindowFlagsNumFlags == (uint32_t)Window::NumFlags);
	
	// Tellusim::Window::Cursor
	TS_STATIC_ASSERT(TS_WindowCursorArrow == (uint32_t)Window::CursorArrow);
	TS_STATIC_ASSERT(TS_WindowCursorInvalid == (uint32_t)Window::CursorInvalid);
	TS_STATIC_ASSERT(TS_WindowCursorLeft == (uint32_t)Window::CursorLeft);
	TS_STATIC_ASSERT(TS_WindowCursorRight == (uint32_t)Window::CursorRight);
	TS_STATIC_ASSERT(TS_WindowCursorBottom == (uint32_t)Window::CursorBottom);
	TS_STATIC_ASSERT(TS_WindowCursorTop == (uint32_t)Window::CursorTop);
	TS_STATIC_ASSERT(TS_WindowCursorWidth == (uint32_t)Window::CursorWidth);
	TS_STATIC_ASSERT(TS_WindowCursorHeight == (uint32_t)Window::CursorHeight);
	TS_STATIC_ASSERT(TS_WindowCursorMajor == (uint32_t)Window::CursorMajor);
	TS_STATIC_ASSERT(TS_WindowCursorMinor == (uint32_t)Window::CursorMinor);
	TS_STATIC_ASSERT(TS_WindowCursorAll == (uint32_t)Window::CursorAll);
	TS_STATIC_ASSERT(TS_WindowCursorNumCursors == (uint32_t)Window::NumCursors);
	
	// Tellusim::Window::Button
	TS_STATIC_ASSERT(TS_WindowButtonNone == (uint32_t)Window::ButtonNone);
	TS_STATIC_ASSERT(TS_WindowButtonLeft == (uint32_t)Window::ButtonLeft);
	TS_STATIC_ASSERT(TS_WindowButtonLeft2 == (uint32_t)Window::ButtonLeft2);
	TS_STATIC_ASSERT(TS_WindowButtonRight == (uint32_t)Window::ButtonRight);
	TS_STATIC_ASSERT(TS_WindowButtonRight2 == (uint32_t)Window::ButtonRight2);
	TS_STATIC_ASSERT(TS_WindowButtonMiddle == (uint32_t)Window::ButtonMiddle);
	TS_STATIC_ASSERT(TS_WindowButtonMiddle2 == (uint32_t)Window::ButtonMiddle2);
	TS_STATIC_ASSERT(TS_WindowButtonAux == (uint32_t)Window::ButtonAux);
	TS_STATIC_ASSERT(TS_WindowButtonAux2 == (uint32_t)Window::ButtonAux2);
	TS_STATIC_ASSERT(TS_WindowButtonNumButtons == (uint32_t)Window::NumButtons);
	
	// Tellusim::Window::Axis
	TS_STATIC_ASSERT(TS_WindowAxisX == (uint32_t)Window::AxisX);
	TS_STATIC_ASSERT(TS_WindowAxisY == (uint32_t)Window::AxisY);
	TS_STATIC_ASSERT(TS_WindowAxisZ == (uint32_t)Window::AxisZ);
	TS_STATIC_ASSERT(TS_WindowAxisW == (uint32_t)Window::AxisW);
	TS_STATIC_ASSERT(TS_WindowAxisNumAxes == (uint32_t)Window::NumAxes);
	
	// Tellusim::Window::
	TS_STATIC_ASSERT(TS_WindowNumTouches == (uint32_t)Window::NumTouches);
	
	// Tellusim::Window::Key
	TS_STATIC_ASSERT(TS_WindowKeyNone == (uint32_t)Window::KeyNone);
	TS_STATIC_ASSERT(TS_WindowKeyEsc == (uint32_t)Window::KeyEsc);
	TS_STATIC_ASSERT(TS_WindowKeyTab == (uint32_t)Window::KeyTab);
	TS_STATIC_ASSERT(TS_WindowKeyBackspace == (uint32_t)Window::KeyBackspace);
	TS_STATIC_ASSERT(TS_WindowKeyDelete == (uint32_t)Window::KeyDelete);
	TS_STATIC_ASSERT(TS_WindowKeyInsert == (uint32_t)Window::KeyInsert);
	TS_STATIC_ASSERT(TS_WindowKeyReturn == (uint32_t)Window::KeyReturn);
	TS_STATIC_ASSERT(TS_WindowKeyPause == (uint32_t)Window::KeyPause);
	TS_STATIC_ASSERT(TS_WindowKeyPrior == (uint32_t)Window::KeyPrior);
	TS_STATIC_ASSERT(TS_WindowKeyNext == (uint32_t)Window::KeyNext);
	TS_STATIC_ASSERT(TS_WindowKeyEnd == (uint32_t)Window::KeyEnd);
	TS_STATIC_ASSERT(TS_WindowKeyHome == (uint32_t)Window::KeyHome);
	TS_STATIC_ASSERT(TS_WindowKeyUp == (uint32_t)Window::KeyUp);
	TS_STATIC_ASSERT(TS_WindowKeyDown == (uint32_t)Window::KeyDown);
	TS_STATIC_ASSERT(TS_WindowKeyLeft == (uint32_t)Window::KeyLeft);
	TS_STATIC_ASSERT(TS_WindowKeyRight == (uint32_t)Window::KeyRight);
	TS_STATIC_ASSERT(TS_WindowKeyNum == (uint32_t)Window::KeyNum);
	TS_STATIC_ASSERT(TS_WindowKeyCaps == (uint32_t)Window::KeyCaps);
	TS_STATIC_ASSERT(TS_WindowKeyScroll == (uint32_t)Window::KeyScroll);
	TS_STATIC_ASSERT(TS_WindowKeyShift == (uint32_t)Window::KeyShift);
	TS_STATIC_ASSERT(TS_WindowKeyCtrl == (uint32_t)Window::KeyCtrl);
	TS_STATIC_ASSERT(TS_WindowKeyAlt == (uint32_t)Window::KeyAlt);
	TS_STATIC_ASSERT(TS_WindowKeyWin == (uint32_t)Window::KeyWin);
	TS_STATIC_ASSERT(TS_WindowKeyCmd == (uint32_t)Window::KeyCmd);
	TS_STATIC_ASSERT(TS_WindowKeyMenu == (uint32_t)Window::KeyMenu);
	TS_STATIC_ASSERT(TS_WindowKeyF1 == (uint32_t)Window::KeyF1);
	TS_STATIC_ASSERT(TS_WindowKeyF2 == (uint32_t)Window::KeyF2);
	TS_STATIC_ASSERT(TS_WindowKeyF3 == (uint32_t)Window::KeyF3);
	TS_STATIC_ASSERT(TS_WindowKeyF4 == (uint32_t)Window::KeyF4);
	TS_STATIC_ASSERT(TS_WindowKeyF5 == (uint32_t)Window::KeyF5);
	TS_STATIC_ASSERT(TS_WindowKeyF6 == (uint32_t)Window::KeyF6);
	TS_STATIC_ASSERT(TS_WindowKeyF7 == (uint32_t)Window::KeyF7);
	TS_STATIC_ASSERT(TS_WindowKeyF8 == (uint32_t)Window::KeyF8);
	TS_STATIC_ASSERT(TS_WindowKeyF9 == (uint32_t)Window::KeyF9);
	TS_STATIC_ASSERT(TS_WindowKeyF10 == (uint32_t)Window::KeyF10);
	TS_STATIC_ASSERT(TS_WindowKeyF11 == (uint32_t)Window::KeyF11);
	TS_STATIC_ASSERT(TS_WindowKeyF12 == (uint32_t)Window::KeyF12);
	TS_STATIC_ASSERT(TS_WindowKeyNumKeys == (uint32_t)Window::NumKeys);
	
	// Tellusim::CanvasElement::Type
	TS_STATIC_ASSERT(TS_CanvasElementTypeUnknown == (uint32_t)CanvasElement::TypeUnknown);
	TS_STATIC_ASSERT(TS_CanvasElementTypeText == (uint32_t)CanvasElement::TypeText);
	TS_STATIC_ASSERT(TS_CanvasElementTypeMesh == (uint32_t)CanvasElement::TypeMesh);
	TS_STATIC_ASSERT(TS_CanvasElementTypeRect == (uint32_t)CanvasElement::TypeRect);
	TS_STATIC_ASSERT(TS_CanvasElementTypeTriangle == (uint32_t)CanvasElement::TypeTriangle);
	TS_STATIC_ASSERT(TS_CanvasElementTypeEllipse == (uint32_t)CanvasElement::TypeEllipse);
	TS_STATIC_ASSERT(TS_CanvasElementTypeShape == (uint32_t)CanvasElement::TypeShape);
	TS_STATIC_ASSERT(TS_CanvasElementTypeStrip == (uint32_t)CanvasElement::TypeStrip);
	TS_STATIC_ASSERT(TS_CanvasElementTypeNumTypes == (uint32_t)CanvasElement::NumTypes);
	
	// Tellusim::CanvasElement::Mode
	TS_STATIC_ASSERT(TS_CanvasElementModeSolid == (uint32_t)CanvasElement::ModeSolid);
	TS_STATIC_ASSERT(TS_CanvasElementModeTexture == (uint32_t)CanvasElement::ModeTexture);
	TS_STATIC_ASSERT(TS_CanvasElementModeTextureFetch == (uint32_t)CanvasElement::ModeTextureFetch);
	TS_STATIC_ASSERT(TS_CanvasElementModeTextureClamp == (uint32_t)CanvasElement::ModeTextureClamp);
	TS_STATIC_ASSERT(TS_CanvasElementModeTextureCubic == (uint32_t)CanvasElement::ModeTextureCubic);
	TS_STATIC_ASSERT(TS_CanvasElementModeTextureCubic3x3 == (uint32_t)CanvasElement::ModeTextureCubic3x3);
	TS_STATIC_ASSERT(TS_CanvasElementModeTextureCubic5x5 == (uint32_t)CanvasElement::ModeTextureCubic5x5);
	TS_STATIC_ASSERT(TS_CanvasElementModeTextureRed == (uint32_t)CanvasElement::ModeTextureRed);
	TS_STATIC_ASSERT(TS_CanvasElementModeTextureGreen == (uint32_t)CanvasElement::ModeTextureGreen);
	TS_STATIC_ASSERT(TS_CanvasElementModeTextureBlue == (uint32_t)CanvasElement::ModeTextureBlue);
	TS_STATIC_ASSERT(TS_CanvasElementModeTextureAlpha == (uint32_t)CanvasElement::ModeTextureAlpha);
	TS_STATIC_ASSERT(TS_CanvasElementModeGradient == (uint32_t)CanvasElement::ModeGradient);
	TS_STATIC_ASSERT(TS_CanvasElementModeNumModes == (uint32_t)CanvasElement::NumModes);
	
	// Tellusim::CanvasElement::Align
	TS_STATIC_ASSERT(TS_CanvasElementAlignNone == (uint32_t)CanvasElement::AlignNone);
	TS_STATIC_ASSERT(TS_CanvasElementAlignLeft == (uint32_t)CanvasElement::AlignLeft);
	TS_STATIC_ASSERT(TS_CanvasElementAlignRight == (uint32_t)CanvasElement::AlignRight);
	TS_STATIC_ASSERT(TS_CanvasElementAlignBottom == (uint32_t)CanvasElement::AlignBottom);
	TS_STATIC_ASSERT(TS_CanvasElementAlignTop == (uint32_t)CanvasElement::AlignTop);
	TS_STATIC_ASSERT(TS_CanvasElementAlignCenterX == (uint32_t)CanvasElement::AlignCenterX);
	TS_STATIC_ASSERT(TS_CanvasElementAlignCenterY == (uint32_t)CanvasElement::AlignCenterY);
	TS_STATIC_ASSERT(TS_CanvasElementAlignLeftBottom == (uint32_t)CanvasElement::AlignLeftBottom);
	TS_STATIC_ASSERT(TS_CanvasElementAlignLeftTop == (uint32_t)CanvasElement::AlignLeftTop);
	TS_STATIC_ASSERT(TS_CanvasElementAlignRightBottom == (uint32_t)CanvasElement::AlignRightBottom);
	TS_STATIC_ASSERT(TS_CanvasElementAlignRightTop == (uint32_t)CanvasElement::AlignRightTop);
	TS_STATIC_ASSERT(TS_CanvasElementAlignCenter == (uint32_t)CanvasElement::AlignCenter);
	TS_STATIC_ASSERT(TS_CanvasElementAlignNumAligns == (uint32_t)CanvasElement::NumAligns);
	
	// Tellusim::CanvasElement::Stack
	TS_STATIC_ASSERT(TS_CanvasElementStackNone == (uint32_t)CanvasElement::StackNone);
	TS_STATIC_ASSERT(TS_CanvasElementStackPush == (uint32_t)CanvasElement::StackPush);
	TS_STATIC_ASSERT(TS_CanvasElementStackPop == (uint32_t)CanvasElement::StackPop);
	TS_STATIC_ASSERT(TS_CanvasElementStackSet == (uint32_t)CanvasElement::StackSet);
	TS_STATIC_ASSERT(TS_CanvasElementStackMul == (uint32_t)CanvasElement::StackMul);
	TS_STATIC_ASSERT(TS_CanvasElementStackGet == (uint32_t)CanvasElement::StackGet);
	
	// Tellusim::Control::Type
	TS_STATIC_ASSERT(TS_ControlTypeUnknown == (uint32_t)Control::TypeUnknown);
	TS_STATIC_ASSERT(TS_ControlTypeRoot == (uint32_t)Control::TypeRoot);
	TS_STATIC_ASSERT(TS_ControlTypeText == (uint32_t)Control::TypeText);
	TS_STATIC_ASSERT(TS_ControlTypeRect == (uint32_t)Control::TypeRect);
	TS_STATIC_ASSERT(TS_ControlTypeGrid == (uint32_t)Control::TypeGrid);
	TS_STATIC_ASSERT(TS_ControlTypeGroup == (uint32_t)Control::TypeGroup);
	TS_STATIC_ASSERT(TS_ControlTypePanel == (uint32_t)Control::TypePanel);
	TS_STATIC_ASSERT(TS_ControlTypeDialog == (uint32_t)Control::TypeDialog);
	TS_STATIC_ASSERT(TS_ControlTypeWindow == (uint32_t)Control::TypeWindow);
	TS_STATIC_ASSERT(TS_ControlTypeCheck == (uint32_t)Control::TypeCheck);
	TS_STATIC_ASSERT(TS_ControlTypeCombo == (uint32_t)Control::TypeCombo);
	TS_STATIC_ASSERT(TS_ControlTypeButton == (uint32_t)Control::TypeButton);
	TS_STATIC_ASSERT(TS_ControlTypeSlider == (uint32_t)Control::TypeSlider);
	TS_STATIC_ASSERT(TS_ControlTypeScroll == (uint32_t)Control::TypeScroll);
	TS_STATIC_ASSERT(TS_ControlTypeSplit == (uint32_t)Control::TypeSplit);
	TS_STATIC_ASSERT(TS_ControlTypeArea == (uint32_t)Control::TypeArea);
	TS_STATIC_ASSERT(TS_ControlTypeTree == (uint32_t)Control::TypeTree);
	TS_STATIC_ASSERT(TS_ControlTypeEdit == (uint32_t)Control::TypeEdit);
	TS_STATIC_ASSERT(TS_ControlTypeNumTypes == (uint32_t)Control::NumTypes);
	
	// Tellusim::Control::State
	TS_STATIC_ASSERT(TS_ControlStateUnknown == (uint32_t)Control::StateUnknown);
	TS_STATIC_ASSERT(TS_ControlStateNormal == (uint32_t)Control::StateNormal);
	TS_STATIC_ASSERT(TS_ControlStateFocused == (uint32_t)Control::StateFocused);
	TS_STATIC_ASSERT(TS_ControlStatePressed == (uint32_t)Control::StatePressed);
	TS_STATIC_ASSERT(TS_ControlStateDisabled == (uint32_t)Control::StateDisabled);
	TS_STATIC_ASSERT(TS_ControlStateNumStates == (uint32_t)Control::NumStates);
	
	// Tellusim::Control::Mesh
	TS_STATIC_ASSERT(TS_ControlMeshCheck == (uint32_t)Control::MeshCheck);
	TS_STATIC_ASSERT(TS_ControlMeshButton == (uint32_t)Control::MeshButton);
	TS_STATIC_ASSERT(TS_ControlMeshSliderLine == (uint32_t)Control::MeshSliderLine);
	TS_STATIC_ASSERT(TS_ControlMeshHScrollLine == (uint32_t)Control::MeshHScrollLine);
	TS_STATIC_ASSERT(TS_ControlMeshVScrollLine == (uint32_t)Control::MeshVScrollLine);
	TS_STATIC_ASSERT(TS_ControlMeshSliderHandle == (uint32_t)Control::MeshSliderHandle);
	TS_STATIC_ASSERT(TS_ControlMeshHScrollHandle == (uint32_t)Control::MeshHScrollHandle);
	TS_STATIC_ASSERT(TS_ControlMeshVScrollHandle == (uint32_t)Control::MeshVScrollHandle);
	TS_STATIC_ASSERT(TS_ControlMeshBackground == (uint32_t)Control::MeshBackground);
	TS_STATIC_ASSERT(TS_ControlMeshSelection == (uint32_t)Control::MeshSelection);
	TS_STATIC_ASSERT(TS_ControlMeshBorder == (uint32_t)Control::MeshBorder);
	TS_STATIC_ASSERT(TS_ControlMeshFrame == (uint32_t)Control::MeshFrame);
	TS_STATIC_ASSERT(TS_ControlMeshNumMeshes == (uint32_t)Control::NumMeshes);
	
	// Tellusim::Control::Align
	TS_STATIC_ASSERT(TS_ControlAlignNone == (uint32_t)Control::AlignNone);
	TS_STATIC_ASSERT(TS_ControlAlignLeft == (uint32_t)Control::AlignLeft);
	TS_STATIC_ASSERT(TS_ControlAlignRight == (uint32_t)Control::AlignRight);
	TS_STATIC_ASSERT(TS_ControlAlignBottom == (uint32_t)Control::AlignBottom);
	TS_STATIC_ASSERT(TS_ControlAlignTop == (uint32_t)Control::AlignTop);
	TS_STATIC_ASSERT(TS_ControlAlignCenterX == (uint32_t)Control::AlignCenterX);
	TS_STATIC_ASSERT(TS_ControlAlignCenterY == (uint32_t)Control::AlignCenterY);
	TS_STATIC_ASSERT(TS_ControlAlignExpandX == (uint32_t)Control::AlignExpandX);
	TS_STATIC_ASSERT(TS_ControlAlignExpandY == (uint32_t)Control::AlignExpandY);
	TS_STATIC_ASSERT(TS_ControlAlignOverlap == (uint32_t)Control::AlignOverlap);
	TS_STATIC_ASSERT(TS_ControlAlignSpacer == (uint32_t)Control::AlignSpacer);
	TS_STATIC_ASSERT(TS_ControlAlignAspect == (uint32_t)Control::AlignAspect);
	TS_STATIC_ASSERT(TS_ControlAlignLeftBottom == (uint32_t)Control::AlignLeftBottom);
	TS_STATIC_ASSERT(TS_ControlAlignLeftTop == (uint32_t)Control::AlignLeftTop);
	TS_STATIC_ASSERT(TS_ControlAlignRightBottom == (uint32_t)Control::AlignRightBottom);
	TS_STATIC_ASSERT(TS_ControlAlignRightTop == (uint32_t)Control::AlignRightTop);
	TS_STATIC_ASSERT(TS_ControlAlignCenter == (uint32_t)Control::AlignCenter);
	TS_STATIC_ASSERT(TS_ControlAlignExpand == (uint32_t)Control::AlignExpand);
	TS_STATIC_ASSERT(TS_ControlAlignNumAligns == (uint32_t)Control::NumAligns);
	
	// Tellusim::Control::Button
	TS_STATIC_ASSERT(TS_ControlButtonNone == (uint32_t)Control::ButtonNone);
	TS_STATIC_ASSERT(TS_ControlButtonLeft == (uint32_t)Control::ButtonLeft);
	TS_STATIC_ASSERT(TS_ControlButtonLeft2 == (uint32_t)Control::ButtonLeft2);
	TS_STATIC_ASSERT(TS_ControlButtonRight == (uint32_t)Control::ButtonRight);
	TS_STATIC_ASSERT(TS_ControlButtonRight2 == (uint32_t)Control::ButtonRight2);
	TS_STATIC_ASSERT(TS_ControlButtonMiddle == (uint32_t)Control::ButtonMiddle);
	TS_STATIC_ASSERT(TS_ControlButtonMiddle2 == (uint32_t)Control::ButtonMiddle2);
	TS_STATIC_ASSERT(TS_ControlButtonNumButtons == (uint32_t)Control::NumButtons);
	
	// Tellusim::Control::Axis
	TS_STATIC_ASSERT(TS_ControlAxisUnknown == (uint32_t)Control::AxisUnknown);
	TS_STATIC_ASSERT(TS_ControlAxisX == (uint32_t)Control::AxisX);
	TS_STATIC_ASSERT(TS_ControlAxisY == (uint32_t)Control::AxisY);
	TS_STATIC_ASSERT(TS_ControlAxisZ == (uint32_t)Control::AxisZ);
	TS_STATIC_ASSERT(TS_ControlAxisW == (uint32_t)Control::AxisW);
	TS_STATIC_ASSERT(TS_ControlAxisNumAxes == (uint32_t)Control::NumAxes);
	
	// Tellusim::Control::Key
	TS_STATIC_ASSERT(TS_ControlKeyNone == (uint32_t)Control::KeyNone);
	TS_STATIC_ASSERT(TS_ControlKeyTab == (uint32_t)Control::KeyTab);
	TS_STATIC_ASSERT(TS_ControlKeyBackspace == (uint32_t)Control::KeyBackspace);
	TS_STATIC_ASSERT(TS_ControlKeyDelete == (uint32_t)Control::KeyDelete);
	TS_STATIC_ASSERT(TS_ControlKeyInsert == (uint32_t)Control::KeyInsert);
	TS_STATIC_ASSERT(TS_ControlKeyReturn == (uint32_t)Control::KeyReturn);
	TS_STATIC_ASSERT(TS_ControlKeyPrior == (uint32_t)Control::KeyPrior);
	TS_STATIC_ASSERT(TS_ControlKeyNext == (uint32_t)Control::KeyNext);
	TS_STATIC_ASSERT(TS_ControlKeyEnd == (uint32_t)Control::KeyEnd);
	TS_STATIC_ASSERT(TS_ControlKeyHome == (uint32_t)Control::KeyHome);
	TS_STATIC_ASSERT(TS_ControlKeyUp == (uint32_t)Control::KeyUp);
	TS_STATIC_ASSERT(TS_ControlKeyDown == (uint32_t)Control::KeyDown);
	TS_STATIC_ASSERT(TS_ControlKeyLeft == (uint32_t)Control::KeyLeft);
	TS_STATIC_ASSERT(TS_ControlKeyRight == (uint32_t)Control::KeyRight);
	TS_STATIC_ASSERT(TS_ControlKeyShift == (uint32_t)Control::KeyShift);
	TS_STATIC_ASSERT(TS_ControlKeyCtrl == (uint32_t)Control::KeyCtrl);
	TS_STATIC_ASSERT(TS_ControlKeyAlt == (uint32_t)Control::KeyAlt);
	TS_STATIC_ASSERT(TS_ControlKeyCmd == (uint32_t)Control::KeyCmd);
	TS_STATIC_ASSERT(TS_ControlKeyNumKeys == (uint32_t)Control::NumKeys);
	
	// Tellusim::ControlEdit::EditMode
	TS_STATIC_ASSERT(TS_ControlEditEditModeText == (uint32_t)ControlEdit::EditModeText);
	TS_STATIC_ASSERT(TS_ControlEditEditModePassword == (uint32_t)ControlEdit::EditModePassword);
	TS_STATIC_ASSERT(TS_ControlEditEditModeNumber == (uint32_t)ControlEdit::EditModeNumber);
	TS_STATIC_ASSERT(TS_ControlEditEditModeSigned == (uint32_t)ControlEdit::EditModeSigned);
	TS_STATIC_ASSERT(TS_ControlEditEditModeUnsigned == (uint32_t)ControlEdit::EditModeUnsigned);
	TS_STATIC_ASSERT(TS_ControlEditEditModeHexadecimal == (uint32_t)ControlEdit::EditModeHexadecimal);
	
	// Tellusim::DialogMessage::Flags
	TS_STATIC_ASSERT(TS_DialogMessageFlagsNone == (uint32_t)DialogMessage::FlagNone);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsYes == (uint32_t)DialogMessage::FlagYes);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsNo == (uint32_t)DialogMessage::FlagNo);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsOk == (uint32_t)DialogMessage::FlagOk);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsCancel == (uint32_t)DialogMessage::FlagCancel);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsClose == (uint32_t)DialogMessage::FlagClose);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsMessage == (uint32_t)DialogMessage::FlagMessage);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsWarning == (uint32_t)DialogMessage::FlagWarning);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsQuestion == (uint32_t)DialogMessage::FlagQuestion);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsError == (uint32_t)DialogMessage::FlagError);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsMouse == (uint32_t)DialogMessage::FlagMouse);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsYesNo == (uint32_t)DialogMessage::FlagYesNo);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsOkCancel == (uint32_t)DialogMessage::FlagOkCancel);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsDefaultFlags == (uint32_t)DialogMessage::DefaultFlags);
	TS_STATIC_ASSERT(TS_DialogMessageFlagsNumFlags == (uint32_t)DialogMessage::NumFlags);
	
	// Tellusim::DialogMessage::Result
	TS_STATIC_ASSERT(TS_DialogMessageResultClose == (uint32_t)DialogMessage::ResultClose);
	TS_STATIC_ASSERT(TS_DialogMessageResultCancel == (uint32_t)DialogMessage::ResultCancel);
	TS_STATIC_ASSERT(TS_DialogMessageResultOk == (uint32_t)DialogMessage::ResultOk);
	TS_STATIC_ASSERT(TS_DialogMessageResultNo == (uint32_t)DialogMessage::ResultNo);
	TS_STATIC_ASSERT(TS_DialogMessageResultYes == (uint32_t)DialogMessage::ResultYes);
	TS_STATIC_ASSERT(TS_DialogMessageResultNumResults == (uint32_t)DialogMessage::NumResults);
	
	// Tellusim::DialogFileOpen::Flags
	TS_STATIC_ASSERT(TS_DialogFileOpenFlagsNone == (uint32_t)DialogFileOpen::FlagNone);
	TS_STATIC_ASSERT(TS_DialogFileOpenFlagsHidden == (uint32_t)DialogFileOpen::FlagHidden);
	TS_STATIC_ASSERT(TS_DialogFileOpenFlagsMouse == (uint32_t)DialogFileOpen::FlagMouse);
	TS_STATIC_ASSERT(TS_DialogFileOpenFlagsDefaultFlags == (uint32_t)DialogFileOpen::DefaultFlags);
	TS_STATIC_ASSERT(TS_DialogFileOpenFlagsNumFlags == (uint32_t)DialogFileOpen::NumFlags);
	
	// Tellusim::DialogFileOpen::Result
	TS_STATIC_ASSERT(TS_DialogFileOpenResultCancel == (uint32_t)DialogFileOpen::ResultCancel);
	TS_STATIC_ASSERT(TS_DialogFileOpenResultOk == (uint32_t)DialogFileOpen::ResultOk);
	TS_STATIC_ASSERT(TS_DialogFileOpenResultNumResults == (uint32_t)DialogFileOpen::NumResults);
	
	// Tellusim::DialogFileSave::Flags
	TS_STATIC_ASSERT(TS_DialogFileSaveFlagsNone == (uint32_t)DialogFileSave::FlagNone);
	TS_STATIC_ASSERT(TS_DialogFileSaveFlagsHidden == (uint32_t)DialogFileSave::FlagHidden);
	TS_STATIC_ASSERT(TS_DialogFileSaveFlagsOverwrite == (uint32_t)DialogFileSave::FlagOverwrite);
	TS_STATIC_ASSERT(TS_DialogFileSaveFlagsMouse == (uint32_t)DialogFileSave::FlagMouse);
	TS_STATIC_ASSERT(TS_DialogFileSaveFlagsDefaultFlags == (uint32_t)DialogFileSave::DefaultFlags);
	TS_STATIC_ASSERT(TS_DialogFileSaveFlagsNumFlags == (uint32_t)DialogFileSave::NumFlags);
	
	// Tellusim::DialogFileSave::Result
	TS_STATIC_ASSERT(TS_DialogFileSaveResultCancel == (uint32_t)DialogFileSave::ResultCancel);
	TS_STATIC_ASSERT(TS_DialogFileSaveResultOk == (uint32_t)DialogFileSave::ResultOk);
	TS_STATIC_ASSERT(TS_DialogFileSaveResultNumResults == (uint32_t)DialogFileSave::NumResults);
	
	// Tellusim::DialogDirectory::Flags
	TS_STATIC_ASSERT(TS_DialogDirectoryFlagsNone == (uint32_t)DialogDirectory::FlagNone);
	TS_STATIC_ASSERT(TS_DialogDirectoryFlagsMouse == (uint32_t)DialogDirectory::FlagMouse);
	TS_STATIC_ASSERT(TS_DialogDirectoryFlagsDefaultFlags == (uint32_t)DialogDirectory::DefaultFlags);
	TS_STATIC_ASSERT(TS_DialogDirectoryFlagsNumFlags == (uint32_t)DialogDirectory::NumFlags);
	
	// Tellusim::DialogDirectory::Result
	TS_STATIC_ASSERT(TS_DialogDirectoryResultCancel == (uint32_t)DialogDirectory::ResultCancel);
	TS_STATIC_ASSERT(TS_DialogDirectoryResultOk == (uint32_t)DialogDirectory::ResultOk);
	TS_STATIC_ASSERT(TS_DialogDirectoryResultNumResults == (uint32_t)DialogDirectory::NumResults);
	
	// Tellusim::DialogProgress::Flags
	TS_STATIC_ASSERT(TS_DialogProgressFlagsNone == (uint32_t)DialogProgress::FlagNone);
	TS_STATIC_ASSERT(TS_DialogProgressFlagsMouse == (uint32_t)DialogProgress::FlagMouse);
	TS_STATIC_ASSERT(TS_DialogProgressFlagsDefaultFlags == (uint32_t)DialogProgress::DefaultFlags);
	TS_STATIC_ASSERT(TS_DialogProgressFlagsNumFlags == (uint32_t)DialogProgress::NumFlags);
	
	// Tellusim::DialogProgress::Result
	TS_STATIC_ASSERT(TS_DialogProgressResultCancel == (uint32_t)DialogProgress::ResultCancel);
	TS_STATIC_ASSERT(TS_DialogProgressResultOk == (uint32_t)DialogProgress::ResultOk);
	TS_STATIC_ASSERT(TS_DialogProgressResultNumResults == (uint32_t)DialogProgress::NumResults);
	
	// Tellusim::DialogColor::Flags
	TS_STATIC_ASSERT(TS_DialogColorFlagsNone == (uint32_t)DialogColor::FlagNone);
	TS_STATIC_ASSERT(TS_DialogColorFlagsAlpha == (uint32_t)DialogColor::FlagAlpha);
	TS_STATIC_ASSERT(TS_DialogColorFlagsMouse == (uint32_t)DialogColor::FlagMouse);
	TS_STATIC_ASSERT(TS_DialogColorFlagsDefaultFlags == (uint32_t)DialogColor::DefaultFlags);
	TS_STATIC_ASSERT(TS_DialogColorFlagsNumFlags == (uint32_t)DialogColor::NumFlags);
	
	// Tellusim::DialogColor::Result
	TS_STATIC_ASSERT(TS_DialogColorResultCancel == (uint32_t)DialogColor::ResultCancel);
	TS_STATIC_ASSERT(TS_DialogColorResultOk == (uint32_t)DialogColor::ResultOk);
	TS_STATIC_ASSERT(TS_DialogColorResultNumResults == (uint32_t)DialogColor::NumResults);
	
	// Tellusim::DialogMenu::Flags
	TS_STATIC_ASSERT(TS_DialogMenuFlagsNone == (uint32_t)DialogMenu::FlagNone);
	TS_STATIC_ASSERT(TS_DialogMenuFlagsMouse == (uint32_t)DialogMenu::FlagMouse);
	TS_STATIC_ASSERT(TS_DialogMenuFlagsDefaultFlags == (uint32_t)DialogMenu::DefaultFlags);
	TS_STATIC_ASSERT(TS_DialogMenuFlagsNumFlags == (uint32_t)DialogMenu::NumFlags);
	
	// Tellusim::DialogMenu::Result
	TS_STATIC_ASSERT(TS_DialogMenuResultCancel == (uint32_t)DialogMenu::ResultCancel);
	TS_STATIC_ASSERT(TS_DialogMenuResultClick == (uint32_t)DialogMenu::ResultClick);
	TS_STATIC_ASSERT(TS_DialogMenuResultNumResults == (uint32_t)DialogMenu::NumResults);
	
	// Tellusim::CubeFilter::Mode
	TS_STATIC_ASSERT(TS_CubeFilterModeCube == (uint32_t)CubeFilter::ModeCube);
	TS_STATIC_ASSERT(TS_CubeFilterModePanorama == (uint32_t)CubeFilter::ModePanorama);
	TS_STATIC_ASSERT(TS_CubeFilterModeNumModes == (uint32_t)CubeFilter::NumModes);
	
	// Tellusim::CubeFilter::Flags
	TS_STATIC_ASSERT(TS_CubeFilterFlagsCube == (uint32_t)CubeFilter::FlagCube);
	TS_STATIC_ASSERT(TS_CubeFilterFlagsPanorama == (uint32_t)CubeFilter::FlagPanorama);
	TS_STATIC_ASSERT(TS_CubeFilterFlagsAll == (uint32_t)CubeFilter::FlagsAll);
	
	// Tellusim::DecoderJPEG::Mode
	TS_STATIC_ASSERT(TS_DecoderJPEGModeR == (uint32_t)DecoderJPEG::ModeR);
	TS_STATIC_ASSERT(TS_DecoderJPEGModeRG == (uint32_t)DecoderJPEG::ModeRG);
	TS_STATIC_ASSERT(TS_DecoderJPEGModeRGBA == (uint32_t)DecoderJPEG::ModeRGBA);
	TS_STATIC_ASSERT(TS_DecoderJPEGModeYUV444 == (uint32_t)DecoderJPEG::ModeYUV444);
	TS_STATIC_ASSERT(TS_DecoderJPEGModeYUV422H == (uint32_t)DecoderJPEG::ModeYUV422H);
	TS_STATIC_ASSERT(TS_DecoderJPEGModeYUV422V == (uint32_t)DecoderJPEG::ModeYUV422V);
	TS_STATIC_ASSERT(TS_DecoderJPEGModeYUV420 == (uint32_t)DecoderJPEG::ModeYUV420);
	TS_STATIC_ASSERT(TS_DecoderJPEGModeNumModes == (uint32_t)DecoderJPEG::NumModes);
	
	// Tellusim::DecoderJPEG::Flags
	TS_STATIC_ASSERT(TS_DecoderJPEGFlagsNone == (uint32_t)DecoderJPEG::FlagNone);
	TS_STATIC_ASSERT(TS_DecoderJPEGFlagsR == (uint32_t)DecoderJPEG::FlagR);
	TS_STATIC_ASSERT(TS_DecoderJPEGFlagsRG == (uint32_t)DecoderJPEG::FlagRG);
	TS_STATIC_ASSERT(TS_DecoderJPEGFlagsRGBA == (uint32_t)DecoderJPEG::FlagRGBA);
	TS_STATIC_ASSERT(TS_DecoderJPEGFlagsYUV444 == (uint32_t)DecoderJPEG::FlagYUV444);
	TS_STATIC_ASSERT(TS_DecoderJPEGFlagsYUV422H == (uint32_t)DecoderJPEG::FlagYUV422H);
	TS_STATIC_ASSERT(TS_DecoderJPEGFlagsYUV422V == (uint32_t)DecoderJPEG::FlagYUV422V);
	TS_STATIC_ASSERT(TS_DecoderJPEGFlagsYUV420 == (uint32_t)DecoderJPEG::FlagYUV420);
	TS_STATIC_ASSERT(TS_DecoderJPEGFlagsAll == (uint32_t)DecoderJPEG::FlagsAll);
	
	// Tellusim::EncoderBC15::Mode
	TS_STATIC_ASSERT(TS_EncoderBC15ModeBC1RGBu8n == (uint32_t)EncoderBC15::ModeBC1RGBu8n);
	TS_STATIC_ASSERT(TS_EncoderBC15ModeBC2RGBAu8n == (uint32_t)EncoderBC15::ModeBC2RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderBC15ModeBC3RGBAu8n == (uint32_t)EncoderBC15::ModeBC3RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderBC15ModeBC4Ru8n == (uint32_t)EncoderBC15::ModeBC4Ru8n);
	TS_STATIC_ASSERT(TS_EncoderBC15ModeBC5RGu8n == (uint32_t)EncoderBC15::ModeBC5RGu8n);
	TS_STATIC_ASSERT(TS_EncoderBC15ModeNumModes == (uint32_t)EncoderBC15::NumModes);
	
	// Tellusim::EncoderBC15::Flags
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsNone == (uint32_t)EncoderBC15::FlagNone);
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsBC1RGBu8n == (uint32_t)EncoderBC15::FlagBC1RGBu8n);
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsBC2RGBAu8n == (uint32_t)EncoderBC15::FlagBC2RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsBC3RGBAu8n == (uint32_t)EncoderBC15::FlagBC3RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsBC4Ru8n == (uint32_t)EncoderBC15::FlagBC4Ru8n);
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsBC5RGu8n == (uint32_t)EncoderBC15::FlagBC5RGu8n);
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsCube == (uint32_t)EncoderBC15::FlagCube);
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsBC13 == (uint32_t)EncoderBC15::FlagsBC13);
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsBC45 == (uint32_t)EncoderBC15::FlagsBC45);
	TS_STATIC_ASSERT(TS_EncoderBC15FlagsAll == (uint32_t)EncoderBC15::FlagsAll);
	
	// Tellusim::EncoderBC67::Mode
	TS_STATIC_ASSERT(TS_EncoderBC67ModeBC6RGBf16s == (uint32_t)EncoderBC67::ModeBC6RGBf16s);
	TS_STATIC_ASSERT(TS_EncoderBC67ModeBC6RGBf16u == (uint32_t)EncoderBC67::ModeBC6RGBf16u);
	TS_STATIC_ASSERT(TS_EncoderBC67ModeBC7RGBAu8n == (uint32_t)EncoderBC67::ModeBC7RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderBC67ModeNumModes == (uint32_t)EncoderBC67::NumModes);
	
	// Tellusim::EncoderBC67::Flags
	TS_STATIC_ASSERT(TS_EncoderBC67FlagsNone == (uint32_t)EncoderBC67::FlagNone);
	TS_STATIC_ASSERT(TS_EncoderBC67FlagsBC6RGBf16s == (uint32_t)EncoderBC67::FlagBC6RGBf16s);
	TS_STATIC_ASSERT(TS_EncoderBC67FlagsBC6RGBf16u == (uint32_t)EncoderBC67::FlagBC6RGBf16u);
	TS_STATIC_ASSERT(TS_EncoderBC67FlagsBC7RGBAu8n == (uint32_t)EncoderBC67::FlagBC7RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderBC67FlagsCube == (uint32_t)EncoderBC67::FlagCube);
	TS_STATIC_ASSERT(TS_EncoderBC67FlagsAll == (uint32_t)EncoderBC67::FlagsAll);
	
	// Tellusim::EncoderASTC::Mode
	TS_STATIC_ASSERT(TS_EncoderASTCModeASTC44RGBAu8n == (uint32_t)EncoderASTC::ModeASTC44RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderASTCModeASTC54RGBAu8n == (uint32_t)EncoderASTC::ModeASTC54RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderASTCModeASTC55RGBAu8n == (uint32_t)EncoderASTC::ModeASTC55RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderASTCModeNumModes == (uint32_t)EncoderASTC::NumModes);
	
	// Tellusim::EncoderASTC::Flags
	TS_STATIC_ASSERT(TS_EncoderASTCFlagsNone == (uint32_t)EncoderASTC::FlagNone);
	TS_STATIC_ASSERT(TS_EncoderASTCFlagsASTC44RGBAu8n == (uint32_t)EncoderASTC::FlagASTC44RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderASTCFlagsASTC54RGBAu8n == (uint32_t)EncoderASTC::FlagASTC54RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderASTCFlagsASTC55RGBAu8n == (uint32_t)EncoderASTC::FlagASTC55RGBAu8n);
	TS_STATIC_ASSERT(TS_EncoderASTCFlagsCube == (uint32_t)EncoderASTC::FlagCube);
	TS_STATIC_ASSERT(TS_EncoderASTCFlagsAll == (uint32_t)EncoderASTC::FlagsAll);
	
	// Tellusim::MeshModel::Flags
	TS_STATIC_ASSERT(TS_MeshModelFlagsNone == (uint32_t)MeshModel::FlagNone);
	TS_STATIC_ASSERT(TS_MeshModelFlagsDirect == (uint32_t)MeshModel::FlagDirect);
	TS_STATIC_ASSERT(TS_MeshModelFlagsVerbose == (uint32_t)MeshModel::FlagVerbose);
	TS_STATIC_ASSERT(TS_MeshModelFlagsOptimize == (uint32_t)MeshModel::FlagOptimize);
	TS_STATIC_ASSERT(TS_MeshModelFlagsMaterials == (uint32_t)MeshModel::FlagMaterials);
	TS_STATIC_ASSERT(TS_MeshModelFlagsIndices10 == (uint32_t)MeshModel::FlagIndices10);
	TS_STATIC_ASSERT(TS_MeshModelFlagsIndices16 == (uint32_t)MeshModel::FlagIndices16);
	TS_STATIC_ASSERT(TS_MeshModelFlagsIndices32 == (uint32_t)MeshModel::FlagIndices32);
	TS_STATIC_ASSERT(TS_MeshModelFlagsMeshlet64x84 == (uint32_t)MeshModel::FlagMeshlet64x84);
	TS_STATIC_ASSERT(TS_MeshModelFlagsMeshlet64x126 == (uint32_t)MeshModel::FlagMeshlet64x126);
	TS_STATIC_ASSERT(TS_MeshModelFlagsMeshlet96x169 == (uint32_t)MeshModel::FlagMeshlet96x169);
	TS_STATIC_ASSERT(TS_MeshModelFlagsMeshlet128x212 == (uint32_t)MeshModel::FlagMeshlet128x212);
	TS_STATIC_ASSERT(TS_MeshModelFlagsBufferWrite == (uint32_t)MeshModel::FlagBufferWrite);
	TS_STATIC_ASSERT(TS_MeshModelFlagsBufferSource == (uint32_t)MeshModel::FlagBufferSource);
	TS_STATIC_ASSERT(TS_MeshModelFlagsBufferStorage == (uint32_t)MeshModel::FlagBufferStorage);
	TS_STATIC_ASSERT(TS_MeshModelFlagsBufferTracing == (uint32_t)MeshModel::FlagBufferTracing);
	TS_STATIC_ASSERT(TS_MeshModelFlagsBufferAddress == (uint32_t)MeshModel::FlagBufferAddress);
	TS_STATIC_ASSERT(TS_MeshModelFlagsBufferTexel == (uint32_t)MeshModel::FlagBufferTexel);
	TS_STATIC_ASSERT(TS_MeshModelFlagsMeshlets == (uint32_t)MeshModel::FlagMeshlets);
	TS_STATIC_ASSERT(TS_MeshModelFlagsDefaultFlags == (uint32_t)MeshModel::DefaultFlags);
	TS_STATIC_ASSERT(TS_MeshModelFlagsNumFlags == (uint32_t)MeshModel::NumFlags);
	
	// Tellusim::SeparableFilter::Mode
	TS_STATIC_ASSERT(TS_SeparableFilterModeHorizontal == (uint32_t)SeparableFilter::ModeHorizontal);
	TS_STATIC_ASSERT(TS_SeparableFilterModeVertical == (uint32_t)SeparableFilter::ModeVertical);
	TS_STATIC_ASSERT(TS_SeparableFilterModeNumModes == (uint32_t)SeparableFilter::NumModes);
	
	// Tellusim::SeparableFilter::Flags
	TS_STATIC_ASSERT(TS_SeparableFilterFlagsNone == (uint32_t)SeparableFilter::FlagNone);
	TS_STATIC_ASSERT(TS_SeparableFilterFlagsRepeat == (uint32_t)SeparableFilter::FlagRepeat);
	TS_STATIC_ASSERT(TS_SeparableFilterFlagsZero == (uint32_t)SeparableFilter::FlagZero);
	TS_STATIC_ASSERT(TS_SeparableFilterFlagsDefaultFlags == (uint32_t)SeparableFilter::DefaultFlags);
	
	// Tellusim::PrefixScan::Mode
	TS_STATIC_ASSERT(TS_PrefixScanModeSingle == (uint32_t)PrefixScan::ModeSingle);
	TS_STATIC_ASSERT(TS_PrefixScanModeMultiple == (uint32_t)PrefixScan::ModeMultiple);
	TS_STATIC_ASSERT(TS_PrefixScanModeNumModes == (uint32_t)PrefixScan::NumModes);
	
	// Tellusim::PrefixScan::Flags
	TS_STATIC_ASSERT(TS_PrefixScanFlagsNone == (uint32_t)PrefixScan::FlagNone);
	TS_STATIC_ASSERT(TS_PrefixScanFlagsSingle == (uint32_t)PrefixScan::FlagSingle);
	TS_STATIC_ASSERT(TS_PrefixScanFlagsMultiple == (uint32_t)PrefixScan::FlagMultiple);
	TS_STATIC_ASSERT(TS_PrefixScanFlagsIndirect == (uint32_t)PrefixScan::FlagIndirect);
	TS_STATIC_ASSERT(TS_PrefixScanFlagsRepeat == (uint32_t)PrefixScan::FlagRepeat);
	TS_STATIC_ASSERT(TS_PrefixScanFlagsAll == (uint32_t)PrefixScan::FlagsAll);
	
	// Tellusim::RadixSort::Mode
	TS_STATIC_ASSERT(TS_RadixSortModeSingle == (uint32_t)RadixSort::ModeSingle);
	TS_STATIC_ASSERT(TS_RadixSortModeMultiple == (uint32_t)RadixSort::ModeMultiple);
	TS_STATIC_ASSERT(TS_RadixSortModeNumModes == (uint32_t)RadixSort::NumModes);
	
	// Tellusim::RadixSort::Flags
	TS_STATIC_ASSERT(TS_RadixSortFlagsNone == (uint32_t)RadixSort::FlagNone);
	TS_STATIC_ASSERT(TS_RadixSortFlagsSingle == (uint32_t)RadixSort::FlagSingle);
	TS_STATIC_ASSERT(TS_RadixSortFlagsMultiple == (uint32_t)RadixSort::FlagMultiple);
	TS_STATIC_ASSERT(TS_RadixSortFlagsIndirect == (uint32_t)RadixSort::FlagIndirect);
	TS_STATIC_ASSERT(TS_RadixSortFlagsOrder == (uint32_t)RadixSort::FlagOrder);
	TS_STATIC_ASSERT(TS_RadixSortFlagsTracing == (uint32_t)RadixSort::FlagTracing);
	TS_STATIC_ASSERT(TS_RadixSortFlagsScratch == (uint32_t)RadixSort::FlagScratch);
	TS_STATIC_ASSERT(TS_RadixSortFlagsAll == (uint32_t)RadixSort::FlagsAll);
	
	// Tellusim::BitonicSort::Mode
	TS_STATIC_ASSERT(TS_BitonicSortModeSingle == (uint32_t)BitonicSort::ModeSingle);
	TS_STATIC_ASSERT(TS_BitonicSortModeMultiple == (uint32_t)BitonicSort::ModeMultiple);
	TS_STATIC_ASSERT(TS_BitonicSortModeNumModes == (uint32_t)BitonicSort::NumModes);
	
	// Tellusim::BitonicSort::Flags
	TS_STATIC_ASSERT(TS_BitonicSortFlagsNone == (uint32_t)BitonicSort::FlagNone);
	TS_STATIC_ASSERT(TS_BitonicSortFlagsSingle == (uint32_t)BitonicSort::FlagSingle);
	TS_STATIC_ASSERT(TS_BitonicSortFlagsMultiple == (uint32_t)BitonicSort::FlagMultiple);
	TS_STATIC_ASSERT(TS_BitonicSortFlagsIndirect == (uint32_t)BitonicSort::FlagIndirect);
	TS_STATIC_ASSERT(TS_BitonicSortFlagsOrder == (uint32_t)BitonicSort::FlagOrder);
	TS_STATIC_ASSERT(TS_BitonicSortFlagsAll == (uint32_t)BitonicSort::FlagsAll);
	
	// Tellusim::SpatialTree::Mode
	TS_STATIC_ASSERT(TS_SpatialTreeModeSingle == (uint32_t)SpatialTree::ModeSingle);
	TS_STATIC_ASSERT(TS_SpatialTreeModeMultiple == (uint32_t)SpatialTree::ModeMultiple);
	TS_STATIC_ASSERT(TS_SpatialTreeModeNumModes == (uint32_t)SpatialTree::NumModes);
	
	// Tellusim::SpatialTree::Hash
	TS_STATIC_ASSERT(TS_SpatialTreeHashXYZ10 == (uint32_t)SpatialTree::HashXYZ10);
	TS_STATIC_ASSERT(TS_SpatialTreeHashXYZ9 == (uint32_t)SpatialTree::HashXYZ9);
	TS_STATIC_ASSERT(TS_SpatialTreeHashXYZ8 == (uint32_t)SpatialTree::HashXYZ8);
	TS_STATIC_ASSERT(TS_SpatialTreeHashXY15 == (uint32_t)SpatialTree::HashXY15);
	TS_STATIC_ASSERT(TS_SpatialTreeHashXY14 == (uint32_t)SpatialTree::HashXY14);
	TS_STATIC_ASSERT(TS_SpatialTreeHashXY12 == (uint32_t)SpatialTree::HashXY12);
	TS_STATIC_ASSERT(TS_SpatialTreeHashXY10 == (uint32_t)SpatialTree::HashXY10);
	
	// Tellusim::SpatialTree::Flags
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsNone == (uint32_t)SpatialTree::FlagNone);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsSingle == (uint32_t)SpatialTree::FlagSingle);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsMultiple == (uint32_t)SpatialTree::FlagMultiple);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsUpdate == (uint32_t)SpatialTree::FlagUpdate);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsOptimize == (uint32_t)SpatialTree::FlagOptimize);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsTracing == (uint32_t)SpatialTree::FlagTracing);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsScratch == (uint32_t)SpatialTree::FlagScratch);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsAtomic == (uint32_t)SpatialTree::FlagAtomic);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsSingleUpdate == (uint32_t)SpatialTree::FlagSingleUpdate);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsMultipleUpdate == (uint32_t)SpatialTree::FlagMultipleUpdate);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsSingleOptimize == (uint32_t)SpatialTree::FlagSingleOptimize);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsMultipleOptimize == (uint32_t)SpatialTree::FlagMultipleOptimize);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsAll == (uint32_t)SpatialTree::FlagsAll);
	TS_STATIC_ASSERT(TS_SpatialTreeFlagsAllOptimize == (uint32_t)SpatialTree::FlagsAllOptimize);
	
	// Tellusim::FourierTransform::Mode
	TS_STATIC_ASSERT(TS_FourierTransformModeRf16i == (uint32_t)FourierTransform::ModeRf16i);
	TS_STATIC_ASSERT(TS_FourierTransformModeRf32i == (uint32_t)FourierTransform::ModeRf32i);
	TS_STATIC_ASSERT(TS_FourierTransformModeRGf16i == (uint32_t)FourierTransform::ModeRGf16i);
	TS_STATIC_ASSERT(TS_FourierTransformModeRGf32i == (uint32_t)FourierTransform::ModeRGf32i);
	TS_STATIC_ASSERT(TS_FourierTransformModeRGBf16c == (uint32_t)FourierTransform::ModeRGBf16c);
	TS_STATIC_ASSERT(TS_FourierTransformModeRGBf21c == (uint32_t)FourierTransform::ModeRGBf21c);
	TS_STATIC_ASSERT(TS_FourierTransformModeRGBf16p == (uint32_t)FourierTransform::ModeRGBf16p);
	TS_STATIC_ASSERT(TS_FourierTransformModeRGBf32p == (uint32_t)FourierTransform::ModeRGBf32p);
	TS_STATIC_ASSERT(TS_FourierTransformModeNumModes == (uint32_t)FourierTransform::NumModes);
	
	// Tellusim::FourierTransform::Flags
	TS_STATIC_ASSERT(TS_FourierTransformFlagsNone == (uint32_t)FourierTransform::FlagNone);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsRf16i == (uint32_t)FourierTransform::FlagRf16i);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsRf32i == (uint32_t)FourierTransform::FlagRf32i);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsRGf16i == (uint32_t)FourierTransform::FlagRGf16i);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsRGf32i == (uint32_t)FourierTransform::FlagRGf32i);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsRGBf16c == (uint32_t)FourierTransform::FlagRGBf16c);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsRGBf21c == (uint32_t)FourierTransform::FlagRGBf21c);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsRGBf16p == (uint32_t)FourierTransform::FlagRGBf16p);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsRGBf32p == (uint32_t)FourierTransform::FlagRGBf32p);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsInterleaved == (uint32_t)FourierTransform::FlagsInterleaved);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsComplex == (uint32_t)FourierTransform::FlagsComplex);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsPlanar == (uint32_t)FourierTransform::FlagsPlanar);
	TS_STATIC_ASSERT(TS_FourierTransformFlagsAll == (uint32_t)FourierTransform::FlagsAll);
	
	// Tellusim::FourierTransform::Operation
	TS_STATIC_ASSERT(TS_FourierTransformOperationForwardCtoC == (uint32_t)FourierTransform::ForwardCtoC);
	TS_STATIC_ASSERT(TS_FourierTransformOperationBackwardCtoC == (uint32_t)FourierTransform::BackwardCtoC);
	TS_STATIC_ASSERT(TS_FourierTransformOperationForwardRtoC == (uint32_t)FourierTransform::ForwardRtoC);
	TS_STATIC_ASSERT(TS_FourierTransformOperationBackwardCtoR == (uint32_t)FourierTransform::BackwardCtoR);
	TS_STATIC_ASSERT(TS_FourierTransformOperationNumOperations == (uint32_t)FourierTransform::NumOperations);
	
	// Tellusim::TensorGraph::Operation
	TS_STATIC_ASSERT(TS_TensorGraphOperationClear == (uint32_t)TensorGraph::Clear);
	TS_STATIC_ASSERT(TS_TensorGraphOperationRange == (uint32_t)TensorGraph::Range);
	TS_STATIC_ASSERT(TS_TensorGraphOperationCopy == (uint32_t)TensorGraph::Copy);
	TS_STATIC_ASSERT(TS_TensorGraphOperationCat == (uint32_t)TensorGraph::Cat);
	TS_STATIC_ASSERT(TS_TensorGraphOperationTranspose == (uint32_t)TensorGraph::Transpose);
	TS_STATIC_ASSERT(TS_TensorGraphOperationMatMul == (uint32_t)TensorGraph::MatMul);
	TS_STATIC_ASSERT(TS_TensorGraphOperationMul == (uint32_t)TensorGraph::Mul);
	TS_STATIC_ASSERT(TS_TensorGraphOperationMad == (uint32_t)TensorGraph::Mad);
	TS_STATIC_ASSERT(TS_TensorGraphOperationDiv == (uint32_t)TensorGraph::Div);
	TS_STATIC_ASSERT(TS_TensorGraphOperationAdd == (uint32_t)TensorGraph::Add);
	TS_STATIC_ASSERT(TS_TensorGraphOperationConv == (uint32_t)TensorGraph::Conv);
	TS_STATIC_ASSERT(TS_TensorGraphOperationDeConv == (uint32_t)TensorGraph::DeConv);
	TS_STATIC_ASSERT(TS_TensorGraphOperationBatchNorm == (uint32_t)TensorGraph::BatchNorm);
	TS_STATIC_ASSERT(TS_TensorGraphOperationBatchMad == (uint32_t)TensorGraph::BatchMad);
	TS_STATIC_ASSERT(TS_TensorGraphOperationSoftMin == (uint32_t)TensorGraph::SoftMin);
	TS_STATIC_ASSERT(TS_TensorGraphOperationSoftMax == (uint32_t)TensorGraph::SoftMax);
	TS_STATIC_ASSERT(TS_TensorGraphOperationMaxPool == (uint32_t)TensorGraph::MaxPool);
	TS_STATIC_ASSERT(TS_TensorGraphOperationAvgPool == (uint32_t)TensorGraph::AvgPool);
	TS_STATIC_ASSERT(TS_TensorGraphOperationGELU == (uint32_t)TensorGraph::GELU);
	TS_STATIC_ASSERT(TS_TensorGraphOperationReLU == (uint32_t)TensorGraph::ReLU);
	TS_STATIC_ASSERT(TS_TensorGraphOperationSiLU == (uint32_t)TensorGraph::SiLU);
	TS_STATIC_ASSERT(TS_TensorGraphOperationSigm == (uint32_t)TensorGraph::Sigm);
	TS_STATIC_ASSERT(TS_TensorGraphOperationTanh == (uint32_t)TensorGraph::Tanh);
	TS_STATIC_ASSERT(TS_TensorGraphOperationSin == (uint32_t)TensorGraph::Sin);
	TS_STATIC_ASSERT(TS_TensorGraphOperationCos == (uint32_t)TensorGraph::Cos);
	TS_STATIC_ASSERT(TS_TensorGraphOperationExp == (uint32_t)TensorGraph::Exp);
	TS_STATIC_ASSERT(TS_TensorGraphOperationNumOperations == (uint32_t)TensorGraph::NumOperations);
	
	// Tellusim::TensorGraph::Flags
	TS_STATIC_ASSERT(TS_TensorGraphFlagsNone == (uint32_t)TensorGraph::FlagNone);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsSizeQuery == (uint32_t)TensorGraph::FlagSizeQuery);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsFormatRf32 == (uint32_t)TensorGraph::FlagFormatRf32);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsFormatRf16 == (uint32_t)TensorGraph::FlagFormatRf16);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsTranspose == (uint32_t)TensorGraph::FlagTranspose);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsWrapClamp == (uint32_t)TensorGraph::FlagWrapClamp);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsWrapRepeat == (uint32_t)TensorGraph::FlagWrapRepeat);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsReadScale == (uint32_t)TensorGraph::FlagReadScale);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsReadBias == (uint32_t)TensorGraph::FlagReadBias);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsConvert == (uint32_t)TensorGraph::FlagConvert);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsKernel == (uint32_t)TensorGraph::FlagKernel);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsGELU == (uint32_t)TensorGraph::FlagGELU);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsReLU == (uint32_t)TensorGraph::FlagReLU);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsSiLU == (uint32_t)TensorGraph::FlagSiLU);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsSigm == (uint32_t)TensorGraph::FlagSigm);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsTanh == (uint32_t)TensorGraph::FlagTanh);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsSin == (uint32_t)TensorGraph::FlagSin);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsCos == (uint32_t)TensorGraph::FlagCos);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsExp == (uint32_t)TensorGraph::FlagExp);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsFormat == (uint32_t)TensorGraph::FlagFormat);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsWrap == (uint32_t)TensorGraph::FlagWrap);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsRead == (uint32_t)TensorGraph::FlagRead);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsUnit == (uint32_t)TensorGraph::FlagUnit);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsMath == (uint32_t)TensorGraph::FlagMath);
	TS_STATIC_ASSERT(TS_TensorGraphFlagsAll == (uint32_t)TensorGraph::FlagsAll);
	
	// Tellusim::TensorGraph::Masks
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskNone == (uint32_t)TensorGraph::MaskNone);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskClear == (uint32_t)TensorGraph::MaskClear);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskRange == (uint32_t)TensorGraph::MaskRange);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskCopy == (uint32_t)TensorGraph::MaskCopy);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskCat == (uint32_t)TensorGraph::MaskCat);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskTranspose == (uint32_t)TensorGraph::MaskTranspose);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskMatMul == (uint32_t)TensorGraph::MaskMatMul);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskMul == (uint32_t)TensorGraph::MaskMul);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskMad == (uint32_t)TensorGraph::MaskMad);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskDiv == (uint32_t)TensorGraph::MaskDiv);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskAdd == (uint32_t)TensorGraph::MaskAdd);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskConv == (uint32_t)TensorGraph::MaskConv);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskDeConv == (uint32_t)TensorGraph::MaskDeConv);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskBatchNorm == (uint32_t)TensorGraph::MaskBatchNorm);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskBatchMad == (uint32_t)TensorGraph::MaskBatchMad);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskSoftMin == (uint32_t)TensorGraph::MaskSoftMin);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskSoftMax == (uint32_t)TensorGraph::MaskSoftMax);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskMaxPool == (uint32_t)TensorGraph::MaskMaxPool);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskAvgPool == (uint32_t)TensorGraph::MaskAvgPool);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskGELU == (uint32_t)TensorGraph::MaskGELU);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskReLU == (uint32_t)TensorGraph::MaskReLU);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskSiLU == (uint32_t)TensorGraph::MaskSiLU);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskSigm == (uint32_t)TensorGraph::MaskSigm);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskTanh == (uint32_t)TensorGraph::MaskTanh);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskSin == (uint32_t)TensorGraph::MaskSin);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskCos == (uint32_t)TensorGraph::MaskCos);
	TS_STATIC_ASSERT(TS_TensorGraphMasksMaskExp == (uint32_t)TensorGraph::MaskExp);
	TS_STATIC_ASSERT(TS_TensorGraphMasksAll == (uint32_t)TensorGraph::MasksAll);
	
	// Tellusim::Log::Level
	TS_STATIC_ASSERT(TS_LogLevelFatal == (uint32_t)Log::Fatal);
	TS_STATIC_ASSERT(TS_LogLevelError == (uint32_t)Log::Error);
	TS_STATIC_ASSERT(TS_LogLevelWarning == (uint32_t)Log::Warning);
	TS_STATIC_ASSERT(TS_LogLevelMessage == (uint32_t)Log::Message);
	TS_STATIC_ASSERT(TS_LogLevelVerbose == (uint32_t)Log::Verbose);
	TS_STATIC_ASSERT(TS_LogLevelUnknown == (uint32_t)Log::Unknown);
	TS_STATIC_ASSERT(TS_LogLevelNumLevels == (uint32_t)Log::NumLevels);
	
	// Tellusim::Time::
	TS_STATIC_ASSERT(TS_TimeSeconds == (uint32_t)Time::Seconds);
	TS_STATIC_ASSERT(TS_TimeMSeconds == (uint32_t)Time::MSeconds);
	TS_STATIC_ASSERT(TS_TimeUSeconds == (uint32_t)Time::USeconds);
	
	// Tellusim::Command
	TS_STATIC_ASSERT(sizeof(TSCommandDrawArraysIndirect) == sizeof(Command::DrawArraysIndirect));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawArraysIndirect, num_vertices) == offsetof(Command::DrawArraysIndirect, num_vertices));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawArraysIndirect, num_instances) == offsetof(Command::DrawArraysIndirect, num_instances));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawArraysIndirect, base_vertex) == offsetof(Command::DrawArraysIndirect, base_vertex));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawArraysIndirect, base_instance) == offsetof(Command::DrawArraysIndirect, base_instance));
	TS_STATIC_ASSERT(sizeof(TSCommandDrawElementsIndirect) == sizeof(Command::DrawElementsIndirect));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawElementsIndirect, num_indices) == offsetof(Command::DrawElementsIndirect, num_indices));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawElementsIndirect, num_instances) == offsetof(Command::DrawElementsIndirect, num_instances));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawElementsIndirect, base_index) == offsetof(Command::DrawElementsIndirect, base_index));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawElementsIndirect, base_vertex) == offsetof(Command::DrawElementsIndirect, base_vertex));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawElementsIndirect, base_instance) == offsetof(Command::DrawElementsIndirect, base_instance));
	TS_STATIC_ASSERT(sizeof(TSCommandDrawMeshIndirect) == sizeof(Command::DrawMeshIndirect));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawMeshIndirect, group_width) == offsetof(Command::DrawMeshIndirect, group_width));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawMeshIndirect, group_height) == offsetof(Command::DrawMeshIndirect, group_height));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawMeshIndirect, group_depth) == offsetof(Command::DrawMeshIndirect, group_depth));
	TS_STATIC_ASSERT(offsetof(TSCommandDrawMeshIndirect, padding) == offsetof(Command::DrawMeshIndirect, padding));
	
	// Tellusim::Compute
	TS_STATIC_ASSERT(sizeof(TSComputeDispatchIndirect) == sizeof(Compute::DispatchIndirect));
	TS_STATIC_ASSERT(offsetof(TSComputeDispatchIndirect, group_width) == offsetof(Compute::DispatchIndirect, group_width));
	TS_STATIC_ASSERT(offsetof(TSComputeDispatchIndirect, group_height) == offsetof(Compute::DispatchIndirect, group_height));
	TS_STATIC_ASSERT(offsetof(TSComputeDispatchIndirect, group_depth) == offsetof(Compute::DispatchIndirect, group_depth));
	TS_STATIC_ASSERT(offsetof(TSComputeDispatchIndirect, padding) == offsetof(Compute::DispatchIndirect, padding));
	
	// Tellusim::Query
	TS_STATIC_ASSERT(sizeof(TSQueryStatistics) == sizeof(Query::Statistics));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, num_vertices) == offsetof(Query::Statistics, num_vertices));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, num_primitives) == offsetof(Query::Statistics, num_primitives));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, vertex_invocations) == offsetof(Query::Statistics, vertex_invocations));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, control_invocations) == offsetof(Query::Statistics, control_invocations));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, evaluate_invocations) == offsetof(Query::Statistics, evaluate_invocations));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, geometry_invocations) == offsetof(Query::Statistics, geometry_invocations));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, geometry_primitives) == offsetof(Query::Statistics, geometry_primitives));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, fragment_invocations) == offsetof(Query::Statistics, fragment_invocations));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, compute_invocations) == offsetof(Query::Statistics, compute_invocations));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, clipping_invocations) == offsetof(Query::Statistics, clipping_invocations));
	TS_STATIC_ASSERT(offsetof(TSQueryStatistics, clipping_primitives) == offsetof(Query::Statistics, clipping_primitives));
	
	// Tellusim::Tracing
	TS_STATIC_ASSERT(sizeof(TSTracingInstance) == sizeof(Tracing::Instance));
	TS_STATIC_ASSERT(offsetof(TSTracingInstance, transform) == offsetof(Tracing::Instance, transform));
	TS_STATIC_ASSERT(offsetof(TSTracingInstance, data) == offsetof(Tracing::Instance, data));
	TS_STATIC_ASSERT(offsetof(TSTracingInstance, mask) == offsetof(Tracing::Instance, mask));
	TS_STATIC_ASSERT(offsetof(TSTracingInstance, flags) == offsetof(Tracing::Instance, flags));
	TS_STATIC_ASSERT(offsetof(TSTracingInstance, offset) == offsetof(Tracing::Instance, offset));
	TS_STATIC_ASSERT(offsetof(TSTracingInstance, tracing) == offsetof(Tracing::Instance, tracing));
	TS_STATIC_ASSERT(sizeof(TSTracingBuildIndirect) == sizeof(Tracing::BuildIndirect));
	TS_STATIC_ASSERT(offsetof(TSTracingBuildIndirect, num_primitives) == offsetof(Tracing::BuildIndirect, num_primitives));
	TS_STATIC_ASSERT(offsetof(TSTracingBuildIndirect, base_primitive) == offsetof(Tracing::BuildIndirect, base_primitive));
	TS_STATIC_ASSERT(offsetof(TSTracingBuildIndirect, base_vertex) == offsetof(Tracing::BuildIndirect, base_vertex));
	TS_STATIC_ASSERT(offsetof(TSTracingBuildIndirect, base_transform) == offsetof(Tracing::BuildIndirect, base_transform));
	
	// Tellusim::Device
	TS_STATIC_ASSERT(sizeof(TSDeviceFeatures) == sizeof(Device::Features));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, threadAccess) == offsetof(Device::Features, threadAccess));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, sparseBuffer) == offsetof(Device::Features, sparseBuffer));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, bufferTable) == offsetof(Device::Features, bufferTable));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, sparseTexture) == offsetof(Device::Features, sparseTexture));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, sparseArrayTexture) == offsetof(Device::Features, sparseArrayTexture));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, cubeArrayTexture) == offsetof(Device::Features, cubeArrayTexture));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, textureTable) == offsetof(Device::Features, textureTable));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, baseInstanceIndex) == offsetof(Device::Features, baseInstanceIndex));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, drawIndirectIndex) == offsetof(Device::Features, drawIndirectIndex));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, drawIndirectCount) == offsetof(Device::Features, drawIndirectCount));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, taskIndirectCount) == offsetof(Device::Features, taskIndirectCount));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, vertexStorage) == offsetof(Device::Features, vertexStorage));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, vertexIndexLayer) == offsetof(Device::Features, vertexIndexLayer));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, geometryPassthrough) == offsetof(Device::Features, geometryPassthrough));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, fragmentBarycentric) == offsetof(Device::Features, fragmentBarycentric));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, fragmentStencilExport) == offsetof(Device::Features, fragmentStencilExport));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, dualSourceBlending) == offsetof(Device::Features, dualSourceBlending));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, depthRangeOneToOne) == offsetof(Device::Features, depthRangeOneToOne));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, conservativeRaster) == offsetof(Device::Features, conservativeRaster));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, conditionalRendering) == offsetof(Device::Features, conditionalRendering));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, rayTracing) == offsetof(Device::Features, rayTracing));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, computeTracing) == offsetof(Device::Features, computeTracing));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, fragmentTracing) == offsetof(Device::Features, fragmentTracing));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, indirectTracing) == offsetof(Device::Features, indirectTracing));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, recursionDepth) == offsetof(Device::Features, recursionDepth));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, subgroupVote) == offsetof(Device::Features, subgroupVote));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, subgroupMath) == offsetof(Device::Features, subgroupMath));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, subgroupShuffle) == offsetof(Device::Features, subgroupShuffle));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, subgroupSize) == offsetof(Device::Features, subgroupSize));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, minSubgroupSize) == offsetof(Device::Features, minSubgroupSize));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxSubgroupSize) == offsetof(Device::Features, maxSubgroupSize));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, shaderu8) == offsetof(Device::Features, shaderu8));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, shaderf16) == offsetof(Device::Features, shaderf16));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, shaderu16) == offsetof(Device::Features, shaderu16));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, shaderf64) == offsetof(Device::Features, shaderf64));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, shaderu64) == offsetof(Device::Features, shaderu64));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, atomicGroupf32) == offsetof(Device::Features, atomicGroupf32));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, atomicGroupu64) == offsetof(Device::Features, atomicGroupu64));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, atomicBufferf32) == offsetof(Device::Features, atomicBufferf32));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, atomicBufferu64) == offsetof(Device::Features, atomicBufferu64));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, atomicTexturef32) == offsetof(Device::Features, atomicTexturef32));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, atomicTextureu32) == offsetof(Device::Features, atomicTextureu32));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, atomicTextureu64) == offsetof(Device::Features, atomicTextureu64));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, matrix16f16) == offsetof(Device::Features, matrix16f16));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, matrix16x8x8f16) == offsetof(Device::Features, matrix16x8x8f16));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, matrix16x8x16f16) == offsetof(Device::Features, matrix16x8x16f16));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, matrix16f16f32) == offsetof(Device::Features, matrix16f16f32));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, matrix16x8x8f16f32) == offsetof(Device::Features, matrix16x8x8f16f32));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, matrix16x8x16f16f32) == offsetof(Device::Features, matrix16x8x16f16f32));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, uniformAlignment) == offsetof(Device::Features, uniformAlignment));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, storageAlignment) == offsetof(Device::Features, storageAlignment));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxTextureSamples) == offsetof(Device::Features, maxTextureSamples));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxTexture2DSize) == offsetof(Device::Features, maxTexture2DSize));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxTexture3DSize) == offsetof(Device::Features, maxTexture3DSize));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxTextureLayers) == offsetof(Device::Features, maxTextureLayers));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxGroupSizeX) == offsetof(Device::Features, maxGroupSizeX));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxGroupSizeY) == offsetof(Device::Features, maxGroupSizeY));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxGroupSizeZ) == offsetof(Device::Features, maxGroupSizeZ));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxGroupCountX) == offsetof(Device::Features, maxGroupCountX));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxGroupCountY) == offsetof(Device::Features, maxGroupCountY));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxGroupCountZ) == offsetof(Device::Features, maxGroupCountZ));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxTaskCount) == offsetof(Device::Features, maxTaskCount));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxTaskMemory) == offsetof(Device::Features, maxTaskMemory));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxTaskMeshes) == offsetof(Device::Features, maxTaskMeshes));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxMeshMemory) == offsetof(Device::Features, maxMeshMemory));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxMeshVertices) == offsetof(Device::Features, maxMeshVertices));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxMeshPrimitives) == offsetof(Device::Features, maxMeshPrimitives));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxViewportCount) == offsetof(Device::Features, maxViewportCount));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxClipCullCount) == offsetof(Device::Features, maxClipCullCount));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxUniformSize) == offsetof(Device::Features, maxUniformSize));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, maxStorageSize) == offsetof(Device::Features, maxStorageSize));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, groupMemory) == offsetof(Device::Features, groupMemory));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, videoMemory) == offsetof(Device::Features, videoMemory));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, vendorID) == offsetof(Device::Features, vendorID));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, deviceID) == offsetof(Device::Features, deviceID));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, pciBusID) == offsetof(Device::Features, pciBusID));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, pciDomainID) == offsetof(Device::Features, pciDomainID));
	TS_STATIC_ASSERT(offsetof(TSDeviceFeatures, pciDeviceID) == offsetof(Device::Features, pciDeviceID));
	
	// Tellusim::PrefixScan
	TS_STATIC_ASSERT(sizeof(TSPrefixScanDispatchParameters) == sizeof(PrefixScan::DispatchParameters));
	TS_STATIC_ASSERT(offsetof(TSPrefixScanDispatchParameters, offset) == offsetof(PrefixScan::DispatchParameters, offset));
	TS_STATIC_ASSERT(offsetof(TSPrefixScanDispatchParameters, size) == offsetof(PrefixScan::DispatchParameters, size));
	TS_STATIC_ASSERT(offsetof(TSPrefixScanDispatchParameters, padding_0) == offsetof(PrefixScan::DispatchParameters, padding_0));
	TS_STATIC_ASSERT(offsetof(TSPrefixScanDispatchParameters, padding_1) == offsetof(PrefixScan::DispatchParameters, padding_1));
	
	// Tellusim::RadixSort
	TS_STATIC_ASSERT(sizeof(TSRadixSortDispatchParameters) == sizeof(RadixSort::DispatchParameters));
	TS_STATIC_ASSERT(offsetof(TSRadixSortDispatchParameters, keys_offset) == offsetof(RadixSort::DispatchParameters, keys_offset));
	TS_STATIC_ASSERT(offsetof(TSRadixSortDispatchParameters, data_offset) == offsetof(RadixSort::DispatchParameters, data_offset));
	TS_STATIC_ASSERT(offsetof(TSRadixSortDispatchParameters, size) == offsetof(RadixSort::DispatchParameters, size));
	TS_STATIC_ASSERT(offsetof(TSRadixSortDispatchParameters, padding) == offsetof(RadixSort::DispatchParameters, padding));
	
	// Tellusim::BitonicSort
	TS_STATIC_ASSERT(sizeof(TSBitonicSortDispatchParameters) == sizeof(BitonicSort::DispatchParameters));
	TS_STATIC_ASSERT(offsetof(TSBitonicSortDispatchParameters, keys_offset) == offsetof(BitonicSort::DispatchParameters, keys_offset));
	TS_STATIC_ASSERT(offsetof(TSBitonicSortDispatchParameters, data_offset) == offsetof(BitonicSort::DispatchParameters, data_offset));
	TS_STATIC_ASSERT(offsetof(TSBitonicSortDispatchParameters, size) == offsetof(BitonicSort::DispatchParameters, size));
	TS_STATIC_ASSERT(offsetof(TSBitonicSortDispatchParameters, padding) == offsetof(BitonicSort::DispatchParameters, padding));
	
	// Tellusim::SpatialGrid
	TS_STATIC_ASSERT(sizeof(TSSpatialGridDispatchParameters) == sizeof(SpatialGrid::DispatchParameters));
	TS_STATIC_ASSERT(offsetof(TSSpatialGridDispatchParameters, offset) == offsetof(SpatialGrid::DispatchParameters, offset));
	TS_STATIC_ASSERT(offsetof(TSSpatialGridDispatchParameters, size) == offsetof(SpatialGrid::DispatchParameters, size));
	TS_STATIC_ASSERT(offsetof(TSSpatialGridDispatchParameters, padding_0) == offsetof(SpatialGrid::DispatchParameters, padding_0));
	TS_STATIC_ASSERT(offsetof(TSSpatialGridDispatchParameters, padding_1) == offsetof(SpatialGrid::DispatchParameters, padding_1));
	
	// Tellusim::SpatialTree
	TS_STATIC_ASSERT(sizeof(TSSpatialTreeNode) == sizeof(SpatialTree::Node));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeNode, bound_min) == offsetof(SpatialTree::Node, bound_min));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeNode, is_enabled) == offsetof(SpatialTree::Node, is_enabled));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeNode, bound_max) == offsetof(SpatialTree::Node, bound_max));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeNode, data) == offsetof(SpatialTree::Node, data));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeNode, left) == offsetof(SpatialTree::Node, left));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeNode, right) == offsetof(SpatialTree::Node, right));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeNode, parent) == offsetof(SpatialTree::Node, parent));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeNode, spatial) == offsetof(SpatialTree::Node, spatial));
	TS_STATIC_ASSERT(sizeof(TSSpatialTreeDispatchParameters) == sizeof(SpatialTree::DispatchParameters));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeDispatchParameters, offset) == offsetof(SpatialTree::DispatchParameters, offset));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeDispatchParameters, size) == offsetof(SpatialTree::DispatchParameters, size));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeDispatchParameters, padding_0) == offsetof(SpatialTree::DispatchParameters, padding_0));
	TS_STATIC_ASSERT(offsetof(TSSpatialTreeDispatchParameters, padding_1) == offsetof(SpatialTree::DispatchParameters, padding_1));

	// Tellusim::Window
	static void TSWindowMousePressedCallback_func(Window::Button button, id<TSWindowMousePressedCallback> func) {
		[func run: (TS_WindowButton)button];
	}
	static Window::MousePressedCallback makeTSWindowMousePressedCallback(id<TSWindowMousePressedCallback> func) {
		auto ret = makeFunction(TSWindowMousePressedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSWindowMouseReleasedCallback_func(Window::Button button, id<TSWindowMouseReleasedCallback> func) {
		[func run: (TS_WindowButton)button];
	}
	static Window::MouseReleasedCallback makeTSWindowMouseReleasedCallback(id<TSWindowMouseReleasedCallback> func) {
		auto ret = makeFunction(TSWindowMouseReleasedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSWindowMouseChangedCallback_func(int32_t x, int32_t y, id<TSWindowMouseChangedCallback> func) {
		[func run: x y:y];
	}
	static Window::MouseChangedCallback makeTSWindowMouseChangedCallback(id<TSWindowMouseChangedCallback> func) {
		auto ret = makeFunction(TSWindowMouseChangedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static void TSWindowMouseRotatedCallback_func(Window::Axis axis, float32_t delta, id<TSWindowMouseRotatedCallback> func) {
		[func run: (TS_WindowAxis)axis delta:delta];
	}
	static Window::MouseRotatedCallback makeTSWindowMouseRotatedCallback(id<TSWindowMouseRotatedCallback> func) {
		auto ret = makeFunction(TSWindowMouseRotatedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static void TSWindowTouchChangedCallback_func(id<TSWindowTouchChangedCallback> func) {
		[func run];
	}
	static Window::TouchChangedCallback makeTSWindowTouchChangedCallback(id<TSWindowTouchChangedCallback> func) {
		auto ret = makeFunction(TSWindowTouchChangedCallback_func);
		ret.setArg0(func);
		return ret;
	}
	static void TSWindowKeyboardPressedCallback_func(uint32_t key, uint32_t code, id<TSWindowKeyboardPressedCallback> func) {
		[func run: key code:code];
	}
	static Window::KeyboardPressedCallback makeTSWindowKeyboardPressedCallback(id<TSWindowKeyboardPressedCallback> func) {
		auto ret = makeFunction(TSWindowKeyboardPressedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static void TSWindowKeyboardReleasedCallback_func(uint32_t key, id<TSWindowKeyboardReleasedCallback> func) {
		[func run: key];
	}
	static Window::KeyboardReleasedCallback makeTSWindowKeyboardReleasedCallback(id<TSWindowKeyboardReleasedCallback> func) {
		auto ret = makeFunction(TSWindowKeyboardReleasedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSWindowSizeChangedCallback_func(uint32_t width, uint32_t height, id<TSWindowSizeChangedCallback> func) {
		[func run: width height:height];
	}
	static Window::SizeChangedCallback makeTSWindowSizeChangedCallback(id<TSWindowSizeChangedCallback> func) {
		auto ret = makeFunction(TSWindowSizeChangedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static void TSWindowFocusChangedCallback_func(bool changed, id<TSWindowFocusChangedCallback> func) {
		[func run: changed];
	}
	static Window::FocusChangedCallback makeTSWindowFocusChangedCallback(id<TSWindowFocusChangedCallback> func) {
		auto ret = makeFunction(TSWindowFocusChangedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSWindowCloseClickedCallback_func(id<TSWindowCloseClickedCallback> func) {
		[func run];
	}
	static Window::CloseClickedCallback makeTSWindowCloseClickedCallback(id<TSWindowCloseClickedCallback> func) {
		auto ret = makeFunction(TSWindowCloseClickedCallback_func);
		ret.setArg0(func);
		return ret;
	}
	static void TSWindowPauseChangedCallback_func(bool paused, id<TSWindowPauseChangedCallback> func) {
		[func run: paused];
	}
	static Window::PauseChangedCallback makeTSWindowPauseChangedCallback(id<TSWindowPauseChangedCallback> func) {
		auto ret = makeFunction(TSWindowPauseChangedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSWindowFileDroppedCallback_func(const char *name, uint32_t remain, id<TSWindowFileDroppedCallback> func) {
		[func run: [NSString stringWithUTF8String:name] remain:remain];
	}
	static Window::FileDroppedCallback makeTSWindowFileDroppedCallback(id<TSWindowFileDroppedCallback> func) {
		auto ret = makeFunction(TSWindowFileDroppedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static void TSWindowUpdateCallback_func(id<TSWindowUpdateCallback> func) {
		[func run];
	}
	static Window::UpdateCallback makeTSWindowUpdateCallback(id<TSWindowUpdateCallback> func) {
		auto ret = makeFunction(TSWindowUpdateCallback_func);
		ret.setArg0(func);
		return ret;
	}
	static void TSWindowPresentCallback_func(id<TSWindowPresentCallback> func) {
		[func run];
	}
	static Window::PresentCallback makeTSWindowPresentCallback(id<TSWindowPresentCallback> func) {
		auto ret = makeFunction(TSWindowPresentCallback_func);
		ret.setArg0(func);
		return ret;
	}
	static bool TSWindowMainLoopCallback_func(id<TSWindowMainLoopCallback> func) {
		return (bool)[func run];
	}
	static Window::MainLoopCallback makeTSWindowMainLoopCallback(id<TSWindowMainLoopCallback> func) {
		auto ret = makeFunction(TSWindowMainLoopCallback_func);
		ret.setArg0(func);
		return ret;
	}

	// Tellusim::CanvasElement
	static bool TSCanvasElementDrawCallback_func(Command command, CanvasElement element, id<TSCanvasElementDrawCallback> func) {
		return (bool)[func run: [[TSCommand alloc] init_ref:(command)] element:[[TSCanvasElement alloc] init_ref:(element)]];
	}
	static CanvasElement::DrawCallback makeTSCanvasElementDrawCallback(id<TSCanvasElementDrawCallback> func) {
		auto ret = makeFunction(TSCanvasElementDrawCallback_func);
		ret.setArg2(func);
		return ret;
	}

	// Tellusim::Canvas
	static bool TSCanvasCreateCallback_func(const Device device, Canvas canvas, uint32_t scale, id<TSCanvasCreateCallback> func) {
		return (bool)[func run: [[TSDevice alloc] init_ref:(device)] canvas:[[TSCanvas alloc] init_ref:(canvas)] scale:scale];
	}
	static Canvas::CreateCallback makeTSCanvasCreateCallback(id<TSCanvasCreateCallback> func) {
		auto ret = makeFunction(TSCanvasCreateCallback_func);
		ret.setArg3(func);
		return ret;
	}
	static bool TSCanvasPipelineCallback_func(Pipeline pipeline, Canvas canvas, CanvasElement element, id<TSCanvasPipelineCallback> func) {
		return (bool)[func run: [[TSPipeline alloc] init_ref:(pipeline)] canvas:[[TSCanvas alloc] init_ref:(canvas)] element:[[TSCanvasElement alloc] init_ref:(element)]];
	}
	static Canvas::PipelineCallback makeTSCanvasPipelineCallback(id<TSCanvasPipelineCallback> func) {
		auto ret = makeFunction(TSCanvasPipelineCallback_func);
		ret.setArg3(func);
		return ret;
	}
	static bool TSCanvasBeginCallback_func(Command command, Canvas canvas, id<TSCanvasBeginCallback> func) {
		return (bool)[func run: [[TSCommand alloc] init_ref:(command)] canvas:[[TSCanvas alloc] init_ref:(canvas)]];
	}
	static Canvas::BeginCallback makeTSCanvasBeginCallback(id<TSCanvasBeginCallback> func) {
		auto ret = makeFunction(TSCanvasBeginCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static bool TSCanvasDrawCallback_func(Command command, Canvas canvas, id<TSCanvasDrawCallback> func) {
		return (bool)[func run: [[TSCommand alloc] init_ref:(command)] canvas:[[TSCanvas alloc] init_ref:(canvas)]];
	}
	static Canvas::DrawCallback makeTSCanvasDrawCallback(id<TSCanvasDrawCallback> func) {
		auto ret = makeFunction(TSCanvasDrawCallback_func);
		ret.setArg2(func);
		return ret;
	}

	// Tellusim::ControlRoot
	static void TSControlRootCopyCallback_func(ControlRoot a0, const char *text, id<TSControlRootCopyCallback> func) {
		[func run: [[TSControlRoot alloc] init_ref:(a0)] text:[NSString stringWithUTF8String:text]];
	}
	static ControlRoot::CopyCallback makeTSControlRootCopyCallback(id<TSControlRootCopyCallback> func) {
		auto ret = makeFunction(TSControlRootCopyCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static String TSControlRootPasteCallback_func(ControlRoot a0, id<TSControlRootPasteCallback> func) {
		return String([[func run: [[TSControlRoot alloc] init_ref:(a0)]] UTF8String]);
	}
	static ControlRoot::PasteCallback makeTSControlRootPasteCallback(id<TSControlRootPasteCallback> func) {
		auto ret = makeFunction(TSControlRootPasteCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlRect
	static void TSControlRectPressedCallback_func(ControlRect a0, float32_t x, float32_t y, id<TSControlRectPressedCallback> func) {
		[func run: [[TSControlRect alloc] init_ref:(a0)] x:x y:y];
	}
	static ControlRect::PressedCallback makeTSControlRectPressedCallback(id<TSControlRectPressedCallback> func) {
		auto ret = makeFunction(TSControlRectPressedCallback_func);
		ret.setArg3(func);
		return ret;
	}
	static void TSControlRectReleasedCallback_func(ControlRect a0, float32_t x, float32_t y, id<TSControlRectReleasedCallback> func) {
		[func run: [[TSControlRect alloc] init_ref:(a0)] x:x y:y];
	}
	static ControlRect::ReleasedCallback makeTSControlRectReleasedCallback(id<TSControlRectReleasedCallback> func) {
		auto ret = makeFunction(TSControlRectReleasedCallback_func);
		ret.setArg3(func);
		return ret;
	}
	static void TSControlRectClickedCallback_func(ControlRect a0, id<TSControlRectClickedCallback> func) {
		[func run: [[TSControlRect alloc] init_ref:(a0)]];
	}
	static ControlRect::ClickedCallback makeTSControlRectClickedCallback(id<TSControlRectClickedCallback> func) {
		auto ret = makeFunction(TSControlRectClickedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlGroup
	static void TSControlGroupClickedCallback_func(ControlGroup a0, id<TSControlGroupClickedCallback> func) {
		[func run: [[TSControlGroup alloc] init_ref:(a0)]];
	}
	static ControlGroup::ClickedCallback makeTSControlGroupClickedCallback(id<TSControlGroupClickedCallback> func) {
		auto ret = makeFunction(TSControlGroupClickedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlDialog
	static void TSControlDialogUpdatedCallback_func(ControlDialog a0, id<TSControlDialogUpdatedCallback> func) {
		[func run: [[TSControlDialog alloc] init_ref:(a0)]];
	}
	static ControlDialog::UpdatedCallback makeTSControlDialogUpdatedCallback(id<TSControlDialogUpdatedCallback> func) {
		auto ret = makeFunction(TSControlDialogUpdatedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlCheck
	static void TSControlCheckClickedCallback_func(ControlCheck a0, id<TSControlCheckClickedCallback> func) {
		[func run: [[TSControlCheck alloc] init_ref:(a0)]];
	}
	static ControlCheck::ClickedCallback makeTSControlCheckClickedCallback(id<TSControlCheckClickedCallback> func) {
		auto ret = makeFunction(TSControlCheckClickedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlCombo
	static void TSControlComboClickedCallback_func(ControlCombo a0, id<TSControlComboClickedCallback> func) {
		[func run: [[TSControlCombo alloc] init_ref:(a0)]];
	}
	static ControlCombo::ClickedCallback makeTSControlComboClickedCallback(id<TSControlComboClickedCallback> func) {
		auto ret = makeFunction(TSControlComboClickedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSControlComboChangedCallback_func(ControlCombo a0, id<TSControlComboChangedCallback> func) {
		[func run: [[TSControlCombo alloc] init_ref:(a0)]];
	}
	static ControlCombo::ChangedCallback makeTSControlComboChangedCallback(id<TSControlComboChangedCallback> func) {
		auto ret = makeFunction(TSControlComboChangedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlButton
	static void TSControlButtonPressedCallback_func(ControlButton a0, float32_t x, float32_t y, id<TSControlButtonPressedCallback> func) {
		[func run: [[TSControlButton alloc] init_ref:(a0)] x:x y:y];
	}
	static ControlButton::PressedCallback makeTSControlButtonPressedCallback(id<TSControlButtonPressedCallback> func) {
		auto ret = makeFunction(TSControlButtonPressedCallback_func);
		ret.setArg3(func);
		return ret;
	}
	static void TSControlButtonReleasedCallback_func(ControlButton a0, float32_t x, float32_t y, id<TSControlButtonReleasedCallback> func) {
		[func run: [[TSControlButton alloc] init_ref:(a0)] x:x y:y];
	}
	static ControlButton::ReleasedCallback makeTSControlButtonReleasedCallback(id<TSControlButtonReleasedCallback> func) {
		auto ret = makeFunction(TSControlButtonReleasedCallback_func);
		ret.setArg3(func);
		return ret;
	}
	static void TSControlButtonClickedCallback_func(ControlButton a0, id<TSControlButtonClickedCallback> func) {
		[func run: [[TSControlButton alloc] init_ref:(a0)]];
	}
	static ControlButton::ClickedCallback makeTSControlButtonClickedCallback(id<TSControlButtonClickedCallback> func) {
		auto ret = makeFunction(TSControlButtonClickedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlSlider
	static String TSControlSliderFormatCallback_func(ControlSlider a0, id<TSControlSliderFormatCallback> func) {
		return String([[func run: [[TSControlSlider alloc] init_ref:(a0)]] UTF8String]);
	}
	static ControlSlider::FormatCallback makeTSControlSliderFormatCallback(id<TSControlSliderFormatCallback> func) {
		auto ret = makeFunction(TSControlSliderFormatCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSControlSliderReleasedCallback_func(ControlSlider a0, id<TSControlSliderReleasedCallback> func) {
		[func run: [[TSControlSlider alloc] init_ref:(a0)]];
	}
	static ControlSlider::ReleasedCallback makeTSControlSliderReleasedCallback(id<TSControlSliderReleasedCallback> func) {
		auto ret = makeFunction(TSControlSliderReleasedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSControlSliderClickedCallback_func(ControlSlider a0, id<TSControlSliderClickedCallback> func) {
		[func run: [[TSControlSlider alloc] init_ref:(a0)]];
	}
	static ControlSlider::ClickedCallback makeTSControlSliderClickedCallback(id<TSControlSliderClickedCallback> func) {
		auto ret = makeFunction(TSControlSliderClickedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSControlSliderChangedCallback_func(ControlSlider a0, id<TSControlSliderChangedCallback> func) {
		[func run: [[TSControlSlider alloc] init_ref:(a0)]];
	}
	static ControlSlider::ChangedCallback makeTSControlSliderChangedCallback(id<TSControlSliderChangedCallback> func) {
		auto ret = makeFunction(TSControlSliderChangedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlScroll
	static void TSControlScrollClickedCallback_func(ControlScroll a0, id<TSControlScrollClickedCallback> func) {
		[func run: [[TSControlScroll alloc] init_ref:(a0)]];
	}
	static ControlScroll::ClickedCallback makeTSControlScrollClickedCallback(id<TSControlScrollClickedCallback> func) {
		auto ret = makeFunction(TSControlScrollClickedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSControlScrollChangedCallback_func(ControlScroll a0, id<TSControlScrollChangedCallback> func) {
		[func run: [[TSControlScroll alloc] init_ref:(a0)]];
	}
	static ControlScroll::ChangedCallback makeTSControlScrollChangedCallback(id<TSControlScrollChangedCallback> func) {
		auto ret = makeFunction(TSControlScrollChangedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlTree
	static void TSControlTreeChangedCallback_func(ControlTree a0, uint32_t item, id<TSControlTreeChangedCallback> func) {
		[func run: [[TSControlTree alloc] init_ref:(a0)] item:item];
	}
	static ControlTree::ChangedCallback makeTSControlTreeChangedCallback(id<TSControlTreeChangedCallback> func) {
		auto ret = makeFunction(TSControlTreeChangedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static bool TSControlTreeDraggedCallback_func(ControlTree a0, uint32_t item, id<TSControlTreeDraggedCallback> func) {
		return (bool)[func run: [[TSControlTree alloc] init_ref:(a0)] item:item];
	}
	static ControlTree::DraggedCallback makeTSControlTreeDraggedCallback(id<TSControlTreeDraggedCallback> func) {
		auto ret = makeFunction(TSControlTreeDraggedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static void TSControlTreeDroppedCallback_func(ControlTree a0, uint32_t item, id<TSControlTreeDroppedCallback> func) {
		[func run: [[TSControlTree alloc] init_ref:(a0)] item:item];
	}
	static ControlTree::DroppedCallback makeTSControlTreeDroppedCallback(id<TSControlTreeDroppedCallback> func) {
		auto ret = makeFunction(TSControlTreeDroppedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static void TSControlTreeClickedCallback_func(ControlTree a0, uint32_t item, id<TSControlTreeClickedCallback> func) {
		[func run: [[TSControlTree alloc] init_ref:(a0)] item:item];
	}
	static ControlTree::ClickedCallback makeTSControlTreeClickedCallback(id<TSControlTreeClickedCallback> func) {
		auto ret = makeFunction(TSControlTreeClickedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static void TSControlTreeExpandedCallback_func(ControlTree a0, uint32_t item, id<TSControlTreeExpandedCallback> func) {
		[func run: [[TSControlTree alloc] init_ref:(a0)] item:item];
	}
	static ControlTree::ExpandedCallback makeTSControlTreeExpandedCallback(id<TSControlTreeExpandedCallback> func) {
		auto ret = makeFunction(TSControlTreeExpandedCallback_func);
		ret.setArg2(func);
		return ret;
	}
	static void TSControlTreeSelectedCallback_func(ControlTree a0, id<TSControlTreeSelectedCallback> func) {
		[func run: [[TSControlTree alloc] init_ref:(a0)]];
	}
	static ControlTree::SelectedCallback makeTSControlTreeSelectedCallback(id<TSControlTreeSelectedCallback> func) {
		auto ret = makeFunction(TSControlTreeSelectedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::ControlEdit
	static void TSControlEditClickedCallback_func(ControlEdit a0, id<TSControlEditClickedCallback> func) {
		[func run: [[TSControlEdit alloc] init_ref:(a0)]];
	}
	static ControlEdit::ClickedCallback makeTSControlEditClickedCallback(id<TSControlEditClickedCallback> func) {
		auto ret = makeFunction(TSControlEditClickedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSControlEditChangedCallback_func(ControlEdit a0, id<TSControlEditChangedCallback> func) {
		[func run: [[TSControlEdit alloc] init_ref:(a0)]];
	}
	static ControlEdit::ChangedCallback makeTSControlEditChangedCallback(id<TSControlEditChangedCallback> func) {
		auto ret = makeFunction(TSControlEditChangedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static void TSControlEditReturnedCallback_func(ControlEdit a0, id<TSControlEditReturnedCallback> func) {
		[func run: [[TSControlEdit alloc] init_ref:(a0)]];
	}
	static ControlEdit::ReturnedCallback makeTSControlEditReturnedCallback(id<TSControlEditReturnedCallback> func) {
		auto ret = makeFunction(TSControlEditReturnedCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::DialogMessage
	static bool TSDialogMessageUpdateCallback_func(id<TSDialogMessageUpdateCallback> func) {
		return (bool)[func run];
	}
	static DialogMessage::UpdateCallback makeTSDialogMessageUpdateCallback(id<TSDialogMessageUpdateCallback> func) {
		auto ret = makeFunction(TSDialogMessageUpdateCallback_func);
		ret.setArg0(func);
		return ret;
	}

	// Tellusim::DialogFileOpen
	static bool TSDialogFileOpenUpdateCallback_func(id<TSDialogFileOpenUpdateCallback> func) {
		return (bool)[func run];
	}
	static DialogFileOpen::UpdateCallback makeTSDialogFileOpenUpdateCallback(id<TSDialogFileOpenUpdateCallback> func) {
		auto ret = makeFunction(TSDialogFileOpenUpdateCallback_func);
		ret.setArg0(func);
		return ret;
	}

	// Tellusim::DialogFileSave
	static bool TSDialogFileSaveUpdateCallback_func(id<TSDialogFileSaveUpdateCallback> func) {
		return (bool)[func run];
	}
	static DialogFileSave::UpdateCallback makeTSDialogFileSaveUpdateCallback(id<TSDialogFileSaveUpdateCallback> func) {
		auto ret = makeFunction(TSDialogFileSaveUpdateCallback_func);
		ret.setArg0(func);
		return ret;
	}

	// Tellusim::DialogDirectory
	static bool TSDialogDirectoryUpdateCallback_func(id<TSDialogDirectoryUpdateCallback> func) {
		return (bool)[func run];
	}
	static DialogDirectory::UpdateCallback makeTSDialogDirectoryUpdateCallback(id<TSDialogDirectoryUpdateCallback> func) {
		auto ret = makeFunction(TSDialogDirectoryUpdateCallback_func);
		ret.setArg0(func);
		return ret;
	}

	// Tellusim::DialogColor
	static void TSDialogColorChangedCallback_func(Color a0, id<TSDialogColorChangedCallback> func) {
		[func run: *(TSColor*)&a0];
	}
	static DialogColor::ChangedCallback makeTSDialogColorChangedCallback(id<TSDialogColorChangedCallback> func) {
		auto ret = makeFunction(TSDialogColorChangedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static bool TSDialogColorUpdateCallback_func(id<TSDialogColorUpdateCallback> func) {
		return (bool)[func run];
	}
	static DialogColor::UpdateCallback makeTSDialogColorUpdateCallback(id<TSDialogColorUpdateCallback> func) {
		auto ret = makeFunction(TSDialogColorUpdateCallback_func);
		ret.setArg0(func);
		return ret;
	}

	// Tellusim::DialogMenu
	static void TSDialogMenuClickedCallback_func(id<TSDialogMenuClickedCallback> func) {
		[func run];
	}
	static DialogMenu::ClickedCallback makeTSDialogMenuClickedCallback(id<TSDialogMenuClickedCallback> func) {
		auto ret = makeFunction(TSDialogMenuClickedCallback_func);
		ret.setArg0(func);
		return ret;
	}
	static void TSDialogMenuChangedCallback_func(bool a0, id<TSDialogMenuChangedCallback> func) {
		[func run: a0];
	}
	static DialogMenu::ChangedCallback makeTSDialogMenuChangedCallback(id<TSDialogMenuChangedCallback> func) {
		auto ret = makeFunction(TSDialogMenuChangedCallback_func);
		ret.setArg1(func);
		return ret;
	}
	static bool TSDialogMenuUpdateCallback_func(id<TSDialogMenuUpdateCallback> func) {
		return (bool)[func run];
	}
	static DialogMenu::UpdateCallback makeTSDialogMenuUpdateCallback(id<TSDialogMenuUpdateCallback> func) {
		auto ret = makeFunction(TSDialogMenuUpdateCallback_func);
		ret.setArg0(func);
		return ret;
	}

	// Tellusim::MeshModel
	static bool TSMeshModelCreateCallback_func(const void *src, size_t size, bool owner, id<TSMeshModelCreateCallback> func) {
		return (bool)[func run: src size:size owner:owner];
	}
	static MeshModel::CreateCallback makeTSMeshModelCreateCallback(id<TSMeshModelCreateCallback> func) {
		auto ret = makeFunction(TSMeshModelCreateCallback_func);
		ret.setArg3(func);
		return ret;
	}

	// Tellusim::MeshGraph
	static bool TSMeshGraphProgressCallback_func(uint32_t progress, id<TSMeshGraphProgressCallback> func) {
		return (bool)[func run: progress];
	}
	static MeshGraph::ProgressCallback makeTSMeshGraphProgressCallback(id<TSMeshGraphProgressCallback> func) {
		auto ret = makeFunction(TSMeshGraphProgressCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::MeshReduce
	static bool TSMeshReduceProgressCallback_func(uint32_t progress, id<TSMeshReduceProgressCallback> func) {
		return (bool)[func run: progress];
	}
	static MeshReduce::ProgressCallback makeTSMeshReduceProgressCallback(id<TSMeshReduceProgressCallback> func) {
		auto ret = makeFunction(TSMeshReduceProgressCallback_func);
		ret.setArg1(func);
		return ret;
	}

	// Tellusim::MeshSolid
	static bool TSMeshSolidProgressCallback_func(uint32_t progress, id<TSMeshSolidProgressCallback> func) {
		return (bool)[func run: progress];
	}
	static MeshSolid::ProgressCallback makeTSMeshSolidProgressCallback(id<TSMeshSolidProgressCallback> func) {
		auto ret = makeFunction(TSMeshSolidProgressCallback_func);
		ret.setArg1(func);
		return ret;
	}
	
} /* namespace Tellusim */

/*
 */
extern "C" {

// Tellusim::String
@implementation TSString
	-(id)init {
		self = [super init];
		impl = new Tellusim::String();
		return self;
	}
	-(id)init_1: (uint32_t)size {
		self = [super init];
		impl = new Tellusim::String(size);
		return self;
	}
	-(id)init_1_: (uint32_t)size {
		self = [super init];
		impl = new Tellusim::String(size);
		return self;
	}
	-(id)init_2: (uint32_t)size c: (char)c {
		self = [super init];
		impl = new Tellusim::String(size, c);
		return self;
	}
	-(id)init_2_: (uint32_t)size c: (char)c {
		self = [super init];
		impl = new Tellusim::String(size, c);
		return self;
	}
	-(id)init_3: (const char*)str {
		self = [super init];
		impl = new Tellusim::String(str);
		return self;
	}
	-(id)init_3_: (const char*)str {
		self = [super init];
		impl = new Tellusim::String(str);
		return self;
	}
	-(id)init_4: (const char*)str length: (uint32_t)length {
		self = [super init];
		impl = new Tellusim::String(str, length);
		return self;
	}
	-(id)init_4_: (const char*)str length: (uint32_t)length {
		self = [super init];
		impl = new Tellusim::String(str, length);
		return self;
	}
	-(id)init_5: (const wchar_t*)str {
		self = [super init];
		impl = new Tellusim::String(str);
		return self;
	}
	-(id)init_5_: (const wchar_t*)str {
		self = [super init];
		impl = new Tellusim::String(str);
		return self;
	}
	-(id)init_6: (const wchar_t*)str length: (uint32_t)length {
		self = [super init];
		impl = new Tellusim::String(str, length);
		return self;
	}
	-(id)init_6_: (const wchar_t*)str length: (uint32_t)length {
		self = [super init];
		impl = new Tellusim::String(str, length);
		return self;
	}
	-(id)init_7: (const uint32_t*)str {
		self = [super init];
		impl = new Tellusim::String(str);
		return self;
	}
	-(id)init_7_: (const uint32_t*)str {
		self = [super init];
		impl = new Tellusim::String(str);
		return self;
	}
	-(id)init_8: (const uint32_t*)str length: (uint32_t)length {
		self = [super init];
		impl = new Tellusim::String(str, length);
		return self;
	}
	-(id)init_8_: (const uint32_t*)str length: (uint32_t)length {
		self = [super init];
		impl = new Tellusim::String(str, length);
		return self;
	}
	-(id)init_ptr: (Tellusim::String*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::String&)ref {
		self = [super init];
		impl = new Tellusim::String((Tellusim::String&)ref);
		return self;
	}
	-(Tellusim::String*)pointer {
		return (Tellusim::String*)impl;
	}
	-(Tellusim::String&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::String*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::String*)impl;
	}
	-(TSString*)reserve: (uint32_t)size {
		[self ref].reserve(size);
		return self;
	}
	-(TSString*)reserve_: (uint32_t)size {
		[self ref].reserve(size);
		return self;
	}
	-(TSString*)reserve_1: (uint32_t)size discard: (BOOL)discard {
		[self ref].reserve(size, (bool)discard);
		return self;
	}
	-(TSString*)reserve_1_: (uint32_t)size discard: (BOOL)discard {
		[self ref].reserve(size, (bool)discard);
		return self;
	}
	-(TSString*)resize: (uint32_t)size {
		[self ref].resize(size);
		return self;
	}
	-(TSString*)resize_: (uint32_t)size {
		[self ref].resize(size);
		return self;
	}
	-(TSString*)resize_1: (uint32_t)size c: (char)c {
		[self ref].resize(size, c);
		return self;
	}
	-(TSString*)resize_1_: (uint32_t)size c: (char)c {
		[self ref].resize(size, c);
		return self;
	}
	-(TSString*)resize_2: (uint32_t)size c: (char)c reserve: (BOOL)reserve {
		[self ref].resize(size, c, (bool)reserve);
		return self;
	}
	-(TSString*)resize_2_: (uint32_t)size c: (char)c reserve: (BOOL)reserve {
		[self ref].resize(size, c, (bool)reserve);
		return self;
	}
	-(void)release_ {
		[self ref].release();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(void)copy: (const char*)str {
		[self ref].copy(str);
	}
	-(void)copy_: (const char*)str {
		[self ref].copy(str);
	}
	-(void)copy_1: (const char*)str length: (uint32_t)length {
		[self ref].copy(str, length);
	}
	-(void)copy_1_: (const char*)str length: (uint32_t)length {
		[self ref].copy(str, length);
	}
	-(void)copy_2: (const wchar_t*)str {
		[self ref].copy(str);
	}
	-(void)copy_2_: (const wchar_t*)str {
		[self ref].copy(str);
	}
	-(void)copy_3: (const wchar_t*)str length: (uint32_t)length {
		[self ref].copy(str, length);
	}
	-(void)copy_3_: (const wchar_t*)str length: (uint32_t)length {
		[self ref].copy(str, length);
	}
	-(void)copy_4: (const uint32_t*)str {
		[self ref].copy(str);
	}
	-(void)copy_4_: (const uint32_t*)str {
		[self ref].copy(str);
	}
	-(void)copy_5: (const uint32_t*)str length: (uint32_t)length {
		[self ref].copy(str, length);
	}
	-(void)copy_5_: (const uint32_t*)str length: (uint32_t)length {
		[self ref].copy(str, length);
	}
	-(void)copy_6: (const TSString*)string {
		[self ref].copy((string) ? [string ref] : Tellusim::String::null);
	}
	-(void)copy_6_: (const TSString*)string {
		[self ref].copy((string) ? [string ref] : Tellusim::String::null);
	}
	-(void)copy_7: (const TSString*)string length: (uint32_t)length {
		[self ref].copy((string) ? [string ref] : Tellusim::String::null, length);
	}
	-(void)copy_7_: (const TSString*)string length: (uint32_t)length {
		[self ref].copy((string) ? [string ref] : Tellusim::String::null, length);
	}
	-(TSString*)append: (char)c {
		[self ref].append(c);
		return self;
	}
	-(TSString*)append_: (char)c {
		[self ref].append(c);
		return self;
	}
	-(TSString*)append_1: (const char*)str {
		[self ref].append(str);
		return self;
	}
	-(TSString*)append_1_: (const char*)str {
		[self ref].append(str);
		return self;
	}
	-(TSString*)append_2: (const char*)str length: (uint32_t)length {
		[self ref].append(str, length);
		return self;
	}
	-(TSString*)append_2_: (const char*)str length: (uint32_t)length {
		[self ref].append(str, length);
		return self;
	}
	-(TSString*)append_3: (const TSString*)string {
		[self ref].append((string) ? [string ref] : Tellusim::String::null);
		return self;
	}
	-(TSString*)append_3_: (const TSString*)string {
		[self ref].append((string) ? [string ref] : Tellusim::String::null);
		return self;
	}
	-(TSString*)append_4: (const TSString*)string length: (uint32_t)length {
		[self ref].append((string) ? [string ref] : Tellusim::String::null, length);
		return self;
	}
	-(TSString*)append_4_: (const TSString*)string length: (uint32_t)length {
		[self ref].append((string) ? [string ref] : Tellusim::String::null, length);
		return self;
	}
	-(TSString*)insert: (uint32_t)pos str: (const char*)str {
		[self ref].insert(pos, str);
		return self;
	}
	-(TSString*)insert_: (uint32_t)pos str: (const char*)str {
		[self ref].insert(pos, str);
		return self;
	}
	-(TSString*)insert_1: (uint32_t)pos str: (const char*)str length: (uint32_t)length {
		[self ref].insert(pos, str, length);
		return self;
	}
	-(TSString*)insert_1_: (uint32_t)pos str: (const char*)str length: (uint32_t)length {
		[self ref].insert(pos, str, length);
		return self;
	}
	-(TSString*)insert_2: (uint32_t)pos string: (const TSString*)string {
		[self ref].insert(pos, (string) ? [string ref] : Tellusim::String::null);
		return self;
	}
	-(TSString*)insert_2_: (uint32_t)pos string: (const TSString*)string {
		[self ref].insert(pos, (string) ? [string ref] : Tellusim::String::null);
		return self;
	}
	-(TSString*)insert_3: (uint32_t)pos string: (const TSString*)string length: (uint32_t)length {
		[self ref].insert(pos, (string) ? [string ref] : Tellusim::String::null, length);
		return self;
	}
	-(TSString*)insert_3_: (uint32_t)pos string: (const TSString*)string length: (uint32_t)length {
		[self ref].insert(pos, (string) ? [string ref] : Tellusim::String::null, length);
		return self;
	}
	-(TSString*)removeBack {
		[self ref].removeBack();
		return self;
	}
	-(TSString*)removeBack_1: (uint32_t)length {
		[self ref].removeBack(length);
		return self;
	}
	-(TSString*)removeBack_1_: (uint32_t)length {
		[self ref].removeBack(length);
		return self;
	}
	-(TSString*)remove: (uint32_t)pos {
		[self ref].remove(pos);
		return self;
	}
	-(TSString*)remove_: (uint32_t)pos {
		[self ref].remove(pos);
		return self;
	}
	-(TSString*)remove_1: (uint32_t)pos length: (uint32_t)length {
		[self ref].remove(pos, length);
		return self;
	}
	-(TSString*)remove_1_: (uint32_t)pos length: (uint32_t)length {
		[self ref].remove(pos, length);
		return self;
	}
	-(TSString*)reverse {
		[self ref].reverse();
		return self;
	}
	-(TSString*)reverse_1: (uint32_t)pos {
		[self ref].reverse(pos);
		return self;
	}
	-(TSString*)reverse_1_: (uint32_t)pos {
		[self ref].reverse(pos);
		return self;
	}
	-(TSString*)reverse_2: (uint32_t)pos length: (uint32_t)length {
		[self ref].reverse(pos, length);
		return self;
	}
	-(TSString*)reverse_2_: (uint32_t)pos length: (uint32_t)length {
		[self ref].reverse(pos, length);
		return self;
	}
	-(uint32_t)size {
		return [self ref].size();
	}
	-(BOOL)empty {
		return [self ref].empty();
	}
	-(char*)get {
		return [self ref].get();
	}
	-(NSString*)get_1 {
		return [NSString stringWithUTF8String:[self ref].get()];
	}
	-(char*)get_2: (uint32_t)index {
		return &([self ref].get(index));
	}
	-(char*)get_2_: (uint32_t)index {
		return &([self ref].get(index));
	}
	-(char)get_3: (uint32_t)index {
		return [self ref].get(index);
	}
	-(char)get_3_: (uint32_t)index {
		return [self ref].get(index);
	}
	-(uint32_t)find: (char)c {
		return [self ref].find(c);
	}
	-(uint32_t)find_: (char)c {
		return [self ref].find(c);
	}
	-(uint32_t)find_1: (char)c pos: (uint32_t)pos {
		return [self ref].find(c, pos);
	}
	-(uint32_t)find_1_: (char)c pos: (uint32_t)pos {
		return [self ref].find(c, pos);
	}
	-(uint32_t)rfind: (char)c {
		return [self ref].rfind(c);
	}
	-(uint32_t)rfind_: (char)c {
		return [self ref].rfind(c);
	}
	-(uint32_t)rfind_1: (char)c pos: (uint32_t)pos {
		return [self ref].rfind(c, pos);
	}
	-(uint32_t)rfind_1_: (char)c pos: (uint32_t)pos {
		return [self ref].rfind(c, pos);
	}
	-(uint32_t)count: (char)c {
		return [self ref].count(c);
	}
	-(uint32_t)count_: (char)c {
		return [self ref].count(c);
	}
	-(uint32_t)count_1: (char)c pos: (uint32_t)pos {
		return [self ref].count(c, pos);
	}
	-(uint32_t)count_1_: (char)c pos: (uint32_t)pos {
		return [self ref].count(c, pos);
	}
	-(uint32_t)find_2: (const char*)str {
		return [self ref].find(str);
	}
	-(uint32_t)find_2_: (const char*)str {
		return [self ref].find(str);
	}
	-(uint32_t)find_3: (const char*)str pos: (uint32_t)pos {
		return [self ref].find(str, pos);
	}
	-(uint32_t)find_3_: (const char*)str pos: (uint32_t)pos {
		return [self ref].find(str, pos);
	}
	-(uint32_t)rfind_2: (const char*)str {
		return [self ref].rfind(str);
	}
	-(uint32_t)rfind_2_: (const char*)str {
		return [self ref].rfind(str);
	}
	-(uint32_t)rfind_3: (const char*)str pos: (uint32_t)pos {
		return [self ref].rfind(str, pos);
	}
	-(uint32_t)rfind_3_: (const char*)str pos: (uint32_t)pos {
		return [self ref].rfind(str, pos);
	}
	-(uint32_t)count_2: (const char*)str {
		return [self ref].count(str);
	}
	-(uint32_t)count_2_: (const char*)str {
		return [self ref].count(str);
	}
	-(uint32_t)count_3: (const char*)str pos: (uint32_t)pos {
		return [self ref].count(str, pos);
	}
	-(uint32_t)count_3_: (const char*)str pos: (uint32_t)pos {
		return [self ref].count(str, pos);
	}
	-(BOOL)begins: (const char*)str {
		return [self ref].begins(str);
	}
	-(BOOL)begins_: (const char*)str {
		return [self ref].begins(str);
	}
	-(BOOL)begins_1: (const char*)str length: (uint32_t)length {
		return [self ref].begins(str, length);
	}
	-(BOOL)begins_1_: (const char*)str length: (uint32_t)length {
		return [self ref].begins(str, length);
	}
	-(BOOL)begins_2: (const char*)str length: (uint32_t)length pos: (uint32_t)pos {
		return [self ref].begins(str, length, pos);
	}
	-(BOOL)begins_2_: (const char*)str length: (uint32_t)length pos: (uint32_t)pos {
		return [self ref].begins(str, length, pos);
	}
	-(BOOL)contains: (const char*)str {
		return [self ref].contains(str);
	}
	-(BOOL)contains_: (const char*)str {
		return [self ref].contains(str);
	}
	-(BOOL)contains_1: (const char*)str length: (uint32_t)length {
		return [self ref].contains(str, length);
	}
	-(BOOL)contains_1_: (const char*)str length: (uint32_t)length {
		return [self ref].contains(str, length);
	}
	-(BOOL)contains_2: (const char*)str length: (uint32_t)length pos: (uint32_t)pos {
		return [self ref].contains(str, length, pos);
	}
	-(BOOL)contains_2_: (const char*)str length: (uint32_t)length pos: (uint32_t)pos {
		return [self ref].contains(str, length, pos);
	}
	-(BOOL)match: (const char*)str {
		return [self ref].match(str);
	}
	-(BOOL)match_: (const char*)str {
		return [self ref].match(str);
	}
	-(BOOL)match_1: (const char*)str length: (uint32_t)length {
		return [self ref].match(str, length);
	}
	-(BOOL)match_1_: (const char*)str length: (uint32_t)length {
		return [self ref].match(str, length);
	}
	-(BOOL)match_2: (const char*)str length: (uint32_t)length pos: (uint32_t)pos {
		return [self ref].match(str, length, pos);
	}
	-(BOOL)match_2_: (const char*)str length: (uint32_t)length pos: (uint32_t)pos {
		return [self ref].match(str, length, pos);
	}
	-(int32_t)compare: (const char*)str {
		return [self ref].compare(str);
	}
	-(int32_t)compare_: (const char*)str {
		return [self ref].compare(str);
	}
	-(int32_t)compare_1: (const char*)str pos: (uint32_t)pos {
		return [self ref].compare(str, pos);
	}
	-(int32_t)compare_1_: (const char*)str pos: (uint32_t)pos {
		return [self ref].compare(str, pos);
	}
	-(uint32_t)distance: (const char*)str {
		return [self ref].distance(str);
	}
	-(uint32_t)distance_: (const char*)str {
		return [self ref].distance(str);
	}
	-(uint32_t)distance_1: (const char*)str scan: (BOOL)scan {
		return [self ref].distance(str, (bool)scan);
	}
	-(uint32_t)distance_1_: (const char*)str scan: (BOOL)scan {
		return [self ref].distance(str, (bool)scan);
	}
	-(uint32_t)distance_2: (const char*)str scan: (BOOL)scan pos: (uint32_t)pos {
		return [self ref].distance(str, (bool)scan, pos);
	}
	-(uint32_t)distance_2_: (const char*)str scan: (BOOL)scan pos: (uint32_t)pos {
		return [self ref].distance(str, (bool)scan, pos);
	}
	-(NSString*)begin {
		return [NSString stringWithUTF8String:[self ref].begin()];
	}
	-(NSString*)end {
		return [NSString stringWithUTF8String:[self ref].end()];
	}
	-(char)front {
		return [self ref].front();
	}
	-(char)front_1: (uint32_t)index {
		return [self ref].front(index);
	}
	-(char)front_1_: (uint32_t)index {
		return [self ref].front(index);
	}
	-(char)back {
		return [self ref].back();
	}
	-(char)back_1: (uint32_t)index {
		return [self ref].back(index);
	}
	-(char)back_1_: (uint32_t)index {
		return [self ref].back(index);
	}
	-(char*)front_2 {
		return &([self ref].front());
	}
	-(char*)front_3: (uint32_t)index {
		return &([self ref].front(index));
	}
	-(char*)front_3_: (uint32_t)index {
		return &([self ref].front(index));
	}
	-(char*)back_2 {
		return &([self ref].back());
	}
	-(char*)back_3: (uint32_t)index {
		return &([self ref].back(index));
	}
	-(char*)back_3_: (uint32_t)index {
		return &([self ref].back(index));
	}
	-(NSString*)substring: (uint32_t)pos {
		return [NSString stringWithUTF8String:[self ref].substring(pos).get()];
	}
	-(NSString*)substring_: (uint32_t)pos {
		return [NSString stringWithUTF8String:[self ref].substring(pos).get()];
	}
	-(NSString*)substring_1: (uint32_t)pos length: (uint32_t)length {
		return [NSString stringWithUTF8String:[self ref].substring(pos, length).get()];
	}
	-(NSString*)substring_1_: (uint32_t)pos length: (uint32_t)length {
		return [NSString stringWithUTF8String:[self ref].substring(pos, length).get()];
	}
	-(NSString*)replace: (char)before after: (char)after {
		return [NSString stringWithUTF8String:[self ref].replace(before, after).get()];
	}
	-(NSString*)replace_: (char)before after: (char)after {
		return [NSString stringWithUTF8String:[self ref].replace(before, after).get()];
	}
	-(NSString*)replace_1: (char)before after: (char)after pos: (uint32_t)pos {
		return [NSString stringWithUTF8String:[self ref].replace(before, after, pos).get()];
	}
	-(NSString*)replace_1_: (char)before after: (char)after pos: (uint32_t)pos {
		return [NSString stringWithUTF8String:[self ref].replace(before, after, pos).get()];
	}
	-(NSString*)replace_2: (const char*)before after: (const char*)after {
		return [NSString stringWithUTF8String:[self ref].replace(before, after).get()];
	}
	-(NSString*)replace_2_: (const char*)before after: (const char*)after {
		return [NSString stringWithUTF8String:[self ref].replace(before, after).get()];
	}
	-(NSString*)replace_3: (const char*)before after: (const char*)after pos: (uint32_t)pos {
		return [NSString stringWithUTF8String:[self ref].replace(before, after, pos).get()];
	}
	-(NSString*)replace_3_: (const char*)before after: (const char*)after pos: (uint32_t)pos {
		return [NSString stringWithUTF8String:[self ref].replace(before, after, pos).get()];
	}
	-(NSArray<TSString*>*)split: (const char*)delimiters {
		const auto &ret = [self ref].split(delimiters);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(NSArray<TSString*>*)split_: (const char*)delimiters {
		const auto &ret = [self ref].split(delimiters);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(NSArray<TSString*>*)split_1: (const char*)delimiters length: (uint32_t)length {
		const auto &ret = [self ref].split(delimiters, length);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(NSArray<TSString*>*)split_1_: (const char*)delimiters length: (uint32_t)length {
		const auto &ret = [self ref].split(delimiters, length);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(NSArray<TSString*>*)split_2: (const TSString*)delimiters {
		const auto &ret = [self ref].split((delimiters) ? [delimiters ref] : Tellusim::String::null);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(NSArray<TSString*>*)split_2_: (const TSString*)delimiters {
		const auto &ret = [self ref].split((delimiters) ? [delimiters ref] : Tellusim::String::null);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(NSArray<TSString*>*)split_3: (const TSString*)delimiters length: (uint32_t)length {
		const auto &ret = [self ref].split((delimiters) ? [delimiters ref] : Tellusim::String::null, length);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(NSArray<TSString*>*)split_3_: (const TSString*)delimiters length: (uint32_t)length {
		const auto &ret = [self ref].split((delimiters) ? [delimiters ref] : Tellusim::String::null, length);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(NSString*)extension: (const char*)extension {
		return [NSString stringWithUTF8String:[self ref].extension(extension).get()];
	}
	-(NSString*)extension_: (const char*)extension {
		return [NSString stringWithUTF8String:[self ref].extension(extension).get()];
	}
	-(NSString*)extension_1 {
		return [NSString stringWithUTF8String:[self ref].extension().get()];
	}
	-(NSString*)pathname {
		return [NSString stringWithUTF8String:[self ref].pathname().get()];
	}
	-(NSString*)basename {
		return [NSString stringWithUTF8String:[self ref].basename().get()];
	}
	-(NSString*)dirname {
		return [NSString stringWithUTF8String:[self ref].dirname().get()];
	}
	+(NSString*)relname: (const char*)path str: (const char*)str {
		return [NSString stringWithUTF8String:Tellusim::String::relname(path, str).get()];
	}
	+(NSString*)relname_: (const char*)path str: (const char*)str {
		return [NSString stringWithUTF8String:Tellusim::String::relname(path, str).get()];
	}
	+(NSString*)relname_1: (const TSString*)path str: (const TSString*)str {
		return [NSString stringWithUTF8String:Tellusim::String::relname((path) ? [path ref] : Tellusim::String::null, (str) ? [str ref] : Tellusim::String::null).get()];
	}
	+(NSString*)relname_1_: (const TSString*)path str: (const TSString*)str {
		return [NSString stringWithUTF8String:Tellusim::String::relname((path) ? [path ref] : Tellusim::String::null, (str) ? [str ref] : Tellusim::String::null).get()];
	}
	-(NSString*)capitalize {
		return [NSString stringWithUTF8String:[self ref].capitalize().get()];
	}
	-(NSString*)capitalize_1: (const char*)delimiters {
		return [NSString stringWithUTF8String:[self ref].capitalize(delimiters).get()];
	}
	-(NSString*)capitalize_1_: (const char*)delimiters {
		return [NSString stringWithUTF8String:[self ref].capitalize(delimiters).get()];
	}
	-(NSString*)capitalize_2: (const char*)delimiters spaces: (const char*)spaces {
		return [NSString stringWithUTF8String:[self ref].capitalize(delimiters, spaces).get()];
	}
	-(NSString*)capitalize_2_: (const char*)delimiters spaces: (const char*)spaces {
		return [NSString stringWithUTF8String:[self ref].capitalize(delimiters, spaces).get()];
	}
	-(NSString*)lower {
		return [NSString stringWithUTF8String:[self ref].lower().get()];
	}
	-(NSString*)upper {
		return [NSString stringWithUTF8String:[self ref].upper().get()];
	}
	+(uint32_t)toUtf32: (const char*)str code: (uint32_t*)code {
		TS_ASSERT(code);
		return Tellusim::String::toUtf32(str, *code);
	}
	+(uint32_t)toUtf32_: (const char*)str code: (uint32_t*)code {
		TS_ASSERT(code);
		return Tellusim::String::toUtf32(str, *code);
	}
	-(uint32_t)toUtf16: (wchar_t*)d length: (uint32_t)length {
		return [self ref].toUtf16(d, length);
	}
	-(uint32_t)toUtf16_: (wchar_t*)d length: (uint32_t)length {
		return [self ref].toUtf16(d, length);
	}
	-(uint32_t)toUtf32_1: (uint32_t*)d length: (uint32_t)length {
		return [self ref].toUtf32(d, length);
	}
	-(uint32_t)toUtf32_1_: (uint32_t*)d length: (uint32_t)length {
		return [self ref].toUtf32(d, length);
	}
	+(uint32_t)fromUtf32: (TSString*)d code: (uint32_t)code {
		return Tellusim::String::fromUtf32([d ref], code);
	}
	+(uint32_t)fromUtf32_: (TSString*)d code: (uint32_t)code {
		return Tellusim::String::fromUtf32([d ref], code);
	}
	+(NSString*)fromUtf16: (const wchar_t*)str {
		return [NSString stringWithUTF8String:Tellusim::String::fromUtf16(str).get()];
	}
	+(NSString*)fromUtf16_: (const wchar_t*)str {
		return [NSString stringWithUTF8String:Tellusim::String::fromUtf16(str).get()];
	}
	+(NSString*)fromUtf16_1: (const wchar_t*)str length: (uint32_t)length {
		return [NSString stringWithUTF8String:Tellusim::String::fromUtf16(str, length).get()];
	}
	+(NSString*)fromUtf16_1_: (const wchar_t*)str length: (uint32_t)length {
		return [NSString stringWithUTF8String:Tellusim::String::fromUtf16(str, length).get()];
	}
	+(NSString*)fromUtf32_1: (const uint32_t*)str {
		return [NSString stringWithUTF8String:Tellusim::String::fromUtf32(str).get()];
	}
	+(NSString*)fromUtf32_1_: (const uint32_t*)str {
		return [NSString stringWithUTF8String:Tellusim::String::fromUtf32(str).get()];
	}
	+(NSString*)fromUtf32_2: (const uint32_t*)str length: (uint32_t)length {
		return [NSString stringWithUTF8String:Tellusim::String::fromUtf32(str, length).get()];
	}
	+(NSString*)fromUtf32_2_: (const uint32_t*)str length: (uint32_t)length {
		return [NSString stringWithUTF8String:Tellusim::String::fromUtf32(str, length).get()];
	}
	+(NSString*)fromUrl: (const char*)str {
		return [NSString stringWithUTF8String:Tellusim::String::fromUrl(str).get()];
	}
	+(NSString*)fromUrl_: (const char*)str {
		return [NSString stringWithUTF8String:Tellusim::String::fromUrl(str).get()];
	}
	+(NSString*)fromUrl_1: (const char*)str length: (uint32_t)length {
		return [NSString stringWithUTF8String:Tellusim::String::fromUrl(str, length).get()];
	}
	+(NSString*)fromUrl_1_: (const char*)str length: (uint32_t)length {
		return [NSString stringWithUTF8String:Tellusim::String::fromUrl(str, length).get()];
	}
	+(NSString*)fromUrl_2: (const TSString*)string {
		return [NSString stringWithUTF8String:Tellusim::String::fromUrl((string) ? [string ref] : Tellusim::String::null).get()];
	}
	+(NSString*)fromUrl_2_: (const TSString*)string {
		return [NSString stringWithUTF8String:Tellusim::String::fromUrl((string) ? [string ref] : Tellusim::String::null).get()];
	}
	+(NSString*)fromUrl_3: (const TSString*)string length: (uint32_t)length {
		return [NSString stringWithUTF8String:Tellusim::String::fromUrl((string) ? [string ref] : Tellusim::String::null, length).get()];
	}
	+(NSString*)fromUrl_3_: (const TSString*)string length: (uint32_t)length {
		return [NSString stringWithUTF8String:Tellusim::String::fromUrl((string) ? [string ref] : Tellusim::String::null, length).get()];
	}
	-(uint32_t)vscanf: (const char*)format args: (va_list)args {
		return [self ref].vscanf(format, args);
	}
	-(uint32_t)vscanf_: (const char*)format args: (va_list)args {
		return [self ref].vscanf(format, args);
	}
	-(TSString*)vprintf: (const char*)format args: (va_list)args {
		[self ref].vprintf(format, args);
		return self;
	}
	-(TSString*)vprintf_: (const char*)format args: (va_list)args {
		[self ref].vprintf(format, args);
		return self;
	}
	+(NSString*)vformat: (const char*)format args: (va_list)args {
		return [NSString stringWithUTF8String:Tellusim::String::vformat(format, args).get()];
	}
	+(NSString*)vformat_: (const char*)format args: (va_list)args {
		return [NSString stringWithUTF8String:Tellusim::String::vformat(format, args).get()];
	}
	+(NSString*)format: (const char*)format {
		return [NSString stringWithUTF8String:Tellusim::String::format("%s", format).get()];
	}
	+(NSString*)format_: (const char*)format {
		return [NSString stringWithUTF8String:Tellusim::String::format("%s", format).get()];
	}
	+(TSString*)fromi32: (TSString*)d value: (int32_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromi32([d ref], value))];
	}
	+(TSString*)fromi32_: (TSString*)d value: (int32_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromi32([d ref], value))];
	}
	+(TSString*)fromi32_1: (TSString*)d value: (int32_t)value radix: (uint32_t)radix {
		return [[TSString alloc] init_ref:(Tellusim::String::fromi32([d ref], value, radix))];
	}
	+(TSString*)fromi32_1_: (TSString*)d value: (int32_t)value radix: (uint32_t)radix {
		return [[TSString alloc] init_ref:(Tellusim::String::fromi32([d ref], value, radix))];
	}
	+(TSString*)fromi64: (TSString*)d value: (int64_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromi64([d ref], value))];
	}
	+(TSString*)fromi64_: (TSString*)d value: (int64_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromi64([d ref], value))];
	}
	+(TSString*)fromi64_1: (TSString*)d value: (int64_t)value radix: (uint32_t)radix {
		return [[TSString alloc] init_ref:(Tellusim::String::fromi64([d ref], value, radix))];
	}
	+(TSString*)fromi64_1_: (TSString*)d value: (int64_t)value radix: (uint32_t)radix {
		return [[TSString alloc] init_ref:(Tellusim::String::fromi64([d ref], value, radix))];
	}
	+(TSString*)fromu32: (TSString*)d value: (uint32_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromu32([d ref], value))];
	}
	+(TSString*)fromu32_: (TSString*)d value: (uint32_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromu32([d ref], value))];
	}
	+(TSString*)fromu32_1: (TSString*)d value: (uint32_t)value radix: (uint32_t)radix {
		return [[TSString alloc] init_ref:(Tellusim::String::fromu32([d ref], value, radix))];
	}
	+(TSString*)fromu32_1_: (TSString*)d value: (uint32_t)value radix: (uint32_t)radix {
		return [[TSString alloc] init_ref:(Tellusim::String::fromu32([d ref], value, radix))];
	}
	+(TSString*)fromu64: (TSString*)d value: (uint64_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromu64([d ref], value))];
	}
	+(TSString*)fromu64_: (TSString*)d value: (uint64_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromu64([d ref], value))];
	}
	+(TSString*)fromu64_1: (TSString*)d value: (uint64_t)value radix: (uint32_t)radix {
		return [[TSString alloc] init_ref:(Tellusim::String::fromu64([d ref], value, radix))];
	}
	+(TSString*)fromu64_1_: (TSString*)d value: (uint64_t)value radix: (uint32_t)radix {
		return [[TSString alloc] init_ref:(Tellusim::String::fromu64([d ref], value, radix))];
	}
	+(TSString*)fromf32: (TSString*)d value: (float32_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf32([d ref], value))];
	}
	+(TSString*)fromf32_: (TSString*)d value: (float32_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf32([d ref], value))];
	}
	+(TSString*)fromf32_1: (TSString*)d value: (float32_t)value digits: (uint32_t)digits {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf32([d ref], value, digits))];
	}
	+(TSString*)fromf32_1_: (TSString*)d value: (float32_t)value digits: (uint32_t)digits {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf32([d ref], value, digits))];
	}
	+(TSString*)fromf32_2: (TSString*)d value: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf32([d ref], value, digits, (bool)compact))];
	}
	+(TSString*)fromf32_2_: (TSString*)d value: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf32([d ref], value, digits, (bool)compact))];
	}
	+(TSString*)fromf32_3: (TSString*)d value: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf32([d ref], value, digits, (bool)compact, (bool)exponent))];
	}
	+(TSString*)fromf32_3_: (TSString*)d value: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf32([d ref], value, digits, (bool)compact, (bool)exponent))];
	}
	+(TSString*)fromf64: (TSString*)d value: (float64_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf64([d ref], value))];
	}
	+(TSString*)fromf64_: (TSString*)d value: (float64_t)value {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf64([d ref], value))];
	}
	+(TSString*)fromf64_1: (TSString*)d value: (float64_t)value digits: (uint32_t)digits {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf64([d ref], value, digits))];
	}
	+(TSString*)fromf64_1_: (TSString*)d value: (float64_t)value digits: (uint32_t)digits {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf64([d ref], value, digits))];
	}
	+(TSString*)fromf64_2: (TSString*)d value: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf64([d ref], value, digits, (bool)compact))];
	}
	+(TSString*)fromf64_2_: (TSString*)d value: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf64([d ref], value, digits, (bool)compact))];
	}
	+(TSString*)fromf64_3: (TSString*)d value: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf64([d ref], value, digits, (bool)compact, (bool)exponent))];
	}
	+(TSString*)fromf64_3_: (TSString*)d value: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		return [[TSString alloc] init_ref:(Tellusim::String::fromf64([d ref], value, digits, (bool)compact, (bool)exponent))];
	}
	+(NSString*)fromi32_2: (int32_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromi32(value).get()];
	}
	+(NSString*)fromi32_2_: (int32_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromi32(value).get()];
	}
	+(NSString*)fromi32_3: (int32_t)value radix: (uint32_t)radix {
		return [NSString stringWithUTF8String:Tellusim::String::fromi32(value, radix).get()];
	}
	+(NSString*)fromi32_3_: (int32_t)value radix: (uint32_t)radix {
		return [NSString stringWithUTF8String:Tellusim::String::fromi32(value, radix).get()];
	}
	+(NSString*)fromi64_2: (int64_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromi64(value).get()];
	}
	+(NSString*)fromi64_2_: (int64_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromi64(value).get()];
	}
	+(NSString*)fromi64_3: (int64_t)value radix: (uint32_t)radix {
		return [NSString stringWithUTF8String:Tellusim::String::fromi64(value, radix).get()];
	}
	+(NSString*)fromi64_3_: (int64_t)value radix: (uint32_t)radix {
		return [NSString stringWithUTF8String:Tellusim::String::fromi64(value, radix).get()];
	}
	+(NSString*)fromu32_2: (uint32_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromu32(value).get()];
	}
	+(NSString*)fromu32_2_: (uint32_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromu32(value).get()];
	}
	+(NSString*)fromu32_3: (uint32_t)value radix: (uint32_t)radix {
		return [NSString stringWithUTF8String:Tellusim::String::fromu32(value, radix).get()];
	}
	+(NSString*)fromu32_3_: (uint32_t)value radix: (uint32_t)radix {
		return [NSString stringWithUTF8String:Tellusim::String::fromu32(value, radix).get()];
	}
	+(NSString*)fromu64_2: (uint64_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromu64(value).get()];
	}
	+(NSString*)fromu64_2_: (uint64_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromu64(value).get()];
	}
	+(NSString*)fromu64_3: (uint64_t)value radix: (uint32_t)radix {
		return [NSString stringWithUTF8String:Tellusim::String::fromu64(value, radix).get()];
	}
	+(NSString*)fromu64_3_: (uint64_t)value radix: (uint32_t)radix {
		return [NSString stringWithUTF8String:Tellusim::String::fromu64(value, radix).get()];
	}
	+(NSString*)fromf32_4: (float32_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromf32(value).get()];
	}
	+(NSString*)fromf32_4_: (float32_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromf32(value).get()];
	}
	+(NSString*)fromf32_5: (float32_t)value digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromf32(value, digits).get()];
	}
	+(NSString*)fromf32_5_: (float32_t)value digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromf32(value, digits).get()];
	}
	+(NSString*)fromf32_6: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		return [NSString stringWithUTF8String:Tellusim::String::fromf32(value, digits, (bool)compact).get()];
	}
	+(NSString*)fromf32_6_: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		return [NSString stringWithUTF8String:Tellusim::String::fromf32(value, digits, (bool)compact).get()];
	}
	+(NSString*)fromf32_7: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		return [NSString stringWithUTF8String:Tellusim::String::fromf32(value, digits, (bool)compact, (bool)exponent).get()];
	}
	+(NSString*)fromf32_7_: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		return [NSString stringWithUTF8String:Tellusim::String::fromf32(value, digits, (bool)compact, (bool)exponent).get()];
	}
	+(NSString*)fromf64_4: (float64_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromf64(value).get()];
	}
	+(NSString*)fromf64_4_: (float64_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromf64(value).get()];
	}
	+(NSString*)fromf64_5: (float64_t)value digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromf64(value, digits).get()];
	}
	+(NSString*)fromf64_5_: (float64_t)value digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromf64(value, digits).get()];
	}
	+(NSString*)fromf64_6: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		return [NSString stringWithUTF8String:Tellusim::String::fromf64(value, digits, (bool)compact).get()];
	}
	+(NSString*)fromf64_6_: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		return [NSString stringWithUTF8String:Tellusim::String::fromf64(value, digits, (bool)compact).get()];
	}
	+(NSString*)fromf64_7: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		return [NSString stringWithUTF8String:Tellusim::String::fromf64(value, digits, (bool)compact, (bool)exponent).get()];
	}
	+(NSString*)fromf64_7_: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		return [NSString stringWithUTF8String:Tellusim::String::fromf64(value, digits, (bool)compact, (bool)exponent).get()];
	}
	+(int32_t)toi32: (const char*)str {
		return Tellusim::String::toi32(str);
	}
	+(int32_t)toi32_: (const char*)str {
		return Tellusim::String::toi32(str);
	}
	+(int32_t)toi32_1: (const char*)str radix: (uint32_t)radix {
		return Tellusim::String::toi32(str, radix);
	}
	+(int32_t)toi32_1_: (const char*)str radix: (uint32_t)radix {
		return Tellusim::String::toi32(str, radix);
	}
	+(int32_t)toi32_2: (const char*)str radix: (uint32_t)radix size: (uint32_t*)size {
		return Tellusim::String::toi32(str, radix, size);
	}
	+(int32_t)toi32_2_: (const char*)str radix: (uint32_t)radix size: (uint32_t*)size {
		return Tellusim::String::toi32(str, radix, size);
	}
	+(int64_t)toi64: (const char*)str {
		return Tellusim::String::toi64(str);
	}
	+(int64_t)toi64_: (const char*)str {
		return Tellusim::String::toi64(str);
	}
	+(int64_t)toi64_1: (const char*)str radix: (uint32_t)radix {
		return Tellusim::String::toi64(str, radix);
	}
	+(int64_t)toi64_1_: (const char*)str radix: (uint32_t)radix {
		return Tellusim::String::toi64(str, radix);
	}
	+(int64_t)toi64_2: (const char*)str radix: (uint32_t)radix size: (uint32_t*)size {
		return Tellusim::String::toi64(str, radix, size);
	}
	+(int64_t)toi64_2_: (const char*)str radix: (uint32_t)radix size: (uint32_t*)size {
		return Tellusim::String::toi64(str, radix, size);
	}
	+(uint32_t)tou32: (const char*)str {
		return Tellusim::String::tou32(str);
	}
	+(uint32_t)tou32_: (const char*)str {
		return Tellusim::String::tou32(str);
	}
	+(uint32_t)tou32_1: (const char*)str radix: (uint32_t)radix {
		return Tellusim::String::tou32(str, radix);
	}
	+(uint32_t)tou32_1_: (const char*)str radix: (uint32_t)radix {
		return Tellusim::String::tou32(str, radix);
	}
	+(uint32_t)tou32_2: (const char*)str radix: (uint32_t)radix size: (uint32_t*)size {
		return Tellusim::String::tou32(str, radix, size);
	}
	+(uint32_t)tou32_2_: (const char*)str radix: (uint32_t)radix size: (uint32_t*)size {
		return Tellusim::String::tou32(str, radix, size);
	}
	+(uint64_t)tou64: (const char*)str {
		return Tellusim::String::tou64(str);
	}
	+(uint64_t)tou64_: (const char*)str {
		return Tellusim::String::tou64(str);
	}
	+(uint64_t)tou64_1: (const char*)str radix: (uint32_t)radix {
		return Tellusim::String::tou64(str, radix);
	}
	+(uint64_t)tou64_1_: (const char*)str radix: (uint32_t)radix {
		return Tellusim::String::tou64(str, radix);
	}
	+(uint64_t)tou64_2: (const char*)str radix: (uint32_t)radix size: (uint32_t*)size {
		return Tellusim::String::tou64(str, radix, size);
	}
	+(uint64_t)tou64_2_: (const char*)str radix: (uint32_t)radix size: (uint32_t*)size {
		return Tellusim::String::tou64(str, radix, size);
	}
	+(int32_t)toi32_3: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toi32(str, size);
	}
	+(int32_t)toi32_3_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toi32(str, size);
	}
	+(int64_t)toi64_3: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toi64(str, size);
	}
	+(int64_t)toi64_3_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toi64(str, size);
	}
	+(uint32_t)tou32_3: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::tou32(str, size);
	}
	+(uint32_t)tou32_3_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::tou32(str, size);
	}
	+(uint64_t)tou64_3: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::tou64(str, size);
	}
	+(uint64_t)tou64_3_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::tou64(str, size);
	}
	+(float32_t)tof32: (const char*)str {
		return Tellusim::String::tof32(str);
	}
	+(float32_t)tof32_: (const char*)str {
		return Tellusim::String::tof32(str);
	}
	+(float32_t)tof32_1: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::tof32(str, size);
	}
	+(float32_t)tof32_1_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::tof32(str, size);
	}
	+(float64_t)tof64: (const char*)str {
		return Tellusim::String::tof64(str);
	}
	+(float64_t)tof64_: (const char*)str {
		return Tellusim::String::tof64(str);
	}
	+(float64_t)tof64_1: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::tof64(str, size);
	}
	+(float64_t)tof64_1_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::tof64(str, size);
	}
	-(int32_t)toi32_4 {
		return [self ref].toi32();
	}
	-(int32_t)toi32_5: (uint32_t)radix {
		return [self ref].toi32(radix);
	}
	-(int32_t)toi32_5_: (uint32_t)radix {
		return [self ref].toi32(radix);
	}
	-(int32_t)toi32_6: (uint32_t)radix pos: (uint32_t)pos {
		return [self ref].toi32(radix, pos);
	}
	-(int32_t)toi32_6_: (uint32_t)radix pos: (uint32_t)pos {
		return [self ref].toi32(radix, pos);
	}
	-(int64_t)toi64_4 {
		return [self ref].toi64();
	}
	-(int64_t)toi64_5: (uint32_t)radix {
		return [self ref].toi64(radix);
	}
	-(int64_t)toi64_5_: (uint32_t)radix {
		return [self ref].toi64(radix);
	}
	-(int64_t)toi64_6: (uint32_t)radix pos: (uint32_t)pos {
		return [self ref].toi64(radix, pos);
	}
	-(int64_t)toi64_6_: (uint32_t)radix pos: (uint32_t)pos {
		return [self ref].toi64(radix, pos);
	}
	-(uint32_t)tou32_4 {
		return [self ref].tou32();
	}
	-(uint32_t)tou32_5: (uint32_t)radix {
		return [self ref].tou32(radix);
	}
	-(uint32_t)tou32_5_: (uint32_t)radix {
		return [self ref].tou32(radix);
	}
	-(uint32_t)tou32_6: (uint32_t)radix pos: (uint32_t)pos {
		return [self ref].tou32(radix, pos);
	}
	-(uint32_t)tou32_6_: (uint32_t)radix pos: (uint32_t)pos {
		return [self ref].tou32(radix, pos);
	}
	-(uint64_t)tou64_4 {
		return [self ref].tou64();
	}
	-(uint64_t)tou64_5: (uint32_t)radix {
		return [self ref].tou64(radix);
	}
	-(uint64_t)tou64_5_: (uint32_t)radix {
		return [self ref].tou64(radix);
	}
	-(uint64_t)tou64_6: (uint32_t)radix pos: (uint32_t)pos {
		return [self ref].tou64(radix, pos);
	}
	-(uint64_t)tou64_6_: (uint32_t)radix pos: (uint32_t)pos {
		return [self ref].tou64(radix, pos);
	}
	-(float32_t)tof32_2 {
		return [self ref].tof32();
	}
	-(float32_t)tof32_3: (uint32_t)pos {
		return [self ref].tof32(pos);
	}
	-(float32_t)tof32_3_: (uint32_t)pos {
		return [self ref].tof32(pos);
	}
	-(float64_t)tof64_2 {
		return [self ref].tof64();
	}
	-(float64_t)tof64_3: (uint32_t)pos {
		return [self ref].tof64(pos);
	}
	-(float64_t)tof64_3_: (uint32_t)pos {
		return [self ref].tof64(pos);
	}
	-(uint32_t)toHashu32 {
		return [self ref].toHashu32();
	}
	-(uint32_t)toHashu32_1: (uint32_t)pos {
		return [self ref].toHashu32(pos);
	}
	-(uint32_t)toHashu32_1_: (uint32_t)pos {
		return [self ref].toHashu32(pos);
	}
	-(uint64_t)toHashu64 {
		return [self ref].toHashu64();
	}
	-(uint64_t)toHashu64_1: (uint32_t)pos {
		return [self ref].toHashu64(pos);
	}
	-(uint64_t)toHashu64_1_: (uint32_t)pos {
		return [self ref].toHashu64(pos);
	}
	-(uint32_t)toRGBAu8 {
		return [self ref].toRGBAu8();
	}
	-(uint32_t)toRGBAu8_1: (uint32_t)pos {
		return [self ref].toRGBAu8(pos);
	}
	-(uint32_t)toRGBAu8_1_: (uint32_t)pos {
		return [self ref].toRGBAu8(pos);
	}
	+(NSString*)fromTime: (uint64_t)usec {
		return [NSString stringWithUTF8String:Tellusim::String::fromTime(usec).get()];
	}
	+(NSString*)fromTime_: (uint64_t)usec {
		return [NSString stringWithUTF8String:Tellusim::String::fromTime(usec).get()];
	}
	+(NSString*)fromTime_1: (uint64_t)usec digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromTime(usec, digits).get()];
	}
	+(NSString*)fromTime_1_: (uint64_t)usec digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromTime(usec, digits).get()];
	}
	+(NSString*)fromBytes: (uint64_t)bytes {
		return [NSString stringWithUTF8String:Tellusim::String::fromBytes(bytes).get()];
	}
	+(NSString*)fromBytes_: (uint64_t)bytes {
		return [NSString stringWithUTF8String:Tellusim::String::fromBytes(bytes).get()];
	}
	+(NSString*)fromBytes_1: (uint64_t)bytes digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromBytes(bytes, digits).get()];
	}
	+(NSString*)fromBytes_1_: (uint64_t)bytes digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromBytes(bytes, digits).get()];
	}
	+(NSString*)fromNumber: (uint64_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromNumber(value).get()];
	}
	+(NSString*)fromNumber_: (uint64_t)value {
		return [NSString stringWithUTF8String:Tellusim::String::fromNumber(value).get()];
	}
	+(NSString*)fromNumber_1: (uint64_t)value digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromNumber(value, digits).get()];
	}
	+(NSString*)fromNumber_1_: (uint64_t)value digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromNumber(value, digits).get()];
	}
	+(NSString*)fromFrequency: (uint64_t)hz {
		return [NSString stringWithUTF8String:Tellusim::String::fromFrequency(hz).get()];
	}
	+(NSString*)fromFrequency_: (uint64_t)hz {
		return [NSString stringWithUTF8String:Tellusim::String::fromFrequency(hz).get()];
	}
	+(NSString*)fromFrequency_1: (uint64_t)hz digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromFrequency(hz, digits).get()];
	}
	+(NSString*)fromFrequency_1_: (uint64_t)hz digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromFrequency(hz, digits).get()];
	}
	+(NSString*)fromLength: (float64_t)distance {
		return [NSString stringWithUTF8String:Tellusim::String::fromLength(distance).get()];
	}
	+(NSString*)fromLength_: (float64_t)distance {
		return [NSString stringWithUTF8String:Tellusim::String::fromLength(distance).get()];
	}
	+(NSString*)fromLength_1: (float64_t)distance digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromLength(distance, digits).get()];
	}
	+(NSString*)fromLength_1_: (float64_t)distance digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromLength(distance, digits).get()];
	}
	+(NSString*)fromAngle: (float64_t)angle {
		return [NSString stringWithUTF8String:Tellusim::String::fromAngle(angle).get()];
	}
	+(NSString*)fromAngle_: (float64_t)angle {
		return [NSString stringWithUTF8String:Tellusim::String::fromAngle(angle).get()];
	}
	+(NSString*)fromAngle_1: (float64_t)angle digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromAngle(angle, digits).get()];
	}
	+(NSString*)fromAngle_1_: (float64_t)angle digits: (uint32_t)digits {
		return [NSString stringWithUTF8String:Tellusim::String::fromAngle(angle, digits).get()];
	}
	+(uint64_t)toBytes: (const char*)str {
		return Tellusim::String::toBytes(str);
	}
	+(uint64_t)toBytes_: (const char*)str {
		return Tellusim::String::toBytes(str);
	}
	+(uint64_t)toBytes_1: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toBytes(str, size);
	}
	+(uint64_t)toBytes_1_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toBytes(str, size);
	}
	+(uint64_t)toNumber: (const char*)str {
		return Tellusim::String::toNumber(str);
	}
	+(uint64_t)toNumber_: (const char*)str {
		return Tellusim::String::toNumber(str);
	}
	+(uint64_t)toNumber_1: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toNumber(str, size);
	}
	+(uint64_t)toNumber_1_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toNumber(str, size);
	}
	+(uint64_t)toFrequency: (const char*)str {
		return Tellusim::String::toFrequency(str);
	}
	+(uint64_t)toFrequency_: (const char*)str {
		return Tellusim::String::toFrequency(str);
	}
	+(uint64_t)toFrequency_1: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toFrequency(str, size);
	}
	+(uint64_t)toFrequency_1_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toFrequency(str, size);
	}
	+(float64_t)toLength: (const char*)str {
		return Tellusim::String::toLength(str);
	}
	+(float64_t)toLength_: (const char*)str {
		return Tellusim::String::toLength(str);
	}
	+(float64_t)toLength_1: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toLength(str, size);
	}
	+(float64_t)toLength_1_: (const char*)str size: (uint32_t*)size {
		return Tellusim::String::toLength(str, size);
	}
	-(uint64_t)toBytes_2 {
		return [self ref].toBytes();
	}
	-(uint64_t)toBytes_3: (uint32_t)pos {
		return [self ref].toBytes(pos);
	}
	-(uint64_t)toBytes_3_: (uint32_t)pos {
		return [self ref].toBytes(pos);
	}
	-(uint64_t)toBytes_4: (uint32_t)pos size: (uint32_t*)size {
		return [self ref].toBytes(pos, size);
	}
	-(uint64_t)toBytes_4_: (uint32_t)pos size: (uint32_t*)size {
		return [self ref].toBytes(pos, size);
	}
	-(uint64_t)toNumber_2 {
		return [self ref].toNumber();
	}
	-(uint64_t)toNumber_3: (uint32_t)pos {
		return [self ref].toNumber(pos);
	}
	-(uint64_t)toNumber_3_: (uint32_t)pos {
		return [self ref].toNumber(pos);
	}
	-(uint64_t)toNumber_4: (uint32_t)pos size: (uint32_t*)size {
		return [self ref].toNumber(pos, size);
	}
	-(uint64_t)toNumber_4_: (uint32_t)pos size: (uint32_t*)size {
		return [self ref].toNumber(pos, size);
	}
	-(uint64_t)toFrequency_2 {
		return [self ref].toFrequency();
	}
	-(uint64_t)toFrequency_3: (uint32_t)pos {
		return [self ref].toFrequency(pos);
	}
	-(uint64_t)toFrequency_3_: (uint32_t)pos {
		return [self ref].toFrequency(pos);
	}
	-(uint64_t)toFrequency_4: (uint32_t)pos size: (uint32_t*)size {
		return [self ref].toFrequency(pos, size);
	}
	-(uint64_t)toFrequency_4_: (uint32_t)pos size: (uint32_t*)size {
		return [self ref].toFrequency(pos, size);
	}
	-(float64_t)toLength_2 {
		return [self ref].toLength();
	}
	-(float64_t)toLength_3: (uint32_t)pos {
		return [self ref].toLength(pos);
	}
	-(float64_t)toLength_3_: (uint32_t)pos {
		return [self ref].toLength(pos);
	}
	-(float64_t)toLength_4: (uint32_t)pos size: (uint32_t*)size {
		return [self ref].toLength(pos, size);
	}
	-(float64_t)toLength_4_: (uint32_t)pos size: (uint32_t*)size {
		return [self ref].toLength(pos, size);
	}
@end

// Tellusim::App
@implementation TSApp
	-(id)init: (int32_t)argc argv: (char**)argv {
		self = [super init];
		impl = new Tellusim::App(argc, argv);
		return self;
	}
	-(id)init_: (int32_t)argc argv: (char**)argv {
		self = [super init];
		impl = new Tellusim::App(argc, argv);
		return self;
	}
	-(id)init_ptr: (Tellusim::App*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(Tellusim::App*)pointer {
		return (Tellusim::App*)impl;
	}
	-(Tellusim::App&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::App*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::App*)impl;
	}
	-(void)clear {
		[self ref].clear();
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(uint32_t)getDevice {
		return [self ref].getDevice();
	}
	-(uint32_t)getWidth {
		return [self ref].getWidth();
	}
	-(uint32_t)getHeight {
		return [self ref].getHeight();
	}
	-(uint32_t)getMultisample {
		return [self ref].getMultisample();
	}
	-(uint32_t)getNumArguments {
		return [self ref].getNumArguments();
	}
	-(const TSString*)getArgument: (uint32_t)num {
		return [[TSString alloc] init_ref:([self ref].getArgument(num))];
	}
	-(const TSString*)getArgument_: (uint32_t)num {
		return [[TSString alloc] init_ref:([self ref].getArgument(num))];
	}
	-(NSArray<TSString*>*)getArguments {
		const auto &ret = [self ref].getArguments();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(BOOL)isArgument: (const char*)name {
		return [self ref].isArgument(name);
	}
	-(BOOL)isArgument_: (const char*)name {
		return [self ref].isArgument(name);
	}
	-(const TSString*)getArgument_1: (const char*)name {
		return [[TSString alloc] init_ref:([self ref].getArgument(name))];
	}
	-(const TSString*)getArgument_1_: (const char*)name {
		return [[TSString alloc] init_ref:([self ref].getArgument(name))];
	}
	-(BOOL)create {
		return [self ref].create();
	}
	-(BOOL)create_1: (TS_Platform)platform {
		return [self ref].create((Tellusim::Platform)platform);
	}
	-(BOOL)create_1_: (TS_Platform)platform {
		return [self ref].create((Tellusim::Platform)platform);
	}
	-(BOOL)create_2: (TS_Platform)platform version: (uint32_t)version {
		return [self ref].create((Tellusim::Platform)platform, version);
	}
	-(BOOL)create_2_: (TS_Platform)platform version: (uint32_t)version {
		return [self ref].create((Tellusim::Platform)platform, version);
	}
	+(void)setPlatform: (TS_Platform)platform {
		Tellusim::App::setPlatform((Tellusim::Platform)platform);
	}
	+(void)setPlatform_: (TS_Platform)platform {
		Tellusim::App::setPlatform((Tellusim::Platform)platform);
	}
	+(void)setPlatform_1: (TS_Platform)platform device: (uint32_t)device {
		Tellusim::App::setPlatform((Tellusim::Platform)platform, device);
	}
	+(void)setPlatform_1_: (TS_Platform)platform device: (uint32_t)device {
		Tellusim::App::setPlatform((Tellusim::Platform)platform, device);
	}
	+(void)setSize: (uint32_t)width height: (uint32_t)height {
		Tellusim::App::setSize(width, height);
	}
	+(void)setSize_: (uint32_t)width height: (uint32_t)height {
		Tellusim::App::setSize(width, height);
	}
	+(void)setSize_1: (uint32_t)width height: (uint32_t)height multisample: (uint32_t)multisample {
		Tellusim::App::setSize(width, height, multisample);
	}
	+(void)setSize_1_: (uint32_t)width height: (uint32_t)height multisample: (uint32_t)multisample {
		Tellusim::App::setSize(width, height, multisample);
	}
	+(BOOL)isBuildDebug {
		return Tellusim::App::isBuildDebug();
	}
	+(BOOL)isBuildFloat64 {
		return Tellusim::App::isBuildFloat64();
	}
	+(NSString*)getBuildDate {
		return [NSString stringWithUTF8String:Tellusim::App::getBuildDate().get()];
	}
	+(NSString*)getBuildInfo {
		return [NSString stringWithUTF8String:Tellusim::App::getBuildInfo().get()];
	}
	+(uint32_t)getVersion {
		return Tellusim::App::getVersion();
	}
	+(uint64_t)getAPIHash {
		return Tellusim::App::getAPIHash();
	}
@end

// Tellusim::Async
@implementation TSAsync
	-(id)init {
		self = [super init];
		impl = new Tellusim::Async();
		return self;
	}
	-(id)init_ptr: (Tellusim::Async*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Async&)ref {
		self = [super init];
		impl = new Tellusim::Async((Tellusim::Async&)ref);
		return self;
	}
	-(Tellusim::Async*)pointer {
		return (Tellusim::Async*)impl;
	}
	-(Tellusim::Async&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Async*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Async*)impl;
	}
	-(BOOL)equalPtr: (const TSAsync*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSAsync*)copyPtr {
		return [[TSAsync alloc] init_ref:[self ref]];
	}
	-(TSAsync*)clonePtr {
		return [[TSAsync alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSAsync*)null {
		return [[TSAsync alloc] init_ptr:nullptr];
	}
	-(BOOL)initialize {
		return [self ref].init();
	}
	-(BOOL)initialize_1: (uint32_t)num {
		return [self ref].init(num);
	}
	-(BOOL)initialize_1_: (uint32_t)num {
		return [self ref].init(num);
	}
	-(BOOL)shutdown {
		return [self ref].shutdown();
	}
	-(BOOL)isInitialized {
		return [self ref].isInitialized();
	}
	+(uint32_t)getNumCores {
		return Tellusim::Async::getNumCores();
	}
	-(uint32_t)getNumThreads {
		return [self ref].getNumThreads();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(uint32_t)getNumTasks {
		return [self ref].getNumTasks();
	}
	-(uint32_t)getNumTasks_1: (BOOL)check {
		return [self ref].getNumTasks((bool)check);
	}
	-(uint32_t)getNumTasks_1_: (BOOL)check {
		return [self ref].getNumTasks((bool)check);
	}
	-(BOOL)check {
		return [self ref].check();
	}
	-(BOOL)wait {
		return [self ref].wait();
	}
@end

// Tellusim::Stream
@implementation TSStream
	-(id)init {
		self = [super init];
		impl = new Tellusim::Stream();
		return self;
	}
	-(id)init_ptr: (Tellusim::Stream*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Stream&)ref {
		self = [super init];
		impl = new Tellusim::Stream((Tellusim::Stream&)ref);
		return self;
	}
	-(Tellusim::Stream*)pointer {
		return (Tellusim::Stream*)impl;
	}
	-(Tellusim::Stream&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Stream*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Stream*)impl;
	}
	-(BOOL)equalPtr: (const TSStream*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSStream*)copyPtr {
		return [[TSStream alloc] init_ref:[self ref]];
	}
	-(TSStream*)clonePtr {
		return [[TSStream alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSStream*)null {
		return [[TSStream alloc] init_ptr:nullptr];
	}
	-(TSStream*)move {
		return [[TSStream alloc] init_ref:([self ref].move())];
	}
	-(BOOL)isOpened {
		return [self ref].isOpened();
	}
	-(BOOL)isMapped {
		return [self ref].isMapped();
	}
	-(BOOL)isAvailable {
		return [self ref].isAvailable();
	}
	-(size_t)getSize {
		return [self ref].getSize();
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(size_t)tell {
		return [self ref].tell();
	}
	-(BOOL)seek: (size_t)offset {
		return [self ref].seek(offset);
	}
	-(BOOL)seek_: (size_t)offset {
		return [self ref].seek(offset);
	}
	-(BOOL)seekBack: (size_t)offset {
		return [self ref].seekBack(offset);
	}
	-(BOOL)seekBack_: (size_t)offset {
		return [self ref].seekBack(offset);
	}
	-(BOOL)seekCur: (int64_t)offset {
		return [self ref].seekCur(offset);
	}
	-(BOOL)seekCur_: (int64_t)offset {
		return [self ref].seekCur(offset);
	}
	-(const uint8_t*)getData {
		return [self ref].getData();
	}
	-(size_t)read: (void*)dest size: (size_t)size {
		return [self ref].read(dest, size);
	}
	-(size_t)read_: (void*)dest size: (size_t)size {
		return [self ref].read(dest, size);
	}
	-(size_t)write: (const void*)src size: (size_t)size {
		return [self ref].write(src, size);
	}
	-(size_t)write_: (const void*)src size: (size_t)size {
		return [self ref].write(src, size);
	}
	-(BOOL)flush {
		return [self ref].flush();
	}
	-(BOOL)puts: (const char*)str {
		return [self ref].puts(str);
	}
	-(BOOL)puts_: (const char*)str {
		return [self ref].puts(str);
	}
	-(BOOL)puts_1: (const TSString*)str {
		return [self ref].puts((str) ? [str ref] : Tellusim::String::null);
	}
	-(BOOL)puts_1_: (const TSString*)str {
		return [self ref].puts((str) ? [str ref] : Tellusim::String::null);
	}
	-(BOOL)vprintf: (const char*)format args: (va_list)args {
		return [self ref].vprintf(format, args);
	}
	-(BOOL)vprintf_: (const char*)format args: (va_list)args {
		return [self ref].vprintf(format, args);
	}
	-(NSString*)gets {
		return [NSString stringWithUTF8String:[self ref].gets().get()];
	}
	-(NSString*)gets_1: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].gets((bool*)status).get()];
	}
	-(NSString*)gets_1_: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].gets((bool*)status).get()];
	}
	-(int8_t)readi8 {
		return [self ref].readi8();
	}
	-(int8_t)readi8_1: (BOOL*)status {
		return [self ref].readi8((bool*)status);
	}
	-(int8_t)readi8_1_: (BOOL*)status {
		return [self ref].readi8((bool*)status);
	}
	-(BOOL)writei8: (int8_t)value {
		return [self ref].writei8(value);
	}
	-(BOOL)writei8_: (int8_t)value {
		return [self ref].writei8(value);
	}
	-(uint8_t)readu8 {
		return [self ref].readu8();
	}
	-(uint8_t)readu8_1: (BOOL*)status {
		return [self ref].readu8((bool*)status);
	}
	-(uint8_t)readu8_1_: (BOOL*)status {
		return [self ref].readu8((bool*)status);
	}
	-(BOOL)writeu8: (uint8_t)value {
		return [self ref].writeu8(value);
	}
	-(BOOL)writeu8_: (uint8_t)value {
		return [self ref].writeu8(value);
	}
	-(int16_t)readi16 {
		return [self ref].readi16();
	}
	-(int16_t)readi16_1: (BOOL*)status {
		return [self ref].readi16((bool*)status);
	}
	-(int16_t)readi16_1_: (BOOL*)status {
		return [self ref].readi16((bool*)status);
	}
	-(BOOL)writei16: (int16_t)value {
		return [self ref].writei16(value);
	}
	-(BOOL)writei16_: (int16_t)value {
		return [self ref].writei16(value);
	}
	-(uint16_t)readu16 {
		return [self ref].readu16();
	}
	-(uint16_t)readu16_1: (BOOL*)status {
		return [self ref].readu16((bool*)status);
	}
	-(uint16_t)readu16_1_: (BOOL*)status {
		return [self ref].readu16((bool*)status);
	}
	-(BOOL)writeu16: (uint16_t)value {
		return [self ref].writeu16(value);
	}
	-(BOOL)writeu16_: (uint16_t)value {
		return [self ref].writeu16(value);
	}
	-(int32_t)readi32 {
		return [self ref].readi32();
	}
	-(int32_t)readi32_1: (BOOL*)status {
		return [self ref].readi32((bool*)status);
	}
	-(int32_t)readi32_1_: (BOOL*)status {
		return [self ref].readi32((bool*)status);
	}
	-(BOOL)writei32: (int32_t)value {
		return [self ref].writei32(value);
	}
	-(BOOL)writei32_: (int32_t)value {
		return [self ref].writei32(value);
	}
	-(uint32_t)readu32 {
		return [self ref].readu32();
	}
	-(uint32_t)readu32_1: (BOOL*)status {
		return [self ref].readu32((bool*)status);
	}
	-(uint32_t)readu32_1_: (BOOL*)status {
		return [self ref].readu32((bool*)status);
	}
	-(BOOL)writeu32: (uint32_t)value {
		return [self ref].writeu32(value);
	}
	-(BOOL)writeu32_: (uint32_t)value {
		return [self ref].writeu32(value);
	}
	-(int64_t)readi64 {
		return [self ref].readi64();
	}
	-(int64_t)readi64_1: (BOOL*)status {
		return [self ref].readi64((bool*)status);
	}
	-(int64_t)readi64_1_: (BOOL*)status {
		return [self ref].readi64((bool*)status);
	}
	-(BOOL)writei64: (int64_t)value {
		return [self ref].writei64(value);
	}
	-(BOOL)writei64_: (int64_t)value {
		return [self ref].writei64(value);
	}
	-(uint64_t)readu64 {
		return [self ref].readu64();
	}
	-(uint64_t)readu64_1: (BOOL*)status {
		return [self ref].readu64((bool*)status);
	}
	-(uint64_t)readu64_1_: (BOOL*)status {
		return [self ref].readu64((bool*)status);
	}
	-(BOOL)writeu64: (uint64_t)value {
		return [self ref].writeu64(value);
	}
	-(BOOL)writeu64_: (uint64_t)value {
		return [self ref].writeu64(value);
	}
	-(float32_t)readf32 {
		return [self ref].readf32();
	}
	-(float32_t)readf32_1: (BOOL*)status {
		return [self ref].readf32((bool*)status);
	}
	-(float32_t)readf32_1_: (BOOL*)status {
		return [self ref].readf32((bool*)status);
	}
	-(BOOL)writef32: (float32_t)value {
		return [self ref].writef32(value);
	}
	-(BOOL)writef32_: (float32_t)value {
		return [self ref].writef32(value);
	}
	-(float64_t)readf64 {
		return [self ref].readf64();
	}
	-(float64_t)readf64_1: (BOOL*)status {
		return [self ref].readf64((bool*)status);
	}
	-(float64_t)readf64_1_: (BOOL*)status {
		return [self ref].readf64((bool*)status);
	}
	-(BOOL)writef64: (float64_t)value {
		return [self ref].writef64(value);
	}
	-(BOOL)writef64_: (float64_t)value {
		return [self ref].writef64(value);
	}
	-(int32_t)readi32e {
		return [self ref].readi32e();
	}
	-(int32_t)readi32e_1: (BOOL*)status {
		return [self ref].readi32e((bool*)status);
	}
	-(int32_t)readi32e_1_: (BOOL*)status {
		return [self ref].readi32e((bool*)status);
	}
	-(BOOL)writei32e: (int32_t)value {
		return [self ref].writei32e(value);
	}
	-(BOOL)writei32e_: (int32_t)value {
		return [self ref].writei32e(value);
	}
	-(uint32_t)readu32e {
		return [self ref].readu32e();
	}
	-(uint32_t)readu32e_1: (BOOL*)status {
		return [self ref].readu32e((bool*)status);
	}
	-(uint32_t)readu32e_1_: (BOOL*)status {
		return [self ref].readu32e((bool*)status);
	}
	-(BOOL)writeu32e: (uint32_t)value {
		return [self ref].writeu32e(value);
	}
	-(BOOL)writeu32e_: (uint32_t)value {
		return [self ref].writeu32e(value);
	}
	-(int64_t)readi64e {
		return [self ref].readi64e();
	}
	-(int64_t)readi64e_1: (BOOL*)status {
		return [self ref].readi64e((bool*)status);
	}
	-(int64_t)readi64e_1_: (BOOL*)status {
		return [self ref].readi64e((bool*)status);
	}
	-(BOOL)writei64e: (int64_t)value {
		return [self ref].writei64e(value);
	}
	-(BOOL)writei64e_: (int64_t)value {
		return [self ref].writei64e(value);
	}
	-(uint64_t)readu64e {
		return [self ref].readu64e();
	}
	-(uint64_t)readu64e_1: (BOOL*)status {
		return [self ref].readu64e((bool*)status);
	}
	-(uint64_t)readu64e_1_: (BOOL*)status {
		return [self ref].readu64e((bool*)status);
	}
	-(BOOL)writeu64e: (uint64_t)value {
		return [self ref].writeu64e(value);
	}
	-(BOOL)writeu64e_: (uint64_t)value {
		return [self ref].writeu64e(value);
	}
	-(NSString*)readString {
		return [NSString stringWithUTF8String:[self ref].readString().get()];
	}
	-(NSString*)readString_1: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].readString((bool*)status).get()];
	}
	-(NSString*)readString_1_: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].readString((bool*)status).get()];
	}
	-(BOOL)writeString: (const TSString*)str {
		return [self ref].writeString((str) ? [str ref] : Tellusim::String::null);
	}
	-(BOOL)writeString_: (const TSString*)str {
		return [self ref].writeString((str) ? [str ref] : Tellusim::String::null);
	}
	-(BOOL)writeString_1: (const char*)str {
		return [self ref].writeString(str);
	}
	-(BOOL)writeString_1_: (const char*)str {
		return [self ref].writeString(str);
	}
	-(NSString*)readString_2: (char)term {
		return [NSString stringWithUTF8String:[self ref].readString(term).get()];
	}
	-(NSString*)readString_2_: (char)term {
		return [NSString stringWithUTF8String:[self ref].readString(term).get()];
	}
	-(NSString*)readString_3: (char)term status: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].readString(term, (bool*)status).get()];
	}
	-(NSString*)readString_3_: (char)term status: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].readString(term, (bool*)status).get()];
	}
	-(NSString*)readString_4: (char)term status: (BOOL*)status size: (uint32_t)size {
		return [NSString stringWithUTF8String:[self ref].readString(term, (bool*)status, size).get()];
	}
	-(NSString*)readString_4_: (char)term status: (BOOL*)status size: (uint32_t)size {
		return [NSString stringWithUTF8String:[self ref].readString(term, (bool*)status, size).get()];
	}
	-(BOOL)writeString_2: (const TSString*)str term: (char)term {
		return [self ref].writeString((str) ? [str ref] : Tellusim::String::null, term);
	}
	-(BOOL)writeString_2_: (const TSString*)str term: (char)term {
		return [self ref].writeString((str) ? [str ref] : Tellusim::String::null, term);
	}
	-(BOOL)writeString_3: (const char*)str term: (char)term {
		return [self ref].writeString(str, term);
	}
	-(BOOL)writeString_3_: (const char*)str term: (char)term {
		return [self ref].writeString(str, term);
	}
	-(NSString*)readToken {
		return [NSString stringWithUTF8String:[self ref].readToken().get()];
	}
	-(NSString*)readToken_1: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].readToken((bool*)status).get()];
	}
	-(NSString*)readToken_1_: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].readToken((bool*)status).get()];
	}
	-(BOOL)readToken_2: (TSString*)dest {
		return [self ref].readToken([dest ref]);
	}
	-(BOOL)readToken_2_: (TSString*)dest {
		return [self ref].readToken([dest ref]);
	}
	-(BOOL)readToken_3: (TSString*)dest clear: (BOOL)clear {
		return [self ref].readToken([dest ref], (bool)clear);
	}
	-(BOOL)readToken_3_: (TSString*)dest clear: (BOOL)clear {
		return [self ref].readToken([dest ref], (bool)clear);
	}
	-(NSString*)readLine {
		return [NSString stringWithUTF8String:[self ref].readLine().get()];
	}
	-(NSString*)readLine_1: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].readLine((bool*)status).get()];
	}
	-(NSString*)readLine_1_: (BOOL*)status {
		return [NSString stringWithUTF8String:[self ref].readLine((bool*)status).get()];
	}
	-(BOOL)readLine_2: (TSString*)dest {
		return [self ref].readLine([dest ref]);
	}
	-(BOOL)readLine_2_: (TSString*)dest {
		return [self ref].readLine([dest ref]);
	}
	-(BOOL)readLine_3: (TSString*)dest empty: (BOOL)empty {
		return [self ref].readLine([dest ref], (bool)empty);
	}
	-(BOOL)readLine_3_: (TSString*)dest empty: (BOOL)empty {
		return [self ref].readLine([dest ref], (bool)empty);
	}
	-(BOOL)readLine_4: (TSString*)dest empty: (BOOL)empty clear: (BOOL)clear {
		return [self ref].readLine([dest ref], (bool)empty, (bool)clear);
	}
	-(BOOL)readLine_4_: (TSString*)dest empty: (BOOL)empty clear: (BOOL)clear {
		return [self ref].readLine([dest ref], (bool)empty, (bool)clear);
	}
	-(size_t)readStream: (TSStream*)dest {
		return [self ref].readStream([dest ref]);
	}
	-(size_t)readStream_: (TSStream*)dest {
		return [self ref].readStream([dest ref]);
	}
	-(size_t)readStream_1: (TSStream*)dest size: (size_t)size {
		return [self ref].readStream([dest ref], size);
	}
	-(size_t)readStream_1_: (TSStream*)dest size: (size_t)size {
		return [self ref].readStream([dest ref], size);
	}
	-(size_t)readStream_2: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].readStream([dest ref], size, (bool*)status);
	}
	-(size_t)readStream_2_: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].readStream([dest ref], size, (bool*)status);
	}
	-(size_t)writeStream: (TSStream*)src {
		return [self ref].writeStream([src ref]);
	}
	-(size_t)writeStream_: (TSStream*)src {
		return [self ref].writeStream([src ref]);
	}
	-(size_t)writeStream_1: (TSStream*)src size: (size_t)size {
		return [self ref].writeStream([src ref], size);
	}
	-(size_t)writeStream_1_: (TSStream*)src size: (size_t)size {
		return [self ref].writeStream([src ref], size);
	}
	-(size_t)writeStream_2: (TSStream*)src size: (size_t)size status: (BOOL*)status {
		return [self ref].writeStream([src ref], size, (bool*)status);
	}
	-(size_t)writeStream_2_: (TSStream*)src size: (size_t)size status: (BOOL*)status {
		return [self ref].writeStream([src ref], size, (bool*)status);
	}
	-(size_t)readZip: (void*)dest size: (size_t)size {
		return [self ref].readZip(dest, size);
	}
	-(size_t)readZip_: (void*)dest size: (size_t)size {
		return [self ref].readZip(dest, size);
	}
	-(size_t)writeZip: (const void*)src size: (size_t)size {
		return [self ref].writeZip(src, size);
	}
	-(size_t)writeZip_: (const void*)src size: (size_t)size {
		return [self ref].writeZip(src, size);
	}
	-(size_t)writeZip_1: (const void*)src size: (size_t)size level: (int32_t)level {
		return [self ref].writeZip(src, size, level);
	}
	-(size_t)writeZip_1_: (const void*)src size: (size_t)size level: (int32_t)level {
		return [self ref].writeZip(src, size, level);
	}
	-(size_t)writeZipFast: (const void*)src size: (size_t)size {
		return [self ref].writeZipFast(src, size);
	}
	-(size_t)writeZipFast_: (const void*)src size: (size_t)size {
		return [self ref].writeZipFast(src, size);
	}
	-(size_t)writeZipBest: (const void*)src size: (size_t)size {
		return [self ref].writeZipBest(src, size);
	}
	-(size_t)writeZipBest_: (const void*)src size: (size_t)size {
		return [self ref].writeZipBest(src, size);
	}
	-(size_t)readLz4: (void*)dest size: (size_t)size {
		return [self ref].readLz4(dest, size);
	}
	-(size_t)readLz4_: (void*)dest size: (size_t)size {
		return [self ref].readLz4(dest, size);
	}
	-(size_t)writeLz4: (const void*)src size: (size_t)size {
		return [self ref].writeLz4(src, size);
	}
	-(size_t)writeLz4_: (const void*)src size: (size_t)size {
		return [self ref].writeLz4(src, size);
	}
	-(size_t)writeLz4_1: (const void*)src size: (size_t)size level: (int32_t)level {
		return [self ref].writeLz4(src, size, level);
	}
	-(size_t)writeLz4_1_: (const void*)src size: (size_t)size level: (int32_t)level {
		return [self ref].writeLz4(src, size, level);
	}
	-(size_t)writeLz4Fast: (const void*)src size: (size_t)size {
		return [self ref].writeLz4Fast(src, size);
	}
	-(size_t)writeLz4Fast_: (const void*)src size: (size_t)size {
		return [self ref].writeLz4Fast(src, size);
	}
	-(size_t)writeLz4Best: (const void*)src size: (size_t)size {
		return [self ref].writeLz4Best(src, size);
	}
	-(size_t)writeLz4Best_: (const void*)src size: (size_t)size {
		return [self ref].writeLz4Best(src, size);
	}
	-(size_t)decodeZip: (TSStream*)src {
		return [self ref].decodeZip([src ref]);
	}
	-(size_t)decodeZip_: (TSStream*)src {
		return [self ref].decodeZip([src ref]);
	}
	-(size_t)decodeZip_1: (TSStream*)src size: (size_t)size {
		return [self ref].decodeZip([src ref], size);
	}
	-(size_t)decodeZip_1_: (TSStream*)src size: (size_t)size {
		return [self ref].decodeZip([src ref], size);
	}
	-(size_t)decodeZip_2: (TSStream*)src size: (size_t)size status: (BOOL*)status {
		return [self ref].decodeZip([src ref], size, (bool*)status);
	}
	-(size_t)decodeZip_2_: (TSStream*)src size: (size_t)size status: (BOOL*)status {
		return [self ref].decodeZip([src ref], size, (bool*)status);
	}
	-(size_t)decodeZip_3: (TSStream*)src size: (size_t)size status: (BOOL*)status window: (int32_t)window {
		return [self ref].decodeZip([src ref], size, (bool*)status, window);
	}
	-(size_t)decodeZip_3_: (TSStream*)src size: (size_t)size status: (BOOL*)status window: (int32_t)window {
		return [self ref].decodeZip([src ref], size, (bool*)status, window);
	}
	-(size_t)encodeZip: (TSStream*)dest {
		return [self ref].encodeZip([dest ref]);
	}
	-(size_t)encodeZip_: (TSStream*)dest {
		return [self ref].encodeZip([dest ref]);
	}
	-(size_t)encodeZip_1: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeZip([dest ref], size);
	}
	-(size_t)encodeZip_1_: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeZip([dest ref], size);
	}
	-(size_t)encodeZip_2: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeZip([dest ref], size, (bool*)status);
	}
	-(size_t)encodeZip_2_: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeZip([dest ref], size, (bool*)status);
	}
	-(size_t)encodeZip_3: (TSStream*)dest size: (size_t)size status: (BOOL*)status level: (int32_t)level {
		return [self ref].encodeZip([dest ref], size, (bool*)status, level);
	}
	-(size_t)encodeZip_3_: (TSStream*)dest size: (size_t)size status: (BOOL*)status level: (int32_t)level {
		return [self ref].encodeZip([dest ref], size, (bool*)status, level);
	}
	-(size_t)encodeZipFast: (TSStream*)dest {
		return [self ref].encodeZipFast([dest ref]);
	}
	-(size_t)encodeZipFast_: (TSStream*)dest {
		return [self ref].encodeZipFast([dest ref]);
	}
	-(size_t)encodeZipFast_1: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeZipFast([dest ref], size);
	}
	-(size_t)encodeZipFast_1_: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeZipFast([dest ref], size);
	}
	-(size_t)encodeZipFast_2: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeZipFast([dest ref], size, (bool*)status);
	}
	-(size_t)encodeZipFast_2_: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeZipFast([dest ref], size, (bool*)status);
	}
	-(size_t)encodeZipBest: (TSStream*)dest {
		return [self ref].encodeZipBest([dest ref]);
	}
	-(size_t)encodeZipBest_: (TSStream*)dest {
		return [self ref].encodeZipBest([dest ref]);
	}
	-(size_t)encodeZipBest_1: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeZipBest([dest ref], size);
	}
	-(size_t)encodeZipBest_1_: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeZipBest([dest ref], size);
	}
	-(size_t)encodeZipBest_2: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeZipBest([dest ref], size, (bool*)status);
	}
	-(size_t)encodeZipBest_2_: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeZipBest([dest ref], size, (bool*)status);
	}
	-(size_t)decodeLz4: (TSStream*)src {
		return [self ref].decodeLz4([src ref]);
	}
	-(size_t)decodeLz4_: (TSStream*)src {
		return [self ref].decodeLz4([src ref]);
	}
	-(size_t)decodeLz4_1: (TSStream*)src size: (size_t)size {
		return [self ref].decodeLz4([src ref], size);
	}
	-(size_t)decodeLz4_1_: (TSStream*)src size: (size_t)size {
		return [self ref].decodeLz4([src ref], size);
	}
	-(size_t)decodeLz4_2: (TSStream*)src size: (size_t)size status: (BOOL*)status {
		return [self ref].decodeLz4([src ref], size, (bool*)status);
	}
	-(size_t)decodeLz4_2_: (TSStream*)src size: (size_t)size status: (BOOL*)status {
		return [self ref].decodeLz4([src ref], size, (bool*)status);
	}
	-(size_t)encodeLz4: (TSStream*)dest {
		return [self ref].encodeLz4([dest ref]);
	}
	-(size_t)encodeLz4_: (TSStream*)dest {
		return [self ref].encodeLz4([dest ref]);
	}
	-(size_t)encodeLz4_1: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeLz4([dest ref], size);
	}
	-(size_t)encodeLz4_1_: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeLz4([dest ref], size);
	}
	-(size_t)encodeLz4_2: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeLz4([dest ref], size, (bool*)status);
	}
	-(size_t)encodeLz4_2_: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeLz4([dest ref], size, (bool*)status);
	}
	-(size_t)encodeLz4_3: (TSStream*)dest size: (size_t)size status: (BOOL*)status level: (int32_t)level {
		return [self ref].encodeLz4([dest ref], size, (bool*)status, level);
	}
	-(size_t)encodeLz4_3_: (TSStream*)dest size: (size_t)size status: (BOOL*)status level: (int32_t)level {
		return [self ref].encodeLz4([dest ref], size, (bool*)status, level);
	}
	-(size_t)encodeLz4Fast: (TSStream*)dest {
		return [self ref].encodeLz4Fast([dest ref]);
	}
	-(size_t)encodeLz4Fast_: (TSStream*)dest {
		return [self ref].encodeLz4Fast([dest ref]);
	}
	-(size_t)encodeLz4Fast_1: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeLz4Fast([dest ref], size);
	}
	-(size_t)encodeLz4Fast_1_: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeLz4Fast([dest ref], size);
	}
	-(size_t)encodeLz4Fast_2: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeLz4Fast([dest ref], size, (bool*)status);
	}
	-(size_t)encodeLz4Fast_2_: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeLz4Fast([dest ref], size, (bool*)status);
	}
	-(size_t)encodeLz4Best: (TSStream*)dest {
		return [self ref].encodeLz4Best([dest ref]);
	}
	-(size_t)encodeLz4Best_: (TSStream*)dest {
		return [self ref].encodeLz4Best([dest ref]);
	}
	-(size_t)encodeLz4Best_1: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeLz4Best([dest ref], size);
	}
	-(size_t)encodeLz4Best_1_: (TSStream*)dest size: (size_t)size {
		return [self ref].encodeLz4Best([dest ref], size);
	}
	-(size_t)encodeLz4Best_2: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeLz4Best([dest ref], size, (bool*)status);
	}
	-(size_t)encodeLz4Best_2_: (TSStream*)dest size: (size_t)size status: (BOOL*)status {
		return [self ref].encodeLz4Best([dest ref], size, (bool*)status);
	}
@end

// Tellusim::Blob
@implementation TSBlob
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob();
		return self;
	}
	-(id)init_2: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(name);
		return self;
	}
	-(id)init_2_: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(name);
		return self;
	}
	-(id)init_3: (const TSString*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob((name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_3_: (const TSString*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob((name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4: (const uint8_t*)data size: (size_t)size {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(data, size);
		return self;
	}
	-(id)init_4_: (const uint8_t*)data size: (size_t)size {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(data, size);
		return self;
	}
	-(id)init_5: (const uint8_t*)data size: (size_t)size name: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(data, size, name);
		return self;
	}
	-(id)init_5_: (const uint8_t*)data size: (size_t)size name: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(data, size, name);
		return self;
	}
	-(id)init_6: (const uint8_t(*)[256])blob {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(blob);
		return self;
	}
	-(id)init_6_: (const uint8_t(*)[256])blob {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(blob);
		return self;
	}
	-(id)init_7: (const uint8_t(*)[256])blob name: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(blob, name);
		return self;
	}
	-(id)init_7_: (const uint8_t(*)[256])blob name: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob(blob, name);
		return self;
	}
	-(id)init_8: (const TSBlob*)blob move: (BOOL)move {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob([blob ref], (bool)move);
		return self;
	}
	-(id)init_8_: (const TSBlob*)blob move: (BOOL)move {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob([blob ref], (bool)move);
		return self;
	}
	-(id)init_ptr: (Tellusim::Blob*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Blob&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Blob((Tellusim::Blob&)ref);
		return self;
	}
	-(Tellusim::Blob*)pointer {
		return (Tellusim::Blob*)impl;
	}
	-(Tellusim::Blob&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Blob*)impl;
	}
	-(BOOL)equalPtr: (const TSBlob*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSBlob*)copyPtr {
		return [[TSBlob alloc] init_ref:[self ref]];
	}
	-(TSBlob*)clonePtr {
		return [[TSBlob alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSBlob*)null {
		return [[TSBlob alloc] init_ptr:nullptr];
	}
	-(void)release_ {
		[self ref].release();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_1: (const TSString*)name {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setName_1_: (const TSString*)name {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setSize: (size_t)size {
		[self ref].setSize(size);
	}
	-(void)setSize_: (size_t)size {
		[self ref].setSize(size);
	}
	-(void)setCapacity: (size_t)size {
		[self ref].setCapacity(size);
	}
	-(void)setCapacity_: (size_t)size {
		[self ref].setCapacity(size);
	}
	-(size_t)getCapacity {
		return [self ref].getCapacity();
	}
	-(BOOL)setData: (const uint8_t*)data size: (size_t)size {
		return [self ref].setData(data, size);
	}
	-(BOOL)setData_: (const uint8_t*)data size: (size_t)size {
		return [self ref].setData(data, size);
	}
	-(BOOL)setData_1: (const uint8_t(*)[256])blob {
		return [self ref].setData(blob);
	}
	-(BOOL)setData_1_: (const uint8_t(*)[256])blob {
		return [self ref].setData(blob);
	}
	-(BOOL)setData_2: (const TSBlob*)blob {
		return [self ref].setData([blob ref]);
	}
	-(BOOL)setData_2_: (const TSBlob*)blob {
		return [self ref].setData([blob ref]);
	}
	-(const uint8_t*)getData_1 {
		return [self ref].getData();
	}
	-(uint8_t*)getData_2 {
		return [self ref].getData();
	}
	-(NSString*)encodeBase64 {
		return [NSString stringWithUTF8String:[self ref].encodeBase64().get()];
	}
	-(NSString*)encodeBase64_1: (size_t)size {
		return [NSString stringWithUTF8String:[self ref].encodeBase64(size).get()];
	}
	-(NSString*)encodeBase64_1_: (size_t)size {
		return [NSString stringWithUTF8String:[self ref].encodeBase64(size).get()];
	}
	-(BOOL)decodeBase64: (const char*)src {
		return [self ref].decodeBase64(src);
	}
	-(BOOL)decodeBase64_: (const char*)src {
		return [self ref].decodeBase64(src);
	}
	-(void)getMD5: (uint32_t[ 4])hash {
		[self ref].getMD5(hash);
	}
	-(void)getMD5_: (uint32_t[ 4])hash {
		[self ref].getMD5(hash);
	}
	-(void)getMD5_1: (uint32_t[ 4])hash size: (size_t)size {
		[self ref].getMD5(hash, size);
	}
	-(void)getMD5_1_: (uint32_t[ 4])hash size: (size_t)size {
		[self ref].getMD5(hash, size);
	}
	-(NSString*)getMD5_2 {
		return [NSString stringWithUTF8String:[self ref].getMD5().get()];
	}
	-(NSString*)getMD5_3: (size_t)size {
		return [NSString stringWithUTF8String:[self ref].getMD5(size).get()];
	}
	-(NSString*)getMD5_3_: (size_t)size {
		return [NSString stringWithUTF8String:[self ref].getMD5(size).get()];
	}
	+(NSString*)getMD5_4: (const TSString*)str {
		return [NSString stringWithUTF8String:Tellusim::Blob::getMD5((str) ? [str ref] : Tellusim::String::null).get()];
	}
	+(NSString*)getMD5_4_: (const TSString*)str {
		return [NSString stringWithUTF8String:Tellusim::Blob::getMD5((str) ? [str ref] : Tellusim::String::null).get()];
	}
	+(NSString*)getMD5_5: (const void*)src size: (size_t)size {
		return [NSString stringWithUTF8String:Tellusim::Blob::getMD5(src, size).get()];
	}
	+(NSString*)getMD5_5_: (const void*)src size: (size_t)size {
		return [NSString stringWithUTF8String:Tellusim::Blob::getMD5(src, size).get()];
	}
	+(NSString*)getMD5_6: (TSStream*)src {
		return [NSString stringWithUTF8String:Tellusim::Blob::getMD5([src ref]).get()];
	}
	+(NSString*)getMD5_6_: (TSStream*)src {
		return [NSString stringWithUTF8String:Tellusim::Blob::getMD5([src ref]).get()];
	}
	+(NSString*)getMD5_7: (TSStream*)src size: (size_t)size {
		return [NSString stringWithUTF8String:Tellusim::Blob::getMD5([src ref], size).get()];
	}
	+(NSString*)getMD5_7_: (TSStream*)src size: (size_t)size {
		return [NSString stringWithUTF8String:Tellusim::Blob::getMD5([src ref], size).get()];
	}
	-(void)getSHA1: (uint32_t[ 5])hash {
		[self ref].getSHA1(hash);
	}
	-(void)getSHA1_: (uint32_t[ 5])hash {
		[self ref].getSHA1(hash);
	}
	-(void)getSHA1_1: (uint32_t[ 5])hash size: (size_t)size {
		[self ref].getSHA1(hash, size);
	}
	-(void)getSHA1_1_: (uint32_t[ 5])hash size: (size_t)size {
		[self ref].getSHA1(hash, size);
	}
	-(NSString*)getSHA1_2 {
		return [NSString stringWithUTF8String:[self ref].getSHA1().get()];
	}
	-(NSString*)getSHA1_3: (size_t)size {
		return [NSString stringWithUTF8String:[self ref].getSHA1(size).get()];
	}
	-(NSString*)getSHA1_3_: (size_t)size {
		return [NSString stringWithUTF8String:[self ref].getSHA1(size).get()];
	}
	+(NSString*)getSHA1_4: (const TSString*)str {
		return [NSString stringWithUTF8String:Tellusim::Blob::getSHA1((str) ? [str ref] : Tellusim::String::null).get()];
	}
	+(NSString*)getSHA1_4_: (const TSString*)str {
		return [NSString stringWithUTF8String:Tellusim::Blob::getSHA1((str) ? [str ref] : Tellusim::String::null).get()];
	}
	+(NSString*)getSHA1_5: (const void*)src size: (size_t)size {
		return [NSString stringWithUTF8String:Tellusim::Blob::getSHA1(src, size).get()];
	}
	+(NSString*)getSHA1_5_: (const void*)src size: (size_t)size {
		return [NSString stringWithUTF8String:Tellusim::Blob::getSHA1(src, size).get()];
	}
	+(NSString*)getSHA1_6: (TSStream*)src {
		return [NSString stringWithUTF8String:Tellusim::Blob::getSHA1([src ref]).get()];
	}
	+(NSString*)getSHA1_6_: (TSStream*)src {
		return [NSString stringWithUTF8String:Tellusim::Blob::getSHA1([src ref]).get()];
	}
	+(NSString*)getSHA1_7: (TSStream*)src size: (size_t)size {
		return [NSString stringWithUTF8String:Tellusim::Blob::getSHA1([src ref], size).get()];
	}
	+(NSString*)getSHA1_7_: (TSStream*)src size: (size_t)size {
		return [NSString stringWithUTF8String:Tellusim::Blob::getSHA1([src ref], size).get()];
	}
@end

// Tellusim::File
@implementation TSFile
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::File();
		return self;
	}
	-(id)init_ptr: (Tellusim::File*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::File&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::File((Tellusim::File&)ref);
		return self;
	}
	-(Tellusim::File*)pointer {
		return (Tellusim::File*)impl;
	}
	-(Tellusim::File&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::File*)impl;
	}
	-(BOOL)equalPtr: (const TSFile*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFile*)copyPtr {
		return [[TSFile alloc] init_ref:[self ref]];
	}
	-(TSFile*)clonePtr {
		return [[TSFile alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFile*)null {
		return [[TSFile alloc] init_ptr:nullptr];
	}
	-(BOOL)open: (const char*)name mode: (const char*)mode {
		return [self ref].open(name, mode);
	}
	-(BOOL)open_: (const char*)name mode: (const char*)mode {
		return [self ref].open(name, mode);
	}
	-(BOOL)open_1: (const TSString*)name mode: (const char*)mode {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, mode);
	}
	-(BOOL)open_1_: (const TSString*)name mode: (const char*)mode {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, mode);
	}
	-(BOOL)open_2: (int32_t)fd name: (const char*)name mode: (const char*)mode {
		return [self ref].open(fd, name, mode);
	}
	-(BOOL)open_2_: (int32_t)fd name: (const char*)name mode: (const char*)mode {
		return [self ref].open(fd, name, mode);
	}
	-(BOOL)popen: (const char*)command mode: (const char*)mode {
		return [self ref].popen(command, mode);
	}
	-(BOOL)popen_: (const char*)command mode: (const char*)mode {
		return [self ref].popen(command, mode);
	}
	-(BOOL)popen_1: (const TSString*)command mode: (const char*)mode {
		return [self ref].popen((command) ? [command ref] : Tellusim::String::null, mode);
	}
	-(BOOL)popen_1_: (const TSString*)command mode: (const char*)mode {
		return [self ref].popen((command) ? [command ref] : Tellusim::String::null, mode);
	}
	-(void)close {
		[self ref].close();
	}
	+(BOOL)isFile: (const char*)name {
		return Tellusim::File::isFile(name);
	}
	+(BOOL)isFile_: (const char*)name {
		return Tellusim::File::isFile(name);
	}
	+(BOOL)isFile_1: (const TSString*)name {
		return Tellusim::File::isFile((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)isFile_1_: (const TSString*)name {
		return Tellusim::File::isFile((name) ? [name ref] : Tellusim::String::null);
	}
	+(uint64_t)getMTime: (const char*)name {
		return Tellusim::File::getMTime(name);
	}
	+(uint64_t)getMTime_: (const char*)name {
		return Tellusim::File::getMTime(name);
	}
	+(size_t)getSize_1: (const char*)name {
		return Tellusim::File::getSize(name);
	}
	+(size_t)getSize_1_: (const char*)name {
		return Tellusim::File::getSize(name);
	}
	+(BOOL)remove: (const char*)name {
		return Tellusim::File::remove(name);
	}
	+(BOOL)remove_: (const char*)name {
		return Tellusim::File::remove(name);
	}
@end

// Tellusim::Socket
@implementation TSSocket
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Socket();
		return self;
	}
	-(id)init_2: (TS_SocketType)type {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Socket((Tellusim::Socket::Type)type);
		return self;
	}
	-(id)init_2_: (TS_SocketType)type {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Socket((Tellusim::Socket::Type)type);
		return self;
	}
	-(id)init_ptr: (Tellusim::Socket*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Socket&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Socket((Tellusim::Socket&)ref);
		return self;
	}
	-(Tellusim::Socket*)pointer {
		return (Tellusim::Socket*)impl;
	}
	-(Tellusim::Socket&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Socket*)impl;
	}
	-(BOOL)equalPtr: (const TSSocket*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSSocket*)copyPtr {
		return [[TSSocket alloc] init_ref:[self ref]];
	}
	-(TSSocket*)clonePtr {
		return [[TSSocket alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSSocket*)null {
		return [[TSSocket alloc] init_ptr:nullptr];
	}
	-(BOOL)open: (uint16_t)port {
		return [self ref].open(port);
	}
	-(BOOL)open_: (uint16_t)port {
		return [self ref].open(port);
	}
	-(BOOL)open_1: (uint16_t)port num: (uint16_t)num {
		return [self ref].open(port, num);
	}
	-(BOOL)open_1_: (uint16_t)port num: (uint16_t)num {
		return [self ref].open(port, num);
	}
	-(BOOL)open_2: (const char*)name port: (uint16_t)port {
		return [self ref].open(name, port);
	}
	-(BOOL)open_2_: (const char*)name port: (uint16_t)port {
		return [self ref].open(name, port);
	}
	-(BOOL)open_3: (const TSString*)name port: (uint16_t)port {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, port);
	}
	-(BOOL)open_3_: (const TSString*)name port: (uint16_t)port {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, port);
	}
	-(void)close {
		[self ref].close();
	}
	-(BOOL)connect: (uint32_t)sec {
		return [self ref].connect(sec);
	}
	-(BOOL)connect_: (uint32_t)sec {
		return [self ref].connect(sec);
	}
	-(BOOL)connect_1: (uint32_t)sec usec: (uint32_t)usec {
		return [self ref].connect(sec, usec);
	}
	-(BOOL)connect_1_: (uint32_t)sec usec: (uint32_t)usec {
		return [self ref].connect(sec, usec);
	}
	-(BOOL)accept: (TSSocket*)socket {
		return [self ref].accept([socket ref]);
	}
	-(BOOL)accept_: (TSSocket*)socket {
		return [self ref].accept([socket ref]);
	}
	-(BOOL)select: (uint32_t)sec {
		return [self ref].select(sec);
	}
	-(BOOL)select_: (uint32_t)sec {
		return [self ref].select(sec);
	}
	-(BOOL)select_1: (uint32_t)sec usec: (uint32_t)usec {
		return [self ref].select(sec, usec);
	}
	-(BOOL)select_1_: (uint32_t)sec usec: (uint32_t)usec {
		return [self ref].select(sec, usec);
	}
	-(BOOL)setTimeout: (uint32_t)sec {
		return [self ref].setTimeout(sec);
	}
	-(BOOL)setTimeout_: (uint32_t)sec {
		return [self ref].setTimeout(sec);
	}
	-(uint32_t)getTimeout {
		return [self ref].getTimeout();
	}
	-(BOOL)setBlock: (BOOL)block {
		return [self ref].setBlock((bool)block);
	}
	-(BOOL)setBlock_: (BOOL)block {
		return [self ref].setBlock((bool)block);
	}
	-(BOOL)getBlock {
		return [self ref].getBlock();
	}
	-(BOOL)setDelay: (BOOL)delay {
		return [self ref].setDelay((bool)delay);
	}
	-(BOOL)setDelay_: (BOOL)delay {
		return [self ref].setDelay((bool)delay);
	}
	-(BOOL)getDelay {
		return [self ref].getDelay();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_1: (const TSString*)name {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setName_1_: (const TSString*)name {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null);
	}
	-(uint16_t)getPort {
		return [self ref].getPort();
	}
	-(int32_t)getFD {
		return [self ref].getFD();
	}
	-(TS_SocketType)getType {
		return (TS_SocketType)[self ref].getType();
	}
	+(NSString*)getAddress {
		return [NSString stringWithUTF8String:Tellusim::Socket::getAddress().get()];
	}
	+(NSString*)getAddress_1: (const char*)delimiter {
		return [NSString stringWithUTF8String:Tellusim::Socket::getAddress(delimiter).get()];
	}
	+(NSString*)getAddress_1_: (const char*)delimiter {
		return [NSString stringWithUTF8String:Tellusim::Socket::getAddress(delimiter).get()];
	}
@end

// Tellusim::SocketSSL
@implementation TSSocketSSL
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::SocketSSL();
		return self;
	}
	-(id)init_ptr: (Tellusim::SocketSSL*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::SocketSSL&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::SocketSSL((Tellusim::SocketSSL&)ref);
		return self;
	}
	-(Tellusim::SocketSSL*)pointer {
		return (Tellusim::SocketSSL*)impl;
	}
	-(Tellusim::SocketSSL&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::SocketSSL*)impl;
	}
	-(id)initSocket: (TSSocket*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::SocketSSL([base ref]);
		return self;
	}
	-(TSSocket*)getSocket {
		return [[TSSocket alloc] init_ref:([self ref].getSocket())];
	}
	-(BOOL)equalPtr: (const TSSocketSSL*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSSocketSSL*)copyPtr {
		return [[TSSocketSSL alloc] init_ref:[self ref]];
	}
	-(TSSocketSSL*)clonePtr {
		return [[TSSocketSSL alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSSocketSSL*)null {
		return [[TSSocketSSL alloc] init_ptr:nullptr];
	}
	-(BOOL)handshake {
		return [self ref].handshake();
	}
	-(BOOL)handshake_1: (const char*)name {
		return [self ref].handshake(name);
	}
	-(BOOL)handshake_1_: (const char*)name {
		return [self ref].handshake(name);
	}
	-(BOOL)accept_1: (TSSocketSSL*)socket {
		return [self ref].accept([socket ref]);
	}
	-(BOOL)accept_1_: (TSSocketSSL*)socket {
		return [self ref].accept([socket ref]);
	}
	-(BOOL)accept_2: (TSSocket*)socket {
		return [self ref].accept([socket ref]);
	}
	-(BOOL)accept_2_: (TSSocket*)socket {
		return [self ref].accept([socket ref]);
	}
	-(BOOL)load: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)load_: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)load_1: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_1_: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_2: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)load_2_: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)isConnected {
		return [self ref].isConnected();
	}
@end

// Tellusim::Source
@implementation TSSource
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Source();
		return self;
	}
	-(id)init_2: (const uint8_t*)data size: (size_t)size {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Source(data, size);
		return self;
	}
	-(id)init_2_: (const uint8_t*)data size: (size_t)size {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Source(data, size);
		return self;
	}
	-(id)init_3: (const uint8_t*)data size: (size_t)size name: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Source(data, size, name);
		return self;
	}
	-(id)init_3_: (const uint8_t*)data size: (size_t)size name: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Source(data, size, name);
		return self;
	}
	-(id)init_ptr: (Tellusim::Source*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Source&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::Source((Tellusim::Source&)ref);
		return self;
	}
	-(Tellusim::Source*)pointer {
		return (Tellusim::Source*)impl;
	}
	-(Tellusim::Source&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Source*)impl;
	}
	-(BOOL)equalPtr: (const TSSource*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSSource*)copyPtr {
		return [[TSSource alloc] init_ref:[self ref]];
	}
	-(TSSource*)clonePtr {
		return [[TSSource alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSSource*)null {
		return [[TSSource alloc] init_ptr:nullptr];
	}
	-(BOOL)open: (const char*)name {
		return [self ref].open(name);
	}
	-(BOOL)open_: (const char*)name {
		return [self ref].open(name);
	}
	-(BOOL)open_1: (const char*)name callback: (BOOL)callback {
		return [self ref].open(name, (bool)callback);
	}
	-(BOOL)open_1_: (const char*)name callback: (BOOL)callback {
		return [self ref].open(name, (bool)callback);
	}
	-(BOOL)open_2: (const char*)name callback: (BOOL)callback write: (BOOL)write {
		return [self ref].open(name, (bool)callback, (bool)write);
	}
	-(BOOL)open_2_: (const char*)name callback: (BOOL)callback write: (BOOL)write {
		return [self ref].open(name, (bool)callback, (bool)write);
	}
	-(BOOL)open_3: (const TSString*)name {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)open_3_: (const TSString*)name {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)open_4: (const TSString*)name callback: (BOOL)callback {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, (bool)callback);
	}
	-(BOOL)open_4_: (const TSString*)name callback: (BOOL)callback {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, (bool)callback);
	}
	-(BOOL)open_5: (const TSString*)name callback: (BOOL)callback write: (BOOL)write {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, (bool)callback, (bool)write);
	}
	-(BOOL)open_5_: (const TSString*)name callback: (BOOL)callback write: (BOOL)write {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, (bool)callback, (bool)write);
	}
	-(void)close {
		[self ref].close();
	}
	-(void)setName: (const char*)name offset: (size_t)offset size: (size_t)size {
		[self ref].setName(name, offset, size);
	}
	-(void)setName_: (const char*)name offset: (size_t)offset size: (size_t)size {
		[self ref].setName(name, offset, size);
	}
	-(void)setName_1: (const TSString*)name offset: (size_t)offset size: (size_t)size {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null, offset, size);
	}
	-(void)setName_1_: (const TSString*)name offset: (size_t)offset size: (size_t)size {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null, offset, size);
	}
	-(void)setData: (const uint8_t*)data size: (size_t)size {
		[self ref].setData(data, size);
	}
	-(void)setData_: (const uint8_t*)data size: (size_t)size {
		[self ref].setData(data, size);
	}
	-(void)setData_1: (const uint8_t*)data size: (size_t)size name: (const char*)name {
		[self ref].setData(data, size, name);
	}
	-(void)setData_1_: (const uint8_t*)data size: (size_t)size name: (const char*)name {
		[self ref].setData(data, size, name);
	}
	+(BOOL)isSource: (const char*)name {
		return Tellusim::Source::isSource(name);
	}
	+(BOOL)isSource_: (const char*)name {
		return Tellusim::Source::isSource(name);
	}
	+(BOOL)isSource_1: (const TSString*)name {
		return Tellusim::Source::isSource((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)isSource_1_: (const TSString*)name {
		return Tellusim::Source::isSource((name) ? [name ref] : Tellusim::String::null);
	}
	+(uint64_t)getMTime: (const char*)name {
		return Tellusim::Source::getMTime(name);
	}
	+(uint64_t)getMTime_: (const char*)name {
		return Tellusim::Source::getMTime(name);
	}
	+(size_t)getSize_1: (const char*)name {
		return Tellusim::Source::getSize(name);
	}
	+(size_t)getSize_1_: (const char*)name {
		return Tellusim::Source::getSize(name);
	}
@end

// Tellusim::Date
@implementation TSDate
	-(id)init {
		self = [super init];
		impl = new Tellusim::Date();
		return self;
	}
	-(id)init_1: (int64_t)time {
		self = [super init];
		impl = new Tellusim::Date(time);
		return self;
	}
	-(id)init_1_: (int64_t)time {
		self = [super init];
		impl = new Tellusim::Date(time);
		return self;
	}
	-(id)init_2: (int64_t)time local: (BOOL)local {
		self = [super init];
		impl = new Tellusim::Date(time, (bool)local);
		return self;
	}
	-(id)init_2_: (int64_t)time local: (BOOL)local {
		self = [super init];
		impl = new Tellusim::Date(time, (bool)local);
		return self;
	}
	-(id)init_3: (const char*)str {
		self = [super init];
		impl = new Tellusim::Date(str);
		return self;
	}
	-(id)init_3_: (const char*)str {
		self = [super init];
		impl = new Tellusim::Date(str);
		return self;
	}
	-(id)init_4: (const char*)str format: (const char*)format {
		self = [super init];
		impl = new Tellusim::Date(str, format);
		return self;
	}
	-(id)init_4_: (const char*)str format: (const char*)format {
		self = [super init];
		impl = new Tellusim::Date(str, format);
		return self;
	}
	-(id)init_ptr: (Tellusim::Date*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Date&)ref {
		self = [super init];
		impl = new Tellusim::Date((Tellusim::Date&)ref);
		return self;
	}
	-(Tellusim::Date*)pointer {
		return (Tellusim::Date*)impl;
	}
	-(Tellusim::Date&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Date*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Date*)impl;
	}
	-(BOOL)equalPtr: (const TSDate*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDate*)copyPtr {
		return [[TSDate alloc] init_ref:[self ref]];
	}
	-(TSDate*)clonePtr {
		return [[TSDate alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDate*)null {
		return [[TSDate alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(void)setTime: (int64_t)time {
		[self ref].setTime(time);
	}
	-(void)setTime_: (int64_t)time {
		[self ref].setTime(time);
	}
	-(void)setTime_1: (int64_t)time local: (BOOL)local {
		[self ref].setTime(time, (bool)local);
	}
	-(void)setTime_1_: (int64_t)time local: (BOOL)local {
		[self ref].setTime(time, (bool)local);
	}
	-(int64_t)getTime {
		return [self ref].getTime();
	}
	-(int64_t)getTime_1: (BOOL)local {
		return [self ref].getTime((bool)local);
	}
	-(int64_t)getTime_1_: (BOOL)local {
		return [self ref].getTime((bool)local);
	}
	-(BOOL)setString: (const char*)str {
		return [self ref].setString(str);
	}
	-(BOOL)setString_: (const char*)str {
		return [self ref].setString(str);
	}
	-(BOOL)setString_1: (const char*)str format: (const char*)format {
		return [self ref].setString(str, format);
	}
	-(BOOL)setString_1_: (const char*)str format: (const char*)format {
		return [self ref].setString(str, format);
	}
	-(NSString*)getString {
		return [NSString stringWithUTF8String:[self ref].getString().get()];
	}
	-(NSString*)getString_1: (const char*)format {
		return [NSString stringWithUTF8String:[self ref].getString(format).get()];
	}
	-(NSString*)getString_1_: (const char*)format {
		return [NSString stringWithUTF8String:[self ref].getString(format).get()];
	}
	-(void)setYear: (uint32_t)year {
		[self ref].setYear(year);
	}
	-(void)setYear_: (uint32_t)year {
		[self ref].setYear(year);
	}
	-(void)setMonth: (uint32_t)month {
		[self ref].setMonth(month);
	}
	-(void)setMonth_: (uint32_t)month {
		[self ref].setMonth(month);
	}
	-(void)setDate: (uint32_t)date {
		[self ref].setDate(date);
	}
	-(void)setDate_: (uint32_t)date {
		[self ref].setDate(date);
	}
	-(void)setDay: (uint32_t)day {
		[self ref].setDay(day);
	}
	-(void)setDay_: (uint32_t)day {
		[self ref].setDay(day);
	}
	-(void)setHours: (uint32_t)hours {
		[self ref].setHours(hours);
	}
	-(void)setHours_: (uint32_t)hours {
		[self ref].setHours(hours);
	}
	-(void)setMinutes: (uint32_t)minutes {
		[self ref].setMinutes(minutes);
	}
	-(void)setMinutes_: (uint32_t)minutes {
		[self ref].setMinutes(minutes);
	}
	-(void)setSeconds: (uint32_t)seconds {
		[self ref].setSeconds(seconds);
	}
	-(void)setSeconds_: (uint32_t)seconds {
		[self ref].setSeconds(seconds);
	}
	-(uint32_t)getYear {
		return [self ref].getYear();
	}
	-(uint32_t)getMonth {
		return [self ref].getMonth();
	}
	-(uint32_t)getDate {
		return [self ref].getDate();
	}
	-(uint32_t)getDay {
		return [self ref].getDay();
	}
	-(uint32_t)getHours {
		return [self ref].getHours();
	}
	-(uint32_t)getMinutes {
		return [self ref].getMinutes();
	}
	-(uint32_t)getSeconds {
		return [self ref].getSeconds();
	}
	+(int32_t)getTimeZone {
		return Tellusim::Date::getTimeZone();
	}
@end

// Tellusim::Info
@implementation TSInfo
	-(id)init {
		self = [super init];
		impl = new Tellusim::Info();
		return self;
	}
	-(id)init_ptr: (Tellusim::Info*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Info&)ref {
		self = [super init];
		impl = new Tellusim::Info((Tellusim::Info&)ref);
		return self;
	}
	-(Tellusim::Info*)pointer {
		return (Tellusim::Info*)impl;
	}
	-(Tellusim::Info&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Info*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Info*)impl;
	}
	-(BOOL)equalPtr: (const TSInfo*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSInfo*)copyPtr {
		return [[TSInfo alloc] init_ref:[self ref]];
	}
	-(TSInfo*)clonePtr {
		return [[TSInfo alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSInfo*)null {
		return [[TSInfo alloc] init_ptr:nullptr];
	}
	-(size_t)getSystemMemory {
		return [self ref].getSystemMemory();
	}
	-(uint64_t)getSystemUptime {
		return [self ref].getSystemUptime();
	}
	-(NSString*)getSystemName {
		return [NSString stringWithUTF8String:[self ref].getSystemName().get()];
	}
	-(NSString*)getSystemVersion {
		return [NSString stringWithUTF8String:[self ref].getSystemVersion().get()];
	}
	-(NSString*)getKernelVersion {
		return [NSString stringWithUTF8String:[self ref].getKernelVersion().get()];
	}
	-(uint32_t)getCPUCount {
		return [self ref].getCPUCount();
	}
	-(NSString*)getCPUName: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getCPUName(index).get()];
	}
	-(NSString*)getCPUName_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getCPUName(index).get()];
	}
	-(NSString*)getCPUVendor: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getCPUVendor(index).get()];
	}
	-(NSString*)getCPUVendor_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getCPUVendor(index).get()];
	}
	-(uint32_t)getCPUCores: (uint32_t)index {
		return [self ref].getCPUCores(index);
	}
	-(uint32_t)getCPUCores_: (uint32_t)index {
		return [self ref].getCPUCores(index);
	}
	-(uint32_t)getCPUThreads: (uint32_t)index {
		return [self ref].getCPUThreads(index);
	}
	-(uint32_t)getCPUThreads_: (uint32_t)index {
		return [self ref].getCPUThreads(index);
	}
	-(uint64_t)getCPUFrequency: (uint32_t)index {
		return [self ref].getCPUFrequency(index);
	}
	-(uint64_t)getCPUFrequency_: (uint32_t)index {
		return [self ref].getCPUFrequency(index);
	}
	-(uint32_t)getCPUTemperature: (uint32_t)index {
		return [self ref].getCPUTemperature(index);
	}
	-(uint32_t)getCPUTemperature_: (uint32_t)index {
		return [self ref].getCPUTemperature(index);
	}
	-(uint32_t)getCPUUtilization: (uint32_t)index {
		return [self ref].getCPUUtilization(index);
	}
	-(uint32_t)getCPUUtilization_: (uint32_t)index {
		return [self ref].getCPUUtilization(index);
	}
	-(uint32_t)getCPUFanSpeed: (uint32_t)index {
		return [self ref].getCPUFanSpeed(index);
	}
	-(uint32_t)getCPUFanSpeed_: (uint32_t)index {
		return [self ref].getCPUFanSpeed(index);
	}
	-(uint32_t)getCPUPower: (uint32_t)index {
		return [self ref].getCPUPower(index);
	}
	-(uint32_t)getCPUPower_: (uint32_t)index {
		return [self ref].getCPUPower(index);
	}
	-(uint32_t)getGPUCount {
		return [self ref].getGPUCount();
	}
	-(NSString*)getGPUName: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUName(index).get()];
	}
	-(NSString*)getGPUName_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUName(index).get()];
	}
	-(NSString*)getGPUVendor: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUVendor(index).get()];
	}
	-(NSString*)getGPUVendor_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUVendor(index).get()];
	}
	-(NSString*)getGPUSerial: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUSerial(index).get()];
	}
	-(NSString*)getGPUSerial_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUSerial(index).get()];
	}
	-(NSString*)getGPUDevice: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUDevice(index).get()];
	}
	-(NSString*)getGPUDevice_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUDevice(index).get()];
	}
	-(NSString*)getGPUVersion: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUVersion(index).get()];
	}
	-(NSString*)getGPUVersion_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getGPUVersion(index).get()];
	}
	-(size_t)getGPUMemory: (uint32_t)index {
		return [self ref].getGPUMemory(index);
	}
	-(size_t)getGPUMemory_: (uint32_t)index {
		return [self ref].getGPUMemory(index);
	}
	-(uint32_t)getGPUScreens: (uint32_t)index {
		return [self ref].getGPUScreens(index);
	}
	-(uint32_t)getGPUScreens_: (uint32_t)index {
		return [self ref].getGPUScreens(index);
	}
	-(uint64_t)getGPUFrequency: (uint32_t)index {
		return [self ref].getGPUFrequency(index);
	}
	-(uint64_t)getGPUFrequency_: (uint32_t)index {
		return [self ref].getGPUFrequency(index);
	}
	-(uint32_t)getGPUTemperature: (uint32_t)index {
		return [self ref].getGPUTemperature(index);
	}
	-(uint32_t)getGPUTemperature_: (uint32_t)index {
		return [self ref].getGPUTemperature(index);
	}
	-(uint32_t)getGPUUtilization: (uint32_t)index {
		return [self ref].getGPUUtilization(index);
	}
	-(uint32_t)getGPUUtilization_: (uint32_t)index {
		return [self ref].getGPUUtilization(index);
	}
	-(uint32_t)getGPUFanSpeed: (uint32_t)index {
		return [self ref].getGPUFanSpeed(index);
	}
	-(uint32_t)getGPUFanSpeed_: (uint32_t)index {
		return [self ref].getGPUFanSpeed(index);
	}
	-(uint32_t)getGPUPower: (uint32_t)index {
		return [self ref].getGPUPower(index);
	}
	-(uint32_t)getGPUPower_: (uint32_t)index {
		return [self ref].getGPUPower(index);
	}
	-(BOOL)isGPUThrottling: (uint32_t)index {
		return [self ref].isGPUThrottling(index);
	}
	-(BOOL)isGPUThrottling_: (uint32_t)index {
		return [self ref].isGPUThrottling(index);
	}
@end

// Tellusim::Directory
@implementation TSDirectory
	-(id)init {
		self = [super init];
		impl = new Tellusim::Directory();
		return self;
	}
	-(id)init_ptr: (Tellusim::Directory*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Directory&)ref {
		self = [super init];
		impl = new Tellusim::Directory((Tellusim::Directory&)ref);
		return self;
	}
	-(Tellusim::Directory*)pointer {
		return (Tellusim::Directory*)impl;
	}
	-(Tellusim::Directory&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Directory*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Directory*)impl;
	}
	-(BOOL)equalPtr: (const TSDirectory*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDirectory*)copyPtr {
		return [[TSDirectory alloc] init_ref:[self ref]];
	}
	-(TSDirectory*)clonePtr {
		return [[TSDirectory alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDirectory*)null {
		return [[TSDirectory alloc] init_ptr:nullptr];
	}
	-(BOOL)open: (const char*)name {
		return [self ref].open(name);
	}
	-(BOOL)open_: (const char*)name {
		return [self ref].open(name);
	}
	-(BOOL)open_1: (const char*)name children: (BOOL)children {
		return [self ref].open(name, (bool)children);
	}
	-(BOOL)open_1_: (const char*)name children: (BOOL)children {
		return [self ref].open(name, (bool)children);
	}
	-(BOOL)open_2: (const TSString*)name {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)open_2_: (const TSString*)name {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)open_3: (const TSString*)name children: (BOOL)children {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, (bool)children);
	}
	-(BOOL)open_3_: (const TSString*)name children: (BOOL)children {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, (bool)children);
	}
	-(void)close {
		[self ref].close();
	}
	-(BOOL)isOpened {
		return [self ref].isOpened();
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(uint32_t)getNumFiles {
		return [self ref].getNumFiles();
	}
	-(NSString*)getFileName: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getFileName(index).get()];
	}
	-(NSString*)getFileName_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getFileName(index).get()];
	}
	-(TS_DirectoryAttributes)getFileAttributes: (uint32_t)index {
		return (TS_DirectoryAttributes)[self ref].getFileAttributes(index);
	}
	-(TS_DirectoryAttributes)getFileAttributes_: (uint32_t)index {
		return (TS_DirectoryAttributes)[self ref].getFileAttributes(index);
	}
	-(uint64_t)getFileMTime: (uint32_t)index {
		return [self ref].getFileMTime(index);
	}
	-(uint64_t)getFileMTime_: (uint32_t)index {
		return [self ref].getFileMTime(index);
	}
	-(uint64_t)getFileATime: (uint32_t)index {
		return [self ref].getFileATime(index);
	}
	-(uint64_t)getFileATime_: (uint32_t)index {
		return [self ref].getFileATime(index);
	}
	-(uint64_t)getFileCTime: (uint32_t)index {
		return [self ref].getFileCTime(index);
	}
	-(uint64_t)getFileCTime_: (uint32_t)index {
		return [self ref].getFileCTime(index);
	}
	-(size_t)getFileSize: (uint32_t)index {
		return [self ref].getFileSize(index);
	}
	-(size_t)getFileSize_: (uint32_t)index {
		return [self ref].getFileSize(index);
	}
	-(NSArray<TSString*>*)getFiles {
		const auto &ret = [self ref].getFiles();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(uint32_t)getNumDirectories {
		return [self ref].getNumDirectories();
	}
	-(NSString*)getDirectoryName: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getDirectoryName(index).get()];
	}
	-(NSString*)getDirectoryName_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getDirectoryName(index).get()];
	}
	-(TS_DirectoryAttributes)getDirectoryAttributes: (uint32_t)index {
		return (TS_DirectoryAttributes)[self ref].getDirectoryAttributes(index);
	}
	-(TS_DirectoryAttributes)getDirectoryAttributes_: (uint32_t)index {
		return (TS_DirectoryAttributes)[self ref].getDirectoryAttributes(index);
	}
	-(uint64_t)getDirectoryCTime: (uint32_t)index {
		return [self ref].getDirectoryCTime(index);
	}
	-(uint64_t)getDirectoryCTime_: (uint32_t)index {
		return [self ref].getDirectoryCTime(index);
	}
	-(uint32_t)getDirectorySize: (uint32_t)index {
		return [self ref].getDirectorySize(index);
	}
	-(uint32_t)getDirectorySize_: (uint32_t)index {
		return [self ref].getDirectorySize(index);
	}
	-(NSArray<TSString*>*)getDirectories {
		const auto &ret = [self ref].getDirectories();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
	+(BOOL)isFile: (const char*)name {
		return Tellusim::Directory::isFile(name);
	}
	+(BOOL)isFile_: (const char*)name {
		return Tellusim::Directory::isFile(name);
	}
	+(BOOL)isFile_1: (const TSString*)name {
		return Tellusim::Directory::isFile((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)isFile_1_: (const TSString*)name {
		return Tellusim::Directory::isFile((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)setFileAttributes: (const char*)name attributes: (TS_DirectoryAttributes)attributes {
		return Tellusim::Directory::setFileAttributes(name, (Tellusim::Directory::Attributes)attributes);
	}
	+(BOOL)setFileAttributes_: (const char*)name attributes: (TS_DirectoryAttributes)attributes {
		return Tellusim::Directory::setFileAttributes(name, (Tellusim::Directory::Attributes)attributes);
	}
	+(TS_DirectoryAttributes)getFileAttributes_1: (const char*)name {
		return (TS_DirectoryAttributes)Tellusim::Directory::getFileAttributes(name);
	}
	+(TS_DirectoryAttributes)getFileAttributes_1_: (const char*)name {
		return (TS_DirectoryAttributes)Tellusim::Directory::getFileAttributes(name);
	}
	+(BOOL)setFileMTime: (const char*)name time: (uint64_t)time {
		return Tellusim::Directory::setFileMTime(name, time);
	}
	+(BOOL)setFileMTime_: (const char*)name time: (uint64_t)time {
		return Tellusim::Directory::setFileMTime(name, time);
	}
	+(uint64_t)getFileMTime_1: (const char*)name {
		return Tellusim::Directory::getFileMTime(name);
	}
	+(uint64_t)getFileMTime_1_: (const char*)name {
		return Tellusim::Directory::getFileMTime(name);
	}
	+(uint64_t)getFileATime_1: (const char*)name {
		return Tellusim::Directory::getFileATime(name);
	}
	+(uint64_t)getFileATime_1_: (const char*)name {
		return Tellusim::Directory::getFileATime(name);
	}
	+(uint64_t)getFileCTime_1: (const char*)name {
		return Tellusim::Directory::getFileCTime(name);
	}
	+(uint64_t)getFileCTime_1_: (const char*)name {
		return Tellusim::Directory::getFileCTime(name);
	}
	+(size_t)getFileSize_1: (const char*)name {
		return Tellusim::Directory::getFileSize(name);
	}
	+(size_t)getFileSize_1_: (const char*)name {
		return Tellusim::Directory::getFileSize(name);
	}
	+(size_t)getFileSize_2: (const TSString*)name {
		return Tellusim::Directory::getFileSize((name) ? [name ref] : Tellusim::String::null);
	}
	+(size_t)getFileSize_2_: (const TSString*)name {
		return Tellusim::Directory::getFileSize((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)removeFile: (const char*)name {
		return Tellusim::Directory::removeFile(name);
	}
	+(BOOL)removeFile_: (const char*)name {
		return Tellusim::Directory::removeFile(name);
	}
	+(BOOL)removeFile_1: (const TSString*)name {
		return Tellusim::Directory::removeFile((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)removeFile_1_: (const TSString*)name {
		return Tellusim::Directory::removeFile((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)copyFile: (const char*)name new_name: (const char*)new_name {
		return Tellusim::Directory::copyFile(name, new_name);
	}
	+(BOOL)copyFile_: (const char*)name new_name: (const char*)new_name {
		return Tellusim::Directory::copyFile(name, new_name);
	}
	+(BOOL)copyFile_1: (const char*)name new_name: (const char*)new_name attributes: (BOOL)attributes {
		return Tellusim::Directory::copyFile(name, new_name, (bool)attributes);
	}
	+(BOOL)copyFile_1_: (const char*)name new_name: (const char*)new_name attributes: (BOOL)attributes {
		return Tellusim::Directory::copyFile(name, new_name, (bool)attributes);
	}
	+(BOOL)copyFile_2: (const TSString*)name new_name: (const TSString*)new_name {
		return Tellusim::Directory::copyFile((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null);
	}
	+(BOOL)copyFile_2_: (const TSString*)name new_name: (const TSString*)new_name {
		return Tellusim::Directory::copyFile((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null);
	}
	+(BOOL)copyFile_3: (const TSString*)name new_name: (const TSString*)new_name attributes: (BOOL)attributes {
		return Tellusim::Directory::copyFile((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null, (bool)attributes);
	}
	+(BOOL)copyFile_3_: (const TSString*)name new_name: (const TSString*)new_name attributes: (BOOL)attributes {
		return Tellusim::Directory::copyFile((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null, (bool)attributes);
	}
	+(BOOL)isDirectory: (const char*)name {
		return Tellusim::Directory::isDirectory(name);
	}
	+(BOOL)isDirectory_: (const char*)name {
		return Tellusim::Directory::isDirectory(name);
	}
	+(BOOL)isDirectory_1: (const TSString*)name {
		return Tellusim::Directory::isDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)isDirectory_1_: (const TSString*)name {
		return Tellusim::Directory::isDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)changeDirectory: (const char*)name {
		return Tellusim::Directory::changeDirectory(name);
	}
	+(BOOL)changeDirectory_: (const char*)name {
		return Tellusim::Directory::changeDirectory(name);
	}
	+(BOOL)changeDirectory_1: (const TSString*)name {
		return Tellusim::Directory::changeDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)changeDirectory_1_: (const TSString*)name {
		return Tellusim::Directory::changeDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)createDirectory: (const char*)name {
		return Tellusim::Directory::createDirectory(name);
	}
	+(BOOL)createDirectory_: (const char*)name {
		return Tellusim::Directory::createDirectory(name);
	}
	+(BOOL)createDirectory_1: (const char*)name children: (BOOL)children {
		return Tellusim::Directory::createDirectory(name, (bool)children);
	}
	+(BOOL)createDirectory_1_: (const char*)name children: (BOOL)children {
		return Tellusim::Directory::createDirectory(name, (bool)children);
	}
	+(BOOL)createDirectory_2: (const TSString*)name {
		return Tellusim::Directory::createDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)createDirectory_2_: (const TSString*)name {
		return Tellusim::Directory::createDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)createDirectory_3: (const TSString*)name children: (BOOL)children {
		return Tellusim::Directory::createDirectory((name) ? [name ref] : Tellusim::String::null, (bool)children);
	}
	+(BOOL)createDirectory_3_: (const TSString*)name children: (BOOL)children {
		return Tellusim::Directory::createDirectory((name) ? [name ref] : Tellusim::String::null, (bool)children);
	}
	+(BOOL)removeDirectory: (const char*)name {
		return Tellusim::Directory::removeDirectory(name);
	}
	+(BOOL)removeDirectory_: (const char*)name {
		return Tellusim::Directory::removeDirectory(name);
	}
	+(BOOL)removeDirectory_1: (const char*)name children: (BOOL)children {
		return Tellusim::Directory::removeDirectory(name, (bool)children);
	}
	+(BOOL)removeDirectory_1_: (const char*)name children: (BOOL)children {
		return Tellusim::Directory::removeDirectory(name, (bool)children);
	}
	+(BOOL)removeDirectory_2: (const TSString*)name {
		return Tellusim::Directory::removeDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)removeDirectory_2_: (const TSString*)name {
		return Tellusim::Directory::removeDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	+(BOOL)removeDirectory_3: (const TSString*)name children: (BOOL)children {
		return Tellusim::Directory::removeDirectory((name) ? [name ref] : Tellusim::String::null, (bool)children);
	}
	+(BOOL)removeDirectory_3_: (const TSString*)name children: (BOOL)children {
		return Tellusim::Directory::removeDirectory((name) ? [name ref] : Tellusim::String::null, (bool)children);
	}
	+(BOOL)copyDirectory: (const char*)name new_name: (const char*)new_name {
		return Tellusim::Directory::copyDirectory(name, new_name);
	}
	+(BOOL)copyDirectory_: (const char*)name new_name: (const char*)new_name {
		return Tellusim::Directory::copyDirectory(name, new_name);
	}
	+(BOOL)copyDirectory_1: (const char*)name new_name: (const char*)new_name attributes: (BOOL)attributes {
		return Tellusim::Directory::copyDirectory(name, new_name, (bool)attributes);
	}
	+(BOOL)copyDirectory_1_: (const char*)name new_name: (const char*)new_name attributes: (BOOL)attributes {
		return Tellusim::Directory::copyDirectory(name, new_name, (bool)attributes);
	}
	+(BOOL)copyDirectory_2: (const TSString*)name new_name: (const TSString*)new_name {
		return Tellusim::Directory::copyDirectory((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null);
	}
	+(BOOL)copyDirectory_2_: (const TSString*)name new_name: (const TSString*)new_name {
		return Tellusim::Directory::copyDirectory((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null);
	}
	+(BOOL)copyDirectory_3: (const TSString*)name new_name: (const TSString*)new_name attributes: (BOOL)attributes {
		return Tellusim::Directory::copyDirectory((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null, (bool)attributes);
	}
	+(BOOL)copyDirectory_3_: (const TSString*)name new_name: (const TSString*)new_name attributes: (BOOL)attributes {
		return Tellusim::Directory::copyDirectory((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null, (bool)attributes);
	}
	+(BOOL)rename: (const char*)name new_name: (const char*)new_name {
		return Tellusim::Directory::rename(name, new_name);
	}
	+(BOOL)rename_: (const char*)name new_name: (const char*)new_name {
		return Tellusim::Directory::rename(name, new_name);
	}
	+(BOOL)rename_1: (const TSString*)name new_name: (const TSString*)new_name {
		return Tellusim::Directory::rename((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null);
	}
	+(BOOL)rename_1_: (const TSString*)name new_name: (const TSString*)new_name {
		return Tellusim::Directory::rename((name) ? [name ref] : Tellusim::String::null, (new_name) ? [new_name ref] : Tellusim::String::null);
	}
	+(NSString*)getCurrentDirectory {
		return [NSString stringWithUTF8String:Tellusim::Directory::getCurrentDirectory().get()];
	}
	+(NSString*)getHomeDirectory {
		return [NSString stringWithUTF8String:Tellusim::Directory::getHomeDirectory().get()];
	}
	+(NSString*)getTempDirectory {
		return [NSString stringWithUTF8String:Tellusim::Directory::getTempDirectory().get()];
	}
	+(NSString*)getConfigDirectory {
		return [NSString stringWithUTF8String:Tellusim::Directory::getConfigDirectory().get()];
	}
	+(NSString*)getDocumentsDirectory {
		return [NSString stringWithUTF8String:Tellusim::Directory::getDocumentsDirectory().get()];
	}
	+(NSArray<TSString*>*)getDriveNames {
		const auto &ret = Tellusim::Directory::getDriveNames();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSString alloc] init_ref:ret[i]]];
		return [array copy];
	}
@end

// Tellusim::Archive
@implementation TSArchive
	-(id)init {
		self = [super init];
		impl = new Tellusim::Archive();
		return self;
	}
	-(id)init_ptr: (Tellusim::Archive*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(Tellusim::Archive*)pointer {
		return (Tellusim::Archive*)impl;
	}
	-(Tellusim::Archive&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Archive*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Archive*)impl;
	}
	-(BOOL)open: (const char*)name {
		return [self ref].open(name);
	}
	-(BOOL)open_: (const char*)name {
		return [self ref].open(name);
	}
	-(BOOL)open_1: (const char*)name type: (const char*)type {
		return [self ref].open(name, type);
	}
	-(BOOL)open_1_: (const char*)name type: (const char*)type {
		return [self ref].open(name, type);
	}
	-(BOOL)open_2: (const TSString*)name {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)open_2_: (const TSString*)name {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)open_3: (const TSString*)name type: (const char*)type {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, type);
	}
	-(BOOL)open_3_: (const TSString*)name type: (const char*)type {
		return [self ref].open((name) ? [name ref] : Tellusim::String::null, type);
	}
	-(BOOL)open_4: (TSStream*)stream {
		return [self ref].open([stream ref]);
	}
	-(BOOL)open_4_: (TSStream*)stream {
		return [self ref].open([stream ref]);
	}
	-(BOOL)open_5: (TSStream*)stream type: (const char*)type {
		return [self ref].open([stream ref], type);
	}
	-(BOOL)open_5_: (TSStream*)stream type: (const char*)type {
		return [self ref].open([stream ref], type);
	}
	-(void)close {
		[self ref].close();
	}
	-(BOOL)isOpened {
		return [self ref].isOpened();
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(uint32_t)getNumFiles {
		return [self ref].getNumFiles();
	}
	-(NSString*)getFileName: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getFileName(index).get()];
	}
	-(NSString*)getFileName_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getFileName(index).get()];
	}
	-(uint64_t)getFileMTime: (uint32_t)index {
		return [self ref].getFileMTime(index);
	}
	-(uint64_t)getFileMTime_: (uint32_t)index {
		return [self ref].getFileMTime(index);
	}
	-(size_t)getFileSize: (uint32_t)index {
		return [self ref].getFileSize(index);
	}
	-(size_t)getFileSize_: (uint32_t)index {
		return [self ref].getFileSize(index);
	}
	-(uint32_t)findFile: (const char*)name {
		return [self ref].findFile(name);
	}
	-(uint32_t)findFile_: (const char*)name {
		return [self ref].findFile(name);
	}
	-(uint32_t)findFile_1: (const TSString*)name {
		return [self ref].findFile((name) ? [name ref] : Tellusim::String::null);
	}
	-(uint32_t)findFile_1_: (const TSString*)name {
		return [self ref].findFile((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)isFile: (const char*)name {
		return [self ref].isFile(name);
	}
	-(BOOL)isFile_: (const char*)name {
		return [self ref].isFile(name);
	}
	-(BOOL)isFile_1: (const TSString*)name {
		return [self ref].isFile((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)isFile_1_: (const TSString*)name {
		return [self ref].isFile((name) ? [name ref] : Tellusim::String::null);
	}
	-(TSStream*)openFile: (const char*)name {
		return [[TSStream alloc] init_ref:([self ref].openFile(name))];
	}
	-(TSStream*)openFile_: (const char*)name {
		return [[TSStream alloc] init_ref:([self ref].openFile(name))];
	}
	-(TSStream*)openFile_1: (const TSString*)name {
		return [[TSStream alloc] init_ref:([self ref].openFile((name) ? [name ref] : Tellusim::String::null))];
	}
	-(TSStream*)openFile_1_: (const TSString*)name {
		return [[TSStream alloc] init_ref:([self ref].openFile((name) ? [name ref] : Tellusim::String::null))];
	}
	-(TSStream*)openFile_2: (uint32_t)index {
		return [[TSStream alloc] init_ref:([self ref].openFile(index))];
	}
	-(TSStream*)openFile_2_: (uint32_t)index {
		return [[TSStream alloc] init_ref:([self ref].openFile(index))];
	}
@end

// Tellusim::Image
@implementation TSImage
	-(id)init {
		self = [super init];
		impl = new Tellusim::Image();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::Image(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::Image(name);
		return self;
	}
	-(id)init_2: (const char*)name flags: (TS_ImageFlags)flags {
		self = [super init];
		impl = new Tellusim::Image(name, (Tellusim::Image::Flags)flags);
		return self;
	}
	-(id)init_2_: (const char*)name flags: (TS_ImageFlags)flags {
		self = [super init];
		impl = new Tellusim::Image(name, (Tellusim::Image::Flags)flags);
		return self;
	}
	-(id)init_3: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		self = [super init];
		impl = new Tellusim::Image(name, (Tellusim::Image::Flags)flags, offset);
		return self;
	}
	-(id)init_3_: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		self = [super init];
		impl = new Tellusim::Image(name, (Tellusim::Image::Flags)flags, offset);
		return self;
	}
	-(id)init_4: (TSStream*)stream {
		self = [super init];
		impl = new Tellusim::Image([stream ref]);
		return self;
	}
	-(id)init_4_: (TSStream*)stream {
		self = [super init];
		impl = new Tellusim::Image([stream ref]);
		return self;
	}
	-(id)init_5: (TSStream*)stream flags: (TS_ImageFlags)flags {
		self = [super init];
		impl = new Tellusim::Image([stream ref], (Tellusim::Image::Flags)flags);
		return self;
	}
	-(id)init_5_: (TSStream*)stream flags: (TS_ImageFlags)flags {
		self = [super init];
		impl = new Tellusim::Image([stream ref], (Tellusim::Image::Flags)flags);
		return self;
	}
	-(id)init_6: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		self = [super init];
		impl = new Tellusim::Image([stream ref], (Tellusim::Image::Flags)flags, offset);
		return self;
	}
	-(id)init_6_: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		self = [super init];
		impl = new Tellusim::Image([stream ref], (Tellusim::Image::Flags)flags, offset);
		return self;
	}
	-(id)init_7: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size {
		self = [super init];
		impl = new Tellusim::Image((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size);
		return self;
	}
	-(id)init_7_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size {
		self = [super init];
		impl = new Tellusim::Image((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size);
		return self;
	}
	-(id)init_8: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size flags: (TS_ImageFlags)flags {
		self = [super init];
		impl = new Tellusim::Image((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, (Tellusim::Image::Flags)flags);
		return self;
	}
	-(id)init_8_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size flags: (TS_ImageFlags)flags {
		self = [super init];
		impl = new Tellusim::Image((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, (Tellusim::Image::Flags)flags);
		return self;
	}
	-(id)init_9: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers {
		self = [super init];
		impl = new Tellusim::Image((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers);
		return self;
	}
	-(id)init_9_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers {
		self = [super init];
		impl = new Tellusim::Image((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers);
		return self;
	}
	-(id)init_10: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers flags: (TS_ImageFlags)flags {
		self = [super init];
		impl = new Tellusim::Image((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers, (Tellusim::Image::Flags)flags);
		return self;
	}
	-(id)init_10_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers flags: (TS_ImageFlags)flags {
		self = [super init];
		impl = new Tellusim::Image((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers, (Tellusim::Image::Flags)flags);
		return self;
	}
	-(id)init_ptr: (Tellusim::Image*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Image&)ref {
		self = [super init];
		impl = new Tellusim::Image((Tellusim::Image&)ref);
		return self;
	}
	-(Tellusim::Image*)pointer {
		return (Tellusim::Image*)impl;
	}
	-(Tellusim::Image&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Image*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Image*)impl;
	}
	-(BOOL)equalPtr: (const TSImage*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSImage*)copyPtr {
		return [[TSImage alloc] init_ref:[self ref]];
	}
	-(TSImage*)clonePtr {
		return [[TSImage alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSImage*)null {
		return [[TSImage alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isLoaded {
		return [self ref].isLoaded();
	}
	-(BOOL)isAllocated {
		return [self ref].isAllocated();
	}
	-(TS_ImageType)getType {
		return (TS_ImageType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_ImageType)type {
		return [NSString stringWithUTF8String:Tellusim::Image::getTypeName((Tellusim::Image::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_ImageType)type {
		return [NSString stringWithUTF8String:Tellusim::Image::getTypeName((Tellusim::Image::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)is2DType {
		return [self ref].is2DType();
	}
	-(BOOL)is3DType {
		return [self ref].is3DType();
	}
	-(BOOL)isCubeType {
		return [self ref].isCubeType();
	}
	-(TS_Format)getFormat {
		return (TS_Format)[self ref].getFormat();
	}
	-(NSString*)getFormatName {
		return [NSString stringWithUTF8String:[self ref].getFormatName()];
	}
	-(BOOL)isColorFormat {
		return [self ref].isColorFormat();
	}
	-(BOOL)isDepthFormat {
		return [self ref].isDepthFormat();
	}
	-(BOOL)isPixelFormat {
		return [self ref].isPixelFormat();
	}
	-(BOOL)isPlainFormat {
		return [self ref].isPlainFormat();
	}
	-(BOOL)isMixedFormat {
		return [self ref].isMixedFormat();
	}
	-(BOOL)isBlockFormat {
		return [self ref].isBlockFormat();
	}
	-(BOOL)isStencilFormat {
		return [self ref].isStencilFormat();
	}
	-(BOOL)isNormFormat {
		return [self ref].isNormFormat();
	}
	-(BOOL)isSRGBFormat {
		return [self ref].isSRGBFormat();
	}
	-(BOOL)isFloatFormat {
		return [self ref].isFloatFormat();
	}
	-(BOOL)isSignedFormat {
		return [self ref].isSignedFormat();
	}
	-(BOOL)isUnsignedFormat {
		return [self ref].isUnsignedFormat();
	}
	-(BOOL)isIntegerFormat {
		return [self ref].isIntegerFormat();
	}
	-(BOOL)isi8Format {
		return [self ref].isi8Format();
	}
	-(BOOL)isu8Format {
		return [self ref].isu8Format();
	}
	-(BOOL)is8BitFormat {
		return [self ref].is8BitFormat();
	}
	-(BOOL)isi16Format {
		return [self ref].isi16Format();
	}
	-(BOOL)isu16Format {
		return [self ref].isu16Format();
	}
	-(BOOL)isf16Format {
		return [self ref].isf16Format();
	}
	-(BOOL)is16BitFormat {
		return [self ref].is16BitFormat();
	}
	-(BOOL)isi32Format {
		return [self ref].isi32Format();
	}
	-(BOOL)isu32Format {
		return [self ref].isu32Format();
	}
	-(BOOL)isf32Format {
		return [self ref].isf32Format();
	}
	-(BOOL)is32BitFormat {
		return [self ref].is32BitFormat();
	}
	-(BOOL)isi64Format {
		return [self ref].isi64Format();
	}
	-(BOOL)isu64Format {
		return [self ref].isu64Format();
	}
	-(BOOL)isf64Format {
		return [self ref].isf64Format();
	}
	-(BOOL)is64BitFormat {
		return [self ref].is64BitFormat();
	}
	-(BOOL)isBC15Format {
		return [self ref].isBC15Format();
	}
	-(BOOL)isBC67Format {
		return [self ref].isBC67Format();
	}
	-(BOOL)isETC2Format {
		return [self ref].isETC2Format();
	}
	-(BOOL)isASTCFormat {
		return [self ref].isASTCFormat();
	}
	-(uint32_t)getComponents {
		return [self ref].getComponents();
	}
	-(uint32_t)getPixelSize {
		return [self ref].getPixelSize();
	}
	-(uint32_t)getBlockSize {
		return [self ref].getBlockSize();
	}
	-(uint32_t)getBlockWidth {
		return [self ref].getBlockWidth();
	}
	-(uint32_t)getBlockHeight {
		return [self ref].getBlockHeight();
	}
	-(uint32_t)getWidth {
		return [self ref].getWidth();
	}
	-(uint32_t)getHeight {
		return [self ref].getHeight();
	}
	-(uint32_t)getDepth {
		return [self ref].getDepth();
	}
	-(uint32_t)getFaces {
		return [self ref].getFaces();
	}
	-(uint32_t)getLayers {
		return [self ref].getLayers();
	}
	-(uint32_t)getMipmaps {
		return [self ref].getMipmaps();
	}
	-(uint32_t)findMipmap: (TSSize)size {
		return [self ref].findMipmap(*(Tellusim::Size*)&size);
	}
	-(uint32_t)findMipmap_: (TSSize)size {
		return [self ref].findMipmap(*(Tellusim::Size*)&size);
	}
	-(uint32_t)getWidth_1: (uint32_t)mipmap {
		return [self ref].getWidth(mipmap);
	}
	-(uint32_t)getWidth_1_: (uint32_t)mipmap {
		return [self ref].getWidth(mipmap);
	}
	-(uint32_t)getHeight_1: (uint32_t)mipmap {
		return [self ref].getHeight(mipmap);
	}
	-(uint32_t)getHeight_1_: (uint32_t)mipmap {
		return [self ref].getHeight(mipmap);
	}
	-(uint32_t)getDepth_1: (uint32_t)mipmap {
		return [self ref].getDepth(mipmap);
	}
	-(uint32_t)getDepth_1_: (uint32_t)mipmap {
		return [self ref].getDepth(mipmap);
	}
	-(BOOL)hasLayers {
		return [self ref].hasLayers();
	}
	-(BOOL)hasMipmaps {
		return [self ref].hasMipmaps();
	}
	-(TSSize)getSize {
		Tellusim::Size ret = [self ref].getSize();
		return *(TSSize*)&ret;
	}
	-(TSRegion)getRegion {
		Tellusim::Region ret = [self ref].getRegion();
		return *(TSRegion*)&ret;
	}
	-(TSSlice)getSlice {
		Tellusim::Slice ret = [self ref].getSlice();
		return *(TSSlice*)&ret;
	}
	-(TSSize)getSize_1: (uint32_t)mipmap {
		Tellusim::Size ret = [self ref].getSize(mipmap);
		return *(TSSize*)&ret;
	}
	-(TSSize)getSize_1_: (uint32_t)mipmap {
		Tellusim::Size ret = [self ref].getSize(mipmap);
		return *(TSSize*)&ret;
	}
	-(TSRegion)getRegion_1: (uint32_t)mipmap {
		Tellusim::Region ret = [self ref].getRegion(mipmap);
		return *(TSRegion*)&ret;
	}
	-(TSRegion)getRegion_1_: (uint32_t)mipmap {
		Tellusim::Region ret = [self ref].getRegion(mipmap);
		return *(TSRegion*)&ret;
	}
	-(TSSlice)getSlice_1: (uint32_t)mipmap {
		Tellusim::Slice ret = [self ref].getSlice(mipmap);
		return *(TSSlice*)&ret;
	}
	-(TSSlice)getSlice_1_: (uint32_t)mipmap {
		Tellusim::Slice ret = [self ref].getSlice(mipmap);
		return *(TSSlice*)&ret;
	}
	-(void)setMetaInfo: (const TSString*)str {
		[self ref].setMetaInfo((str) ? [str ref] : Tellusim::String::null);
	}
	-(void)setMetaInfo_: (const TSString*)str {
		[self ref].setMetaInfo((str) ? [str ref] : Tellusim::String::null);
	}
	-(NSString*)getMetaInfo {
		return [NSString stringWithUTF8String:[self ref].getMetaInfo().get()];
	}
	-(NSString*)getDescription {
		return [NSString stringWithUTF8String:[self ref].getDescription().get()];
	}
	-(size_t)getOffset: (TSSlice)slice {
		return [self ref].getOffset(*(Tellusim::Slice*)&slice);
	}
	-(size_t)getOffset_: (TSSlice)slice {
		return [self ref].getOffset(*(Tellusim::Slice*)&slice);
	}
	-(size_t)getOffset_1: (TSSlice)slice alignment: (uint32_t)alignment {
		return [self ref].getOffset(*(Tellusim::Slice*)&slice, alignment);
	}
	-(size_t)getOffset_1_: (TSSlice)slice alignment: (uint32_t)alignment {
		return [self ref].getOffset(*(Tellusim::Slice*)&slice, alignment);
	}
	-(size_t)getStride {
		return [self ref].getStride();
	}
	-(size_t)getStride_1: (uint32_t)mipmap {
		return [self ref].getStride(mipmap);
	}
	-(size_t)getStride_1_: (uint32_t)mipmap {
		return [self ref].getStride(mipmap);
	}
	-(size_t)getStride_2: (uint32_t)mipmap alignment: (uint32_t)alignment {
		return [self ref].getStride(mipmap, alignment);
	}
	-(size_t)getStride_2_: (uint32_t)mipmap alignment: (uint32_t)alignment {
		return [self ref].getStride(mipmap, alignment);
	}
	-(size_t)getMipmapSize: (uint32_t)mipmap {
		return [self ref].getMipmapSize(mipmap);
	}
	-(size_t)getMipmapSize_: (uint32_t)mipmap {
		return [self ref].getMipmapSize(mipmap);
	}
	-(size_t)getMipmapSize_1: (uint32_t)mipmap alignment: (uint32_t)alignment {
		return [self ref].getMipmapSize(mipmap, alignment);
	}
	-(size_t)getMipmapSize_1_: (uint32_t)mipmap alignment: (uint32_t)alignment {
		return [self ref].getMipmapSize(mipmap, alignment);
	}
	-(size_t)getLayerSize {
		return [self ref].getLayerSize();
	}
	-(size_t)getLayerSize_1: (uint32_t)alignment {
		return [self ref].getLayerSize(alignment);
	}
	-(size_t)getLayerSize_1_: (uint32_t)alignment {
		return [self ref].getLayerSize(alignment);
	}
	-(size_t)getDataSize {
		return [self ref].getDataSize();
	}
	-(size_t)getDataSize_1: (uint32_t)alignment {
		return [self ref].getDataSize(alignment);
	}
	-(size_t)getDataSize_1_: (uint32_t)alignment {
		return [self ref].getDataSize(alignment);
	}
	-(BOOL)create: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size);
	}
	-(BOOL)create_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size);
	}
	-(BOOL)create_1: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size flags: (TS_ImageFlags)flags {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create_1_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size flags: (TS_ImageFlags)flags {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create_2: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers);
	}
	-(BOOL)create_2_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers);
	}
	-(BOOL)create_3: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers flags: (TS_ImageFlags)flags {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create_3_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers flags: (TS_ImageFlags)flags {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create2D: (TS_Format)format size: (uint32_t)size {
		return [self ref].create2D((Tellusim::Format)format, size);
	}
	-(BOOL)create2D_: (TS_Format)format size: (uint32_t)size {
		return [self ref].create2D((Tellusim::Format)format, size);
	}
	-(BOOL)create2D_1: (TS_Format)format size: (uint32_t)size flags: (TS_ImageFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, size, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create2D_1_: (TS_Format)format size: (uint32_t)size flags: (TS_ImageFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, size, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create3D: (TS_Format)format size: (uint32_t)size {
		return [self ref].create3D((Tellusim::Format)format, size);
	}
	-(BOOL)create3D_: (TS_Format)format size: (uint32_t)size {
		return [self ref].create3D((Tellusim::Format)format, size);
	}
	-(BOOL)create3D_1: (TS_Format)format size: (uint32_t)size flags: (TS_ImageFlags)flags {
		return [self ref].create3D((Tellusim::Format)format, size, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create3D_1_: (TS_Format)format size: (uint32_t)size flags: (TS_ImageFlags)flags {
		return [self ref].create3D((Tellusim::Format)format, size, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)createCube: (TS_Format)format size: (uint32_t)size {
		return [self ref].createCube((Tellusim::Format)format, size);
	}
	-(BOOL)createCube_: (TS_Format)format size: (uint32_t)size {
		return [self ref].createCube((Tellusim::Format)format, size);
	}
	-(BOOL)createCube_1: (TS_Format)format size: (uint32_t)size flags: (TS_ImageFlags)flags {
		return [self ref].createCube((Tellusim::Format)format, size, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)createCube_1_: (TS_Format)format size: (uint32_t)size flags: (TS_ImageFlags)flags {
		return [self ref].createCube((Tellusim::Format)format, size, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create2D_2: (TS_Format)format width: (uint32_t)width height: (uint32_t)height {
		return [self ref].create2D((Tellusim::Format)format, width, height);
	}
	-(BOOL)create2D_2_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height {
		return [self ref].create2D((Tellusim::Format)format, width, height);
	}
	-(BOOL)create2D_3: (TS_Format)format width: (uint32_t)width height: (uint32_t)height flags: (TS_ImageFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, width, height, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create2D_3_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height flags: (TS_ImageFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, width, height, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create3D_2: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		return [self ref].create3D((Tellusim::Format)format, width, height, depth);
	}
	-(BOOL)create3D_2_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		return [self ref].create3D((Tellusim::Format)format, width, height, depth);
	}
	-(BOOL)create3D_3: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth flags: (TS_ImageFlags)flags {
		return [self ref].create3D((Tellusim::Format)format, width, height, depth, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create3D_3_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth flags: (TS_ImageFlags)flags {
		return [self ref].create3D((Tellusim::Format)format, width, height, depth, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create2D_4: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers {
		return [self ref].create2D((Tellusim::Format)format, width, height, layers);
	}
	-(BOOL)create2D_4_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers {
		return [self ref].create2D((Tellusim::Format)format, width, height, layers);
	}
	-(BOOL)create2D_5: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers flags: (TS_ImageFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, width, height, layers, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)create2D_5_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers flags: (TS_ImageFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, width, height, layers, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)createCube_2: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers {
		return [self ref].createCube((Tellusim::Format)format, size, layers);
	}
	-(BOOL)createCube_2_: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers {
		return [self ref].createCube((Tellusim::Format)format, size, layers);
	}
	-(BOOL)createCube_3: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers flags: (TS_ImageFlags)flags {
		return [self ref].createCube((Tellusim::Format)format, size, layers, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)createCube_3_: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers flags: (TS_ImageFlags)flags {
		return [self ref].createCube((Tellusim::Format)format, size, layers, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)info: (const char*)name {
		return [self ref].info(name);
	}
	-(BOOL)info_: (const char*)name {
		return [self ref].info(name);
	}
	-(BOOL)info_1: (const char*)name flags: (TS_ImageFlags)flags {
		return [self ref].info(name, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)info_1_: (const char*)name flags: (TS_ImageFlags)flags {
		return [self ref].info(name, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)info_2: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].info(name, (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)info_2_: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].info(name, (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)info_3: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].info(name, (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_3_: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].info(name, (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_4: (const TSString*)name {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)info_4_: (const TSString*)name {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)info_5: (const TSString*)name flags: (TS_ImageFlags)flags {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)info_5_: (const TSString*)name flags: (TS_ImageFlags)flags {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)info_6: (const TSString*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)info_6_: (const TSString*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)info_7: (const TSString*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_7_: (const TSString*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_8: (TSStream*)stream {
		return [self ref].info([stream ref]);
	}
	-(BOOL)info_8_: (TSStream*)stream {
		return [self ref].info([stream ref]);
	}
	-(BOOL)info_9: (TSStream*)stream flags: (TS_ImageFlags)flags {
		return [self ref].info([stream ref], (Tellusim::Image::Flags)flags);
	}
	-(BOOL)info_9_: (TSStream*)stream flags: (TS_ImageFlags)flags {
		return [self ref].info([stream ref], (Tellusim::Image::Flags)flags);
	}
	-(BOOL)info_10: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].info([stream ref], (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)info_10_: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].info([stream ref], (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)info_11: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].info([stream ref], (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_11_: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].info([stream ref], (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_12: (const char*)name async: (TSAsync**)async {
		return [self ref].info(name, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_12_: (const char*)name async: (TSAsync**)async {
		return [self ref].info(name, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_13: (const TSString*)name async: (TSAsync**)async {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_13_: (const TSString*)name async: (TSAsync**)async {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_14: (TSStream*)stream async: (TSAsync**)async {
		return [self ref].info([stream ref], (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_14_: (TSStream*)stream async: (TSAsync**)async {
		return [self ref].info([stream ref], (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_1: (const char*)name flags: (TS_ImageFlags)flags {
		return [self ref].load(name, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)load_1_: (const char*)name flags: (TS_ImageFlags)flags {
		return [self ref].load(name, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)load_2: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].load(name, (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)load_2_: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].load(name, (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)load_3: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].load(name, (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_3_: (const char*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].load(name, (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_4: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)load_4_: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)load_5: (const TSString*)name flags: (TS_ImageFlags)flags {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)load_5_: (const TSString*)name flags: (TS_ImageFlags)flags {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)load_6: (const TSString*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)load_6_: (const TSString*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)load_7: (const TSString*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_7_: (const TSString*)name flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_8: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)load_8_: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)load_9: (TSStream*)stream flags: (TS_ImageFlags)flags {
		return [self ref].load([stream ref], (Tellusim::Image::Flags)flags);
	}
	-(BOOL)load_9_: (TSStream*)stream flags: (TS_ImageFlags)flags {
		return [self ref].load([stream ref], (Tellusim::Image::Flags)flags);
	}
	-(BOOL)load_10: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].load([stream ref], (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)load_10_: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset {
		return [self ref].load([stream ref], (Tellusim::Image::Flags)flags, offset);
	}
	-(BOOL)load_11: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].load([stream ref], (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_11_: (TSStream*)stream flags: (TS_ImageFlags)flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [self ref].load([stream ref], (Tellusim::Image::Flags)flags, offset, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_12: (const char*)name async: (TSAsync**)async {
		return [self ref].load(name, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_12_: (const char*)name async: (TSAsync**)async {
		return [self ref].load(name, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_13: (const TSString*)name async: (TSAsync**)async {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_13_: (const TSString*)name async: (TSAsync**)async {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_14: (TSStream*)stream async: (TSAsync**)async {
		return [self ref].load([stream ref], (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_14_: (TSStream*)stream async: (TSAsync**)async {
		return [self ref].load([stream ref], (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)save: (const char*)name {
		return [self ref].save(name);
	}
	-(BOOL)save_: (const char*)name {
		return [self ref].save(name);
	}
	-(BOOL)save_1: (const char*)name flags: (TS_ImageFlags)flags {
		return [self ref].save(name, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)save_1_: (const char*)name flags: (TS_ImageFlags)flags {
		return [self ref].save(name, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)save_2: (const char*)name flags: (TS_ImageFlags)flags quality: (uint32_t)quality {
		return [self ref].save(name, (Tellusim::Image::Flags)flags, quality);
	}
	-(BOOL)save_2_: (const char*)name flags: (TS_ImageFlags)flags quality: (uint32_t)quality {
		return [self ref].save(name, (Tellusim::Image::Flags)flags, quality);
	}
	-(BOOL)save_3: (const TSString*)name {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)save_3_: (const TSString*)name {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)save_4: (const TSString*)name flags: (TS_ImageFlags)flags {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)save_4_: (const TSString*)name flags: (TS_ImageFlags)flags {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags);
	}
	-(BOOL)save_5: (const TSString*)name flags: (TS_ImageFlags)flags quality: (uint32_t)quality {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, quality);
	}
	-(BOOL)save_5_: (const TSString*)name flags: (TS_ImageFlags)flags quality: (uint32_t)quality {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (Tellusim::Image::Flags)flags, quality);
	}
	-(BOOL)save_6: (TSStream*)stream {
		return [self ref].save([stream ref]);
	}
	-(BOOL)save_6_: (TSStream*)stream {
		return [self ref].save([stream ref]);
	}
	-(BOOL)save_7: (TSStream*)stream flags: (TS_ImageFlags)flags {
		return [self ref].save([stream ref], (Tellusim::Image::Flags)flags);
	}
	-(BOOL)save_7_: (TSStream*)stream flags: (TS_ImageFlags)flags {
		return [self ref].save([stream ref], (Tellusim::Image::Flags)flags);
	}
	-(BOOL)save_8: (TSStream*)stream flags: (TS_ImageFlags)flags quality: (uint32_t)quality {
		return [self ref].save([stream ref], (Tellusim::Image::Flags)flags, quality);
	}
	-(BOOL)save_8_: (TSStream*)stream flags: (TS_ImageFlags)flags quality: (uint32_t)quality {
		return [self ref].save([stream ref], (Tellusim::Image::Flags)flags, quality);
	}
	-(BOOL)swap: (uint32_t)component_0 component_1: (uint32_t)component_1 {
		return [self ref].swap(component_0, component_1);
	}
	-(BOOL)swap_: (uint32_t)component_0 component_1: (uint32_t)component_1 {
		return [self ref].swap(component_0, component_1);
	}
	-(BOOL)copy: (const TSImage*)src dest_component: (uint32_t)dest_component src_component: (uint32_t)src_component {
		return [self ref].copy([src ref], dest_component, src_component);
	}
	-(BOOL)copy_: (const TSImage*)src dest_component: (uint32_t)dest_component src_component: (uint32_t)src_component {
		return [self ref].copy([src ref], dest_component, src_component);
	}
	-(BOOL)flipX: (TSRegion)region slice: (TSSlice)slice {
		return [self ref].flipX(*(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)flipX_: (TSRegion)region slice: (TSSlice)slice {
		return [self ref].flipX(*(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)flipX_1: (TSRegion)region {
		return [self ref].flipX(*(Tellusim::Region*)&region);
	}
	-(BOOL)flipX_1_: (TSRegion)region {
		return [self ref].flipX(*(Tellusim::Region*)&region);
	}
	-(BOOL)flipX_2 {
		return [self ref].flipX();
	}
	-(BOOL)flipY: (TSRegion)region slice: (TSSlice)slice {
		return [self ref].flipY(*(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)flipY_: (TSRegion)region slice: (TSSlice)slice {
		return [self ref].flipY(*(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)flipY_1: (TSRegion)region {
		return [self ref].flipY(*(Tellusim::Region*)&region);
	}
	-(BOOL)flipY_1_: (TSRegion)region {
		return [self ref].flipY(*(Tellusim::Region*)&region);
	}
	-(BOOL)flipY_2 {
		return [self ref].flipY();
	}
	-(BOOL)copy_1: (const TSImage*)src dest_origin: (TSOrigin)dest_origin src_region: (TSRegion)src_region dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].copy([src ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Region*)&src_region, *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copy_1_: (const TSImage*)src dest_origin: (TSOrigin)dest_origin src_region: (TSRegion)src_region dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].copy([src ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Region*)&src_region, *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copy_2: (const TSImage*)src dest_origin: (TSOrigin)dest_origin src_region: (TSRegion)src_region {
		return [self ref].copy([src ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Region*)&src_region);
	}
	-(BOOL)copy_2_: (const TSImage*)src dest_origin: (TSOrigin)dest_origin src_region: (TSRegion)src_region {
		return [self ref].copy([src ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Region*)&src_region);
	}
	-(BOOL)copy_3: (const TSImage*)src dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice {
		return [self ref].copy([src ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice);
	}
	-(BOOL)copy_3_: (const TSImage*)src dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice {
		return [self ref].copy([src ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice);
	}
	-(BOOL)copy_4: (const TSImage*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].copy([src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copy_4_: (const TSImage*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].copy([src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copy_5: (const TSImage*)src dest_origin: (TSOrigin)dest_origin {
		return [self ref].copy([src ref], *(Tellusim::Origin*)&dest_origin);
	}
	-(BOOL)copy_5_: (const TSImage*)src dest_origin: (TSOrigin)dest_origin {
		return [self ref].copy([src ref], *(Tellusim::Origin*)&dest_origin);
	}
	-(BOOL)copy_6: (const TSImage*)src dest_slice: (TSSlice)dest_slice {
		return [self ref].copy([src ref], *(Tellusim::Slice*)&dest_slice);
	}
	-(BOOL)copy_6_: (const TSImage*)src dest_slice: (TSSlice)dest_slice {
		return [self ref].copy([src ref], *(Tellusim::Slice*)&dest_slice);
	}
	-(TSImage*)toType: (TS_ImageType)type flags: (TS_ImageFlags)flags {
		return [[TSImage alloc] init_ref:([self ref].toType((Tellusim::Image::Type)type, (Tellusim::Image::Flags)flags))];
	}
	-(TSImage*)toType_: (TS_ImageType)type flags: (TS_ImageFlags)flags {
		return [[TSImage alloc] init_ref:([self ref].toType((Tellusim::Image::Type)type, (Tellusim::Image::Flags)flags))];
	}
	-(TSImage*)toType_1: (TS_ImageType)type flags: (TS_ImageFlags)flags async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].toType((Tellusim::Image::Type)type, (Tellusim::Image::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)toType_1_: (TS_ImageType)type flags: (TS_ImageFlags)flags async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].toType((Tellusim::Image::Type)type, (Tellusim::Image::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)toType_2: (TS_ImageType)type {
		return [[TSImage alloc] init_ref:([self ref].toType((Tellusim::Image::Type)type))];
	}
	-(TSImage*)toType_2_: (TS_ImageType)type {
		return [[TSImage alloc] init_ref:([self ref].toType((Tellusim::Image::Type)type))];
	}
	-(TSImage*)toType_3: (TS_ImageType)type async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].toType((Tellusim::Image::Type)type, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)toType_3_: (TS_ImageType)type async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].toType((Tellusim::Image::Type)type, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)toFormat: (TS_Format)format flags: (TS_ImageFlags)flags {
		return [[TSImage alloc] init_ref:([self ref].toFormat((Tellusim::Format)format, (Tellusim::Image::Flags)flags))];
	}
	-(TSImage*)toFormat_: (TS_Format)format flags: (TS_ImageFlags)flags {
		return [[TSImage alloc] init_ref:([self ref].toFormat((Tellusim::Format)format, (Tellusim::Image::Flags)flags))];
	}
	-(TSImage*)toFormat_1: (TS_Format)format flags: (TS_ImageFlags)flags async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].toFormat((Tellusim::Format)format, (Tellusim::Image::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)toFormat_1_: (TS_Format)format flags: (TS_ImageFlags)flags async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].toFormat((Tellusim::Format)format, (Tellusim::Image::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)toFormat_2: (TS_Format)format {
		return [[TSImage alloc] init_ref:([self ref].toFormat((Tellusim::Format)format))];
	}
	-(TSImage*)toFormat_2_: (TS_Format)format {
		return [[TSImage alloc] init_ref:([self ref].toFormat((Tellusim::Format)format))];
	}
	-(TSImage*)toFormat_3: (TS_Format)format async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].toFormat((Tellusim::Format)format, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)toFormat_3_: (TS_Format)format async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].toFormat((Tellusim::Format)format, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getSlice_2: (TSSlice)slice {
		return [[TSImage alloc] init_ref:([self ref].getSlice(*(Tellusim::Slice*)&slice))];
	}
	-(TSImage*)getSlice_2_: (TSSlice)slice {
		return [[TSImage alloc] init_ref:([self ref].getSlice(*(Tellusim::Slice*)&slice))];
	}
	-(TSImage*)getComponent: (uint32_t)component {
		return [[TSImage alloc] init_ref:([self ref].getComponent(component))];
	}
	-(TSImage*)getComponent_: (uint32_t)component {
		return [[TSImage alloc] init_ref:([self ref].getComponent(component))];
	}
	-(TSImage*)getRegion_2: (TSRegion)region slice: (TSSlice)slice {
		return [[TSImage alloc] init_ref:([self ref].getRegion(*(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice))];
	}
	-(TSImage*)getRegion_2_: (TSRegion)region slice: (TSSlice)slice {
		return [[TSImage alloc] init_ref:([self ref].getRegion(*(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice))];
	}
	-(TSImage*)getRegion_3: (TSRegion)region {
		return [[TSImage alloc] init_ref:([self ref].getRegion(*(Tellusim::Region*)&region))];
	}
	-(TSImage*)getRegion_3_: (TSRegion)region {
		return [[TSImage alloc] init_ref:([self ref].getRegion(*(Tellusim::Region*)&region))];
	}
	-(TSImage*)getRotated: (int32_t)angle slice: (TSSlice)slice {
		return [[TSImage alloc] init_ref:([self ref].getRotated(angle, *(Tellusim::Slice*)&slice))];
	}
	-(TSImage*)getRotated_: (int32_t)angle slice: (TSSlice)slice {
		return [[TSImage alloc] init_ref:([self ref].getRotated(angle, *(Tellusim::Slice*)&slice))];
	}
	-(TSImage*)getRotated_1: (int32_t)angle {
		return [[TSImage alloc] init_ref:([self ref].getRotated(angle))];
	}
	-(TSImage*)getRotated_1_: (int32_t)angle {
		return [[TSImage alloc] init_ref:([self ref].getRotated(angle))];
	}
	-(TSImage*)getResized: (TSSize)size min: (TS_ImageFilter)min mag: (TS_ImageFilter)mag flags: (TS_ImageFlags)flags {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min, (Tellusim::Image::Filter)mag, (Tellusim::Image::Flags)flags))];
	}
	-(TSImage*)getResized_: (TSSize)size min: (TS_ImageFilter)min mag: (TS_ImageFilter)mag flags: (TS_ImageFlags)flags {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min, (Tellusim::Image::Filter)mag, (Tellusim::Image::Flags)flags))];
	}
	-(TSImage*)getResized_1: (TSSize)size min: (TS_ImageFilter)min mag: (TS_ImageFilter)mag flags: (TS_ImageFlags)flags async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min, (Tellusim::Image::Filter)mag, (Tellusim::Image::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getResized_1_: (TSSize)size min: (TS_ImageFilter)min mag: (TS_ImageFilter)mag flags: (TS_ImageFlags)flags async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min, (Tellusim::Image::Filter)mag, (Tellusim::Image::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getResized_2: (TSSize)size min: (TS_ImageFilter)min {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min))];
	}
	-(TSImage*)getResized_2_: (TSSize)size min: (TS_ImageFilter)min {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min))];
	}
	-(TSImage*)getResized_3: (TSSize)size min: (TS_ImageFilter)min mag: (TS_ImageFilter)mag {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min, (Tellusim::Image::Filter)mag))];
	}
	-(TSImage*)getResized_3_: (TSSize)size min: (TS_ImageFilter)min mag: (TS_ImageFilter)mag {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min, (Tellusim::Image::Filter)mag))];
	}
	-(TSImage*)getResized_4: (TSSize)size min: (TS_ImageFilter)min mag: (TS_ImageFilter)mag async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min, (Tellusim::Image::Filter)mag, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getResized_4_: (TSSize)size min: (TS_ImageFilter)min mag: (TS_ImageFilter)mag async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (Tellusim::Image::Filter)min, (Tellusim::Image::Filter)mag, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getResized_5: (TSSize)size {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size))];
	}
	-(TSImage*)getResized_5_: (TSSize)size {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size))];
	}
	-(TSImage*)getResized_6: (TSSize)size async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getResized_6_: (TSSize)size async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getResized(*(Tellusim::Size*)&size, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getMipmapped: (TS_ImageFilter)filter flags: (TS_ImageFlags)flags {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((Tellusim::Image::Filter)filter, (Tellusim::Image::Flags)flags))];
	}
	-(TSImage*)getMipmapped_: (TS_ImageFilter)filter flags: (TS_ImageFlags)flags {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((Tellusim::Image::Filter)filter, (Tellusim::Image::Flags)flags))];
	}
	-(TSImage*)getMipmapped_1: (TS_ImageFilter)filter flags: (TS_ImageFlags)flags async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((Tellusim::Image::Filter)filter, (Tellusim::Image::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getMipmapped_1_: (TS_ImageFilter)filter flags: (TS_ImageFlags)flags async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((Tellusim::Image::Filter)filter, (Tellusim::Image::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getMipmapped_2: (TS_ImageFilter)filter {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((Tellusim::Image::Filter)filter))];
	}
	-(TSImage*)getMipmapped_2_: (TS_ImageFilter)filter {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((Tellusim::Image::Filter)filter))];
	}
	-(TSImage*)getMipmapped_3: (TS_ImageFilter)filter async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((Tellusim::Image::Filter)filter, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getMipmapped_3_: (TS_ImageFilter)filter async: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((Tellusim::Image::Filter)filter, (async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getMipmapped_4 {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped())];
	}
	-(TSImage*)getMipmapped_5: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((async) ? [*async pointer] : nullptr))];
	}
	-(TSImage*)getMipmapped_5_: (TSAsync**)async {
		return [[TSImage alloc] init_ref:([self ref].getMipmapped((async) ? [*async pointer] : nullptr))];
	}
	-(int32_t)compare: (const TSImage*)image {
		return [self ref].compare([image ref]);
	}
	-(int32_t)compare_: (const TSImage*)image {
		return [self ref].compare([image ref]);
	}
	-(const uint8_t*)getData {
		return [self ref].getData();
	}
	-(const uint8_t*)getData_1: (TSSlice)slice {
		return [self ref].getData(*(Tellusim::Slice*)&slice);
	}
	-(const uint8_t*)getData_1_: (TSSlice)slice {
		return [self ref].getData(*(Tellusim::Slice*)&slice);
	}
	-(uint8_t*)getData_2 {
		return [self ref].getData();
	}
	-(uint8_t*)getData_3: (TSSlice)slice {
		return [self ref].getData(*(Tellusim::Slice*)&slice);
	}
	-(uint8_t*)getData_3_: (TSSlice)slice {
		return [self ref].getData(*(Tellusim::Slice*)&slice);
	}
	-(const uint8_t*)getData_4: (TSOrigin)origin {
		return [self ref].getData(*(Tellusim::Origin*)&origin);
	}
	-(const uint8_t*)getData_4_: (TSOrigin)origin {
		return [self ref].getData(*(Tellusim::Origin*)&origin);
	}
	-(const uint8_t*)getData_5: (TSOrigin)origin slice: (TSSlice)slice {
		return [self ref].getData(*(Tellusim::Origin*)&origin, *(Tellusim::Slice*)&slice);
	}
	-(const uint8_t*)getData_5_: (TSOrigin)origin slice: (TSSlice)slice {
		return [self ref].getData(*(Tellusim::Origin*)&origin, *(Tellusim::Slice*)&slice);
	}
	-(uint8_t*)getData_6: (TSOrigin)origin {
		return [self ref].getData(*(Tellusim::Origin*)&origin);
	}
	-(uint8_t*)getData_6_: (TSOrigin)origin {
		return [self ref].getData(*(Tellusim::Origin*)&origin);
	}
	-(uint8_t*)getData_7: (TSOrigin)origin slice: (TSSlice)slice {
		return [self ref].getData(*(Tellusim::Origin*)&origin, *(Tellusim::Slice*)&slice);
	}
	-(uint8_t*)getData_7_: (TSOrigin)origin slice: (TSSlice)slice {
		return [self ref].getData(*(Tellusim::Origin*)&origin, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)setData: (const void*)src {
		return [self ref].setData(src);
	}
	-(BOOL)setData_: (const void*)src {
		return [self ref].setData(src);
	}
	-(BOOL)setData_1: (const void*)src slice: (TSSlice)slice {
		return [self ref].setData(src, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)setData_1_: (const void*)src slice: (TSSlice)slice {
		return [self ref].setData(src, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)setData_2: (const void*)src slice: (TSSlice)slice alignment: (uint32_t)alignment {
		return [self ref].setData(src, *(Tellusim::Slice*)&slice, alignment);
	}
	-(BOOL)setData_2_: (const void*)src slice: (TSSlice)slice alignment: (uint32_t)alignment {
		return [self ref].setData(src, *(Tellusim::Slice*)&slice, alignment);
	}
	-(BOOL)setData_3: (const void*)src slice: (TSSlice)slice alignment: (uint32_t)alignment stride: (size_t)stride {
		return [self ref].setData(src, *(Tellusim::Slice*)&slice, alignment, stride);
	}
	-(BOOL)setData_3_: (const void*)src slice: (TSSlice)slice alignment: (uint32_t)alignment stride: (size_t)stride {
		return [self ref].setData(src, *(Tellusim::Slice*)&slice, alignment, stride);
	}
	-(BOOL)getData_8: (void*)dest {
		return [self ref].getData(dest);
	}
	-(BOOL)getData_8_: (void*)dest {
		return [self ref].getData(dest);
	}
	-(BOOL)getData_9: (void*)dest slice: (TSSlice)slice {
		return [self ref].getData(dest, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)getData_9_: (void*)dest slice: (TSSlice)slice {
		return [self ref].getData(dest, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)getData_10: (void*)dest slice: (TSSlice)slice alignment: (uint32_t)alignment {
		return [self ref].getData(dest, *(Tellusim::Slice*)&slice, alignment);
	}
	-(BOOL)getData_10_: (void*)dest slice: (TSSlice)slice alignment: (uint32_t)alignment {
		return [self ref].getData(dest, *(Tellusim::Slice*)&slice, alignment);
	}
	-(BOOL)getData_11: (void*)dest slice: (TSSlice)slice alignment: (uint32_t)alignment stride: (size_t)stride {
		return [self ref].getData(dest, *(Tellusim::Slice*)&slice, alignment, stride);
	}
	-(BOOL)getData_11_: (void*)dest slice: (TSSlice)slice alignment: (uint32_t)alignment stride: (size_t)stride {
		return [self ref].getData(dest, *(Tellusim::Slice*)&slice, alignment, stride);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::ImageSampler
@implementation TSImageSampler
	-(id)init {
		self = [super init];
		impl = new Tellusim::ImageSampler();
		return self;
	}
	-(id)init_1: (TSImage*)image {
		self = [super init];
		impl = new Tellusim::ImageSampler([image ref]);
		return self;
	}
	-(id)init_1_: (TSImage*)image {
		self = [super init];
		impl = new Tellusim::ImageSampler([image ref]);
		return self;
	}
	-(id)init_2: (TSImage*)image slice: (TSSlice)slice {
		self = [super init];
		impl = new Tellusim::ImageSampler([image ref], *(Tellusim::Slice*)&slice);
		return self;
	}
	-(id)init_2_: (TSImage*)image slice: (TSSlice)slice {
		self = [super init];
		impl = new Tellusim::ImageSampler([image ref], *(Tellusim::Slice*)&slice);
		return self;
	}
	-(id)init_3: (const TSImage*)image {
		self = [super init];
		impl = new Tellusim::ImageSampler([image ref]);
		return self;
	}
	-(id)init_3_: (const TSImage*)image {
		self = [super init];
		impl = new Tellusim::ImageSampler([image ref]);
		return self;
	}
	-(id)init_4: (const TSImage*)image slice: (TSSlice)slice {
		self = [super init];
		impl = new Tellusim::ImageSampler([image ref], *(Tellusim::Slice*)&slice);
		return self;
	}
	-(id)init_4_: (const TSImage*)image slice: (TSSlice)slice {
		self = [super init];
		impl = new Tellusim::ImageSampler([image ref], *(Tellusim::Slice*)&slice);
		return self;
	}
	-(id)init_ptr: (Tellusim::ImageSampler*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ImageSampler&)ref {
		self = [super init];
		impl = new Tellusim::ImageSampler((Tellusim::ImageSampler&)ref);
		return self;
	}
	-(Tellusim::ImageSampler*)pointer {
		return (Tellusim::ImageSampler*)impl;
	}
	-(Tellusim::ImageSampler&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ImageSampler*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::ImageSampler*)impl;
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(TS_ImageType)getType {
		return (TS_ImageType)[self ref].getType();
	}
	-(BOOL)is2DType {
		return [self ref].is2DType();
	}
	-(BOOL)is3DType {
		return [self ref].is3DType();
	}
	-(BOOL)isCubeType {
		return [self ref].isCubeType();
	}
	-(TS_Format)getFormat {
		return (TS_Format)[self ref].getFormat();
	}
	-(NSString*)getFormatName {
		return [NSString stringWithUTF8String:[self ref].getFormatName()];
	}
	-(uint32_t)getWidth {
		return [self ref].getWidth();
	}
	-(uint32_t)getHeight {
		return [self ref].getHeight();
	}
	-(uint32_t)getDepth {
		return [self ref].getDepth();
	}
	-(uint32_t)getFaces {
		return [self ref].getFaces();
	}
	-(size_t)getTexels {
		return [self ref].getTexels();
	}
	-(TSSize)getSize {
		Tellusim::Size ret = [self ref].getSize();
		return *(TSSize*)&ret;
	}
	-(TSRegion)getRegion {
		Tellusim::Region ret = [self ref].getRegion();
		return *(TSRegion*)&ret;
	}
	-(size_t)getStride {
		return [self ref].getStride();
	}
	-(size_t)getLayerSize {
		return [self ref].getLayerSize();
	}
	-(uint32_t)getPixelSize {
		return [self ref].getPixelSize();
	}
	-(uint32_t)getComponents {
		return [self ref].getComponents();
	}
	-(const uint8_t*)getData {
		return [self ref].getData();
	}
	-(uint8_t*)getData_1 {
		return [self ref].getData();
	}
	-(BOOL)create: (TSImage*)image {
		return [self ref].create([image ref]);
	}
	-(BOOL)create_: (TSImage*)image {
		return [self ref].create([image ref]);
	}
	-(BOOL)create_1: (TSImage*)image slice: (TSSlice)slice {
		return [self ref].create([image ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)create_1_: (TSImage*)image slice: (TSSlice)slice {
		return [self ref].create([image ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)create_2: (const TSImage*)image {
		return [self ref].create([image ref]);
	}
	-(BOOL)create_2_: (const TSImage*)image {
		return [self ref].create([image ref]);
	}
	-(BOOL)create_3: (const TSImage*)image slice: (TSSlice)slice {
		return [self ref].create([image ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)create_3_: (const TSImage*)image slice: (TSSlice)slice {
		return [self ref].create([image ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)create_4: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size stride: (size_t)stride data: (void*)data {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, stride, data);
	}
	-(BOOL)create_4_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size stride: (size_t)stride data: (void*)data {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, stride, data);
	}
	-(BOOL)create_5: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size stride: (size_t)stride data: (const void*)data {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, stride, data);
	}
	-(BOOL)create_5_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size stride: (size_t)stride data: (const void*)data {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, stride, data);
	}
	-(BOOL)create_6: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size stride: (size_t)stride layer_size: (size_t)layer_size data: (void*)data {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, stride, layer_size, data);
	}
	-(BOOL)create_6_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size stride: (size_t)stride layer_size: (size_t)layer_size data: (void*)data {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, stride, layer_size, data);
	}
	-(BOOL)create_7: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size stride: (size_t)stride layer_size: (size_t)layer_size data: (const void*)data {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, stride, layer_size, data);
	}
	-(BOOL)create_7_: (TS_ImageType)type format: (TS_Format)format size: (TSSize)size stride: (size_t)stride layer_size: (size_t)layer_size data: (const void*)data {
		return [self ref].create((Tellusim::Image::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, stride, layer_size, data);
	}
	-(BOOL)clear_1: (TSColor)color {
		return [self ref].clear(*(Tellusim::Color*)&color);
	}
	-(BOOL)clear_1_: (TSColor)color {
		return [self ref].clear(*(Tellusim::Color*)&color);
	}
	-(BOOL)clear_2: (TSImageColor)color {
		return [self ref].clear(*(Tellusim::ImageColor*)&color);
	}
	-(BOOL)clear_2_: (TSImageColor)color {
		return [self ref].clear(*(Tellusim::ImageColor*)&color);
	}
	-(BOOL)mad: (TSColor)m a: (TSColor)a {
		return [self ref].mad(*(Tellusim::Color*)&m, *(Tellusim::Color*)&a);
	}
	-(BOOL)mad_: (TSColor)m a: (TSColor)a {
		return [self ref].mad(*(Tellusim::Color*)&m, *(Tellusim::Color*)&a);
	}
	-(void)set2D: (uint32_t)x y: (uint32_t)y color: (TSImageColor)color {
		[self ref].set2D(x, y, *(Tellusim::ImageColor*)&color);
	}
	-(void)set2D_: (uint32_t)x y: (uint32_t)y color: (TSImageColor)color {
		[self ref].set2D(x, y, *(Tellusim::ImageColor*)&color);
	}
	-(TSImageColor)get2D: (uint32_t)x y: (uint32_t)y {
		Tellusim::ImageColor ret = [self ref].get2D(x, y);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get2D_: (uint32_t)x y: (uint32_t)y {
		Tellusim::ImageColor ret = [self ref].get2D(x, y);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get2D_1: (uint32_t)x y: (uint32_t)y repeat: (BOOL)repeat {
		Tellusim::ImageColor ret = [self ref].get2D(x, y, (bool)repeat);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get2D_1_: (uint32_t)x y: (uint32_t)y repeat: (BOOL)repeat {
		Tellusim::ImageColor ret = [self ref].get2D(x, y, (bool)repeat);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get2D_2: (float64_t)x y: (float64_t)y {
		Tellusim::ImageColor ret = [self ref].get2D(x, y);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get2D_2_: (float64_t)x y: (float64_t)y {
		Tellusim::ImageColor ret = [self ref].get2D(x, y);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get2D_3: (float64_t)x y: (float64_t)y repeat: (BOOL)repeat {
		Tellusim::ImageColor ret = [self ref].get2D(x, y, (bool)repeat);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get2D_3_: (float64_t)x y: (float64_t)y repeat: (BOOL)repeat {
		Tellusim::ImageColor ret = [self ref].get2D(x, y, (bool)repeat);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get2D_4: (float64_t)x y: (float64_t)y repeat: (BOOL)repeat filter: (TS_ImageFilter)filter {
		Tellusim::ImageColor ret = [self ref].get2D(x, y, (bool)repeat, (Tellusim::Image::Filter)filter);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get2D_4_: (float64_t)x y: (float64_t)y repeat: (BOOL)repeat filter: (TS_ImageFilter)filter {
		Tellusim::ImageColor ret = [self ref].get2D(x, y, (bool)repeat, (Tellusim::Image::Filter)filter);
		return *(TSImageColor*)&ret;
	}
	-(void)set3D: (uint32_t)x y: (uint32_t)y z: (uint32_t)z color: (TSImageColor)color {
		[self ref].set3D(x, y, z, *(Tellusim::ImageColor*)&color);
	}
	-(void)set3D_: (uint32_t)x y: (uint32_t)y z: (uint32_t)z color: (TSImageColor)color {
		[self ref].set3D(x, y, z, *(Tellusim::ImageColor*)&color);
	}
	-(TSImageColor)get3D: (uint32_t)x y: (uint32_t)y z: (uint32_t)z {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get3D_: (uint32_t)x y: (uint32_t)y z: (uint32_t)z {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get3D_1: (uint32_t)x y: (uint32_t)y z: (uint32_t)z repeat: (BOOL)repeat {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z, (bool)repeat);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get3D_1_: (uint32_t)x y: (uint32_t)y z: (uint32_t)z repeat: (BOOL)repeat {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z, (bool)repeat);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get3D_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get3D_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get3D_3: (float32_t)x y: (float32_t)y z: (float32_t)z repeat: (BOOL)repeat {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z, (bool)repeat);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get3D_3_: (float32_t)x y: (float32_t)y z: (float32_t)z repeat: (BOOL)repeat {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z, (bool)repeat);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get3D_4: (float32_t)x y: (float32_t)y z: (float32_t)z repeat: (BOOL)repeat filter: (TS_ImageFilter)filter {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z, (bool)repeat, (Tellusim::Image::Filter)filter);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)get3D_4_: (float32_t)x y: (float32_t)y z: (float32_t)z repeat: (BOOL)repeat filter: (TS_ImageFilter)filter {
		Tellusim::ImageColor ret = [self ref].get3D(x, y, z, (bool)repeat, (Tellusim::Image::Filter)filter);
		return *(TSImageColor*)&ret;
	}
	-(void)setCube: (float32_t)x y: (float32_t)y z: (float32_t)z color: (TSImageColor)color {
		[self ref].setCube(x, y, z, *(Tellusim::ImageColor*)&color);
	}
	-(void)setCube_: (float32_t)x y: (float32_t)y z: (float32_t)z color: (TSImageColor)color {
		[self ref].setCube(x, y, z, *(Tellusim::ImageColor*)&color);
	}
	-(TSImageColor)getCube: (float32_t)x y: (float32_t)y z: (float32_t)z {
		Tellusim::ImageColor ret = [self ref].getCube(x, y, z);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)getCube_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		Tellusim::ImageColor ret = [self ref].getCube(x, y, z);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)getCube_1: (float32_t)x y: (float32_t)y z: (float32_t)z filter: (TS_ImageFilter)filter {
		Tellusim::ImageColor ret = [self ref].getCube(x, y, z, (Tellusim::Image::Filter)filter);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)getCube_1_: (float32_t)x y: (float32_t)y z: (float32_t)z filter: (TS_ImageFilter)filter {
		Tellusim::ImageColor ret = [self ref].getCube(x, y, z, (Tellusim::Image::Filter)filter);
		return *(TSImageColor*)&ret;
	}
	-(uint32_t)getCubeFace: (float32_t)x y: (float32_t)y z: (float32_t)z tx: (float32_t*)tx ty: (float32_t*)ty {
		TS_ASSERT(tx);
		TS_ASSERT(ty);
		return [self ref].getCubeFace(x, y, z, *tx, *ty);
	}
	-(uint32_t)getCubeFace_: (float32_t)x y: (float32_t)y z: (float32_t)z tx: (float32_t*)tx ty: (float32_t*)ty {
		TS_ASSERT(tx);
		TS_ASSERT(ty);
		return [self ref].getCubeFace(x, y, z, *tx, *ty);
	}
	-(void)setTexel: (size_t)t color: (TSImageColor)color {
		[self ref].setTexel(t, *(Tellusim::ImageColor*)&color);
	}
	-(void)setTexel_: (size_t)t color: (TSImageColor)color {
		[self ref].setTexel(t, *(Tellusim::ImageColor*)&color);
	}
	-(TSImageColor)getTexel: (size_t)t {
		Tellusim::ImageColor ret = [self ref].getTexel(t);
		return *(TSImageColor*)&ret;
	}
	-(TSImageColor)getTexel_: (size_t)t {
		Tellusim::ImageColor ret = [self ref].getTexel(t);
		return *(TSImageColor*)&ret;
	}
@end

// Tellusim::MeshNode
@implementation TSMeshNode
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshNode();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshNode(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshNode(name);
		return self;
	}
	-(id)init_2: (TSMesh*)mesh {
		self = [super init];
		impl = new Tellusim::MeshNode([mesh ref]);
		return self;
	}
	-(id)init_2_: (TSMesh*)mesh {
		self = [super init];
		impl = new Tellusim::MeshNode([mesh ref]);
		return self;
	}
	-(id)init_3: (TSMesh*)mesh name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshNode([mesh ref], name);
		return self;
	}
	-(id)init_3_: (TSMesh*)mesh name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshNode([mesh ref], name);
		return self;
	}
	-(id)init_4: (TSMeshNode*)parent {
		self = [super init];
		impl = new Tellusim::MeshNode([parent pointer]);
		return self;
	}
	-(id)init_4_: (TSMeshNode*)parent {
		self = [super init];
		impl = new Tellusim::MeshNode([parent pointer]);
		return self;
	}
	-(id)init_5: (TSMeshNode*)parent name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshNode([parent pointer], name);
		return self;
	}
	-(id)init_5_: (TSMeshNode*)parent name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshNode([parent pointer], name);
		return self;
	}
	-(id)init_6: (TSMesh*)mesh parent: (TSMeshNode*)parent {
		self = [super init];
		impl = new Tellusim::MeshNode([mesh ref], [parent pointer]);
		return self;
	}
	-(id)init_6_: (TSMesh*)mesh parent: (TSMeshNode*)parent {
		self = [super init];
		impl = new Tellusim::MeshNode([mesh ref], [parent pointer]);
		return self;
	}
	-(id)init_7: (TSMesh*)mesh parent: (TSMeshNode*)parent name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshNode([mesh ref], [parent pointer], name);
		return self;
	}
	-(id)init_7_: (TSMesh*)mesh parent: (TSMeshNode*)parent name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshNode([mesh ref], [parent pointer], name);
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshNode*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MeshNode&)ref {
		self = [super init];
		impl = new Tellusim::MeshNode((Tellusim::MeshNode&)ref);
		return self;
	}
	-(Tellusim::MeshNode*)pointer {
		return (Tellusim::MeshNode*)impl;
	}
	-(Tellusim::MeshNode&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshNode*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshNode*)impl;
	}
	-(BOOL)equalPtr: (const TSMeshNode*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMeshNode*)copyPtr {
		return [[TSMeshNode alloc] init_ref:[self ref]];
	}
	-(TSMeshNode*)clonePtr {
		return [[TSMeshNode alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMeshNode*)null {
		return [[TSMeshNode alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(TSMeshNode*)clone: (TSMesh*)mesh {
		return [[TSMeshNode alloc] init_ref:([self ref].clone([mesh ref]))];
	}
	-(TSMeshNode*)clone_: (TSMesh*)mesh {
		return [[TSMeshNode alloc] init_ref:([self ref].clone([mesh ref]))];
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)setMesh: (TSMesh*)mesh {
		[self ref].setMesh([mesh ref]);
	}
	-(void)setMesh_: (TSMesh*)mesh {
		[self ref].setMesh([mesh ref]);
	}
	-(void)setMesh_1: (TSMesh*)mesh check: (BOOL)check {
		[self ref].setMesh([mesh ref], (bool)check);
	}
	-(void)setMesh_1_: (TSMesh*)mesh check: (BOOL)check {
		[self ref].setMesh([mesh ref], (bool)check);
	}
	-(const TSMesh*)getMesh {
		return [[TSMesh alloc] init_ref:([self ref].getMesh())];
	}
	-(uint32_t)setParent: (TSMeshNode*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(uint32_t)setParent_: (TSMeshNode*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(uint32_t)setParent_1: (TSMeshNode*)parent check: (BOOL)check {
		return [self ref].setParent([parent ref], (bool)check);
	}
	-(uint32_t)setParent_1_: (TSMeshNode*)parent check: (BOOL)check {
		return [self ref].setParent([parent ref], (bool)check);
	}
	-(const TSMeshNode*)getParent {
		return [[TSMeshNode alloc] init_ref:([self ref].getParent())];
	}
	-(BOOL)isRoot {
		return [self ref].isRoot();
	}
	-(void)reserveChildren: (uint32_t)num_children {
		[self ref].reserveChildren(num_children);
	}
	-(void)reserveChildren_: (uint32_t)num_children {
		[self ref].reserveChildren(num_children);
	}
	-(uint32_t)addChild: (TSMeshNode*)child {
		return [self ref].addChild([child ref]);
	}
	-(uint32_t)addChild_: (TSMeshNode*)child {
		return [self ref].addChild([child ref]);
	}
	-(uint32_t)addChild_1: (TSMeshNode*)child check: (BOOL)check {
		return [self ref].addChild([child ref], (bool)check);
	}
	-(uint32_t)addChild_1_: (TSMeshNode*)child check: (BOOL)check {
		return [self ref].addChild([child ref], (bool)check);
	}
	-(BOOL)removeChild: (TSMeshNode*)child {
		return [self ref].removeChild([child ref]);
	}
	-(BOOL)removeChild_: (TSMeshNode*)child {
		return [self ref].removeChild([child ref]);
	}
	-(void)releaseChildren {
		[self ref].releaseChildren();
	}
	-(uint32_t)findChild: (const TSMeshNode*)child {
		return [self ref].findChild([child ref]);
	}
	-(uint32_t)findChild_: (const TSMeshNode*)child {
		return [self ref].findChild([child ref]);
	}
	-(uint32_t)getNumChildren {
		return [self ref].getNumChildren();
	}
	-(NSArray<TSMeshNode*>*)getChildren {
		const auto &ret = [self ref].getChildren();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshNode alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshNode*)getChild: (uint32_t)index {
		return [[TSMeshNode alloc] init_ref:([self ref].getChild(index))];
	}
	-(const TSMeshNode*)getChild_: (uint32_t)index {
		return [[TSMeshNode alloc] init_ref:([self ref].getChild(index))];
	}
	-(void)clearGeometries {
		[self ref].clearGeometries();
	}
	-(void)reserveGeometries: (uint32_t)num_geometries {
		[self ref].reserveGeometries(num_geometries);
	}
	-(void)reserveGeometries_: (uint32_t)num_geometries {
		[self ref].reserveGeometries(num_geometries);
	}
	-(uint32_t)addGeometry: (TSMeshGeometry*)geometry {
		return [self ref].addGeometry([geometry ref]);
	}
	-(uint32_t)addGeometry_: (TSMeshGeometry*)geometry {
		return [self ref].addGeometry([geometry ref]);
	}
	-(uint32_t)addGeometry_1: (TSMeshGeometry*)geometry check: (BOOL)check {
		return [self ref].addGeometry([geometry ref], (bool)check);
	}
	-(uint32_t)addGeometry_1_: (TSMeshGeometry*)geometry check: (BOOL)check {
		return [self ref].addGeometry([geometry ref], (bool)check);
	}
	-(BOOL)removeGeometry: (TSMeshGeometry*)geometry {
		return [self ref].removeGeometry([geometry ref]);
	}
	-(BOOL)removeGeometry_: (TSMeshGeometry*)geometry {
		return [self ref].removeGeometry([geometry ref]);
	}
	-(BOOL)replaceGeometry: (TSMeshGeometry*)old_geometry geometry: (TSMeshGeometry*)geometry {
		return [self ref].replaceGeometry([old_geometry ref], [geometry ref]);
	}
	-(BOOL)replaceGeometry_: (TSMeshGeometry*)old_geometry geometry: (TSMeshGeometry*)geometry {
		return [self ref].replaceGeometry([old_geometry ref], [geometry ref]);
	}
	-(uint32_t)findGeometry: (const TSMeshGeometry*)geometry {
		return [self ref].findGeometry([geometry ref]);
	}
	-(uint32_t)findGeometry_: (const TSMeshGeometry*)geometry {
		return [self ref].findGeometry([geometry ref]);
	}
	-(uint32_t)getNumGeometries {
		return [self ref].getNumGeometries();
	}
	-(NSArray<TSMeshGeometry*>*)getGeometries {
		const auto &ret = [self ref].getGeometries();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshGeometry alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshGeometry*)getGeometry: (uint32_t)index {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getGeometry(index))];
	}
	-(const TSMeshGeometry*)getGeometry_: (uint32_t)index {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getGeometry(index))];
	}
	-(void)clearAttachments {
		[self ref].clearAttachments();
	}
	-(void)reserveAttachments: (uint32_t)num_attachments {
		[self ref].reserveAttachments(num_attachments);
	}
	-(void)reserveAttachments_: (uint32_t)num_attachments {
		[self ref].reserveAttachments(num_attachments);
	}
	-(uint32_t)addAttachment: (TSMeshAttachment*)attachment {
		return [self ref].addAttachment([attachment ref]);
	}
	-(uint32_t)addAttachment_: (TSMeshAttachment*)attachment {
		return [self ref].addAttachment([attachment ref]);
	}
	-(uint32_t)addAttachment_1: (TSMeshAttachment*)attachment check: (BOOL)check {
		return [self ref].addAttachment([attachment ref], (bool)check);
	}
	-(uint32_t)addAttachment_1_: (TSMeshAttachment*)attachment check: (BOOL)check {
		return [self ref].addAttachment([attachment ref], (bool)check);
	}
	-(BOOL)removeAttachment: (TSMeshAttachment*)attachment {
		return [self ref].removeAttachment([attachment ref]);
	}
	-(BOOL)removeAttachment_: (TSMeshAttachment*)attachment {
		return [self ref].removeAttachment([attachment ref]);
	}
	-(BOOL)replaceAttachment: (TSMeshAttachment*)old_attachment attachment: (TSMeshAttachment*)attachment {
		return [self ref].replaceAttachment([old_attachment ref], [attachment ref]);
	}
	-(BOOL)replaceAttachment_: (TSMeshAttachment*)old_attachment attachment: (TSMeshAttachment*)attachment {
		return [self ref].replaceAttachment([old_attachment ref], [attachment ref]);
	}
	-(uint32_t)findAttachment: (const TSMeshAttachment*)attachment {
		return [self ref].findAttachment([attachment ref]);
	}
	-(uint32_t)findAttachment_: (const TSMeshAttachment*)attachment {
		return [self ref].findAttachment([attachment ref]);
	}
	-(uint32_t)findAttachment_1: (const char*)name {
		return [self ref].findAttachment(name);
	}
	-(uint32_t)findAttachment_1_: (const char*)name {
		return [self ref].findAttachment(name);
	}
	-(uint32_t)getNumAttachments {
		return [self ref].getNumAttachments();
	}
	-(NSArray<TSMeshAttachment*>*)getAttachments {
		const auto &ret = [self ref].getAttachments();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshAttachment alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshAttachment*)getAttachment: (uint32_t)index {
		return [[TSMeshAttachment alloc] init_ref:([self ref].getAttachment(index))];
	}
	-(const TSMeshAttachment*)getAttachment_: (uint32_t)index {
		return [[TSMeshAttachment alloc] init_ref:([self ref].getAttachment(index))];
	}
	-(void)setLocalTransform: (TSMatrix4x3d)transform {
		[self ref].setLocalTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setLocalTransform_: (TSMatrix4x3d)transform {
		[self ref].setLocalTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(TSMatrix4x3d)getLocalTransform {
		Tellusim::Matrix4x3d ret = [self ref].getLocalTransform();
		return *(TSMatrix4x3d*)&ret;
	}
	-(void)setGlobalTransform: (TSMatrix4x3d)transform {
		[self ref].setGlobalTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setGlobalTransform_: (TSMatrix4x3d)transform {
		[self ref].setGlobalTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(TSMatrix4x3d)getGlobalTransform {
		Tellusim::Matrix4x3d ret = [self ref].getGlobalTransform();
		return *(TSMatrix4x3d*)&ret;
	}
	-(void)setPivotTransform: (TSMatrix4x3d)transform {
		[self ref].setPivotTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setPivotTransform_: (TSMatrix4x3d)transform {
		[self ref].setPivotTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(TSMatrix4x3d)getPivotTransform {
		Tellusim::Matrix4x3d ret = [self ref].getPivotTransform();
		return *(TSMatrix4x3d*)&ret;
	}
	-(void)setMorphTransform: (TSVector4f)transform {
		[self ref].setMorphTransform(*(Tellusim::Vector4f*)&transform);
	}
	-(void)setMorphTransform_: (TSVector4f)transform {
		[self ref].setMorphTransform(*(Tellusim::Vector4f*)&transform);
	}
	-(TSVector4f)getMorphTransform {
		Tellusim::Vector4f ret = [self ref].getMorphTransform();
		return *(TSVector4f*)&ret;
	}
	-(void)createLocalTransforms {
		[self ref].createLocalTransforms();
	}
	-(void)createLocalTransforms_1: (TSMatrix4x3d)itransform {
		[self ref].createLocalTransforms(*(Tellusim::Matrix4x3d*)&itransform);
	}
	-(void)createLocalTransforms_1_: (TSMatrix4x3d)itransform {
		[self ref].createLocalTransforms(*(Tellusim::Matrix4x3d*)&itransform);
	}
	-(void)createGlobalTransforms {
		[self ref].createGlobalTransforms();
	}
	-(void)createGlobalTransforms_1: (TSMatrix4x3d)transform {
		[self ref].createGlobalTransforms(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)createGlobalTransforms_1_: (TSMatrix4x3d)transform {
		[self ref].createGlobalTransforms(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setTransform: (TSVector3d)scale {
		[self ref].setTransform(*(Tellusim::Vector3d*)&scale);
	}
	-(void)setTransform_: (TSVector3d)scale {
		[self ref].setTransform(*(Tellusim::Vector3d*)&scale);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::MeshIndices
@implementation TSMeshIndices
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshIndices();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshIndices(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshIndices(name);
		return self;
	}
	-(id)init_2: (TS_MeshIndicesType)type format: (TS_Format)format {
		self = [super init];
		impl = new Tellusim::MeshIndices((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format);
		return self;
	}
	-(id)init_2_: (TS_MeshIndicesType)type format: (TS_Format)format {
		self = [super init];
		impl = new Tellusim::MeshIndices((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format);
		return self;
	}
	-(id)init_3: (TS_MeshIndicesType)type format: (TS_Format)format name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshIndices((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format, name);
		return self;
	}
	-(id)init_3_: (TS_MeshIndicesType)type format: (TS_Format)format name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshIndices((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format, name);
		return self;
	}
	-(id)init_4: (TS_MeshIndicesType)type format: (TS_Format)format size: (uint32_t)size {
		self = [super init];
		impl = new Tellusim::MeshIndices((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format, size);
		return self;
	}
	-(id)init_4_: (TS_MeshIndicesType)type format: (TS_Format)format size: (uint32_t)size {
		self = [super init];
		impl = new Tellusim::MeshIndices((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format, size);
		return self;
	}
	-(id)init_5: (TS_MeshIndicesType)type format: (TS_Format)format size: (uint32_t)size name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshIndices((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format, size, name);
		return self;
	}
	-(id)init_5_: (TS_MeshIndicesType)type format: (TS_Format)format size: (uint32_t)size name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshIndices((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format, size, name);
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshIndices*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MeshIndices&)ref {
		self = [super init];
		impl = new Tellusim::MeshIndices((Tellusim::MeshIndices&)ref);
		return self;
	}
	-(Tellusim::MeshIndices*)pointer {
		return (Tellusim::MeshIndices*)impl;
	}
	-(Tellusim::MeshIndices&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshIndices*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshIndices*)impl;
	}
	-(BOOL)equalPtr: (const TSMeshIndices*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMeshIndices*)copyPtr {
		return [[TSMeshIndices alloc] init_ref:[self ref]];
	}
	-(TSMeshIndices*)clonePtr {
		return [[TSMeshIndices alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMeshIndices*)null {
		return [[TSMeshIndices alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(void)create: (TS_MeshIndicesType)type format: (TS_Format)format {
		[self ref].create((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format);
	}
	-(void)create_: (TS_MeshIndicesType)type format: (TS_Format)format {
		[self ref].create((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format);
	}
	-(void)create_1: (TS_MeshIndicesType)type format: (TS_Format)format size: (uint32_t)size {
		[self ref].create((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format, size);
	}
	-(void)create_1_: (TS_MeshIndicesType)type format: (TS_Format)format size: (uint32_t)size {
		[self ref].create((Tellusim::MeshIndices::Type)type, (Tellusim::Format)format, size);
	}
	-(TS_MeshIndicesType)getType {
		return (TS_MeshIndicesType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_MeshIndicesType)type {
		return [NSString stringWithUTF8String:Tellusim::MeshIndices::getTypeName((Tellusim::MeshIndices::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_MeshIndicesType)type {
		return [NSString stringWithUTF8String:Tellusim::MeshIndices::getTypeName((Tellusim::MeshIndices::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)isUnknown {
		return [self ref].isUnknown();
	}
	-(BOOL)isPoint {
		return [self ref].isPoint();
	}
	-(BOOL)isLine {
		return [self ref].isLine();
	}
	-(BOOL)isTriangle {
		return [self ref].isTriangle();
	}
	-(BOOL)isQuadrilateral {
		return [self ref].isQuadrilateral();
	}
	-(BOOL)isTetrahedron {
		return [self ref].isTetrahedron();
	}
	-(BOOL)isPrimitive {
		return [self ref].isPrimitive();
	}
	-(BOOL)isSolid {
		return [self ref].isSolid();
	}
	-(BOOL)isVolume {
		return [self ref].isVolume();
	}
	-(BOOL)isMaterial {
		return [self ref].isMaterial();
	}
	-(BOOL)isGroup {
		return [self ref].isGroup();
	}
	-(BOOL)isJoint {
		return [self ref].isJoint();
	}
	-(BOOL)isEdge {
		return [self ref].isEdge();
	}
	-(uint32_t)getPrimitiveSize {
		return [self ref].getPrimitiveSize();
	}
	-(TS_Format)getFormat {
		return (TS_Format)[self ref].getFormat();
	}
	-(NSString*)getFormatName {
		return [NSString stringWithUTF8String:[self ref].getFormatName()];
	}
	-(void)setGeometry: (TSMeshGeometry*)geometry {
		[self ref].setGeometry([geometry ref]);
	}
	-(void)setGeometry_: (TSMeshGeometry*)geometry {
		[self ref].setGeometry([geometry ref]);
	}
	-(void)setGeometry_1: (TSMeshGeometry*)geometry check: (BOOL)check {
		[self ref].setGeometry([geometry ref], (bool)check);
	}
	-(void)setGeometry_1_: (TSMeshGeometry*)geometry check: (BOOL)check {
		[self ref].setGeometry([geometry ref], (bool)check);
	}
	-(const TSMeshGeometry*)getGeometry {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getGeometry())];
	}
	-(void)setSize: (uint32_t)size {
		[self ref].setSize(size);
	}
	-(void)setSize_: (uint32_t)size {
		[self ref].setSize(size);
	}
	-(void)setSize_1: (uint32_t)size discard: (BOOL)discard {
		[self ref].setSize(size, (bool)discard);
	}
	-(void)setSize_1_: (uint32_t)size discard: (BOOL)discard {
		[self ref].setSize(size, (bool)discard);
	}
	-(void)setSize_2: (uint32_t)size discard: (BOOL)discard clear: (BOOL)clear {
		[self ref].setSize(size, (bool)discard, (bool)clear);
	}
	-(void)setSize_2_: (uint32_t)size discard: (BOOL)discard clear: (BOOL)clear {
		[self ref].setSize(size, (bool)discard, (bool)clear);
	}
	-(uint32_t)getSize {
		return [self ref].getSize();
	}
	-(uint32_t)getStride {
		return [self ref].getStride();
	}
	-(size_t)getBytes {
		return [self ref].getBytes();
	}
	-(void)setData: (uint32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_: (uint32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_1: (uint32_t)value size: (uint32_t)size {
		[self ref].setData(value, size);
	}
	-(void)setData_1_: (uint32_t)value size: (uint32_t)size {
		[self ref].setData(value, size);
	}
	-(void)setData_2: (uint32_t)value size: (uint32_t)size offset: (uint32_t)offset {
		[self ref].setData(value, size, offset);
	}
	-(void)setData_2_: (uint32_t)value size: (uint32_t)size offset: (uint32_t)offset {
		[self ref].setData(value, size, offset);
	}
	-(void)setData_3: (const void*)src {
		[self ref].setData(src);
	}
	-(void)setData_3_: (const void*)src {
		[self ref].setData(src);
	}
	-(void)setData_4: (const void*)src format: (TS_Format)format {
		[self ref].setData(src, (Tellusim::Format)format);
	}
	-(void)setData_4_: (const void*)src format: (TS_Format)format {
		[self ref].setData(src, (Tellusim::Format)format);
	}
	-(void)setData_5: (const void*)src format: (TS_Format)format size: (uint32_t)size {
		[self ref].setData(src, (Tellusim::Format)format, size);
	}
	-(void)setData_5_: (const void*)src format: (TS_Format)format size: (uint32_t)size {
		[self ref].setData(src, (Tellusim::Format)format, size);
	}
	-(void)setData_6: (const void*)src format: (TS_Format)format size: (uint32_t)size repeat: (uint32_t)repeat {
		[self ref].setData(src, (Tellusim::Format)format, size, repeat);
	}
	-(void)setData_6_: (const void*)src format: (TS_Format)format size: (uint32_t)size repeat: (uint32_t)repeat {
		[self ref].setData(src, (Tellusim::Format)format, size, repeat);
	}
	-(void)getData: (void*)dest {
		[self ref].getData(dest);
	}
	-(void)getData_: (void*)dest {
		[self ref].getData(dest);
	}
	-(void)getData_1: (void*)dest format: (TS_Format)format {
		[self ref].getData(dest, (Tellusim::Format)format);
	}
	-(void)getData_1_: (void*)dest format: (TS_Format)format {
		[self ref].getData(dest, (Tellusim::Format)format);
	}
	-(void)getData_2: (void*)dest format: (TS_Format)format size: (uint32_t)size {
		[self ref].getData(dest, (Tellusim::Format)format, size);
	}
	-(void)getData_2_: (void*)dest format: (TS_Format)format size: (uint32_t)size {
		[self ref].getData(dest, (Tellusim::Format)format, size);
	}
	-(void)getData_3: (void*)dest format: (TS_Format)format size: (uint32_t)size repeat: (uint32_t)repeat {
		[self ref].getData(dest, (Tellusim::Format)format, size, repeat);
	}
	-(void)getData_3_: (void*)dest format: (TS_Format)format size: (uint32_t)size repeat: (uint32_t)repeat {
		[self ref].getData(dest, (Tellusim::Format)format, size, repeat);
	}
	-(const void*)getData_4 {
		return [self ref].getData();
	}
	-(void*)getData_5 {
		return [self ref].getData();
	}
	-(void)set: (uint32_t)index value: (uint32_t)value {
		[self ref].set(index, value);
	}
	-(void)set_: (uint32_t)index value: (uint32_t)value {
		[self ref].set(index, value);
	}
	-(void)set_1: (uint32_t)index value_0: (uint32_t)value_0 value_1: (uint32_t)value_1 {
		[self ref].set(index, value_0, value_1);
	}
	-(void)set_1_: (uint32_t)index value_0: (uint32_t)value_0 value_1: (uint32_t)value_1 {
		[self ref].set(index, value_0, value_1);
	}
	-(void)set_2: (uint32_t)index value_0: (uint32_t)value_0 value_1: (uint32_t)value_1 value_2: (uint32_t)value_2 {
		[self ref].set(index, value_0, value_1, value_2);
	}
	-(void)set_2_: (uint32_t)index value_0: (uint32_t)value_0 value_1: (uint32_t)value_1 value_2: (uint32_t)value_2 {
		[self ref].set(index, value_0, value_1, value_2);
	}
	-(void)set_3: (uint32_t)index value_0: (uint32_t)value_0 value_1: (uint32_t)value_1 value_2: (uint32_t)value_2 value_3: (uint32_t)value_3 {
		[self ref].set(index, value_0, value_1, value_2, value_3);
	}
	-(void)set_3_: (uint32_t)index value_0: (uint32_t)value_0 value_1: (uint32_t)value_1 value_2: (uint32_t)value_2 value_3: (uint32_t)value_3 {
		[self ref].set(index, value_0, value_1, value_2, value_3);
	}
	-(uint32_t)get: (uint32_t)index {
		return [self ref].get(index);
	}
	-(uint32_t)get_: (uint32_t)index {
		return [self ref].get(index);
	}
	-(void)get_1: (uint32_t)index value_0: (uint32_t*)value_0 value_1: (uint32_t*)value_1 {
		TS_ASSERT(value_0);
		TS_ASSERT(value_1);
		[self ref].get(index, *value_0, *value_1);
	}
	-(void)get_1_: (uint32_t)index value_0: (uint32_t*)value_0 value_1: (uint32_t*)value_1 {
		TS_ASSERT(value_0);
		TS_ASSERT(value_1);
		[self ref].get(index, *value_0, *value_1);
	}
	-(void)get_2: (uint32_t)index value_0: (uint32_t*)value_0 value_1: (uint32_t*)value_1 value_2: (uint32_t*)value_2 {
		TS_ASSERT(value_0);
		TS_ASSERT(value_1);
		TS_ASSERT(value_2);
		[self ref].get(index, *value_0, *value_1, *value_2);
	}
	-(void)get_2_: (uint32_t)index value_0: (uint32_t*)value_0 value_1: (uint32_t*)value_1 value_2: (uint32_t*)value_2 {
		TS_ASSERT(value_0);
		TS_ASSERT(value_1);
		TS_ASSERT(value_2);
		[self ref].get(index, *value_0, *value_1, *value_2);
	}
	-(void)get_3: (uint32_t)index value_0: (uint32_t*)value_0 value_1: (uint32_t*)value_1 value_2: (uint32_t*)value_2 value_3: (uint32_t*)value_3 {
		TS_ASSERT(value_0);
		TS_ASSERT(value_1);
		TS_ASSERT(value_2);
		TS_ASSERT(value_3);
		[self ref].get(index, *value_0, *value_1, *value_2, *value_3);
	}
	-(void)get_3_: (uint32_t)index value_0: (uint32_t*)value_0 value_1: (uint32_t*)value_1 value_2: (uint32_t*)value_2 value_3: (uint32_t*)value_3 {
		TS_ASSERT(value_0);
		TS_ASSERT(value_1);
		TS_ASSERT(value_2);
		TS_ASSERT(value_3);
		[self ref].get(index, *value_0, *value_1, *value_2, *value_3);
	}
	-(const void*)getPtr: (uint32_t)index {
		return [self ref].getPtr(index);
	}
	-(const void*)getPtr_: (uint32_t)index {
		return [self ref].getPtr(index);
	}
	-(void*)getPtr_1: (uint32_t)index {
		return [self ref].getPtr(index);
	}
	-(void*)getPtr_1_: (uint32_t)index {
		return [self ref].getPtr(index);
	}
	-(BOOL)isDirect {
		return [self ref].isDirect();
	}
	-(BOOL)isUniform {
		return [self ref].isUniform();
	}
	-(uint32_t)getMinIndex {
		return [self ref].getMinIndex();
	}
	-(uint32_t)getMaxIndex {
		return [self ref].getMaxIndex();
	}
	-(int32_t)compare: (const TSMeshIndices*)indices {
		return [self ref].compare([indices ref]);
	}
	-(int32_t)compare_: (const TSMeshIndices*)indices {
		return [self ref].compare([indices ref]);
	}
	-(void)addIndices: (const TSMeshIndices*)indices offset: (uint32_t)offset {
		[self ref].addIndices([indices ref], offset);
	}
	-(void)addIndices_: (const TSMeshIndices*)indices offset: (uint32_t)offset {
		[self ref].addIndices([indices ref], offset);
	}
	-(void)addIndices_1: (const TSMeshIndices*)indices offset: (uint32_t)offset expand: (BOOL)expand {
		[self ref].addIndices([indices ref], offset, (bool)expand);
	}
	-(void)addIndices_1_: (const TSMeshIndices*)indices offset: (uint32_t)offset expand: (BOOL)expand {
		[self ref].addIndices([indices ref], offset, (bool)expand);
	}
	-(TSMeshIndices*)toFormat: (TS_Format)format {
		return [[TSMeshIndices alloc] init_ref:([self ref].toFormat((Tellusim::Format)format))];
	}
	-(TSMeshIndices*)toFormat_: (TS_Format)format {
		return [[TSMeshIndices alloc] init_ref:([self ref].toFormat((Tellusim::Format)format))];
	}
	-(TSMeshIndices*)toType: (TS_MeshIndicesType)type {
		return [[TSMeshIndices alloc] init_ref:([self ref].toType((Tellusim::MeshIndices::Type)type))];
	}
	-(TSMeshIndices*)toType_: (TS_MeshIndicesType)type {
		return [[TSMeshIndices alloc] init_ref:([self ref].toType((Tellusim::MeshIndices::Type)type))];
	}
	-(TSMeshIndices*)toType_1: (TS_MeshIndicesType)type position_attribute: (const TSMeshAttribute*)position_attribute {
		return [[TSMeshIndices alloc] init_ref:([self ref].toType((Tellusim::MeshIndices::Type)type, [position_attribute ref]))];
	}
	-(TSMeshIndices*)toType_1_: (TS_MeshIndicesType)type position_attribute: (const TSMeshAttribute*)position_attribute {
		return [[TSMeshIndices alloc] init_ref:([self ref].toType((Tellusim::MeshIndices::Type)type, [position_attribute ref]))];
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::MeshAttribute
@implementation TSMeshAttribute
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshAttribute();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttribute(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttribute(name);
		return self;
	}
	-(id)init_2: (const char*)name index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::MeshAttribute(name, index);
		return self;
	}
	-(id)init_2_: (const char*)name index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::MeshAttribute(name, index);
		return self;
	}
	-(id)init_3: (TS_MeshAttributeType)type format: (TS_Format)format {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format);
		return self;
	}
	-(id)init_3_: (TS_MeshAttributeType)type format: (TS_Format)format {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format);
		return self;
	}
	-(id)init_4: (TS_MeshAttributeType)type format: (TS_Format)format name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, name);
		return self;
	}
	-(id)init_4_: (TS_MeshAttributeType)type format: (TS_Format)format name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, name);
		return self;
	}
	-(id)init_5: (TS_MeshAttributeType)type format: (TS_Format)format name: (const char*)name index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, name, index);
		return self;
	}
	-(id)init_5_: (TS_MeshAttributeType)type format: (TS_Format)format name: (const char*)name index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, name, index);
		return self;
	}
	-(id)init_6: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size);
		return self;
	}
	-(id)init_6_: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size);
		return self;
	}
	-(id)init_7: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size, name);
		return self;
	}
	-(id)init_7_: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size, name);
		return self;
	}
	-(id)init_8: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size name: (const char*)name index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size, name, index);
		return self;
	}
	-(id)init_8_: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size name: (const char*)name index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size, name, index);
		return self;
	}
	-(id)init_9: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size, index);
		return self;
	}
	-(id)init_9_: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size, index);
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshAttribute*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MeshAttribute&)ref {
		self = [super init];
		impl = new Tellusim::MeshAttribute((Tellusim::MeshAttribute&)ref);
		return self;
	}
	-(Tellusim::MeshAttribute*)pointer {
		return (Tellusim::MeshAttribute*)impl;
	}
	-(Tellusim::MeshAttribute&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshAttribute*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshAttribute*)impl;
	}
	-(BOOL)equalPtr: (const TSMeshAttribute*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMeshAttribute*)copyPtr {
		return [[TSMeshAttribute alloc] init_ref:[self ref]];
	}
	-(TSMeshAttribute*)clonePtr {
		return [[TSMeshAttribute alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMeshAttribute*)null {
		return [[TSMeshAttribute alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(void)create: (TS_MeshAttributeType)type format: (TS_Format)format {
		[self ref].create((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format);
	}
	-(void)create_: (TS_MeshAttributeType)type format: (TS_Format)format {
		[self ref].create((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format);
	}
	-(void)create_1: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size {
		[self ref].create((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size);
	}
	-(void)create_1_: (TS_MeshAttributeType)type format: (TS_Format)format size: (uint32_t)size {
		[self ref].create((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, size);
	}
	-(TS_MeshAttributeType)getType {
		return (TS_MeshAttributeType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_MeshAttributeType)type {
		return [NSString stringWithUTF8String:Tellusim::MeshAttribute::getTypeName((Tellusim::MeshAttribute::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_MeshAttributeType)type {
		return [NSString stringWithUTF8String:Tellusim::MeshAttribute::getTypeName((Tellusim::MeshAttribute::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)isUnknown {
		return [self ref].isUnknown();
	}
	-(BOOL)isPosition {
		return [self ref].isPosition();
	}
	-(BOOL)isBasis {
		return [self ref].isBasis();
	}
	-(BOOL)isNormal {
		return [self ref].isNormal();
	}
	-(BOOL)isTangent {
		return [self ref].isTangent();
	}
	-(BOOL)isBinormal {
		return [self ref].isBinormal();
	}
	-(BOOL)isSpatial {
		return [self ref].isSpatial();
	}
	-(BOOL)isNormalized {
		return [self ref].isNormalized();
	}
	-(BOOL)isTexCoord {
		return [self ref].isTexCoord();
	}
	-(BOOL)isWeights {
		return [self ref].isWeights();
	}
	-(BOOL)isJoints {
		return [self ref].isJoints();
	}
	-(BOOL)isColor {
		return [self ref].isColor();
	}
	-(BOOL)isVertex {
		return [self ref].isVertex();
	}
	-(BOOL)isCrease {
		return [self ref].isCrease();
	}
	-(TS_Format)getFormat {
		return (TS_Format)[self ref].getFormat();
	}
	-(NSString*)getFormatName {
		return [NSString stringWithUTF8String:[self ref].getFormatName()];
	}
	-(uint32_t)getComponents {
		return [self ref].getComponents();
	}
	-(BOOL)isPacked {
		return [self ref].isPacked();
	}
	-(void)setIndex: (uint32_t)index {
		[self ref].setIndex(index);
	}
	-(void)setIndex_: (uint32_t)index {
		[self ref].setIndex(index);
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)setIndices: (TSMeshIndices*)indices {
		[self ref].setIndices([indices ref]);
	}
	-(void)setIndices_: (TSMeshIndices*)indices {
		[self ref].setIndices([indices ref]);
	}
	-(const TSMeshIndices*)getIndices {
		return [[TSMeshIndices alloc] init_ref:([self ref].getIndices())];
	}
	-(void)setGeometry: (TSMeshGeometry*)geometry {
		[self ref].setGeometry([geometry ref]);
	}
	-(void)setGeometry_: (TSMeshGeometry*)geometry {
		[self ref].setGeometry([geometry ref]);
	}
	-(void)setGeometry_1: (TSMeshGeometry*)geometry check: (BOOL)check {
		[self ref].setGeometry([geometry ref], (bool)check);
	}
	-(void)setGeometry_1_: (TSMeshGeometry*)geometry check: (BOOL)check {
		[self ref].setGeometry([geometry ref], (bool)check);
	}
	-(const TSMeshGeometry*)getGeometry {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getGeometry())];
	}
	-(void)setSize: (uint32_t)size {
		[self ref].setSize(size);
	}
	-(void)setSize_: (uint32_t)size {
		[self ref].setSize(size);
	}
	-(void)setSize_1: (uint32_t)size discard: (BOOL)discard {
		[self ref].setSize(size, (bool)discard);
	}
	-(void)setSize_1_: (uint32_t)size discard: (BOOL)discard {
		[self ref].setSize(size, (bool)discard);
	}
	-(void)setSize_2: (uint32_t)size discard: (BOOL)discard clear: (BOOL)clear {
		[self ref].setSize(size, (bool)discard, (bool)clear);
	}
	-(void)setSize_2_: (uint32_t)size discard: (BOOL)discard clear: (BOOL)clear {
		[self ref].setSize(size, (bool)discard, (bool)clear);
	}
	-(uint32_t)getSize {
		return [self ref].getSize();
	}
	-(uint32_t)getStride {
		return [self ref].getStride();
	}
	-(size_t)getBytes {
		return [self ref].getBytes();
	}
	-(void)setData: (const void*)src {
		[self ref].setData(src);
	}
	-(void)setData_: (const void*)src {
		[self ref].setData(src);
	}
	-(void)setData_1: (const void*)src size: (uint32_t)size {
		[self ref].setData(src, size);
	}
	-(void)setData_1_: (const void*)src size: (uint32_t)size {
		[self ref].setData(src, size);
	}
	-(void)setData_2: (const void*)src size: (uint32_t)size stride: (uint32_t)stride {
		[self ref].setData(src, size, stride);
	}
	-(void)setData_2_: (const void*)src size: (uint32_t)size stride: (uint32_t)stride {
		[self ref].setData(src, size, stride);
	}
	-(void)setData_3: (const void*)src indices: (uint32_t*)indices indices_size: (uint32_t)indices_size {
		Tellusim::Array<uint32_t> indices_(indices_size, indices);
		[self ref].setData(src, indices_);
	}
	-(void)setData_3_: (const void*)src indices: (uint32_t*)indices indices_size: (uint32_t)indices_size {
		Tellusim::Array<uint32_t> indices_(indices_size, indices);
		[self ref].setData(src, indices_);
	}
	-(void)setData_4: (const void*)src indices: (uint32_t*)indices indices_size: (uint32_t)indices_size stride: (uint32_t)stride {
		Tellusim::Array<uint32_t> indices_(indices_size, indices);
		[self ref].setData(src, indices_, stride);
	}
	-(void)setData_4_: (const void*)src indices: (uint32_t*)indices indices_size: (uint32_t)indices_size stride: (uint32_t)stride {
		Tellusim::Array<uint32_t> indices_(indices_size, indices);
		[self ref].setData(src, indices_, stride);
	}
	-(void)getData: (void*)dest {
		[self ref].getData(dest);
	}
	-(void)getData_: (void*)dest {
		[self ref].getData(dest);
	}
	-(void)getData_1: (void*)dest size: (uint32_t)size {
		[self ref].getData(dest, size);
	}
	-(void)getData_1_: (void*)dest size: (uint32_t)size {
		[self ref].getData(dest, size);
	}
	-(void)getData_2: (void*)dest size: (uint32_t)size stride: (uint32_t)stride {
		[self ref].getData(dest, size, stride);
	}
	-(void)getData_2_: (void*)dest size: (uint32_t)size stride: (uint32_t)stride {
		[self ref].getData(dest, size, stride);
	}
	-(void)getData_3: (void*)dest indices: (const TSMeshIndices*)indices {
		[self ref].getData(dest, [indices ref]);
	}
	-(void)getData_3_: (void*)dest indices: (const TSMeshIndices*)indices {
		[self ref].getData(dest, [indices ref]);
	}
	-(void)getData_4: (void*)dest indices: (const TSMeshIndices*)indices stride: (uint32_t)stride {
		[self ref].getData(dest, [indices ref], stride);
	}
	-(void)getData_4_: (void*)dest indices: (const TSMeshIndices*)indices stride: (uint32_t)stride {
		[self ref].getData(dest, [indices ref], stride);
	}
	-(void)getData_5: (void*)dest indices: (uint32_t*)indices indices_size: (uint32_t)indices_size {
		Tellusim::Array<uint32_t> indices_(indices_size, indices);
		[self ref].getData(dest, indices_);
	}
	-(void)getData_5_: (void*)dest indices: (uint32_t*)indices indices_size: (uint32_t)indices_size {
		Tellusim::Array<uint32_t> indices_(indices_size, indices);
		[self ref].getData(dest, indices_);
	}
	-(void)getData_6: (void*)dest indices: (uint32_t*)indices indices_size: (uint32_t)indices_size stride: (uint32_t)stride {
		Tellusim::Array<uint32_t> indices_(indices_size, indices);
		[self ref].getData(dest, indices_, stride);
	}
	-(void)getData_6_: (void*)dest indices: (uint32_t*)indices indices_size: (uint32_t)indices_size stride: (uint32_t)stride {
		Tellusim::Array<uint32_t> indices_(indices_size, indices);
		[self ref].getData(dest, indices_, stride);
	}
	-(const void*)getData_7 {
		return [self ref].getData();
	}
	-(void*)getData_8 {
		return [self ref].getData();
	}
	-(void)setValue: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setValue(index, src, size);
	}
	-(void)setValue_: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setValue(index, src, size);
	}
	-(void)getValue: (uint32_t)index dest: (void*)dest size: (size_t)size {
		[self ref].getValue(index, dest, size);
	}
	-(void)getValue_: (uint32_t)index dest: (void*)dest size: (size_t)size {
		[self ref].getValue(index, dest, size);
	}
	-(const void*)getPtr: (uint32_t)index {
		return [self ref].getPtr(index);
	}
	-(const void*)getPtr_: (uint32_t)index {
		return [self ref].getPtr(index);
	}
	-(void*)getPtr_1: (uint32_t)index {
		return [self ref].getPtr(index);
	}
	-(void*)getPtr_1_: (uint32_t)index {
		return [self ref].getPtr(index);
	}
	-(int32_t)compare: (const TSMeshAttribute*)attribute {
		return [self ref].compare([attribute ref]);
	}
	-(int32_t)compare_: (const TSMeshAttribute*)attribute {
		return [self ref].compare([attribute ref]);
	}
	-(int32_t)compare_1: (const TSMeshAttribute*)attribute transform: (TSMatrix4x3f)transform {
		return [self ref].compare([attribute ref], *(Tellusim::Matrix4x3f*)&transform);
	}
	-(int32_t)compare_1_: (const TSMeshAttribute*)attribute transform: (TSMatrix4x3f)transform {
		return [self ref].compare([attribute ref], *(Tellusim::Matrix4x3f*)&transform);
	}
	-(int32_t)compare_2: (const TSMeshAttribute*)attribute transform: (TSMatrix4x3f)transform threshold: (float32_t)threshold {
		return [self ref].compare([attribute ref], *(Tellusim::Matrix4x3f*)&transform, threshold);
	}
	-(int32_t)compare_2_: (const TSMeshAttribute*)attribute transform: (TSMatrix4x3f)transform threshold: (float32_t)threshold {
		return [self ref].compare([attribute ref], *(Tellusim::Matrix4x3f*)&transform, threshold);
	}
	-(int32_t)compare_3: (const TSMeshAttribute*)attribute transform: (TSMatrix4x3f)transform threshold: (float32_t)threshold spatial: (BOOL)spatial {
		return [self ref].compare([attribute ref], *(Tellusim::Matrix4x3f*)&transform, threshold, (bool)spatial);
	}
	-(int32_t)compare_3_: (const TSMeshAttribute*)attribute transform: (TSMatrix4x3f)transform threshold: (float32_t)threshold spatial: (BOOL)spatial {
		return [self ref].compare([attribute ref], *(Tellusim::Matrix4x3f*)&transform, threshold, (bool)spatial);
	}
	-(void)addAttribute: (const TSMeshAttribute*)attribute {
		[self ref].addAttribute([attribute ref]);
	}
	-(void)addAttribute_: (const TSMeshAttribute*)attribute {
		[self ref].addAttribute([attribute ref]);
	}
	-(BOOL)setTransform: (TSMatrix4x3f)transform {
		return [self ref].setTransform(*(Tellusim::Matrix4x3f*)&transform);
	}
	-(BOOL)setTransform_: (TSMatrix4x3f)transform {
		return [self ref].setTransform(*(Tellusim::Matrix4x3f*)&transform);
	}
	-(BOOL)morphAttribute: (const TSMeshAttribute*)attribute k: (float32_t)k {
		return [self ref].morphAttribute([attribute ref], k);
	}
	-(BOOL)morphAttribute_: (const TSMeshAttribute*)attribute k: (float32_t)k {
		return [self ref].morphAttribute([attribute ref], k);
	}
	-(BOOL)packAttributes: (const TSMeshAttribute*)attribute_0 attribute_1: (const TSMeshAttribute*)attribute_1 format: (TS_Format)format {
		return [self ref].packAttributes([attribute_0 ref], [attribute_1 ref], (Tellusim::Format)format);
	}
	-(BOOL)packAttributes_: (const TSMeshAttribute*)attribute_0 attribute_1: (const TSMeshAttribute*)attribute_1 format: (TS_Format)format {
		return [self ref].packAttributes([attribute_0 ref], [attribute_1 ref], (Tellusim::Format)format);
	}
	-(BOOL)unpackAttributes: (TSMeshAttribute*)attribute_0 attribute_1: (TSMeshAttribute*)attribute_1 {
		return [self ref].unpackAttributes([attribute_0 ref], [attribute_1 ref]);
	}
	-(BOOL)unpackAttributes_: (TSMeshAttribute*)attribute_0 attribute_1: (TSMeshAttribute*)attribute_1 {
		return [self ref].unpackAttributes([attribute_0 ref], [attribute_1 ref]);
	}
	-(TSMeshAttribute*)optimizeAttribute: (TSMeshIndices*)indices {
		return [[TSMeshAttribute alloc] init_ref:([self ref].optimizeAttribute([indices ref]))];
	}
	-(TSMeshAttribute*)optimizeAttribute_: (TSMeshIndices*)indices {
		return [[TSMeshAttribute alloc] init_ref:([self ref].optimizeAttribute([indices ref]))];
	}
	-(TSMeshAttribute*)toDirect: (const TSMeshIndices*)indices {
		return [[TSMeshAttribute alloc] init_ref:([self ref].toDirect([indices ref]))];
	}
	-(TSMeshAttribute*)toDirect_: (const TSMeshIndices*)indices {
		return [[TSMeshAttribute alloc] init_ref:([self ref].toDirect([indices ref]))];
	}
	-(TSMeshAttribute*)toFormat: (TS_Format)format {
		return [[TSMeshAttribute alloc] init_ref:([self ref].toFormat((Tellusim::Format)format))];
	}
	-(TSMeshAttribute*)toFormat_: (TS_Format)format {
		return [[TSMeshAttribute alloc] init_ref:([self ref].toFormat((Tellusim::Format)format))];
	}
	-(TSMeshAttribute*)toType: (TS_MeshAttributeType)type {
		return [[TSMeshAttribute alloc] init_ref:([self ref].toType((Tellusim::MeshAttribute::Type)type))];
	}
	-(TSMeshAttribute*)toType_: (TS_MeshAttributeType)type {
		return [[TSMeshAttribute alloc] init_ref:([self ref].toType((Tellusim::MeshAttribute::Type)type))];
	}
	-(TSMatrix4x3f)getCovarianceMatrix {
		Tellusim::Matrix4x3f ret = [self ref].getCovarianceMatrix();
		return *(TSMatrix4x3f*)&ret;
	}
	-(TSMatrix4x3f)getMinTransform {
		Tellusim::Matrix4x3f ret = [self ref].getMinTransform();
		return *(TSMatrix4x3f*)&ret;
	}
	-(TSBoundBoxf)getBoundBox {
		Tellusim::BoundBoxf ret = [self ref].getBoundBox();
		return *(TSBoundBoxf*)&ret;
	}
	-(TSBoundSpheref)getBoundSphere {
		Tellusim::BoundSpheref ret = [self ref].getBoundSphere();
		return *(TSBoundSpheref*)&ret;
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::MeshJoint
@implementation TSMeshJoint
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshJoint();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshJoint(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshJoint(name);
		return self;
	}
	-(id)init_2: (TSMeshGeometry*)geometry {
		self = [super init];
		impl = new Tellusim::MeshJoint([geometry ref]);
		return self;
	}
	-(id)init_2_: (TSMeshGeometry*)geometry {
		self = [super init];
		impl = new Tellusim::MeshJoint([geometry ref]);
		return self;
	}
	-(id)init_3: (TSMeshGeometry*)geometry name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshJoint([geometry ref], name);
		return self;
	}
	-(id)init_3_: (TSMeshGeometry*)geometry name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshJoint([geometry ref], name);
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshJoint*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MeshJoint&)ref {
		self = [super init];
		impl = new Tellusim::MeshJoint((Tellusim::MeshJoint&)ref);
		return self;
	}
	-(Tellusim::MeshJoint*)pointer {
		return (Tellusim::MeshJoint*)impl;
	}
	-(Tellusim::MeshJoint&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshJoint*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshJoint*)impl;
	}
	-(BOOL)equalPtr: (const TSMeshJoint*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMeshJoint*)copyPtr {
		return [[TSMeshJoint alloc] init_ref:[self ref]];
	}
	-(TSMeshJoint*)clonePtr {
		return [[TSMeshJoint alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMeshJoint*)null {
		return [[TSMeshJoint alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(void)setNode: (TSMeshNode*)node {
		[self ref].setNode([node ref]);
	}
	-(void)setNode_: (TSMeshNode*)node {
		[self ref].setNode([node ref]);
	}
	-(const TSMeshNode*)getNode {
		return [[TSMeshNode alloc] init_ref:([self ref].getNode())];
	}
	-(uint32_t)getNodeIndex {
		return [self ref].getNodeIndex();
	}
	-(TSMatrix4x3d)getLocalTransform {
		Tellusim::Matrix4x3d ret = [self ref].getLocalTransform();
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getGlobalTransform {
		Tellusim::Matrix4x3d ret = [self ref].getGlobalTransform();
		return *(TSMatrix4x3d*)&ret;
	}
	-(void)setIndices: (TSMeshIndices*)indices {
		[self ref].setIndices([indices ref]);
	}
	-(void)setIndices_: (TSMeshIndices*)indices {
		[self ref].setIndices([indices ref]);
	}
	-(const TSMeshIndices*)getIndices {
		return [[TSMeshIndices alloc] init_ref:([self ref].getIndices())];
	}
	-(void)setGeometry: (TSMeshGeometry*)geometry {
		[self ref].setGeometry([geometry ref]);
	}
	-(void)setGeometry_: (TSMeshGeometry*)geometry {
		[self ref].setGeometry([geometry ref]);
	}
	-(void)setGeometry_1: (TSMeshGeometry*)geometry check: (BOOL)check {
		[self ref].setGeometry([geometry ref], (bool)check);
	}
	-(void)setGeometry_1_: (TSMeshGeometry*)geometry check: (BOOL)check {
		[self ref].setGeometry([geometry ref], (bool)check);
	}
	-(const TSMeshGeometry*)getGeometry {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getGeometry())];
	}
	-(void)setBoundBox: (TSBoundBoxf)box {
		[self ref].setBoundBox(*(Tellusim::BoundBoxf*)&box);
	}
	-(void)setBoundBox_: (TSBoundBoxf)box {
		[self ref].setBoundBox(*(Tellusim::BoundBoxf*)&box);
	}
	-(TSBoundBoxf)getBoundBox {
		Tellusim::BoundBoxf ret = [self ref].getBoundBox();
		return *(TSBoundBoxf*)&ret;
	}
	-(void)setBoundSphere: (TSBoundSpheref)sphere {
		[self ref].setBoundSphere(*(Tellusim::BoundSpheref*)&sphere);
	}
	-(void)setBoundSphere_: (TSBoundSpheref)sphere {
		[self ref].setBoundSphere(*(Tellusim::BoundSpheref*)&sphere);
	}
	-(TSBoundSpheref)getBoundSphere {
		Tellusim::BoundSpheref ret = [self ref].getBoundSphere();
		return *(TSBoundSpheref*)&ret;
	}
	-(void)setITransform: (TSMatrix4x3f)itransform {
		[self ref].setITransform(*(Tellusim::Matrix4x3f*)&itransform);
	}
	-(void)setITransform_: (TSMatrix4x3f)itransform {
		[self ref].setITransform(*(Tellusim::Matrix4x3f*)&itransform);
	}
	-(TSMatrix4x3f)getITransform {
		Tellusim::Matrix4x3f ret = [self ref].getITransform();
		return *(TSMatrix4x3f*)&ret;
	}
	-(int32_t)compare: (const TSMeshJoint*)joint {
		return [self ref].compare([joint ref]);
	}
	-(int32_t)compare_: (const TSMeshJoint*)joint {
		return [self ref].compare([joint ref]);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::MeshMaterial
@implementation TSMeshMaterial
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshMaterial();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshMaterial(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshMaterial(name);
		return self;
	}
	-(id)init_2: (TSMeshGeometry*)geometry {
		self = [super init];
		impl = new Tellusim::MeshMaterial([geometry ref]);
		return self;
	}
	-(id)init_2_: (TSMeshGeometry*)geometry {
		self = [super init];
		impl = new Tellusim::MeshMaterial([geometry ref]);
		return self;
	}
	-(id)init_3: (TSMeshGeometry*)geometry name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshMaterial([geometry ref], name);
		return self;
	}
	-(id)init_3_: (TSMeshGeometry*)geometry name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshMaterial([geometry ref], name);
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshMaterial*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MeshMaterial&)ref {
		self = [super init];
		impl = new Tellusim::MeshMaterial((Tellusim::MeshMaterial&)ref);
		return self;
	}
	-(Tellusim::MeshMaterial*)pointer {
		return (Tellusim::MeshMaterial*)impl;
	}
	-(Tellusim::MeshMaterial&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshMaterial*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshMaterial*)impl;
	}
	-(BOOL)equalPtr: (const TSMeshMaterial*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMeshMaterial*)copyPtr {
		return [[TSMeshMaterial alloc] init_ref:[self ref]];
	}
	-(TSMeshMaterial*)clonePtr {
		return [[TSMeshMaterial alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMeshMaterial*)null {
		return [[TSMeshMaterial alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)setIndices: (TSMeshIndices*)indices {
		[self ref].setIndices([indices ref]);
	}
	-(void)setIndices_: (TSMeshIndices*)indices {
		[self ref].setIndices([indices ref]);
	}
	-(const TSMeshIndices*)getIndices {
		return [[TSMeshIndices alloc] init_ref:([self ref].getIndices())];
	}
	-(void)setGeometry: (TSMeshGeometry*)geometry {
		[self ref].setGeometry([geometry ref]);
	}
	-(void)setGeometry_: (TSMeshGeometry*)geometry {
		[self ref].setGeometry([geometry ref]);
	}
	-(void)setGeometry_1: (TSMeshGeometry*)geometry check: (BOOL)check {
		[self ref].setGeometry([geometry ref], (bool)check);
	}
	-(void)setGeometry_1_: (TSMeshGeometry*)geometry check: (BOOL)check {
		[self ref].setGeometry([geometry ref], (bool)check);
	}
	-(const TSMeshGeometry*)getGeometry {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getGeometry())];
	}
	-(void)setData: (const char*)data {
		[self ref].setData(data);
	}
	-(void)setData_: (const char*)data {
		[self ref].setData(data);
	}
	-(void)setData_1: (const TSString*)data {
		[self ref].setData((data) ? [data ref] : Tellusim::String::null);
	}
	-(void)setData_1_: (const TSString*)data {
		[self ref].setData((data) ? [data ref] : Tellusim::String::null);
	}
	-(NSString*)getData {
		return [NSString stringWithUTF8String:[self ref].getData().get()];
	}
	-(void)clearParameters {
		[self ref].clearParameters();
	}
	-(BOOL)removeParameter: (const char*)type {
		return [self ref].removeParameter(type);
	}
	-(BOOL)removeParameter_: (const char*)type {
		return [self ref].removeParameter(type);
	}
	-(void)copyParameters: (const TSMeshMaterial*)material {
		[self ref].copyParameters([material ref]);
	}
	-(void)copyParameters_: (const TSMeshMaterial*)material {
		[self ref].copyParameters([material ref]);
	}
	-(uint32_t)findParameter: (const char*)type {
		return [self ref].findParameter(type);
	}
	-(uint32_t)findParameter_: (const char*)type {
		return [self ref].findParameter(type);
	}
	-(BOOL)hasParameter: (const char*)type {
		return [self ref].hasParameter(type);
	}
	-(BOOL)hasParameter_: (const char*)type {
		return [self ref].hasParameter(type);
	}
	-(uint32_t)getNumParameters {
		return [self ref].getNumParameters();
	}
	-(NSString*)getParameterType: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterType(index).get()];
	}
	-(NSString*)getParameterType_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterType(index).get()];
	}
	-(void)addParameter: (const char*)type value: (BOOL)value {
		[self ref].addParameter(type, (bool)value);
	}
	-(void)addParameter_: (const char*)type value: (BOOL)value {
		[self ref].addParameter(type, (bool)value);
	}
	-(void)addParameter_1: (const char*)type value: (float32_t)value {
		[self ref].addParameter(type, value);
	}
	-(void)addParameter_1_: (const char*)type value: (float32_t)value {
		[self ref].addParameter(type, value);
	}
	-(void)addParameter_2: (const char*)type value: (TSVector4f)value {
		[self ref].addParameter(type, *(Tellusim::Vector4f*)&value);
	}
	-(void)addParameter_2_: (const char*)type value: (TSVector4f)value {
		[self ref].addParameter(type, *(Tellusim::Vector4f*)&value);
	}
	-(void)addParameter_3: (const char*)type value: (TSMatrix3x2f)value {
		[self ref].addParameter(type, *(Tellusim::Matrix3x2f*)&value);
	}
	-(void)addParameter_3_: (const char*)type value: (TSMatrix3x2f)value {
		[self ref].addParameter(type, *(Tellusim::Matrix3x2f*)&value);
	}
	-(void)addParameter_4: (const char*)type color: (TSColor)color {
		[self ref].addParameter(type, *(Tellusim::Color*)&color);
	}
	-(void)addParameter_4_: (const char*)type color: (TSColor)color {
		[self ref].addParameter(type, *(Tellusim::Color*)&color);
	}
	-(void)addParameter_5: (const char*)type name: (const char*)name {
		[self ref].addParameter(type, name);
	}
	-(void)addParameter_5_: (const char*)type name: (const char*)name {
		[self ref].addParameter(type, name);
	}
	-(void)addParameter_6: (const char*)type name: (const char*)name layout: (const char*)layout {
		[self ref].addParameter(type, name, layout);
	}
	-(void)addParameter_6_: (const char*)type name: (const char*)name layout: (const char*)layout {
		[self ref].addParameter(type, name, layout);
	}
	-(void)addParameter_7: (const char*)type name: (const TSString*)name {
		[self ref].addParameter(type, (name) ? [name ref] : Tellusim::String::null);
	}
	-(void)addParameter_7_: (const char*)type name: (const TSString*)name {
		[self ref].addParameter(type, (name) ? [name ref] : Tellusim::String::null);
	}
	-(void)addParameter_8: (const char*)type name: (const TSString*)name layout: (const char*)layout {
		[self ref].addParameter(type, (name) ? [name ref] : Tellusim::String::null, layout);
	}
	-(void)addParameter_8_: (const char*)type name: (const TSString*)name layout: (const char*)layout {
		[self ref].addParameter(type, (name) ? [name ref] : Tellusim::String::null, layout);
	}
	-(void)addParameter_9: (const char*)type image: (const TSImage*)image {
		[self ref].addParameter(type, [image ref]);
	}
	-(void)addParameter_9_: (const char*)type image: (const TSImage*)image {
		[self ref].addParameter(type, [image ref]);
	}
	-(void)addParameter_10: (const char*)type image: (const TSImage*)image layout: (const char*)layout {
		[self ref].addParameter(type, [image ref], layout);
	}
	-(void)addParameter_10_: (const char*)type image: (const TSImage*)image layout: (const char*)layout {
		[self ref].addParameter(type, [image ref], layout);
	}
	-(void)addParameter_11: (const char*)type blob: (TSBlob*)blob {
		[self ref].addParameter(type, [blob ref]);
	}
	-(void)addParameter_11_: (const char*)type blob: (TSBlob*)blob {
		[self ref].addParameter(type, [blob ref]);
	}
	-(void)addParameter_12: (const char*)type blob: (TSBlob*)blob layout: (const char*)layout {
		[self ref].addParameter(type, [blob ref], layout);
	}
	-(void)addParameter_12_: (const char*)type blob: (TSBlob*)blob layout: (const char*)layout {
		[self ref].addParameter(type, [blob ref], layout);
	}
	-(TS_MeshMaterialFlags)getParameterFlags: (uint32_t)index {
		return (TS_MeshMaterialFlags)[self ref].getParameterFlags(index);
	}
	-(TS_MeshMaterialFlags)getParameterFlags_: (uint32_t)index {
		return (TS_MeshMaterialFlags)[self ref].getParameterFlags(index);
	}
	-(BOOL)hasParameterFlag: (uint32_t)index flags: (TS_MeshMaterialFlags)flags {
		return [self ref].hasParameterFlag(index, (Tellusim::MeshMaterial::Flags)flags);
	}
	-(BOOL)hasParameterFlag_: (uint32_t)index flags: (TS_MeshMaterialFlags)flags {
		return [self ref].hasParameterFlag(index, (Tellusim::MeshMaterial::Flags)flags);
	}
	-(BOOL)hasParameterFlags: (uint32_t)index flags: (TS_MeshMaterialFlags)flags {
		return [self ref].hasParameterFlags(index, (Tellusim::MeshMaterial::Flags)flags);
	}
	-(BOOL)hasParameterFlags_: (uint32_t)index flags: (TS_MeshMaterialFlags)flags {
		return [self ref].hasParameterFlags(index, (Tellusim::MeshMaterial::Flags)flags);
	}
	-(BOOL)getParameterBool: (uint32_t)index {
		return [self ref].getParameterBool(index);
	}
	-(BOOL)getParameterBool_: (uint32_t)index {
		return [self ref].getParameterBool(index);
	}
	-(BOOL)getParameterBool_1: (uint32_t)index value: (BOOL)value {
		return [self ref].getParameterBool(index, (bool)value);
	}
	-(BOOL)getParameterBool_1_: (uint32_t)index value: (BOOL)value {
		return [self ref].getParameterBool(index, (bool)value);
	}
	-(float32_t)getParameterScalarf32: (uint32_t)index {
		return [self ref].getParameterScalarf32(index);
	}
	-(float32_t)getParameterScalarf32_: (uint32_t)index {
		return [self ref].getParameterScalarf32(index);
	}
	-(float32_t)getParameterScalarf32_1: (uint32_t)index value: (float32_t)value {
		return [self ref].getParameterScalarf32(index, value);
	}
	-(float32_t)getParameterScalarf32_1_: (uint32_t)index value: (float32_t)value {
		return [self ref].getParameterScalarf32(index, value);
	}
	-(TSVector4f)getParameterVector4f: (uint32_t)index {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(index);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_: (uint32_t)index {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(index);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_1: (uint32_t)index vector: (TSVector4f)vector {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(index, *(Tellusim::Vector4f*)&vector);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_1_: (uint32_t)index vector: (TSVector4f)vector {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(index, *(Tellusim::Vector4f*)&vector);
		return *(TSVector4f*)&ret;
	}
	-(TSMatrix3x2f)getParameterMatrix3x2f: (uint32_t)index {
		Tellusim::Matrix3x2f ret = [self ref].getParameterMatrix3x2f(index);
		return *(TSMatrix3x2f*)&ret;
	}
	-(TSMatrix3x2f)getParameterMatrix3x2f_: (uint32_t)index {
		Tellusim::Matrix3x2f ret = [self ref].getParameterMatrix3x2f(index);
		return *(TSMatrix3x2f*)&ret;
	}
	-(TSMatrix3x2f)getParameterMatrix3x2f_1: (uint32_t)index matrix: (TSMatrix3x2f)matrix {
		Tellusim::Matrix3x2f ret = [self ref].getParameterMatrix3x2f(index, *(Tellusim::Matrix3x2f*)&matrix);
		return *(TSMatrix3x2f*)&ret;
	}
	-(TSMatrix3x2f)getParameterMatrix3x2f_1_: (uint32_t)index matrix: (TSMatrix3x2f)matrix {
		Tellusim::Matrix3x2f ret = [self ref].getParameterMatrix3x2f(index, *(Tellusim::Matrix3x2f*)&matrix);
		return *(TSMatrix3x2f*)&ret;
	}
	-(TSColor)getParameterColor: (uint32_t)index {
		Tellusim::Color ret = [self ref].getParameterColor(index);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_: (uint32_t)index {
		Tellusim::Color ret = [self ref].getParameterColor(index);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_1: (uint32_t)index color: (TSColor)color {
		Tellusim::Color ret = [self ref].getParameterColor(index, *(Tellusim::Color*)&color);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_1_: (uint32_t)index color: (TSColor)color {
		Tellusim::Color ret = [self ref].getParameterColor(index, *(Tellusim::Color*)&color);
		return *(TSColor*)&ret;
	}
	-(NSString*)getParameterName: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterName(index).get()];
	}
	-(NSString*)getParameterName_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterName(index).get()];
	}
	-(NSString*)getParameterName_1: (uint32_t)index name: (const TSString*)name {
		return [NSString stringWithUTF8String:[self ref].getParameterName(index, (name) ? [name ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getParameterName_1_: (uint32_t)index name: (const TSString*)name {
		return [NSString stringWithUTF8String:[self ref].getParameterName(index, (name) ? [name ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getParameterLayout: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterLayout(index).get()];
	}
	-(NSString*)getParameterLayout_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterLayout(index).get()];
	}
	-(NSString*)getParameterLayout_1: (uint32_t)index layout: (const TSString*)layout {
		return [NSString stringWithUTF8String:[self ref].getParameterLayout(index, (layout) ? [layout ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getParameterLayout_1_: (uint32_t)index layout: (const TSString*)layout {
		return [NSString stringWithUTF8String:[self ref].getParameterLayout(index, (layout) ? [layout ref] : Tellusim::String::null).get()];
	}
	-(const TSImage*)getParameterImage: (uint32_t)index {
		return [[TSImage alloc] init_ref:([self ref].getParameterImage(index))];
	}
	-(const TSImage*)getParameterImage_: (uint32_t)index {
		return [[TSImage alloc] init_ref:([self ref].getParameterImage(index))];
	}
	-(TSBlob*)getParameterBlob: (uint32_t)index {
		return [[TSBlob alloc] init_ref:([self ref].getParameterBlob(index))];
	}
	-(TSBlob*)getParameterBlob_: (uint32_t)index {
		return [[TSBlob alloc] init_ref:([self ref].getParameterBlob(index))];
	}
	-(TS_MeshMaterialFlags)getParameterFlags_1: (const char*)type {
		return (TS_MeshMaterialFlags)[self ref].getParameterFlags(type);
	}
	-(TS_MeshMaterialFlags)getParameterFlags_1_: (const char*)type {
		return (TS_MeshMaterialFlags)[self ref].getParameterFlags(type);
	}
	-(BOOL)hasParameterFlag_1: (const char*)type flags: (TS_MeshMaterialFlags)flags {
		return [self ref].hasParameterFlag(type, (Tellusim::MeshMaterial::Flags)flags);
	}
	-(BOOL)hasParameterFlag_1_: (const char*)type flags: (TS_MeshMaterialFlags)flags {
		return [self ref].hasParameterFlag(type, (Tellusim::MeshMaterial::Flags)flags);
	}
	-(BOOL)hasParameterFlags_1: (const char*)type flags: (TS_MeshMaterialFlags)flags {
		return [self ref].hasParameterFlags(type, (Tellusim::MeshMaterial::Flags)flags);
	}
	-(BOOL)hasParameterFlags_1_: (const char*)type flags: (TS_MeshMaterialFlags)flags {
		return [self ref].hasParameterFlags(type, (Tellusim::MeshMaterial::Flags)flags);
	}
	-(BOOL)getParameterBool_2: (const char*)type {
		return [self ref].getParameterBool(type);
	}
	-(BOOL)getParameterBool_2_: (const char*)type {
		return [self ref].getParameterBool(type);
	}
	-(BOOL)getParameterBool_3: (const char*)type value: (BOOL)value {
		return [self ref].getParameterBool(type, (bool)value);
	}
	-(BOOL)getParameterBool_3_: (const char*)type value: (BOOL)value {
		return [self ref].getParameterBool(type, (bool)value);
	}
	-(float32_t)getParameterScalarf32_2: (const char*)type {
		return [self ref].getParameterScalarf32(type);
	}
	-(float32_t)getParameterScalarf32_2_: (const char*)type {
		return [self ref].getParameterScalarf32(type);
	}
	-(float32_t)getParameterScalarf32_3: (const char*)type value: (float32_t)value {
		return [self ref].getParameterScalarf32(type, value);
	}
	-(float32_t)getParameterScalarf32_3_: (const char*)type value: (float32_t)value {
		return [self ref].getParameterScalarf32(type, value);
	}
	-(TSVector4f)getParameterVector4f_2: (const char*)type {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(type);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_2_: (const char*)type {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(type);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_3: (const char*)type vector: (TSVector4f)vector {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(type, *(Tellusim::Vector4f*)&vector);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_3_: (const char*)type vector: (TSVector4f)vector {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(type, *(Tellusim::Vector4f*)&vector);
		return *(TSVector4f*)&ret;
	}
	-(TSMatrix3x2f)getParameterMatrix3x2f_2: (const char*)type {
		Tellusim::Matrix3x2f ret = [self ref].getParameterMatrix3x2f(type);
		return *(TSMatrix3x2f*)&ret;
	}
	-(TSMatrix3x2f)getParameterMatrix3x2f_2_: (const char*)type {
		Tellusim::Matrix3x2f ret = [self ref].getParameterMatrix3x2f(type);
		return *(TSMatrix3x2f*)&ret;
	}
	-(TSMatrix3x2f)getParameterMatrix3x2f_3: (const char*)type matrix: (TSMatrix3x2f)matrix {
		Tellusim::Matrix3x2f ret = [self ref].getParameterMatrix3x2f(type, *(Tellusim::Matrix3x2f*)&matrix);
		return *(TSMatrix3x2f*)&ret;
	}
	-(TSMatrix3x2f)getParameterMatrix3x2f_3_: (const char*)type matrix: (TSMatrix3x2f)matrix {
		Tellusim::Matrix3x2f ret = [self ref].getParameterMatrix3x2f(type, *(Tellusim::Matrix3x2f*)&matrix);
		return *(TSMatrix3x2f*)&ret;
	}
	-(TSColor)getParameterColor_2: (const char*)type {
		Tellusim::Color ret = [self ref].getParameterColor(type);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_2_: (const char*)type {
		Tellusim::Color ret = [self ref].getParameterColor(type);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_3: (const char*)type color: (TSColor)color {
		Tellusim::Color ret = [self ref].getParameterColor(type, *(Tellusim::Color*)&color);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_3_: (const char*)type color: (TSColor)color {
		Tellusim::Color ret = [self ref].getParameterColor(type, *(Tellusim::Color*)&color);
		return *(TSColor*)&ret;
	}
	-(NSString*)getParameterName_2: (const char*)type {
		return [NSString stringWithUTF8String:[self ref].getParameterName(type).get()];
	}
	-(NSString*)getParameterName_2_: (const char*)type {
		return [NSString stringWithUTF8String:[self ref].getParameterName(type).get()];
	}
	-(NSString*)getParameterName_3: (const char*)type name: (const TSString*)name {
		return [NSString stringWithUTF8String:[self ref].getParameterName(type, (name) ? [name ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getParameterName_3_: (const char*)type name: (const TSString*)name {
		return [NSString stringWithUTF8String:[self ref].getParameterName(type, (name) ? [name ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getParameterLayout_2: (const char*)type {
		return [NSString stringWithUTF8String:[self ref].getParameterLayout(type).get()];
	}
	-(NSString*)getParameterLayout_2_: (const char*)type {
		return [NSString stringWithUTF8String:[self ref].getParameterLayout(type).get()];
	}
	-(NSString*)getParameterLayout_3: (const char*)type layout: (const TSString*)layout {
		return [NSString stringWithUTF8String:[self ref].getParameterLayout(type, (layout) ? [layout ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getParameterLayout_3_: (const char*)type layout: (const TSString*)layout {
		return [NSString stringWithUTF8String:[self ref].getParameterLayout(type, (layout) ? [layout ref] : Tellusim::String::null).get()];
	}
	-(int32_t)compare: (const TSMeshMaterial*)material {
		return [self ref].compare([material ref]);
	}
	-(int32_t)compare_: (const TSMeshMaterial*)material {
		return [self ref].compare([material ref]);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end
TS_CAPI NSString *tsMeshMaterialTypeBump = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeBump];
TS_CAPI NSString *tsMeshMaterialTypeNormal = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeNormal];
TS_CAPI NSString *tsMeshMaterialTypeEmission = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeEmission];
TS_CAPI NSString *tsMeshMaterialTypeOcclusion = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeOcclusion];
TS_CAPI NSString *tsMeshMaterialTypeOpacity = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeOpacity];
TS_CAPI NSString *tsMeshMaterialTypeAmbient = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeAmbient];
TS_CAPI NSString *tsMeshMaterialTypeDiffuse = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeDiffuse];
TS_CAPI NSString *tsMeshMaterialTypeSpecular = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeSpecular];
TS_CAPI NSString *tsMeshMaterialTypeMetallic = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeMetallic];
TS_CAPI NSString *tsMeshMaterialTypeRoughness = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeRoughness];
TS_CAPI NSString *tsMeshMaterialTypeShininess = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeShininess];
TS_CAPI NSString *tsMeshMaterialTypeGlossiness = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeGlossiness];
TS_CAPI NSString *tsMeshMaterialTypeTransparent = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeTransparent];
TS_CAPI NSString *tsMeshMaterialTypeTransparency = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeTransparency];
TS_CAPI NSString *tsMeshMaterialTypeTransmission = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeTransmission];
TS_CAPI NSString *tsMeshMaterialTypeReflective = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeReflective];
TS_CAPI NSString *tsMeshMaterialTypeReflectivity = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeReflectivity];
TS_CAPI NSString *tsMeshMaterialTypeRefractiveIndex = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeRefractiveIndex];
TS_CAPI NSString *tsMeshMaterialTypeClearcoat = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeClearcoat];
TS_CAPI NSString *tsMeshMaterialTypeClearcoatNormal = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeClearcoatNormal];
TS_CAPI NSString *tsMeshMaterialTypeClearcoatRoughness = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeClearcoatRoughness];
TS_CAPI NSString *tsMeshMaterialTypeClearcoatGlossiness = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeClearcoatGlossiness];
TS_CAPI NSString *tsMeshMaterialTypeIridescence = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeIridescence];
TS_CAPI NSString *tsMeshMaterialTypeIridescenceThickness = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeIridescenceThickness];
TS_CAPI NSString *tsMeshMaterialTypeIridescenceRefractiveIndex = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeIridescenceRefractiveIndex];
TS_CAPI NSString *tsMeshMaterialTypeSheen = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeSheen];
TS_CAPI NSString *tsMeshMaterialTypeSheenRoughness = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeSheenRoughness];
TS_CAPI NSString *tsMeshMaterialTypeVolume = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeVolume];
TS_CAPI NSString *tsMeshMaterialTypeVolumeThickness = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeVolumeThickness];
TS_CAPI NSString *tsMeshMaterialTypeAnisotropy = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeAnisotropy];
TS_CAPI NSString *tsMeshMaterialTypeAnisotropyAngle = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeAnisotropyAngle];
TS_CAPI NSString *tsMeshMaterialTypeDoubleSided = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeDoubleSided];
TS_CAPI NSString *tsMeshMaterialTypeAlphaBlend = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeAlphaBlend];
TS_CAPI NSString *tsMeshMaterialTypeAlphaMask = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeAlphaMask];
TS_CAPI NSString *tsMeshMaterialTypeTechnique = [NSString stringWithUTF8String:Tellusim::MeshMaterial::TypeTechnique];

// Tellusim::MeshGeometry
@implementation TSMeshGeometry
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshGeometry();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshGeometry(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshGeometry(name);
		return self;
	}
	-(id)init_2: (TSMesh*)mesh {
		self = [super init];
		impl = new Tellusim::MeshGeometry([mesh ref]);
		return self;
	}
	-(id)init_2_: (TSMesh*)mesh {
		self = [super init];
		impl = new Tellusim::MeshGeometry([mesh ref]);
		return self;
	}
	-(id)init_3: (TSMesh*)mesh name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshGeometry([mesh ref], name);
		return self;
	}
	-(id)init_3_: (TSMesh*)mesh name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshGeometry([mesh ref], name);
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshGeometry*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MeshGeometry&)ref {
		self = [super init];
		impl = new Tellusim::MeshGeometry((Tellusim::MeshGeometry&)ref);
		return self;
	}
	-(Tellusim::MeshGeometry*)pointer {
		return (Tellusim::MeshGeometry*)impl;
	}
	-(Tellusim::MeshGeometry&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshGeometry*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshGeometry*)impl;
	}
	-(BOOL)equalPtr: (const TSMeshGeometry*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMeshGeometry*)copyPtr {
		return [[TSMeshGeometry alloc] init_ref:[self ref]];
	}
	-(TSMeshGeometry*)clonePtr {
		return [[TSMeshGeometry alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMeshGeometry*)null {
		return [[TSMeshGeometry alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)setMesh: (TSMesh*)mesh {
		[self ref].setMesh([mesh ref]);
	}
	-(void)setMesh_: (TSMesh*)mesh {
		[self ref].setMesh([mesh ref]);
	}
	-(void)setMesh_1: (TSMesh*)mesh check: (BOOL)check {
		[self ref].setMesh([mesh ref], (bool)check);
	}
	-(void)setMesh_1_: (TSMesh*)mesh check: (BOOL)check {
		[self ref].setMesh([mesh ref], (bool)check);
	}
	-(const TSMesh*)getMesh {
		return [[TSMesh alloc] init_ref:([self ref].getMesh())];
	}
	-(uint32_t)setParent0: (TSMeshGeometry*)parent {
		return [self ref].setParent0([parent ref]);
	}
	-(uint32_t)setParent0_: (TSMeshGeometry*)parent {
		return [self ref].setParent0([parent ref]);
	}
	-(uint32_t)setParent0_1: (TSMeshGeometry*)parent check: (BOOL)check {
		return [self ref].setParent0([parent ref], (bool)check);
	}
	-(uint32_t)setParent0_1_: (TSMeshGeometry*)parent check: (BOOL)check {
		return [self ref].setParent0([parent ref], (bool)check);
	}
	-(uint32_t)setParent1: (TSMeshGeometry*)parent {
		return [self ref].setParent1([parent ref]);
	}
	-(uint32_t)setParent1_: (TSMeshGeometry*)parent {
		return [self ref].setParent1([parent ref]);
	}
	-(uint32_t)setParent1_1: (TSMeshGeometry*)parent check: (BOOL)check {
		return [self ref].setParent1([parent ref], (bool)check);
	}
	-(uint32_t)setParent1_1_: (TSMeshGeometry*)parent check: (BOOL)check {
		return [self ref].setParent1([parent ref], (bool)check);
	}
	-(const TSMeshGeometry*)getParent0 {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getParent0())];
	}
	-(const TSMeshGeometry*)getParent1 {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getParent1())];
	}
	-(BOOL)isRoot {
		return [self ref].isRoot();
	}
	-(void)reserveChildren: (uint32_t)num_children {
		[self ref].reserveChildren(num_children);
	}
	-(void)reserveChildren_: (uint32_t)num_children {
		[self ref].reserveChildren(num_children);
	}
	-(uint32_t)addChild0: (TSMeshGeometry*)child {
		return [self ref].addChild0([child ref]);
	}
	-(uint32_t)addChild0_: (TSMeshGeometry*)child {
		return [self ref].addChild0([child ref]);
	}
	-(uint32_t)addChild0_1: (TSMeshGeometry*)child check: (BOOL)check {
		return [self ref].addChild0([child ref], (bool)check);
	}
	-(uint32_t)addChild0_1_: (TSMeshGeometry*)child check: (BOOL)check {
		return [self ref].addChild0([child ref], (bool)check);
	}
	-(uint32_t)addChild1: (TSMeshGeometry*)child {
		return [self ref].addChild1([child ref]);
	}
	-(uint32_t)addChild1_: (TSMeshGeometry*)child {
		return [self ref].addChild1([child ref]);
	}
	-(uint32_t)addChild1_1: (TSMeshGeometry*)child check: (BOOL)check {
		return [self ref].addChild1([child ref], (bool)check);
	}
	-(uint32_t)addChild1_1_: (TSMeshGeometry*)child check: (BOOL)check {
		return [self ref].addChild1([child ref], (bool)check);
	}
	-(BOOL)removeChild: (TSMeshGeometry*)child {
		return [self ref].removeChild([child ref]);
	}
	-(BOOL)removeChild_: (TSMeshGeometry*)child {
		return [self ref].removeChild([child ref]);
	}
	-(void)releaseChildren {
		[self ref].releaseChildren();
	}
	-(uint32_t)findChild: (const TSMeshGeometry*)child {
		return [self ref].findChild([child ref]);
	}
	-(uint32_t)findChild_: (const TSMeshGeometry*)child {
		return [self ref].findChild([child ref]);
	}
	-(uint32_t)getNumChildren {
		return [self ref].getNumChildren();
	}
	-(NSArray<TSMeshGeometry*>*)getChildren {
		const auto &ret = [self ref].getChildren();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshGeometry alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshGeometry*)getChild: (uint32_t)index {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getChild(index))];
	}
	-(const TSMeshGeometry*)getChild_: (uint32_t)index {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getChild(index))];
	}
	-(void)clearIndices {
		[self ref].clearIndices();
	}
	-(void)reserveIndices: (uint32_t)num_indices {
		[self ref].reserveIndices(num_indices);
	}
	-(void)reserveIndices_: (uint32_t)num_indices {
		[self ref].reserveIndices(num_indices);
	}
	-(uint32_t)addIndices: (TSMeshIndices*)indices {
		return [self ref].addIndices([indices ref]);
	}
	-(uint32_t)addIndices_: (TSMeshIndices*)indices {
		return [self ref].addIndices([indices ref]);
	}
	-(uint32_t)addIndices_1: (TSMeshIndices*)indices check: (BOOL)check {
		return [self ref].addIndices([indices ref], (bool)check);
	}
	-(uint32_t)addIndices_1_: (TSMeshIndices*)indices check: (BOOL)check {
		return [self ref].addIndices([indices ref], (bool)check);
	}
	-(BOOL)removeIndices: (TSMeshIndices*)indices {
		return [self ref].removeIndices([indices ref]);
	}
	-(BOOL)removeIndices_: (TSMeshIndices*)indices {
		return [self ref].removeIndices([indices ref]);
	}
	-(BOOL)replaceIndices: (TSMeshIndices*)old_indices indices: (TSMeshIndices*)indices {
		return [self ref].replaceIndices([old_indices ref], [indices ref]);
	}
	-(BOOL)replaceIndices_: (TSMeshIndices*)old_indices indices: (TSMeshIndices*)indices {
		return [self ref].replaceIndices([old_indices ref], [indices ref]);
	}
	-(uint32_t)findIndices: (const TSMeshIndices*)indices {
		return [self ref].findIndices([indices ref]);
	}
	-(uint32_t)findIndices_: (const TSMeshIndices*)indices {
		return [self ref].findIndices([indices ref]);
	}
	-(uint32_t)findIndices_1: (TS_MeshIndicesType)type {
		return [self ref].findIndices((Tellusim::MeshIndices::Type)type);
	}
	-(uint32_t)findIndices_1_: (TS_MeshIndicesType)type {
		return [self ref].findIndices((Tellusim::MeshIndices::Type)type);
	}
	-(BOOL)hasIndices: (TS_MeshIndicesType)type {
		return [self ref].hasIndices((Tellusim::MeshIndices::Type)type);
	}
	-(BOOL)hasIndices_: (TS_MeshIndicesType)type {
		return [self ref].hasIndices((Tellusim::MeshIndices::Type)type);
	}
	-(BOOL)hasSolidIndices {
		return [self ref].hasSolidIndices();
	}
	-(uint32_t)getNumIndices: (TS_MeshIndicesType)type {
		return [self ref].getNumIndices((Tellusim::MeshIndices::Type)type);
	}
	-(uint32_t)getNumIndices_: (TS_MeshIndicesType)type {
		return [self ref].getNumIndices((Tellusim::MeshIndices::Type)type);
	}
	-(const TSMeshIndices*)getIndices: (TS_MeshIndicesType)type {
		return [[TSMeshIndices alloc] init_ref:([self ref].getIndices((Tellusim::MeshIndices::Type)type))];
	}
	-(const TSMeshIndices*)getIndices_: (TS_MeshIndicesType)type {
		return [[TSMeshIndices alloc] init_ref:([self ref].getIndices((Tellusim::MeshIndices::Type)type))];
	}
	-(uint32_t)getNumIndices_1 {
		return [self ref].getNumIndices();
	}
	-(NSArray<TSMeshIndices*>*)getIndices_1 {
		const auto &ret = [self ref].getIndices();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshIndices alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshIndices*)getIndices_2: (uint32_t)index {
		return [[TSMeshIndices alloc] init_ref:([self ref].getIndices(index))];
	}
	-(const TSMeshIndices*)getIndices_2_: (uint32_t)index {
		return [[TSMeshIndices alloc] init_ref:([self ref].getIndices(index))];
	}
	-(void)clearAttributes {
		[self ref].clearAttributes();
	}
	-(void)reserveAttributes: (uint32_t)num_attributes {
		[self ref].reserveAttributes(num_attributes);
	}
	-(void)reserveAttributes_: (uint32_t)num_attributes {
		[self ref].reserveAttributes(num_attributes);
	}
	-(uint32_t)addAttribute: (TSMeshAttribute*)attribute {
		return [self ref].addAttribute([attribute ref]);
	}
	-(uint32_t)addAttribute_: (TSMeshAttribute*)attribute {
		return [self ref].addAttribute([attribute ref]);
	}
	-(uint32_t)addAttribute_1: (TSMeshAttribute*)attribute check: (BOOL)check {
		return [self ref].addAttribute([attribute ref], (bool)check);
	}
	-(uint32_t)addAttribute_1_: (TSMeshAttribute*)attribute check: (BOOL)check {
		return [self ref].addAttribute([attribute ref], (bool)check);
	}
	-(uint32_t)addAttribute_2: (TSMeshAttribute*)attribute indices: (TSMeshIndices*)indices {
		return [self ref].addAttribute([attribute ref], [indices ref]);
	}
	-(uint32_t)addAttribute_2_: (TSMeshAttribute*)attribute indices: (TSMeshIndices*)indices {
		return [self ref].addAttribute([attribute ref], [indices ref]);
	}
	-(uint32_t)addAttribute_3: (TSMeshAttribute*)attribute indices: (TSMeshIndices*)indices check: (BOOL)check {
		return [self ref].addAttribute([attribute ref], [indices ref], (bool)check);
	}
	-(uint32_t)addAttribute_3_: (TSMeshAttribute*)attribute indices: (TSMeshIndices*)indices check: (BOOL)check {
		return [self ref].addAttribute([attribute ref], [indices ref], (bool)check);
	}
	-(BOOL)removeAttribute: (TSMeshAttribute*)attribute {
		return [self ref].removeAttribute([attribute ref]);
	}
	-(BOOL)removeAttribute_: (TSMeshAttribute*)attribute {
		return [self ref].removeAttribute([attribute ref]);
	}
	-(BOOL)replaceAttribute: (TSMeshAttribute*)old_attribute attribute: (TSMeshAttribute*)attribute {
		return [self ref].replaceAttribute([old_attribute ref], [attribute ref]);
	}
	-(BOOL)replaceAttribute_: (TSMeshAttribute*)old_attribute attribute: (TSMeshAttribute*)attribute {
		return [self ref].replaceAttribute([old_attribute ref], [attribute ref]);
	}
	-(BOOL)replaceAttributeIndices: (const TSMeshIndices*)old_indices indices: (TSMeshIndices*)indices {
		return [self ref].replaceAttributeIndices([old_indices ref], [indices ref]);
	}
	-(BOOL)replaceAttributeIndices_: (const TSMeshIndices*)old_indices indices: (TSMeshIndices*)indices {
		return [self ref].replaceAttributeIndices([old_indices ref], [indices ref]);
	}
	-(uint32_t)findAttribute: (TS_MeshAttributeType)type format: (TS_Format)format {
		return [self ref].findAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format);
	}
	-(uint32_t)findAttribute_: (TS_MeshAttributeType)type format: (TS_Format)format {
		return [self ref].findAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format);
	}
	-(uint32_t)findAttribute_1: (TS_MeshAttributeType)type format: (TS_Format)format index: (uint32_t)index {
		return [self ref].findAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, index);
	}
	-(uint32_t)findAttribute_1_: (TS_MeshAttributeType)type format: (TS_Format)format index: (uint32_t)index {
		return [self ref].findAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, index);
	}
	-(uint32_t)findAttribute_2: (TS_MeshAttributeType)type {
		return [self ref].findAttribute((Tellusim::MeshAttribute::Type)type);
	}
	-(uint32_t)findAttribute_2_: (TS_MeshAttributeType)type {
		return [self ref].findAttribute((Tellusim::MeshAttribute::Type)type);
	}
	-(uint32_t)findAttribute_3: (TS_MeshAttributeType)type index: (uint32_t)index {
		return [self ref].findAttribute((Tellusim::MeshAttribute::Type)type, index);
	}
	-(uint32_t)findAttribute_3_: (TS_MeshAttributeType)type index: (uint32_t)index {
		return [self ref].findAttribute((Tellusim::MeshAttribute::Type)type, index);
	}
	-(uint32_t)findAttribute_4: (const char*)name {
		return [self ref].findAttribute(name);
	}
	-(uint32_t)findAttribute_4_: (const char*)name {
		return [self ref].findAttribute(name);
	}
	-(uint32_t)findAttribute_5: (const char*)name index: (uint32_t)index {
		return [self ref].findAttribute(name, index);
	}
	-(uint32_t)findAttribute_5_: (const char*)name index: (uint32_t)index {
		return [self ref].findAttribute(name, index);
	}
	-(uint32_t)findAttribute_6: (const TSMeshAttribute*)attribute {
		return [self ref].findAttribute([attribute ref]);
	}
	-(uint32_t)findAttribute_6_: (const TSMeshAttribute*)attribute {
		return [self ref].findAttribute([attribute ref]);
	}
	-(BOOL)hasAttribute: (TS_MeshAttributeType)type format: (TS_Format)format {
		return [self ref].hasAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format);
	}
	-(BOOL)hasAttribute_: (TS_MeshAttributeType)type format: (TS_Format)format {
		return [self ref].hasAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format);
	}
	-(BOOL)hasAttribute_1: (TS_MeshAttributeType)type format: (TS_Format)format index: (uint32_t)index {
		return [self ref].hasAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, index);
	}
	-(BOOL)hasAttribute_1_: (TS_MeshAttributeType)type format: (TS_Format)format index: (uint32_t)index {
		return [self ref].hasAttribute((Tellusim::MeshAttribute::Type)type, (Tellusim::Format)format, index);
	}
	-(BOOL)hasAttribute_2: (TS_MeshAttributeType)type {
		return [self ref].hasAttribute((Tellusim::MeshAttribute::Type)type);
	}
	-(BOOL)hasAttribute_2_: (TS_MeshAttributeType)type {
		return [self ref].hasAttribute((Tellusim::MeshAttribute::Type)type);
	}
	-(BOOL)hasAttribute_3: (TS_MeshAttributeType)type index: (uint32_t)index {
		return [self ref].hasAttribute((Tellusim::MeshAttribute::Type)type, index);
	}
	-(BOOL)hasAttribute_3_: (TS_MeshAttributeType)type index: (uint32_t)index {
		return [self ref].hasAttribute((Tellusim::MeshAttribute::Type)type, index);
	}
	-(BOOL)hasAttribute_4: (const char*)name {
		return [self ref].hasAttribute(name);
	}
	-(BOOL)hasAttribute_4_: (const char*)name {
		return [self ref].hasAttribute(name);
	}
	-(BOOL)hasAttribute_5: (const char*)name index: (uint32_t)index {
		return [self ref].hasAttribute(name, index);
	}
	-(BOOL)hasAttribute_5_: (const char*)name index: (uint32_t)index {
		return [self ref].hasAttribute(name, index);
	}
	-(BOOL)hasAttribute_6: (const TSMeshAttribute*)attribute {
		return [self ref].hasAttribute([attribute ref]);
	}
	-(BOOL)hasAttribute_6_: (const TSMeshAttribute*)attribute {
		return [self ref].hasAttribute([attribute ref]);
	}
	-(uint32_t)getNumAttributes: (TS_MeshAttributeType)type {
		return [self ref].getNumAttributes((Tellusim::MeshAttribute::Type)type);
	}
	-(uint32_t)getNumAttributes_: (TS_MeshAttributeType)type {
		return [self ref].getNumAttributes((Tellusim::MeshAttribute::Type)type);
	}
	-(uint32_t)getNumAttributes_1: (const TSMeshIndices*)indices {
		return [self ref].getNumAttributes([indices ref]);
	}
	-(uint32_t)getNumAttributes_1_: (const TSMeshIndices*)indices {
		return [self ref].getNumAttributes([indices ref]);
	}
	-(const TSMeshAttribute*)getAttribute: (TS_MeshAttributeType)type {
		return [[TSMeshAttribute alloc] init_ref:([self ref].getAttribute((Tellusim::MeshAttribute::Type)type))];
	}
	-(const TSMeshAttribute*)getAttribute_: (TS_MeshAttributeType)type {
		return [[TSMeshAttribute alloc] init_ref:([self ref].getAttribute((Tellusim::MeshAttribute::Type)type))];
	}
	-(const TSMeshAttribute*)getAttribute_1: (TS_MeshAttributeType)type index: (uint32_t)index {
		return [[TSMeshAttribute alloc] init_ref:([self ref].getAttribute((Tellusim::MeshAttribute::Type)type, index))];
	}
	-(const TSMeshAttribute*)getAttribute_1_: (TS_MeshAttributeType)type index: (uint32_t)index {
		return [[TSMeshAttribute alloc] init_ref:([self ref].getAttribute((Tellusim::MeshAttribute::Type)type, index))];
	}
	-(uint32_t)getNumAttributes_2 {
		return [self ref].getNumAttributes();
	}
	-(NSArray<TSMeshAttribute*>*)getAttributes {
		const auto &ret = [self ref].getAttributes();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshAttribute alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshAttribute*)getAttribute_2: (uint32_t)index {
		return [[TSMeshAttribute alloc] init_ref:([self ref].getAttribute(index))];
	}
	-(const TSMeshAttribute*)getAttribute_2_: (uint32_t)index {
		return [[TSMeshAttribute alloc] init_ref:([self ref].getAttribute(index))];
	}
	-(void)clearJoints {
		[self ref].clearJoints();
	}
	-(void)reserveJoints: (uint32_t)num_joints {
		[self ref].reserveJoints(num_joints);
	}
	-(void)reserveJoints_: (uint32_t)num_joints {
		[self ref].reserveJoints(num_joints);
	}
	-(uint32_t)addJoint: (TSMeshJoint*)joint {
		return [self ref].addJoint([joint ref]);
	}
	-(uint32_t)addJoint_: (TSMeshJoint*)joint {
		return [self ref].addJoint([joint ref]);
	}
	-(uint32_t)addJoint_1: (TSMeshJoint*)joint check: (BOOL)check {
		return [self ref].addJoint([joint ref], (bool)check);
	}
	-(uint32_t)addJoint_1_: (TSMeshJoint*)joint check: (BOOL)check {
		return [self ref].addJoint([joint ref], (bool)check);
	}
	-(uint32_t)addJoint_2: (TSMeshJoint*)joint node: (TSMeshNode*)node {
		return [self ref].addJoint([joint ref], [node ref]);
	}
	-(uint32_t)addJoint_2_: (TSMeshJoint*)joint node: (TSMeshNode*)node {
		return [self ref].addJoint([joint ref], [node ref]);
	}
	-(uint32_t)addJoint_3: (TSMeshJoint*)joint node: (TSMeshNode*)node check: (BOOL)check {
		return [self ref].addJoint([joint ref], [node ref], (bool)check);
	}
	-(uint32_t)addJoint_3_: (TSMeshJoint*)joint node: (TSMeshNode*)node check: (BOOL)check {
		return [self ref].addJoint([joint ref], [node ref], (bool)check);
	}
	-(BOOL)removeJoint: (TSMeshJoint*)joint {
		return [self ref].removeJoint([joint ref]);
	}
	-(BOOL)removeJoint_: (TSMeshJoint*)joint {
		return [self ref].removeJoint([joint ref]);
	}
	-(BOOL)replaceJoint: (TSMeshJoint*)old_joint joint: (TSMeshJoint*)joint {
		return [self ref].replaceJoint([old_joint ref], [joint ref]);
	}
	-(BOOL)replaceJoint_: (TSMeshJoint*)old_joint joint: (TSMeshJoint*)joint {
		return [self ref].replaceJoint([old_joint ref], [joint ref]);
	}
	-(uint32_t)findJoint: (const TSMeshJoint*)joint {
		return [self ref].findJoint([joint ref]);
	}
	-(uint32_t)findJoint_: (const TSMeshJoint*)joint {
		return [self ref].findJoint([joint ref]);
	}
	-(uint32_t)findJoint_1: (const TSMeshNode*)node {
		return [self ref].findJoint([node ref]);
	}
	-(uint32_t)findJoint_1_: (const TSMeshNode*)node {
		return [self ref].findJoint([node ref]);
	}
	-(uint32_t)findJoint_2: (const char*)name {
		return [self ref].findJoint(name);
	}
	-(uint32_t)findJoint_2_: (const char*)name {
		return [self ref].findJoint(name);
	}
	-(uint32_t)getNumJoints {
		return [self ref].getNumJoints();
	}
	-(NSArray<TSMeshJoint*>*)getJoints {
		const auto &ret = [self ref].getJoints();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshJoint alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshJoint*)getJoint: (uint32_t)index {
		return [[TSMeshJoint alloc] init_ref:([self ref].getJoint(index))];
	}
	-(const TSMeshJoint*)getJoint_: (uint32_t)index {
		return [[TSMeshJoint alloc] init_ref:([self ref].getJoint(index))];
	}
	-(void)clearMaterials {
		[self ref].clearMaterials();
	}
	-(void)reserveMaterials: (uint32_t)num_materials {
		[self ref].reserveMaterials(num_materials);
	}
	-(void)reserveMaterials_: (uint32_t)num_materials {
		[self ref].reserveMaterials(num_materials);
	}
	-(uint32_t)addMaterial: (TSMeshMaterial*)material {
		return [self ref].addMaterial([material ref]);
	}
	-(uint32_t)addMaterial_: (TSMeshMaterial*)material {
		return [self ref].addMaterial([material ref]);
	}
	-(uint32_t)addMaterial_1: (TSMeshMaterial*)material check: (BOOL)check {
		return [self ref].addMaterial([material ref], (bool)check);
	}
	-(uint32_t)addMaterial_1_: (TSMeshMaterial*)material check: (BOOL)check {
		return [self ref].addMaterial([material ref], (bool)check);
	}
	-(uint32_t)addMaterial_2: (TSMeshMaterial*)material indices: (TSMeshIndices*)indices {
		return [self ref].addMaterial([material ref], [indices ref]);
	}
	-(uint32_t)addMaterial_2_: (TSMeshMaterial*)material indices: (TSMeshIndices*)indices {
		return [self ref].addMaterial([material ref], [indices ref]);
	}
	-(uint32_t)addMaterial_3: (TSMeshMaterial*)material indices: (TSMeshIndices*)indices check: (BOOL)check {
		return [self ref].addMaterial([material ref], [indices ref], (bool)check);
	}
	-(uint32_t)addMaterial_3_: (TSMeshMaterial*)material indices: (TSMeshIndices*)indices check: (BOOL)check {
		return [self ref].addMaterial([material ref], [indices ref], (bool)check);
	}
	-(BOOL)removeMaterial: (TSMeshMaterial*)material {
		return [self ref].removeMaterial([material ref]);
	}
	-(BOOL)removeMaterial_: (TSMeshMaterial*)material {
		return [self ref].removeMaterial([material ref]);
	}
	-(BOOL)replaceMaterial: (TSMeshMaterial*)old_material material: (TSMeshMaterial*)material {
		return [self ref].replaceMaterial([old_material ref], [material ref]);
	}
	-(BOOL)replaceMaterial_: (TSMeshMaterial*)old_material material: (TSMeshMaterial*)material {
		return [self ref].replaceMaterial([old_material ref], [material ref]);
	}
	-(uint32_t)findMaterial: (const TSMeshMaterial*)material {
		return [self ref].findMaterial([material ref]);
	}
	-(uint32_t)findMaterial_: (const TSMeshMaterial*)material {
		return [self ref].findMaterial([material ref]);
	}
	-(uint32_t)findMaterial_1: (const char*)name {
		return [self ref].findMaterial(name);
	}
	-(uint32_t)findMaterial_1_: (const char*)name {
		return [self ref].findMaterial(name);
	}
	-(uint32_t)getNumMaterials {
		return [self ref].getNumMaterials();
	}
	-(NSArray<TSMeshMaterial*>*)getMaterials {
		const auto &ret = [self ref].getMaterials();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshMaterial alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshMaterial*)getMaterial: (uint32_t)index {
		return [[TSMeshMaterial alloc] init_ref:([self ref].getMaterial(index))];
	}
	-(const TSMeshMaterial*)getMaterial_: (uint32_t)index {
		return [[TSMeshMaterial alloc] init_ref:([self ref].getMaterial(index))];
	}
	-(void)setBoundBox: (TSBoundBoxf)box {
		[self ref].setBoundBox(*(Tellusim::BoundBoxf*)&box);
	}
	-(void)setBoundBox_: (TSBoundBoxf)box {
		[self ref].setBoundBox(*(Tellusim::BoundBoxf*)&box);
	}
	-(TSBoundBoxf)getBoundBox {
		Tellusim::BoundBoxf ret = [self ref].getBoundBox();
		return *(TSBoundBoxf*)&ret;
	}
	-(void)setBoundSphere: (TSBoundSpheref)sphere {
		[self ref].setBoundSphere(*(Tellusim::BoundSpheref*)&sphere);
	}
	-(void)setBoundSphere_: (TSBoundSpheref)sphere {
		[self ref].setBoundSphere(*(Tellusim::BoundSpheref*)&sphere);
	}
	-(TSBoundSpheref)getBoundSphere {
		Tellusim::BoundSpheref ret = [self ref].getBoundSphere();
		return *(TSBoundSpheref*)&ret;
	}
	-(BOOL)setTransform: (TSVector3f)scale {
		return [self ref].setTransform(*(Tellusim::Vector3f*)&scale);
	}
	-(BOOL)setTransform_: (TSVector3f)scale {
		return [self ref].setTransform(*(Tellusim::Vector3f*)&scale);
	}
	-(BOOL)setTransform_1: (TSMatrix4x3f)transform {
		return [self ref].setTransform(*(Tellusim::Matrix4x3f*)&transform);
	}
	-(BOOL)setTransform_1_: (TSMatrix4x3f)transform {
		return [self ref].setTransform(*(Tellusim::Matrix4x3f*)&transform);
	}
	-(BOOL)setTransform_2: (TSMatrix4x3f)transform apply: (BOOL)apply {
		return [self ref].setTransform(*(Tellusim::Matrix4x3f*)&transform, (bool)apply);
	}
	-(BOOL)setTransform_2_: (TSMatrix4x3f)transform apply: (BOOL)apply {
		return [self ref].setTransform(*(Tellusim::Matrix4x3f*)&transform, (bool)apply);
	}
	-(TSMatrix4x3f)getTransform {
		Tellusim::Matrix4x3f ret = [self ref].getTransform();
		return *(TSMatrix4x3f*)&ret;
	}
	-(void)setJointITransform: (TSMatrix4x3f)itransform {
		[self ref].setJointITransform(*(Tellusim::Matrix4x3f*)&itransform);
	}
	-(void)setJointITransform_: (TSMatrix4x3f)itransform {
		[self ref].setJointITransform(*(Tellusim::Matrix4x3f*)&itransform);
	}
	-(TSMatrix4x3f)getJointITransform {
		Tellusim::Matrix4x3f ret = [self ref].getJointITransform();
		return *(TSMatrix4x3f*)&ret;
	}
	-(void)setMinVisibility: (float32_t)distance {
		[self ref].setMinVisibility(distance);
	}
	-(void)setMinVisibility_: (float32_t)distance {
		[self ref].setMinVisibility(distance);
	}
	-(void)setMaxVisibility: (float32_t)distance {
		[self ref].setMaxVisibility(distance);
	}
	-(void)setMaxVisibility_: (float32_t)distance {
		[self ref].setMaxVisibility(distance);
	}
	-(void)setVisibilityRange: (float32_t)min max: (float32_t)max {
		[self ref].setVisibilityRange(min, max);
	}
	-(void)setVisibilityRange_: (float32_t)min max: (float32_t)max {
		[self ref].setVisibilityRange(min, max);
	}
	-(float32_t)getMinVisibility {
		return [self ref].getMinVisibility();
	}
	-(float32_t)getMaxVisibility {
		return [self ref].getMaxVisibility();
	}
	-(BOOL)hasVisibilityRange {
		return [self ref].hasVisibilityRange();
	}
	-(void)setVisibilityError: (float32_t)error {
		[self ref].setVisibilityError(error);
	}
	-(void)setVisibilityError_: (float32_t)error {
		[self ref].setVisibilityError(error);
	}
	-(float32_t)getVisibilityError {
		return [self ref].getVisibilityError();
	}
	-(BOOL)createBounds {
		return [self ref].createBounds();
	}
	-(BOOL)createBounds_1: (BOOL)force {
		return [self ref].createBounds((bool)force);
	}
	-(BOOL)createBounds_1_: (BOOL)force {
		return [self ref].createBounds((bool)force);
	}
	-(BOOL)createBounds_2: (BOOL)force position: (uint32_t)position {
		return [self ref].createBounds((bool)force, position);
	}
	-(BOOL)createBounds_2_: (BOOL)force position: (uint32_t)position {
		return [self ref].createBounds((bool)force, position);
	}
	-(uint32_t)createBasis {
		return [self ref].createBasis();
	}
	-(uint32_t)createBasis_1: (BOOL)force {
		return [self ref].createBasis((bool)force);
	}
	-(uint32_t)createBasis_1_: (BOOL)force {
		return [self ref].createBasis((bool)force);
	}
	-(uint32_t)createBasis_2: (BOOL)force position: (uint32_t)position {
		return [self ref].createBasis((bool)force, position);
	}
	-(uint32_t)createBasis_2_: (BOOL)force position: (uint32_t)position {
		return [self ref].createBasis((bool)force, position);
	}
	-(uint32_t)createBasis_3: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal {
		return [self ref].createBasis((bool)force, position, normal);
	}
	-(uint32_t)createBasis_3_: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal {
		return [self ref].createBasis((bool)force, position, normal);
	}
	-(uint32_t)createBasis_4: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal tangent: (uint32_t)tangent {
		return [self ref].createBasis((bool)force, position, normal, tangent);
	}
	-(uint32_t)createBasis_4_: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal tangent: (uint32_t)tangent {
		return [self ref].createBasis((bool)force, position, normal, tangent);
	}
	-(uint32_t)createBasis_5: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal tangent: (uint32_t)tangent append: (BOOL)append {
		return [self ref].createBasis((bool)force, position, normal, tangent, (bool)append);
	}
	-(uint32_t)createBasis_5_: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal tangent: (uint32_t)tangent append: (BOOL)append {
		return [self ref].createBasis((bool)force, position, normal, tangent, (bool)append);
	}
	-(uint32_t)createBasis_6: (float32_t)angle {
		return [self ref].createBasis(angle);
	}
	-(uint32_t)createBasis_6_: (float32_t)angle {
		return [self ref].createBasis(angle);
	}
	-(uint32_t)createBasis_7: (float32_t)angle force: (BOOL)force {
		return [self ref].createBasis(angle, (bool)force);
	}
	-(uint32_t)createBasis_7_: (float32_t)angle force: (BOOL)force {
		return [self ref].createBasis(angle, (bool)force);
	}
	-(uint32_t)createBasis_8: (float32_t)angle force: (BOOL)force position: (uint32_t)position {
		return [self ref].createBasis(angle, (bool)force, position);
	}
	-(uint32_t)createBasis_8_: (float32_t)angle force: (BOOL)force position: (uint32_t)position {
		return [self ref].createBasis(angle, (bool)force, position);
	}
	-(uint32_t)createBasis_9: (float32_t)angle force: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal {
		return [self ref].createBasis(angle, (bool)force, position, normal);
	}
	-(uint32_t)createBasis_9_: (float32_t)angle force: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal {
		return [self ref].createBasis(angle, (bool)force, position, normal);
	}
	-(uint32_t)createBasis_10: (float32_t)angle force: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal tangent: (uint32_t)tangent {
		return [self ref].createBasis(angle, (bool)force, position, normal, tangent);
	}
	-(uint32_t)createBasis_10_: (float32_t)angle force: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal tangent: (uint32_t)tangent {
		return [self ref].createBasis(angle, (bool)force, position, normal, tangent);
	}
	-(uint32_t)createBasis_11: (float32_t)angle force: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal tangent: (uint32_t)tangent append: (BOOL)append {
		return [self ref].createBasis(angle, (bool)force, position, normal, tangent, (bool)append);
	}
	-(uint32_t)createBasis_11_: (float32_t)angle force: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal tangent: (uint32_t)tangent append: (BOOL)append {
		return [self ref].createBasis(angle, (bool)force, position, normal, tangent, (bool)append);
	}
	-(uint32_t)createNormals {
		return [self ref].createNormals();
	}
	-(uint32_t)createNormals_1: (BOOL)force {
		return [self ref].createNormals((bool)force);
	}
	-(uint32_t)createNormals_1_: (BOOL)force {
		return [self ref].createNormals((bool)force);
	}
	-(uint32_t)createNormals_2: (BOOL)force position: (uint32_t)position {
		return [self ref].createNormals((bool)force, position);
	}
	-(uint32_t)createNormals_2_: (BOOL)force position: (uint32_t)position {
		return [self ref].createNormals((bool)force, position);
	}
	-(uint32_t)createNormals_3: (BOOL)force position: (uint32_t)position append: (BOOL)append {
		return [self ref].createNormals((bool)force, position, (bool)append);
	}
	-(uint32_t)createNormals_3_: (BOOL)force position: (uint32_t)position append: (BOOL)append {
		return [self ref].createNormals((bool)force, position, (bool)append);
	}
	-(uint32_t)createNormals_4: (float32_t)angle {
		return [self ref].createNormals(angle);
	}
	-(uint32_t)createNormals_4_: (float32_t)angle {
		return [self ref].createNormals(angle);
	}
	-(uint32_t)createNormals_5: (float32_t)angle force: (BOOL)force {
		return [self ref].createNormals(angle, (bool)force);
	}
	-(uint32_t)createNormals_5_: (float32_t)angle force: (BOOL)force {
		return [self ref].createNormals(angle, (bool)force);
	}
	-(uint32_t)createNormals_6: (float32_t)angle force: (BOOL)force position: (uint32_t)position {
		return [self ref].createNormals(angle, (bool)force, position);
	}
	-(uint32_t)createNormals_6_: (float32_t)angle force: (BOOL)force position: (uint32_t)position {
		return [self ref].createNormals(angle, (bool)force, position);
	}
	-(uint32_t)createNormals_7: (float32_t)angle force: (BOOL)force position: (uint32_t)position append: (BOOL)append {
		return [self ref].createNormals(angle, (bool)force, position, (bool)append);
	}
	-(uint32_t)createNormals_7_: (float32_t)angle force: (BOOL)force position: (uint32_t)position append: (BOOL)append {
		return [self ref].createNormals(angle, (bool)force, position, (bool)append);
	}
	-(uint32_t)createTangents {
		return [self ref].createTangents();
	}
	-(uint32_t)createTangents_1: (BOOL)force {
		return [self ref].createTangents((bool)force);
	}
	-(uint32_t)createTangents_1_: (BOOL)force {
		return [self ref].createTangents((bool)force);
	}
	-(uint32_t)createTangents_2: (BOOL)force position: (uint32_t)position {
		return [self ref].createTangents((bool)force, position);
	}
	-(uint32_t)createTangents_2_: (BOOL)force position: (uint32_t)position {
		return [self ref].createTangents((bool)force, position);
	}
	-(uint32_t)createTangents_3: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal {
		return [self ref].createTangents((bool)force, position, normal);
	}
	-(uint32_t)createTangents_3_: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal {
		return [self ref].createTangents((bool)force, position, normal);
	}
	-(uint32_t)createTangents_4: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal texcoord: (uint32_t)texcoord {
		return [self ref].createTangents((bool)force, position, normal, texcoord);
	}
	-(uint32_t)createTangents_4_: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal texcoord: (uint32_t)texcoord {
		return [self ref].createTangents((bool)force, position, normal, texcoord);
	}
	-(uint32_t)createTangents_5: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal texcoord: (uint32_t)texcoord append: (BOOL)append {
		return [self ref].createTangents((bool)force, position, normal, texcoord, (bool)append);
	}
	-(uint32_t)createTangents_5_: (BOOL)force position: (uint32_t)position normal: (uint32_t)normal texcoord: (uint32_t)texcoord append: (BOOL)append {
		return [self ref].createTangents((bool)force, position, normal, texcoord, (bool)append);
	}
	-(uint32_t)createIslands: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives {
		return [self ref].createIslands(max_attributes, max_primitives);
	}
	-(uint32_t)createIslands_: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives {
		return [self ref].createIslands(max_attributes, max_primitives);
	}
	-(uint32_t)createIslands_1: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force);
	}
	-(uint32_t)createIslands_1_: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force);
	}
	-(uint32_t)createIslands_2: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force index: (uint32_t)index {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force, index);
	}
	-(uint32_t)createIslands_2_: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force index: (uint32_t)index {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force, index);
	}
	-(uint32_t)createIslands_3: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force index: (uint32_t)index position: (uint32_t)position {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force, index, position);
	}
	-(uint32_t)createIslands_3_: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force index: (uint32_t)index position: (uint32_t)position {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force, index, position);
	}
	-(uint32_t)createIslands_4: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force index: (uint32_t)index position: (uint32_t)position append: (BOOL)append {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force, index, position, (bool)append);
	}
	-(uint32_t)createIslands_4_: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force index: (uint32_t)index position: (uint32_t)position append: (BOOL)append {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force, index, position, (bool)append);
	}
	-(BOOL)optimizeIndices {
		return [self ref].optimizeIndices();
	}
	-(BOOL)optimizeIndices_1: (uint32_t)cache {
		return [self ref].optimizeIndices(cache);
	}
	-(BOOL)optimizeIndices_1_: (uint32_t)cache {
		return [self ref].optimizeIndices(cache);
	}
	-(BOOL)optimizeIndices_2: (uint32_t)cache transparent: (BOOL)transparent {
		return [self ref].optimizeIndices(cache, (bool)transparent);
	}
	-(BOOL)optimizeIndices_2_: (uint32_t)cache transparent: (BOOL)transparent {
		return [self ref].optimizeIndices(cache, (bool)transparent);
	}
	-(BOOL)optimizeIndices_3: (uint32_t)cache transparent: (BOOL)transparent index: (uint32_t)index {
		return [self ref].optimizeIndices(cache, (bool)transparent, index);
	}
	-(BOOL)optimizeIndices_3_: (uint32_t)cache transparent: (BOOL)transparent index: (uint32_t)index {
		return [self ref].optimizeIndices(cache, (bool)transparent, index);
	}
	-(BOOL)optimizeIndices_4: (uint32_t)cache transparent: (BOOL)transparent index: (uint32_t)index position: (uint32_t)position {
		return [self ref].optimizeIndices(cache, (bool)transparent, index, position);
	}
	-(BOOL)optimizeIndices_4_: (uint32_t)cache transparent: (BOOL)transparent index: (uint32_t)index position: (uint32_t)position {
		return [self ref].optimizeIndices(cache, (bool)transparent, index, position);
	}
	-(BOOL)optimizeAttributes {
		return [self ref].optimizeAttributes();
	}
	-(BOOL)optimizeAttributes_1: (uint32_t)material {
		return [self ref].optimizeAttributes(material);
	}
	-(BOOL)optimizeAttributes_1_: (uint32_t)material {
		return [self ref].optimizeAttributes(material);
	}
	-(void)optimizeMaterials {
		[self ref].optimizeMaterials();
	}
	-(BOOL)packAttributes {
		return [self ref].packAttributes();
	}
	-(BOOL)packAttributes_1: (BOOL)remove {
		return [self ref].packAttributes((bool)remove);
	}
	-(BOOL)packAttributes_1_: (BOOL)remove {
		return [self ref].packAttributes((bool)remove);
	}
	-(BOOL)unpackAttributes {
		return [self ref].unpackAttributes();
	}
	-(BOOL)unpackAttributes_1: (BOOL)remove {
		return [self ref].unpackAttributes((bool)remove);
	}
	-(BOOL)unpackAttributes_1_: (BOOL)remove {
		return [self ref].unpackAttributes((bool)remove);
	}
	-(int32_t)compare: (const TSMeshGeometry*)geometry {
		return [self ref].compare([geometry ref]);
	}
	-(int32_t)compare_: (const TSMeshGeometry*)geometry {
		return [self ref].compare([geometry ref]);
	}
	-(int32_t)compare_1: (const TSMeshGeometry*)geometry transform: (TSMatrix4x3f)transform {
		return [self ref].compare([geometry ref], *(Tellusim::Matrix4x3f*)&transform);
	}
	-(int32_t)compare_1_: (const TSMeshGeometry*)geometry transform: (TSMatrix4x3f)transform {
		return [self ref].compare([geometry ref], *(Tellusim::Matrix4x3f*)&transform);
	}
	-(int32_t)compare_2: (const TSMeshGeometry*)geometry transform: (TSMatrix4x3f)transform threshold: (float32_t)threshold {
		return [self ref].compare([geometry ref], *(Tellusim::Matrix4x3f*)&transform, threshold);
	}
	-(int32_t)compare_2_: (const TSMeshGeometry*)geometry transform: (TSMatrix4x3f)transform threshold: (float32_t)threshold {
		return [self ref].compare([geometry ref], *(Tellusim::Matrix4x3f*)&transform, threshold);
	}
	-(int32_t)compare_3: (const TSMeshGeometry*)geometry transform: (TSMatrix4x3f)transform threshold: (float32_t)threshold spatial: (BOOL)spatial {
		return [self ref].compare([geometry ref], *(Tellusim::Matrix4x3f*)&transform, threshold, (bool)spatial);
	}
	-(int32_t)compare_3_: (const TSMeshGeometry*)geometry transform: (TSMatrix4x3f)transform threshold: (float32_t)threshold spatial: (BOOL)spatial {
		return [self ref].compare([geometry ref], *(Tellusim::Matrix4x3f*)&transform, threshold, (bool)spatial);
	}
	-(BOOL)isOptimized {
		return [self ref].isOptimized();
	}
	-(BOOL)validate {
		return [self ref].validate();
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::MeshTransform
@implementation TSMeshTransform
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshTransform();
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshTransform*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MeshTransform&)ref {
		self = [super init];
		impl = new Tellusim::MeshTransform((Tellusim::MeshTransform&)ref);
		return self;
	}
	-(Tellusim::MeshTransform*)pointer {
		return (Tellusim::MeshTransform*)impl;
	}
	-(Tellusim::MeshTransform&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshTransform*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshTransform*)impl;
	}
	-(BOOL)equalPtr: (const TSMeshTransform*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMeshTransform*)copyPtr {
		return [[TSMeshTransform alloc] init_ref:[self ref]];
	}
	-(TSMeshTransform*)clonePtr {
		return [[TSMeshTransform alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMeshTransform*)null {
		return [[TSMeshTransform alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(float64_t)getMinTime {
		return [self ref].getMinTime();
	}
	-(float64_t)getMaxTime {
		return [self ref].getMaxTime();
	}
	-(void)setTransform: (float64_t)time transform: (TSMatrix4x3d)transform {
		[self ref].setTransform(time, *(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setTransform_: (float64_t)time transform: (TSMatrix4x3d)transform {
		[self ref].setTransform(time, *(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setTransform_1: (float64_t)time transform: (TSMatrix4x3d)transform threshold: (float32_t)threshold {
		[self ref].setTransform(time, *(Tellusim::Matrix4x3d*)&transform, threshold);
	}
	-(void)setTransform_1_: (float64_t)time transform: (TSMatrix4x3d)transform threshold: (float32_t)threshold {
		[self ref].setTransform(time, *(Tellusim::Matrix4x3d*)&transform, threshold);
	}
	-(void)setTranslate: (float64_t)time translate: (TSVector3d)translate {
		[self ref].setTranslate(time, *(Tellusim::Vector3d*)&translate);
	}
	-(void)setTranslate_: (float64_t)time translate: (TSVector3d)translate {
		[self ref].setTranslate(time, *(Tellusim::Vector3d*)&translate);
	}
	-(void)setTranslate_1: (float64_t)time translate: (TSVector3d)translate threshold: (float32_t)threshold {
		[self ref].setTranslate(time, *(Tellusim::Vector3d*)&translate, threshold);
	}
	-(void)setTranslate_1_: (float64_t)time translate: (TSVector3d)translate threshold: (float32_t)threshold {
		[self ref].setTranslate(time, *(Tellusim::Vector3d*)&translate, threshold);
	}
	-(void)setRotate: (float64_t)time rotate: (TSQuaternionf)rotate {
		[self ref].setRotate(time, *(Tellusim::Quaternionf*)&rotate);
	}
	-(void)setRotate_: (float64_t)time rotate: (TSQuaternionf)rotate {
		[self ref].setRotate(time, *(Tellusim::Quaternionf*)&rotate);
	}
	-(void)setRotate_1: (float64_t)time rotate: (TSQuaternionf)rotate threshold: (float32_t)threshold {
		[self ref].setRotate(time, *(Tellusim::Quaternionf*)&rotate, threshold);
	}
	-(void)setRotate_1_: (float64_t)time rotate: (TSQuaternionf)rotate threshold: (float32_t)threshold {
		[self ref].setRotate(time, *(Tellusim::Quaternionf*)&rotate, threshold);
	}
	-(void)setScale: (float64_t)time scale: (TSVector3f)scale {
		[self ref].setScale(time, *(Tellusim::Vector3f*)&scale);
	}
	-(void)setScale_: (float64_t)time scale: (TSVector3f)scale {
		[self ref].setScale(time, *(Tellusim::Vector3f*)&scale);
	}
	-(void)setScale_1: (float64_t)time scale: (TSVector3f)scale threshold: (float32_t)threshold {
		[self ref].setScale(time, *(Tellusim::Vector3f*)&scale, threshold);
	}
	-(void)setScale_1_: (float64_t)time scale: (TSVector3f)scale threshold: (float32_t)threshold {
		[self ref].setScale(time, *(Tellusim::Vector3f*)&scale, threshold);
	}
	-(void)setMorph: (float64_t)time morph: (TSVector4f)morph {
		[self ref].setMorph(time, *(Tellusim::Vector4f*)&morph);
	}
	-(void)setMorph_: (float64_t)time morph: (TSVector4f)morph {
		[self ref].setMorph(time, *(Tellusim::Vector4f*)&morph);
	}
	-(void)setMorph_1: (float64_t)time morph: (TSVector4f)morph threshold: (float32_t)threshold {
		[self ref].setMorph(time, *(Tellusim::Vector4f*)&morph, threshold);
	}
	-(void)setMorph_1_: (float64_t)time morph: (TSVector4f)morph threshold: (float32_t)threshold {
		[self ref].setMorph(time, *(Tellusim::Vector4f*)&morph, threshold);
	}
	-(TSMatrix4x3d)getTransform: (float64_t)time {
		Tellusim::Matrix4x3d ret = [self ref].getTransform(time);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getTransform_: (float64_t)time {
		Tellusim::Matrix4x3d ret = [self ref].getTransform(time);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSVector3d)getTranslate: (float64_t)time {
		Tellusim::Vector3d ret = [self ref].getTranslate(time);
		return *(TSVector3d*)&ret;
	}
	-(TSVector3d)getTranslate_: (float64_t)time {
		Tellusim::Vector3d ret = [self ref].getTranslate(time);
		return *(TSVector3d*)&ret;
	}
	-(TSQuaternionf)getRotate: (float64_t)time {
		Tellusim::Quaternionf ret = [self ref].getRotate(time);
		return *(TSQuaternionf*)&ret;
	}
	-(TSQuaternionf)getRotate_: (float64_t)time {
		Tellusim::Quaternionf ret = [self ref].getRotate(time);
		return *(TSQuaternionf*)&ret;
	}
	-(TSVector3f)getScale: (float64_t)time {
		Tellusim::Vector3f ret = [self ref].getScale(time);
		return *(TSVector3f*)&ret;
	}
	-(TSVector3f)getScale_: (float64_t)time {
		Tellusim::Vector3f ret = [self ref].getScale(time);
		return *(TSVector3f*)&ret;
	}
	-(TSVector4f)getMorph: (float64_t)time {
		Tellusim::Vector4f ret = [self ref].getMorph(time);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getMorph_: (float64_t)time {
		Tellusim::Vector4f ret = [self ref].getMorph(time);
		return *(TSVector4f*)&ret;
	}
	-(BOOL)hasTransformKeys {
		return [self ref].hasTransformKeys();
	}
	-(BOOL)hasTranslateKeys {
		return [self ref].hasTranslateKeys();
	}
	-(BOOL)hasRotateKeys {
		return [self ref].hasRotateKeys();
	}
	-(BOOL)hasScaleKeys {
		return [self ref].hasScaleKeys();
	}
	-(BOOL)hasMorphKeys {
		return [self ref].hasMorphKeys();
	}
	-(void)setTransform_2: (TSVector3d)scale {
		[self ref].setTransform(*(Tellusim::Vector3d*)&scale);
	}
	-(void)setTransform_2_: (TSVector3d)scale {
		[self ref].setTransform(*(Tellusim::Vector3d*)&scale);
	}
	-(void)setTransform_3: (TSMatrix4x3d)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setTransform_3_: (TSMatrix4x3d)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::MeshAnimation
@implementation TSMeshAnimation
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshAnimation();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAnimation(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAnimation(name);
		return self;
	}
	-(id)init_2: (TSMesh*)mesh {
		self = [super init];
		impl = new Tellusim::MeshAnimation([mesh ref]);
		return self;
	}
	-(id)init_2_: (TSMesh*)mesh {
		self = [super init];
		impl = new Tellusim::MeshAnimation([mesh ref]);
		return self;
	}
	-(id)init_3: (TSMesh*)mesh name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAnimation([mesh ref], name);
		return self;
	}
	-(id)init_3_: (TSMesh*)mesh name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAnimation([mesh ref], name);
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshAnimation*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MeshAnimation&)ref {
		self = [super init];
		impl = new Tellusim::MeshAnimation((Tellusim::MeshAnimation&)ref);
		return self;
	}
	-(Tellusim::MeshAnimation*)pointer {
		return (Tellusim::MeshAnimation*)impl;
	}
	-(Tellusim::MeshAnimation&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshAnimation*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshAnimation*)impl;
	}
	-(BOOL)equalPtr: (const TSMeshAnimation*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMeshAnimation*)copyPtr {
		return [[TSMeshAnimation alloc] init_ref:[self ref]];
	}
	-(TSMeshAnimation*)clonePtr {
		return [[TSMeshAnimation alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMeshAnimation*)null {
		return [[TSMeshAnimation alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(void)setMesh: (TSMesh*)mesh {
		[self ref].setMesh([mesh ref]);
	}
	-(void)setMesh_: (TSMesh*)mesh {
		[self ref].setMesh([mesh ref]);
	}
	-(void)setMesh_1: (TSMesh*)mesh check: (BOOL)check {
		[self ref].setMesh([mesh ref], (bool)check);
	}
	-(void)setMesh_1_: (TSMesh*)mesh check: (BOOL)check {
		[self ref].setMesh([mesh ref], (bool)check);
	}
	-(const TSMesh*)getMesh {
		return [[TSMesh alloc] init_ref:([self ref].getMesh())];
	}
	-(float64_t)getMinTime {
		return [self ref].getMinTime();
	}
	-(float64_t)getMaxTime {
		return [self ref].getMaxTime();
	}
	-(void)setNumTransforms: (uint32_t)num_transforms {
		[self ref].setNumTransforms(num_transforms);
	}
	-(void)setNumTransforms_: (uint32_t)num_transforms {
		[self ref].setNumTransforms(num_transforms);
	}
	-(uint32_t)getNumTransforms {
		return [self ref].getNumTransforms();
	}
	-(NSArray<TSMeshTransform*>*)getTransforms {
		const auto &ret = [self ref].getTransforms();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshTransform alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshTransform*)getTransform: (uint32_t)node {
		return [[TSMeshTransform alloc] init_ref:([self ref].getTransform(node))];
	}
	-(const TSMeshTransform*)getTransform_: (uint32_t)node {
		return [[TSMeshTransform alloc] init_ref:([self ref].getTransform(node))];
	}
	-(void)setTransform: (float64_t)time node: (uint32_t)node transform: (TSMatrix4x3d)transform {
		[self ref].setTransform(time, node, *(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setTransform_: (float64_t)time node: (uint32_t)node transform: (TSMatrix4x3d)transform {
		[self ref].setTransform(time, node, *(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setTransform_1: (float64_t)time node: (uint32_t)node transform: (TSMatrix4x3d)transform threshold: (float32_t)threshold {
		[self ref].setTransform(time, node, *(Tellusim::Matrix4x3d*)&transform, threshold);
	}
	-(void)setTransform_1_: (float64_t)time node: (uint32_t)node transform: (TSMatrix4x3d)transform threshold: (float32_t)threshold {
		[self ref].setTransform(time, node, *(Tellusim::Matrix4x3d*)&transform, threshold);
	}
	-(void)setTranslate: (float64_t)time node: (uint32_t)node translate: (TSVector3d)translate {
		[self ref].setTranslate(time, node, *(Tellusim::Vector3d*)&translate);
	}
	-(void)setTranslate_: (float64_t)time node: (uint32_t)node translate: (TSVector3d)translate {
		[self ref].setTranslate(time, node, *(Tellusim::Vector3d*)&translate);
	}
	-(void)setTranslate_1: (float64_t)time node: (uint32_t)node translate: (TSVector3d)translate threshold: (float32_t)threshold {
		[self ref].setTranslate(time, node, *(Tellusim::Vector3d*)&translate, threshold);
	}
	-(void)setTranslate_1_: (float64_t)time node: (uint32_t)node translate: (TSVector3d)translate threshold: (float32_t)threshold {
		[self ref].setTranslate(time, node, *(Tellusim::Vector3d*)&translate, threshold);
	}
	-(void)setRotate: (float64_t)time node: (uint32_t)node rotate: (TSQuaternionf)rotate {
		[self ref].setRotate(time, node, *(Tellusim::Quaternionf*)&rotate);
	}
	-(void)setRotate_: (float64_t)time node: (uint32_t)node rotate: (TSQuaternionf)rotate {
		[self ref].setRotate(time, node, *(Tellusim::Quaternionf*)&rotate);
	}
	-(void)setRotate_1: (float64_t)time node: (uint32_t)node rotate: (TSQuaternionf)rotate threshold: (float32_t)threshold {
		[self ref].setRotate(time, node, *(Tellusim::Quaternionf*)&rotate, threshold);
	}
	-(void)setRotate_1_: (float64_t)time node: (uint32_t)node rotate: (TSQuaternionf)rotate threshold: (float32_t)threshold {
		[self ref].setRotate(time, node, *(Tellusim::Quaternionf*)&rotate, threshold);
	}
	-(void)setScale: (float64_t)time node: (uint32_t)node scale: (TSVector3f)scale {
		[self ref].setScale(time, node, *(Tellusim::Vector3f*)&scale);
	}
	-(void)setScale_: (float64_t)time node: (uint32_t)node scale: (TSVector3f)scale {
		[self ref].setScale(time, node, *(Tellusim::Vector3f*)&scale);
	}
	-(void)setScale_1: (float64_t)time node: (uint32_t)node scale: (TSVector3f)scale threshold: (float32_t)threshold {
		[self ref].setScale(time, node, *(Tellusim::Vector3f*)&scale, threshold);
	}
	-(void)setScale_1_: (float64_t)time node: (uint32_t)node scale: (TSVector3f)scale threshold: (float32_t)threshold {
		[self ref].setScale(time, node, *(Tellusim::Vector3f*)&scale, threshold);
	}
	-(void)setMorph: (float64_t)time node: (uint32_t)node morph: (TSVector4f)morph {
		[self ref].setMorph(time, node, *(Tellusim::Vector4f*)&morph);
	}
	-(void)setMorph_: (float64_t)time node: (uint32_t)node morph: (TSVector4f)morph {
		[self ref].setMorph(time, node, *(Tellusim::Vector4f*)&morph);
	}
	-(void)setMorph_1: (float64_t)time node: (uint32_t)node morph: (TSVector4f)morph threshold: (float32_t)threshold {
		[self ref].setMorph(time, node, *(Tellusim::Vector4f*)&morph, threshold);
	}
	-(void)setMorph_1_: (float64_t)time node: (uint32_t)node morph: (TSVector4f)morph threshold: (float32_t)threshold {
		[self ref].setMorph(time, node, *(Tellusim::Vector4f*)&morph, threshold);
	}
	-(void)setTime: (float64_t)time {
		[self ref].setTime(time);
	}
	-(void)setTime_: (float64_t)time {
		[self ref].setTime(time);
	}
	-(void)setTime_1: (float64_t)time transform: (TSMatrix4x3d)transform {
		[self ref].setTime(time, *(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setTime_1_: (float64_t)time transform: (TSMatrix4x3d)transform {
		[self ref].setTime(time, *(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setTime_2: (float64_t)time transform: (TSMatrix4x3d)transform loop: (BOOL)loop {
		[self ref].setTime(time, *(Tellusim::Matrix4x3d*)&transform, (bool)loop);
	}
	-(void)setTime_2_: (float64_t)time transform: (TSMatrix4x3d)transform loop: (BOOL)loop {
		[self ref].setTime(time, *(Tellusim::Matrix4x3d*)&transform, (bool)loop);
	}
	-(void)setTime_3: (float64_t)time transform: (TSMatrix4x3d)transform loop: (BOOL)loop from: (float64_t)from {
		[self ref].setTime(time, *(Tellusim::Matrix4x3d*)&transform, (bool)loop, from);
	}
	-(void)setTime_3_: (float64_t)time transform: (TSMatrix4x3d)transform loop: (BOOL)loop from: (float64_t)from {
		[self ref].setTime(time, *(Tellusim::Matrix4x3d*)&transform, (bool)loop, from);
	}
	-(void)setTime_4: (float64_t)time transform: (TSMatrix4x3d)transform loop: (BOOL)loop from: (float64_t)from to: (float64_t)to {
		[self ref].setTime(time, *(Tellusim::Matrix4x3d*)&transform, (bool)loop, from, to);
	}
	-(void)setTime_4_: (float64_t)time transform: (TSMatrix4x3d)transform loop: (BOOL)loop from: (float64_t)from to: (float64_t)to {
		[self ref].setTime(time, *(Tellusim::Matrix4x3d*)&transform, (bool)loop, from, to);
	}
	-(void)setTime_5: (float64_t)time loop: (BOOL)loop {
		[self ref].setTime(time, (bool)loop);
	}
	-(void)setTime_5_: (float64_t)time loop: (BOOL)loop {
		[self ref].setTime(time, (bool)loop);
	}
	-(void)setTime_6: (float64_t)time loop: (BOOL)loop from: (float64_t)from {
		[self ref].setTime(time, (bool)loop, from);
	}
	-(void)setTime_6_: (float64_t)time loop: (BOOL)loop from: (float64_t)from {
		[self ref].setTime(time, (bool)loop, from);
	}
	-(void)setTime_7: (float64_t)time loop: (BOOL)loop from: (float64_t)from to: (float64_t)to {
		[self ref].setTime(time, (bool)loop, from, to);
	}
	-(void)setTime_7_: (float64_t)time loop: (BOOL)loop from: (float64_t)from to: (float64_t)to {
		[self ref].setTime(time, (bool)loop, from, to);
	}
	-(TSMatrix4x3d)getLocalTransform: (uint32_t)node {
		Tellusim::Matrix4x3d ret = [self ref].getLocalTransform(node);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getLocalTransform_: (uint32_t)node {
		Tellusim::Matrix4x3d ret = [self ref].getLocalTransform(node);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getLocalTransform_1: (const TSMeshNode*)node {
		Tellusim::Matrix4x3d ret = [self ref].getLocalTransform([node ref]);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getLocalTransform_1_: (const TSMeshNode*)node {
		Tellusim::Matrix4x3d ret = [self ref].getLocalTransform([node ref]);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getLocalTransform_2: (const TSMeshJoint*)joint {
		Tellusim::Matrix4x3d ret = [self ref].getLocalTransform([joint ref]);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getLocalTransform_2_: (const TSMeshJoint*)joint {
		Tellusim::Matrix4x3d ret = [self ref].getLocalTransform([joint ref]);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getGlobalTransform: (uint32_t)node {
		Tellusim::Matrix4x3d ret = [self ref].getGlobalTransform(node);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getGlobalTransform_: (uint32_t)node {
		Tellusim::Matrix4x3d ret = [self ref].getGlobalTransform(node);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getGlobalTransform_1: (const TSMeshNode*)node {
		Tellusim::Matrix4x3d ret = [self ref].getGlobalTransform([node ref]);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getGlobalTransform_1_: (const TSMeshNode*)node {
		Tellusim::Matrix4x3d ret = [self ref].getGlobalTransform([node ref]);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getGlobalTransform_2: (const TSMeshJoint*)joint {
		Tellusim::Matrix4x3d ret = [self ref].getGlobalTransform([joint ref]);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSMatrix4x3d)getGlobalTransform_2_: (const TSMeshJoint*)joint {
		Tellusim::Matrix4x3d ret = [self ref].getGlobalTransform([joint ref]);
		return *(TSMatrix4x3d*)&ret;
	}
	-(TSVector4f)getMorphTransform: (uint32_t)node {
		Tellusim::Vector4f ret = [self ref].getMorphTransform(node);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getMorphTransform_: (uint32_t)node {
		Tellusim::Vector4f ret = [self ref].getMorphTransform(node);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getMorphTransform_1: (const TSMeshNode*)node {
		Tellusim::Vector4f ret = [self ref].getMorphTransform([node ref]);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getMorphTransform_1_: (const TSMeshNode*)node {
		Tellusim::Vector4f ret = [self ref].getMorphTransform([node ref]);
		return *(TSVector4f*)&ret;
	}
	-(TSBoundBoxd)getBoundBox {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox();
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_1: (const TSMeshNode*)node {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([node ref]);
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_1_: (const TSMeshNode*)node {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([node ref]);
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_2: (const TSMeshGeometry*)geometry {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([geometry ref]);
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_2_: (const TSMeshGeometry*)geometry {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([geometry ref]);
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_3: (const TSMeshGeometry*)geometry morph: (TSVector4f)morph {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([geometry ref], *(Tellusim::Vector4f*)&morph);
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_3_: (const TSMeshGeometry*)geometry morph: (TSVector4f)morph {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([geometry ref], *(Tellusim::Vector4f*)&morph);
		return *(TSBoundBoxd*)&ret;
	}
	-(void)setTransform_2: (TSVector3d)scale {
		[self ref].setTransform(*(Tellusim::Vector3d*)&scale);
	}
	-(void)setTransform_2_: (TSVector3d)scale {
		[self ref].setTransform(*(Tellusim::Vector3d*)&scale);
	}
	-(void)setTransform_3: (TSMatrix4x3d)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)setTransform_3_: (TSMatrix4x3d)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)optimizeTransforms {
		[self ref].optimizeTransforms();
	}
	-(void)optimizeTransforms_1: (float32_t)threshold {
		[self ref].optimizeTransforms(threshold);
	}
	-(void)optimizeTransforms_1_: (float32_t)threshold {
		[self ref].optimizeTransforms(threshold);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::MeshAttachment
@implementation TSMeshAttachment
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshAttachment();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttachment(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttachment(name);
		return self;
	}
	-(id)init_2: (TS_MeshAttachmentType)type {
		self = [super init];
		impl = new Tellusim::MeshAttachment((Tellusim::MeshAttachment::Type)type);
		return self;
	}
	-(id)init_2_: (TS_MeshAttachmentType)type {
		self = [super init];
		impl = new Tellusim::MeshAttachment((Tellusim::MeshAttachment::Type)type);
		return self;
	}
	-(id)init_3: (TS_MeshAttachmentType)type name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttachment((Tellusim::MeshAttachment::Type)type, name);
		return self;
	}
	-(id)init_3_: (TS_MeshAttachmentType)type name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttachment((Tellusim::MeshAttachment::Type)type, name);
		return self;
	}
	-(id)init_4: (TSMeshNode*)node {
		self = [super init];
		impl = new Tellusim::MeshAttachment([node ref]);
		return self;
	}
	-(id)init_4_: (TSMeshNode*)node {
		self = [super init];
		impl = new Tellusim::MeshAttachment([node ref]);
		return self;
	}
	-(id)init_5: (TSMeshNode*)node name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttachment([node ref], name);
		return self;
	}
	-(id)init_5_: (TSMeshNode*)node name: (const char*)name {
		self = [super init];
		impl = new Tellusim::MeshAttachment([node ref], name);
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshAttachment*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MeshAttachment&)ref {
		self = [super init];
		impl = new Tellusim::MeshAttachment((Tellusim::MeshAttachment&)ref);
		return self;
	}
	-(Tellusim::MeshAttachment*)pointer {
		return (Tellusim::MeshAttachment*)impl;
	}
	-(Tellusim::MeshAttachment&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshAttachment*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshAttachment*)impl;
	}
	-(BOOL)equalPtr: (const TSMeshAttachment*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMeshAttachment*)copyPtr {
		return [[TSMeshAttachment alloc] init_ref:[self ref]];
	}
	-(TSMeshAttachment*)clonePtr {
		return [[TSMeshAttachment alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMeshAttachment*)null {
		return [[TSMeshAttachment alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(void)setType: (TS_MeshAttachmentType)type {
		[self ref].setType((Tellusim::MeshAttachment::Type)type);
	}
	-(void)setType_: (TS_MeshAttachmentType)type {
		[self ref].setType((Tellusim::MeshAttachment::Type)type);
	}
	-(TS_MeshAttachmentType)getType {
		return (TS_MeshAttachmentType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_MeshAttachmentType)type {
		return [NSString stringWithUTF8String:Tellusim::MeshAttachment::getTypeName((Tellusim::MeshAttachment::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_MeshAttachmentType)type {
		return [NSString stringWithUTF8String:Tellusim::MeshAttachment::getTypeName((Tellusim::MeshAttachment::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)isUnknown {
		return [self ref].isUnknown();
	}
	-(BOOL)isLight {
		return [self ref].isLight();
	}
	-(BOOL)isCamera {
		return [self ref].isCamera();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(void)setNode: (TSMeshNode*)node {
		[self ref].setNode([node ref]);
	}
	-(void)setNode_: (TSMeshNode*)node {
		[self ref].setNode([node ref]);
	}
	-(void)setNode_1: (TSMeshNode*)node check: (BOOL)check {
		[self ref].setNode([node ref], (bool)check);
	}
	-(void)setNode_1_: (TSMeshNode*)node check: (BOOL)check {
		[self ref].setNode([node ref], (bool)check);
	}
	-(const TSMeshNode*)getNode {
		return [[TSMeshNode alloc] init_ref:([self ref].getNode())];
	}
	-(void)setData: (const char*)data {
		[self ref].setData(data);
	}
	-(void)setData_: (const char*)data {
		[self ref].setData(data);
	}
	-(void)setData_1: (const TSString*)data {
		[self ref].setData((data) ? [data ref] : Tellusim::String::null);
	}
	-(void)setData_1_: (const TSString*)data {
		[self ref].setData((data) ? [data ref] : Tellusim::String::null);
	}
	-(NSString*)getData {
		return [NSString stringWithUTF8String:[self ref].getData().get()];
	}
	-(void)clearParameters {
		[self ref].clearParameters();
	}
	-(BOOL)removeParameter: (const char*)type {
		return [self ref].removeParameter(type);
	}
	-(BOOL)removeParameter_: (const char*)type {
		return [self ref].removeParameter(type);
	}
	-(void)copyParameters: (const TSMeshAttachment*)attachment {
		[self ref].copyParameters([attachment ref]);
	}
	-(void)copyParameters_: (const TSMeshAttachment*)attachment {
		[self ref].copyParameters([attachment ref]);
	}
	-(uint32_t)findParameter: (const char*)type {
		return [self ref].findParameter(type);
	}
	-(uint32_t)findParameter_: (const char*)type {
		return [self ref].findParameter(type);
	}
	-(BOOL)hasParameter: (const char*)type {
		return [self ref].hasParameter(type);
	}
	-(BOOL)hasParameter_: (const char*)type {
		return [self ref].hasParameter(type);
	}
	-(uint32_t)getNumParameters {
		return [self ref].getNumParameters();
	}
	-(NSString*)getParameterType: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterType(index).get()];
	}
	-(NSString*)getParameterType_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterType(index).get()];
	}
	-(void)addParameter: (const char*)type value: (BOOL)value {
		[self ref].addParameter(type, (bool)value);
	}
	-(void)addParameter_: (const char*)type value: (BOOL)value {
		[self ref].addParameter(type, (bool)value);
	}
	-(void)addParameter_1: (const char*)type value: (float32_t)value {
		[self ref].addParameter(type, value);
	}
	-(void)addParameter_1_: (const char*)type value: (float32_t)value {
		[self ref].addParameter(type, value);
	}
	-(void)addParameter_2: (const char*)type vector: (TSVector4f)vector {
		[self ref].addParameter(type, *(Tellusim::Vector4f*)&vector);
	}
	-(void)addParameter_2_: (const char*)type vector: (TSVector4f)vector {
		[self ref].addParameter(type, *(Tellusim::Vector4f*)&vector);
	}
	-(void)addParameter_3: (const char*)type color: (TSColor)color {
		[self ref].addParameter(type, *(Tellusim::Color*)&color);
	}
	-(void)addParameter_3_: (const char*)type color: (TSColor)color {
		[self ref].addParameter(type, *(Tellusim::Color*)&color);
	}
	-(void)addParameter_4: (const char*)type name: (const char*)name {
		[self ref].addParameter(type, name);
	}
	-(void)addParameter_4_: (const char*)type name: (const char*)name {
		[self ref].addParameter(type, name);
	}
	-(void)addParameter_5: (const char*)type name: (const TSString*)name {
		[self ref].addParameter(type, (name) ? [name ref] : Tellusim::String::null);
	}
	-(void)addParameter_5_: (const char*)type name: (const TSString*)name {
		[self ref].addParameter(type, (name) ? [name ref] : Tellusim::String::null);
	}
	-(TS_MeshAttachmentFlags)getParameterFlags: (uint32_t)index {
		return (TS_MeshAttachmentFlags)[self ref].getParameterFlags(index);
	}
	-(TS_MeshAttachmentFlags)getParameterFlags_: (uint32_t)index {
		return (TS_MeshAttachmentFlags)[self ref].getParameterFlags(index);
	}
	-(BOOL)hasParameterFlag: (uint32_t)index flags: (TS_MeshAttachmentFlags)flags {
		return [self ref].hasParameterFlag(index, (Tellusim::MeshAttachment::Flags)flags);
	}
	-(BOOL)hasParameterFlag_: (uint32_t)index flags: (TS_MeshAttachmentFlags)flags {
		return [self ref].hasParameterFlag(index, (Tellusim::MeshAttachment::Flags)flags);
	}
	-(BOOL)hasParameterFlags: (uint32_t)index flags: (TS_MeshAttachmentFlags)flags {
		return [self ref].hasParameterFlags(index, (Tellusim::MeshAttachment::Flags)flags);
	}
	-(BOOL)hasParameterFlags_: (uint32_t)index flags: (TS_MeshAttachmentFlags)flags {
		return [self ref].hasParameterFlags(index, (Tellusim::MeshAttachment::Flags)flags);
	}
	-(BOOL)getParameterBool: (uint32_t)index {
		return [self ref].getParameterBool(index);
	}
	-(BOOL)getParameterBool_: (uint32_t)index {
		return [self ref].getParameterBool(index);
	}
	-(BOOL)getParameterBool_1: (uint32_t)index value: (BOOL)value {
		return [self ref].getParameterBool(index, (bool)value);
	}
	-(BOOL)getParameterBool_1_: (uint32_t)index value: (BOOL)value {
		return [self ref].getParameterBool(index, (bool)value);
	}
	-(float32_t)getParameterScalarf32: (uint32_t)index {
		return [self ref].getParameterScalarf32(index);
	}
	-(float32_t)getParameterScalarf32_: (uint32_t)index {
		return [self ref].getParameterScalarf32(index);
	}
	-(float32_t)getParameterScalarf32_1: (uint32_t)index value: (float32_t)value {
		return [self ref].getParameterScalarf32(index, value);
	}
	-(float32_t)getParameterScalarf32_1_: (uint32_t)index value: (float32_t)value {
		return [self ref].getParameterScalarf32(index, value);
	}
	-(TSVector4f)getParameterVector4f: (uint32_t)index {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(index);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_: (uint32_t)index {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(index);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_1: (uint32_t)index vector: (TSVector4f)vector {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(index, *(Tellusim::Vector4f*)&vector);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_1_: (uint32_t)index vector: (TSVector4f)vector {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(index, *(Tellusim::Vector4f*)&vector);
		return *(TSVector4f*)&ret;
	}
	-(TSColor)getParameterColor: (uint32_t)index {
		Tellusim::Color ret = [self ref].getParameterColor(index);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_: (uint32_t)index {
		Tellusim::Color ret = [self ref].getParameterColor(index);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_1: (uint32_t)index color: (TSColor)color {
		Tellusim::Color ret = [self ref].getParameterColor(index, *(Tellusim::Color*)&color);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_1_: (uint32_t)index color: (TSColor)color {
		Tellusim::Color ret = [self ref].getParameterColor(index, *(Tellusim::Color*)&color);
		return *(TSColor*)&ret;
	}
	-(NSString*)getParameterName: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterName(index).get()];
	}
	-(NSString*)getParameterName_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getParameterName(index).get()];
	}
	-(NSString*)getParameterName_1: (uint32_t)index name: (const TSString*)name {
		return [NSString stringWithUTF8String:[self ref].getParameterName(index, (name) ? [name ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getParameterName_1_: (uint32_t)index name: (const TSString*)name {
		return [NSString stringWithUTF8String:[self ref].getParameterName(index, (name) ? [name ref] : Tellusim::String::null).get()];
	}
	-(TS_MeshAttachmentFlags)getParameterFlags_1: (const char*)type {
		return (TS_MeshAttachmentFlags)[self ref].getParameterFlags(type);
	}
	-(TS_MeshAttachmentFlags)getParameterFlags_1_: (const char*)type {
		return (TS_MeshAttachmentFlags)[self ref].getParameterFlags(type);
	}
	-(BOOL)hasParameterFlag_1: (const char*)type flags: (TS_MeshAttachmentFlags)flags {
		return [self ref].hasParameterFlag(type, (Tellusim::MeshAttachment::Flags)flags);
	}
	-(BOOL)hasParameterFlag_1_: (const char*)type flags: (TS_MeshAttachmentFlags)flags {
		return [self ref].hasParameterFlag(type, (Tellusim::MeshAttachment::Flags)flags);
	}
	-(BOOL)hasParameterFlags_1: (const char*)type flags: (TS_MeshAttachmentFlags)flags {
		return [self ref].hasParameterFlags(type, (Tellusim::MeshAttachment::Flags)flags);
	}
	-(BOOL)hasParameterFlags_1_: (const char*)type flags: (TS_MeshAttachmentFlags)flags {
		return [self ref].hasParameterFlags(type, (Tellusim::MeshAttachment::Flags)flags);
	}
	-(BOOL)getParameterBool_2: (const char*)type {
		return [self ref].getParameterBool(type);
	}
	-(BOOL)getParameterBool_2_: (const char*)type {
		return [self ref].getParameterBool(type);
	}
	-(BOOL)getParameterBool_3: (const char*)type value: (BOOL)value {
		return [self ref].getParameterBool(type, (bool)value);
	}
	-(BOOL)getParameterBool_3_: (const char*)type value: (BOOL)value {
		return [self ref].getParameterBool(type, (bool)value);
	}
	-(float32_t)getParameterScalarf32_2: (const char*)type {
		return [self ref].getParameterScalarf32(type);
	}
	-(float32_t)getParameterScalarf32_2_: (const char*)type {
		return [self ref].getParameterScalarf32(type);
	}
	-(float32_t)getParameterScalarf32_3: (const char*)type value: (float32_t)value {
		return [self ref].getParameterScalarf32(type, value);
	}
	-(float32_t)getParameterScalarf32_3_: (const char*)type value: (float32_t)value {
		return [self ref].getParameterScalarf32(type, value);
	}
	-(TSVector4f)getParameterVector4f_2: (const char*)type {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(type);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_2_: (const char*)type {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(type);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_3: (const char*)type vector: (TSVector4f)vector {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(type, *(Tellusim::Vector4f*)&vector);
		return *(TSVector4f*)&ret;
	}
	-(TSVector4f)getParameterVector4f_3_: (const char*)type vector: (TSVector4f)vector {
		Tellusim::Vector4f ret = [self ref].getParameterVector4f(type, *(Tellusim::Vector4f*)&vector);
		return *(TSVector4f*)&ret;
	}
	-(TSColor)getParameterColor_2: (const char*)type {
		Tellusim::Color ret = [self ref].getParameterColor(type);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_2_: (const char*)type {
		Tellusim::Color ret = [self ref].getParameterColor(type);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_3: (const char*)type color: (TSColor)color {
		Tellusim::Color ret = [self ref].getParameterColor(type, *(Tellusim::Color*)&color);
		return *(TSColor*)&ret;
	}
	-(TSColor)getParameterColor_3_: (const char*)type color: (TSColor)color {
		Tellusim::Color ret = [self ref].getParameterColor(type, *(Tellusim::Color*)&color);
		return *(TSColor*)&ret;
	}
	-(NSString*)getParameterName_2: (const char*)type {
		return [NSString stringWithUTF8String:[self ref].getParameterName(type).get()];
	}
	-(NSString*)getParameterName_2_: (const char*)type {
		return [NSString stringWithUTF8String:[self ref].getParameterName(type).get()];
	}
	-(NSString*)getParameterName_3: (const char*)type name: (const TSString*)name {
		return [NSString stringWithUTF8String:[self ref].getParameterName(type, (name) ? [name ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getParameterName_3_: (const char*)type name: (const TSString*)name {
		return [NSString stringWithUTF8String:[self ref].getParameterName(type, (name) ? [name ref] : Tellusim::String::null).get()];
	}
	-(void)setTransform: (TSVector3f)scale {
		[self ref].setTransform(*(Tellusim::Vector3f*)&scale);
	}
	-(void)setTransform_: (TSVector3f)scale {
		[self ref].setTransform(*(Tellusim::Vector3f*)&scale);
	}
	-(void)setTransform_1: (TSMatrix4x3f)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x3f*)&transform);
	}
	-(void)setTransform_1_: (TSMatrix4x3f)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x3f*)&transform);
	}
	-(TSMatrix4x3f)getTransform {
		Tellusim::Matrix4x3f ret = [self ref].getTransform();
		return *(TSMatrix4x3f*)&ret;
	}
	-(int32_t)compare: (const TSMeshAttachment*)attachment {
		return [self ref].compare([attachment ref]);
	}
	-(int32_t)compare_: (const TSMeshAttachment*)attachment {
		return [self ref].compare([attachment ref]);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end
TS_CAPI NSString *tsMeshAttachmentTypeColor = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeColor];
TS_CAPI NSString *tsMeshAttachmentTypeIntensity = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeIntensity];
TS_CAPI NSString *tsMeshAttachmentTypeTemperature = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeTemperature];
TS_CAPI NSString *tsMeshAttachmentTypeInnerAngle = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeInnerAngle];
TS_CAPI NSString *tsMeshAttachmentTypeOuterAngle = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeOuterAngle];
TS_CAPI NSString *tsMeshAttachmentTypeAttenuation = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeAttenuation];
TS_CAPI NSString *tsMeshAttachmentTypeDiffuse = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeDiffuse];
TS_CAPI NSString *tsMeshAttachmentTypeSpecular = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeSpecular];
TS_CAPI NSString *tsMeshAttachmentTypeWidth = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeWidth];
TS_CAPI NSString *tsMeshAttachmentTypeHeight = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeHeight];
TS_CAPI NSString *tsMeshAttachmentTypeRadius = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeRadius];
TS_CAPI NSString *tsMeshAttachmentTypeLength = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeLength];
TS_CAPI NSString *tsMeshAttachmentTypeShadow = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeShadow];
TS_CAPI NSString *tsMeshAttachmentTypeAspect = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeAspect];
TS_CAPI NSString *tsMeshAttachmentTypeFovX = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeFovX];
TS_CAPI NSString *tsMeshAttachmentTypeFovY = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeFovY];
TS_CAPI NSString *tsMeshAttachmentTypeSizeX = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeSizeX];
TS_CAPI NSString *tsMeshAttachmentTypeSizeY = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeSizeY];
TS_CAPI NSString *tsMeshAttachmentTypeZNear = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeZNear];
TS_CAPI NSString *tsMeshAttachmentTypeZFar = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeZFar];
TS_CAPI NSString *tsMeshAttachmentTypeFStop = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeFStop];
TS_CAPI NSString *tsMeshAttachmentTypeExposure = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeExposure];
TS_CAPI NSString *tsMeshAttachmentTypeApertureX = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeApertureX];
TS_CAPI NSString *tsMeshAttachmentTypeApertureY = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeApertureY];
TS_CAPI NSString *tsMeshAttachmentTypeFocalLength = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeFocalLength];
TS_CAPI NSString *tsMeshAttachmentTypeFocusDistance = [NSString stringWithUTF8String:Tellusim::MeshAttachment::TypeFocusDistance];

// Tellusim::Mesh
@implementation TSMesh
	-(id)init {
		self = [super init];
		impl = new Tellusim::Mesh();
		return self;
	}
	-(id)init_ptr: (Tellusim::Mesh*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Mesh&)ref {
		self = [super init];
		impl = new Tellusim::Mesh((Tellusim::Mesh&)ref);
		return self;
	}
	-(Tellusim::Mesh*)pointer {
		return (Tellusim::Mesh*)impl;
	}
	-(Tellusim::Mesh&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Mesh*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Mesh*)impl;
	}
	-(BOOL)equalPtr: (const TSMesh*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMesh*)copyPtr {
		return [[TSMesh alloc] init_ref:[self ref]];
	}
	-(TSMesh*)clonePtr {
		return [[TSMesh alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMesh*)null {
		return [[TSMesh alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isLoaded {
		return [self ref].isLoaded();
	}
	-(BOOL)info: (const char*)name {
		return [self ref].info(name);
	}
	-(BOOL)info_: (const char*)name {
		return [self ref].info(name);
	}
	-(BOOL)info_1: (const char*)name flags: (TS_MeshFlags)flags {
		return [self ref].info(name, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)info_1_: (const char*)name flags: (TS_MeshFlags)flags {
		return [self ref].info(name, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)info_2: (const char*)name flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].info(name, (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_2_: (const char*)name flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].info(name, (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_3: (const TSString*)name {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)info_3_: (const TSString*)name {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)info_4: (const TSString*)name flags: (TS_MeshFlags)flags {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)info_4_: (const TSString*)name flags: (TS_MeshFlags)flags {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)info_5: (const TSString*)name flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_5_: (const TSString*)name flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_6: (TSStream*)stream {
		return [self ref].info([stream ref]);
	}
	-(BOOL)info_6_: (TSStream*)stream {
		return [self ref].info([stream ref]);
	}
	-(BOOL)info_7: (TSStream*)stream flags: (TS_MeshFlags)flags {
		return [self ref].info([stream ref], (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)info_7_: (TSStream*)stream flags: (TS_MeshFlags)flags {
		return [self ref].info([stream ref], (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)info_8: (TSStream*)stream flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].info([stream ref], (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_8_: (TSStream*)stream flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].info([stream ref], (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_9: (const char*)name async: (TSAsync**)async {
		return [self ref].info(name, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_9_: (const char*)name async: (TSAsync**)async {
		return [self ref].info(name, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_10: (const TSString*)name async: (TSAsync**)async {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_10_: (const TSString*)name async: (TSAsync**)async {
		return [self ref].info((name) ? [name ref] : Tellusim::String::null, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_11: (TSStream*)stream async: (TSAsync**)async {
		return [self ref].info([stream ref], (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)info_11_: (TSStream*)stream async: (TSAsync**)async {
		return [self ref].info([stream ref], (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_1: (const char*)name flags: (TS_MeshFlags)flags {
		return [self ref].load(name, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)load_1_: (const char*)name flags: (TS_MeshFlags)flags {
		return [self ref].load(name, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)load_2: (const char*)name flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].load(name, (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_2_: (const char*)name flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].load(name, (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_3: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)load_3_: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)load_4: (const TSString*)name flags: (TS_MeshFlags)flags {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)load_4_: (const TSString*)name flags: (TS_MeshFlags)flags {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)load_5: (const TSString*)name flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_5_: (const TSString*)name flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_6: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)load_6_: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)load_7: (TSStream*)stream flags: (TS_MeshFlags)flags {
		return [self ref].load([stream ref], (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)load_7_: (TSStream*)stream flags: (TS_MeshFlags)flags {
		return [self ref].load([stream ref], (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)load_8: (TSStream*)stream flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].load([stream ref], (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_8_: (TSStream*)stream flags: (TS_MeshFlags)flags async: (TSAsync**)async {
		return [self ref].load([stream ref], (Tellusim::Mesh::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_9: (const char*)name async: (TSAsync**)async {
		return [self ref].load(name, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_9_: (const char*)name async: (TSAsync**)async {
		return [self ref].load(name, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_10: (const TSString*)name async: (TSAsync**)async {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_10_: (const TSString*)name async: (TSAsync**)async {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_11: (TSStream*)stream async: (TSAsync**)async {
		return [self ref].load([stream ref], (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_11_: (TSStream*)stream async: (TSAsync**)async {
		return [self ref].load([stream ref], (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)save: (const char*)name {
		return [self ref].save(name);
	}
	-(BOOL)save_: (const char*)name {
		return [self ref].save(name);
	}
	-(BOOL)save_1: (const char*)name flags: (TS_MeshFlags)flags {
		return [self ref].save(name, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)save_1_: (const char*)name flags: (TS_MeshFlags)flags {
		return [self ref].save(name, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)save_2: (const TSString*)name {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)save_2_: (const TSString*)name {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)save_3: (const TSString*)name flags: (TS_MeshFlags)flags {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)save_3_: (const TSString*)name flags: (TS_MeshFlags)flags {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)save_4: (TSStream*)stream {
		return [self ref].save([stream ref]);
	}
	-(BOOL)save_4_: (TSStream*)stream {
		return [self ref].save([stream ref]);
	}
	-(BOOL)save_5: (TSStream*)stream flags: (TS_MeshFlags)flags {
		return [self ref].save([stream ref], (Tellusim::Mesh::Flags)flags);
	}
	-(BOOL)save_5_: (TSStream*)stream flags: (TS_MeshFlags)flags {
		return [self ref].save([stream ref], (Tellusim::Mesh::Flags)flags);
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(BOOL)setBasis: (TS_MeshAxis)front right: (TS_MeshAxis)right up: (TS_MeshAxis)up {
		return [self ref].setBasis((Tellusim::Mesh::Axis)front, (Tellusim::Mesh::Axis)right, (Tellusim::Mesh::Axis)up);
	}
	-(BOOL)setBasis_: (TS_MeshAxis)front right: (TS_MeshAxis)right up: (TS_MeshAxis)up {
		return [self ref].setBasis((Tellusim::Mesh::Axis)front, (Tellusim::Mesh::Axis)right, (Tellusim::Mesh::Axis)up);
	}
	-(BOOL)setBasis_1: (TS_MeshBasis)basis {
		return [self ref].setBasis((Tellusim::Mesh::Basis)basis);
	}
	-(BOOL)setBasis_1_: (TS_MeshBasis)basis {
		return [self ref].setBasis((Tellusim::Mesh::Basis)basis);
	}
	-(TS_MeshAxis)getFrontAxis {
		return (TS_MeshAxis)[self ref].getFrontAxis();
	}
	-(TS_MeshAxis)getRightAxis {
		return (TS_MeshAxis)[self ref].getRightAxis();
	}
	-(TS_MeshAxis)getUpAxis {
		return (TS_MeshAxis)[self ref].getUpAxis();
	}
	-(TS_MeshBasis)getBasis {
		return (TS_MeshBasis)[self ref].getBasis();
	}
	-(NSString*)getFrontAxisName {
		return [NSString stringWithUTF8String:[self ref].getFrontAxisName()];
	}
	-(NSString*)getRightAxisName {
		return [NSString stringWithUTF8String:[self ref].getRightAxisName()];
	}
	-(NSString*)getUpAxisName {
		return [NSString stringWithUTF8String:[self ref].getUpAxisName()];
	}
	-(NSString*)getBasisName {
		return [NSString stringWithUTF8String:[self ref].getBasisName().get()];
	}
	-(void)clearNodes {
		[self ref].clearNodes();
	}
	-(void)reserveNodes: (uint32_t)num_nodes {
		[self ref].reserveNodes(num_nodes);
	}
	-(void)reserveNodes_: (uint32_t)num_nodes {
		[self ref].reserveNodes(num_nodes);
	}
	-(uint32_t)addNode: (TSMeshNode*)node {
		return [self ref].addNode([node ref]);
	}
	-(uint32_t)addNode_: (TSMeshNode*)node {
		return [self ref].addNode([node ref]);
	}
	-(uint32_t)addNode_1: (TSMeshNode*)node check: (BOOL)check {
		return [self ref].addNode([node ref], (bool)check);
	}
	-(uint32_t)addNode_1_: (TSMeshNode*)node check: (BOOL)check {
		return [self ref].addNode([node ref], (bool)check);
	}
	-(BOOL)removeNode: (TSMeshNode*)node {
		return [self ref].removeNode([node ref]);
	}
	-(BOOL)removeNode_: (TSMeshNode*)node {
		return [self ref].removeNode([node ref]);
	}
	-(uint32_t)findNode: (const TSMeshNode*)node {
		return [self ref].findNode([node ref]);
	}
	-(uint32_t)findNode_: (const TSMeshNode*)node {
		return [self ref].findNode([node ref]);
	}
	-(uint32_t)findNode_1: (const char*)name {
		return [self ref].findNode(name);
	}
	-(uint32_t)findNode_1_: (const char*)name {
		return [self ref].findNode(name);
	}
	-(uint32_t)getNumNodes {
		return [self ref].getNumNodes();
	}
	-(NSArray<TSMeshNode*>*)getNodes {
		const auto &ret = [self ref].getNodes();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshNode alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshNode*)getNode: (uint32_t)index {
		return [[TSMeshNode alloc] init_ref:([self ref].getNode(index))];
	}
	-(const TSMeshNode*)getNode_: (uint32_t)index {
		return [[TSMeshNode alloc] init_ref:([self ref].getNode(index))];
	}
	-(void)createLocalTransforms {
		[self ref].createLocalTransforms();
	}
	-(void)createLocalTransforms_1: (TSMatrix4x3d)itransform {
		[self ref].createLocalTransforms(*(Tellusim::Matrix4x3d*)&itransform);
	}
	-(void)createLocalTransforms_1_: (TSMatrix4x3d)itransform {
		[self ref].createLocalTransforms(*(Tellusim::Matrix4x3d*)&itransform);
	}
	-(void)createGlobalTransforms {
		[self ref].createGlobalTransforms();
	}
	-(void)createGlobalTransforms_1: (TSMatrix4x3d)transform {
		[self ref].createGlobalTransforms(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)createGlobalTransforms_1_: (TSMatrix4x3d)transform {
		[self ref].createGlobalTransforms(*(Tellusim::Matrix4x3d*)&transform);
	}
	-(void)clearGeometries {
		[self ref].clearGeometries();
	}
	-(void)reserveGeometries: (uint32_t)num_geometries {
		[self ref].reserveGeometries(num_geometries);
	}
	-(void)reserveGeometries_: (uint32_t)num_geometries {
		[self ref].reserveGeometries(num_geometries);
	}
	-(uint32_t)addGeometry: (TSMeshGeometry*)geometry {
		return [self ref].addGeometry([geometry ref]);
	}
	-(uint32_t)addGeometry_: (TSMeshGeometry*)geometry {
		return [self ref].addGeometry([geometry ref]);
	}
	-(uint32_t)addGeometry_1: (TSMeshGeometry*)geometry check: (BOOL)check {
		return [self ref].addGeometry([geometry ref], (bool)check);
	}
	-(uint32_t)addGeometry_1_: (TSMeshGeometry*)geometry check: (BOOL)check {
		return [self ref].addGeometry([geometry ref], (bool)check);
	}
	-(uint32_t)addGeometry_2: (TSMeshGeometry*)geometry node: (TSMeshNode*)node {
		return [self ref].addGeometry([geometry ref], [node ref]);
	}
	-(uint32_t)addGeometry_2_: (TSMeshGeometry*)geometry node: (TSMeshNode*)node {
		return [self ref].addGeometry([geometry ref], [node ref]);
	}
	-(uint32_t)addGeometry_3: (TSMeshGeometry*)geometry node: (TSMeshNode*)node check: (BOOL)check {
		return [self ref].addGeometry([geometry ref], [node ref], (bool)check);
	}
	-(uint32_t)addGeometry_3_: (TSMeshGeometry*)geometry node: (TSMeshNode*)node check: (BOOL)check {
		return [self ref].addGeometry([geometry ref], [node ref], (bool)check);
	}
	-(BOOL)removeGeometry: (TSMeshGeometry*)geometry {
		return [self ref].removeGeometry([geometry ref]);
	}
	-(BOOL)removeGeometry_: (TSMeshGeometry*)geometry {
		return [self ref].removeGeometry([geometry ref]);
	}
	-(BOOL)replaceGeometry: (TSMeshGeometry*)old_geometry geometry: (TSMeshGeometry*)geometry {
		return [self ref].replaceGeometry([old_geometry ref], [geometry ref]);
	}
	-(BOOL)replaceGeometry_: (TSMeshGeometry*)old_geometry geometry: (TSMeshGeometry*)geometry {
		return [self ref].replaceGeometry([old_geometry ref], [geometry ref]);
	}
	-(uint32_t)findGeometry: (const TSMeshGeometry*)geometry {
		return [self ref].findGeometry([geometry ref]);
	}
	-(uint32_t)findGeometry_: (const TSMeshGeometry*)geometry {
		return [self ref].findGeometry([geometry ref]);
	}
	-(uint32_t)findGeometry_1: (const char*)name {
		return [self ref].findGeometry(name);
	}
	-(uint32_t)findGeometry_1_: (const char*)name {
		return [self ref].findGeometry(name);
	}
	-(uint32_t)getNumGeometries {
		return [self ref].getNumGeometries();
	}
	-(NSArray<TSMeshGeometry*>*)getGeometries {
		const auto &ret = [self ref].getGeometries();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshGeometry alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshGeometry*)getGeometry: (uint32_t)index {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getGeometry(index))];
	}
	-(const TSMeshGeometry*)getGeometry_: (uint32_t)index {
		return [[TSMeshGeometry alloc] init_ref:([self ref].getGeometry(index))];
	}
	-(BOOL)hasGeometryIndices: (TS_MeshIndicesType)type {
		return [self ref].hasGeometryIndices((Tellusim::MeshIndices::Type)type);
	}
	-(BOOL)hasGeometryIndices_: (TS_MeshIndicesType)type {
		return [self ref].hasGeometryIndices((Tellusim::MeshIndices::Type)type);
	}
	-(BOOL)hasGeometryAttribute: (TS_MeshAttributeType)type {
		return [self ref].hasGeometryAttribute((Tellusim::MeshAttribute::Type)type);
	}
	-(BOOL)hasGeometryAttribute_: (TS_MeshAttributeType)type {
		return [self ref].hasGeometryAttribute((Tellusim::MeshAttribute::Type)type);
	}
	-(size_t)getNumGeometryPositions {
		return [self ref].getNumGeometryPositions();
	}
	-(size_t)getNumGeometryPrimitives {
		return [self ref].getNumGeometryPrimitives();
	}
	-(void)clearAnimations {
		[self ref].clearAnimations();
	}
	-(void)reserveAnimations: (uint32_t)num_animations {
		[self ref].reserveAnimations(num_animations);
	}
	-(void)reserveAnimations_: (uint32_t)num_animations {
		[self ref].reserveAnimations(num_animations);
	}
	-(uint32_t)addAnimation: (TSMeshAnimation*)animation {
		return [self ref].addAnimation([animation ref]);
	}
	-(uint32_t)addAnimation_: (TSMeshAnimation*)animation {
		return [self ref].addAnimation([animation ref]);
	}
	-(uint32_t)addAnimation_1: (TSMeshAnimation*)animation check: (BOOL)check {
		return [self ref].addAnimation([animation ref], (bool)check);
	}
	-(uint32_t)addAnimation_1_: (TSMeshAnimation*)animation check: (BOOL)check {
		return [self ref].addAnimation([animation ref], (bool)check);
	}
	-(BOOL)removeAnimation: (TSMeshAnimation*)animation {
		return [self ref].removeAnimation([animation ref]);
	}
	-(BOOL)removeAnimation_: (TSMeshAnimation*)animation {
		return [self ref].removeAnimation([animation ref]);
	}
	-(BOOL)replaceAnimation: (TSMeshAnimation*)old_animation animation: (TSMeshAnimation*)animation {
		return [self ref].replaceAnimation([old_animation ref], [animation ref]);
	}
	-(BOOL)replaceAnimation_: (TSMeshAnimation*)old_animation animation: (TSMeshAnimation*)animation {
		return [self ref].replaceAnimation([old_animation ref], [animation ref]);
	}
	-(uint32_t)findAnimation: (const TSMeshAnimation*)animation {
		return [self ref].findAnimation([animation ref]);
	}
	-(uint32_t)findAnimation_: (const TSMeshAnimation*)animation {
		return [self ref].findAnimation([animation ref]);
	}
	-(uint32_t)findAnimation_1: (const char*)name {
		return [self ref].findAnimation(name);
	}
	-(uint32_t)findAnimation_1_: (const char*)name {
		return [self ref].findAnimation(name);
	}
	-(uint32_t)getNumAnimations {
		return [self ref].getNumAnimations();
	}
	-(NSArray<TSMeshAnimation*>*)getAnimations {
		const auto &ret = [self ref].getAnimations();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSMeshAnimation alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSMeshAnimation*)getAnimation: (uint32_t)index {
		return [[TSMeshAnimation alloc] init_ref:([self ref].getAnimation(index))];
	}
	-(const TSMeshAnimation*)getAnimation_: (uint32_t)index {
		return [[TSMeshAnimation alloc] init_ref:([self ref].getAnimation(index))];
	}
	-(TSBoundBoxd)getBoundBox {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox();
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_1: (const TSMeshNode*)node {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([node ref]);
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_1_: (const TSMeshNode*)node {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([node ref]);
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_2: (const TSMeshGeometry*)geometry {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([geometry ref]);
		return *(TSBoundBoxd*)&ret;
	}
	-(TSBoundBoxd)getBoundBox_2_: (const TSMeshGeometry*)geometry {
		Tellusim::BoundBoxd ret = [self ref].getBoundBox([geometry ref]);
		return *(TSBoundBoxd*)&ret;
	}
	-(BOOL)createBounds: (BOOL)force {
		return [self ref].createBounds((bool)force);
	}
	-(BOOL)createBounds_: (BOOL)force {
		return [self ref].createBounds((bool)force);
	}
	-(BOOL)createBounds_1: (BOOL)force async: (TSAsync**)async {
		return [self ref].createBounds((bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBounds_1_: (BOOL)force async: (TSAsync**)async {
		return [self ref].createBounds((bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBounds_2 {
		return [self ref].createBounds();
	}
	-(BOOL)createBounds_3: (TSAsync**)async {
		return [self ref].createBounds((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBounds_3_: (TSAsync**)async {
		return [self ref].createBounds((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBasis: (BOOL)force {
		return [self ref].createBasis((bool)force);
	}
	-(BOOL)createBasis_: (BOOL)force {
		return [self ref].createBasis((bool)force);
	}
	-(BOOL)createBasis_1: (BOOL)force async: (TSAsync**)async {
		return [self ref].createBasis((bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBasis_1_: (BOOL)force async: (TSAsync**)async {
		return [self ref].createBasis((bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBasis_2: (float32_t)angle force: (BOOL)force {
		return [self ref].createBasis(angle, (bool)force);
	}
	-(BOOL)createBasis_2_: (float32_t)angle force: (BOOL)force {
		return [self ref].createBasis(angle, (bool)force);
	}
	-(BOOL)createBasis_3: (float32_t)angle force: (BOOL)force async: (TSAsync**)async {
		return [self ref].createBasis(angle, (bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBasis_3_: (float32_t)angle force: (BOOL)force async: (TSAsync**)async {
		return [self ref].createBasis(angle, (bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBasis_4 {
		return [self ref].createBasis();
	}
	-(BOOL)createBasis_5: (TSAsync**)async {
		return [self ref].createBasis((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBasis_5_: (TSAsync**)async {
		return [self ref].createBasis((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBasis_6: (float32_t)angle {
		return [self ref].createBasis(angle);
	}
	-(BOOL)createBasis_6_: (float32_t)angle {
		return [self ref].createBasis(angle);
	}
	-(BOOL)createBasis_7: (float32_t)angle async: (TSAsync**)async {
		return [self ref].createBasis(angle, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createBasis_7_: (float32_t)angle async: (TSAsync**)async {
		return [self ref].createBasis(angle, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createNormals: (BOOL)force {
		return [self ref].createNormals((bool)force);
	}
	-(BOOL)createNormals_: (BOOL)force {
		return [self ref].createNormals((bool)force);
	}
	-(BOOL)createNormals_1: (BOOL)force async: (TSAsync**)async {
		return [self ref].createNormals((bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createNormals_1_: (BOOL)force async: (TSAsync**)async {
		return [self ref].createNormals((bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createNormals_2: (float32_t)angle force: (BOOL)force {
		return [self ref].createNormals(angle, (bool)force);
	}
	-(BOOL)createNormals_2_: (float32_t)angle force: (BOOL)force {
		return [self ref].createNormals(angle, (bool)force);
	}
	-(BOOL)createNormals_3: (float32_t)angle force: (BOOL)force async: (TSAsync**)async {
		return [self ref].createNormals(angle, (bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createNormals_3_: (float32_t)angle force: (BOOL)force async: (TSAsync**)async {
		return [self ref].createNormals(angle, (bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createNormals_4 {
		return [self ref].createNormals();
	}
	-(BOOL)createNormals_5: (TSAsync**)async {
		return [self ref].createNormals((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createNormals_5_: (TSAsync**)async {
		return [self ref].createNormals((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createNormals_6: (float32_t)angle {
		return [self ref].createNormals(angle);
	}
	-(BOOL)createNormals_6_: (float32_t)angle {
		return [self ref].createNormals(angle);
	}
	-(BOOL)createNormals_7: (float32_t)angle async: (TSAsync**)async {
		return [self ref].createNormals(angle, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createNormals_7_: (float32_t)angle async: (TSAsync**)async {
		return [self ref].createNormals(angle, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createTangents: (BOOL)force {
		return [self ref].createTangents((bool)force);
	}
	-(BOOL)createTangents_: (BOOL)force {
		return [self ref].createTangents((bool)force);
	}
	-(BOOL)createTangents_1: (BOOL)force async: (TSAsync**)async {
		return [self ref].createTangents((bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createTangents_1_: (BOOL)force async: (TSAsync**)async {
		return [self ref].createTangents((bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createTangents_2 {
		return [self ref].createTangents();
	}
	-(BOOL)createTangents_3: (TSAsync**)async {
		return [self ref].createTangents((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createTangents_3_: (TSAsync**)async {
		return [self ref].createTangents((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createIslands: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force);
	}
	-(BOOL)createIslands_: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force);
	}
	-(BOOL)createIslands_1: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force async: (TSAsync**)async {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createIslands_1_: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives force: (BOOL)force async: (TSAsync**)async {
		return [self ref].createIslands(max_attributes, max_primitives, (bool)force, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createIslands_2: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives {
		return [self ref].createIslands(max_attributes, max_primitives);
	}
	-(BOOL)createIslands_2_: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives {
		return [self ref].createIslands(max_attributes, max_primitives);
	}
	-(BOOL)createIslands_3: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives async: (TSAsync**)async {
		return [self ref].createIslands(max_attributes, max_primitives, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)createIslands_3_: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives async: (TSAsync**)async {
		return [self ref].createIslands(max_attributes, max_primitives, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)optimizeIndices: (uint32_t)cache transparent: (BOOL)transparent {
		return [self ref].optimizeIndices(cache, (bool)transparent);
	}
	-(BOOL)optimizeIndices_: (uint32_t)cache transparent: (BOOL)transparent {
		return [self ref].optimizeIndices(cache, (bool)transparent);
	}
	-(BOOL)optimizeIndices_1: (uint32_t)cache transparent: (BOOL)transparent async: (TSAsync**)async {
		return [self ref].optimizeIndices(cache, (bool)transparent, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)optimizeIndices_1_: (uint32_t)cache transparent: (BOOL)transparent async: (TSAsync**)async {
		return [self ref].optimizeIndices(cache, (bool)transparent, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)optimizeIndices_2 {
		return [self ref].optimizeIndices();
	}
	-(BOOL)optimizeIndices_3: (TSAsync**)async {
		return [self ref].optimizeIndices((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)optimizeIndices_3_: (TSAsync**)async {
		return [self ref].optimizeIndices((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)optimizeIndices_4: (uint32_t)cache {
		return [self ref].optimizeIndices(cache);
	}
	-(BOOL)optimizeIndices_4_: (uint32_t)cache {
		return [self ref].optimizeIndices(cache);
	}
	-(BOOL)optimizeIndices_5: (uint32_t)cache async: (TSAsync**)async {
		return [self ref].optimizeIndices(cache, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)optimizeIndices_5_: (uint32_t)cache async: (TSAsync**)async {
		return [self ref].optimizeIndices(cache, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)optimizeAttributes {
		return [self ref].optimizeAttributes();
	}
	-(BOOL)optimizeAttributes_1: (TSAsync**)async {
		return [self ref].optimizeAttributes((async) ? [*async pointer] : nullptr);
	}
	-(BOOL)optimizeAttributes_1_: (TSAsync**)async {
		return [self ref].optimizeAttributes((async) ? [*async pointer] : nullptr);
	}
	-(void)optimizeMaterials {
		[self ref].optimizeMaterials();
	}
	-(BOOL)optimizeWinding {
		return [self ref].optimizeWinding();
	}
	-(BOOL)optimizeWinding_1: (BOOL)clockwise {
		return [self ref].optimizeWinding((bool)clockwise);
	}
	-(BOOL)optimizeWinding_1_: (BOOL)clockwise {
		return [self ref].optimizeWinding((bool)clockwise);
	}
	-(void)optimizeGeometries {
		[self ref].optimizeGeometries();
	}
	-(void)optimizeGeometries_1: (float32_t)threshold {
		[self ref].optimizeGeometries(threshold);
	}
	-(void)optimizeGeometries_1_: (float32_t)threshold {
		[self ref].optimizeGeometries(threshold);
	}
	-(void)optimizeGeometries_2: (float32_t)threshold depth: (uint32_t)depth {
		[self ref].optimizeGeometries(threshold, depth);
	}
	-(void)optimizeGeometries_2_: (float32_t)threshold depth: (uint32_t)depth {
		[self ref].optimizeGeometries(threshold, depth);
	}
	-(void)optimizeAnimations {
		[self ref].optimizeAnimations();
	}
	-(void)optimizeAnimations_1: (float32_t)threshold {
		[self ref].optimizeAnimations(threshold);
	}
	-(void)optimizeAnimations_1_: (float32_t)threshold {
		[self ref].optimizeAnimations(threshold);
	}
	-(BOOL)optimizeOrder {
		return [self ref].optimizeOrder();
	}
	-(void)mergeGeometries {
		[self ref].mergeGeometries();
	}
	-(BOOL)packAttributes {
		return [self ref].packAttributes();
	}
	-(BOOL)packAttributes_1: (BOOL)remove {
		return [self ref].packAttributes((bool)remove);
	}
	-(BOOL)packAttributes_1_: (BOOL)remove {
		return [self ref].packAttributes((bool)remove);
	}
	-(BOOL)unpackAttributes {
		return [self ref].unpackAttributes();
	}
	-(BOOL)unpackAttributes_1: (BOOL)remove {
		return [self ref].unpackAttributes((bool)remove);
	}
	-(BOOL)unpackAttributes_1_: (BOOL)remove {
		return [self ref].unpackAttributes((bool)remove);
	}
	-(BOOL)setTransform: (TSVector3d)scale {
		return [self ref].setTransform(*(Tellusim::Vector3d*)&scale);
	}
	-(BOOL)setTransform_: (TSVector3d)scale {
		return [self ref].setTransform(*(Tellusim::Vector3d*)&scale);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::Json
@implementation TSJson
	-(id)init {
		self = [super init];
		impl = new Tellusim::Json();
		return self;
	}
	-(id)init_1: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json((Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_1_: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json((Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_2: (const char*)name {
		self = [super init];
		impl = new Tellusim::Json(name);
		return self;
	}
	-(id)init_2_: (const char*)name {
		self = [super init];
		impl = new Tellusim::Json(name);
		return self;
	}
	-(id)init_3: (const char*)name type: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json(name, (Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_3_: (const char*)name type: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json(name, (Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_4: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::Json((name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4_: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::Json((name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_5: (const TSString*)name type: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json((name) ? [name ref] : Tellusim::String::null, (Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_5_: (const TSString*)name type: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json((name) ? [name ref] : Tellusim::String::null, (Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_6: (TSJson*)parent name: (const char*)name {
		self = [super init];
		impl = new Tellusim::Json([parent pointer], name);
		return self;
	}
	-(id)init_6_: (TSJson*)parent name: (const char*)name {
		self = [super init];
		impl = new Tellusim::Json([parent pointer], name);
		return self;
	}
	-(id)init_7: (TSJson*)parent name: (const char*)name type: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json([parent pointer], name, (Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_7_: (TSJson*)parent name: (const char*)name type: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json([parent pointer], name, (Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_8: (TSJson*)parent name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::Json([parent pointer], (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_8_: (TSJson*)parent name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::Json([parent pointer], (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_9: (TSJson*)parent name: (const TSString*)name type: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json([parent pointer], (name) ? [name ref] : Tellusim::String::null, (Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_9_: (TSJson*)parent name: (const TSString*)name type: (TS_JsonType)type {
		self = [super init];
		impl = new Tellusim::Json([parent pointer], (name) ? [name ref] : Tellusim::String::null, (Tellusim::Json::Type)type);
		return self;
	}
	-(id)init_ptr: (Tellusim::Json*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Json&)ref {
		self = [super init];
		impl = new Tellusim::Json((Tellusim::Json&)ref);
		return self;
	}
	-(Tellusim::Json*)pointer {
		return (Tellusim::Json*)impl;
	}
	-(Tellusim::Json&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Json*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Json*)impl;
	}
	-(BOOL)equalPtr: (const TSJson*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSJson*)copyPtr {
		return [[TSJson alloc] init_ref:[self ref]];
	}
	-(TSJson*)clonePtr {
		return [[TSJson alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSJson*)null {
		return [[TSJson alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)create: (const char*)str {
		return [self ref].create(str);
	}
	-(BOOL)create_: (const char*)str {
		return [self ref].create(str);
	}
	-(BOOL)create_1: (const char*)str size: (size_t)size {
		return [self ref].create(str, size);
	}
	-(BOOL)create_1_: (const char*)str size: (size_t)size {
		return [self ref].create(str, size);
	}
	-(BOOL)create_2: (const char*)str size: (size_t)size owner: (BOOL)owner {
		return [self ref].create(str, size, (bool)owner);
	}
	-(BOOL)create_2_: (const char*)str size: (size_t)size owner: (BOOL)owner {
		return [self ref].create(str, size, (bool)owner);
	}
	-(BOOL)create_3: (const TSString*)str {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null);
	}
	-(BOOL)create_3_: (const TSString*)str {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null);
	}
	-(BOOL)create_4: (const TSString*)str size: (size_t)size {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null, size);
	}
	-(BOOL)create_4_: (const TSString*)str size: (size_t)size {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null, size);
	}
	-(BOOL)create_5: (const TSString*)str size: (size_t)size owner: (BOOL)owner {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null, size, (bool)owner);
	}
	-(BOOL)create_5_: (const TSString*)str size: (size_t)size owner: (BOOL)owner {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null, size, (bool)owner);
	}
	-(BOOL)load: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_1: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)load_1_: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)load_2: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)load_2_: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)save: (const char*)name {
		return [self ref].save(name);
	}
	-(BOOL)save_: (const char*)name {
		return [self ref].save(name);
	}
	-(BOOL)save_1: (const char*)name compact: (BOOL)compact {
		return [self ref].save(name, (bool)compact);
	}
	-(BOOL)save_1_: (const char*)name compact: (BOOL)compact {
		return [self ref].save(name, (bool)compact);
	}
	-(BOOL)save_2: (const TSString*)name {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)save_2_: (const TSString*)name {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)save_3: (const TSString*)name compact: (BOOL)compact {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (bool)compact);
	}
	-(BOOL)save_3_: (const TSString*)name compact: (BOOL)compact {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (bool)compact);
	}
	-(BOOL)save_4: (TSStream*)stream {
		return [self ref].save([stream ref]);
	}
	-(BOOL)save_4_: (TSStream*)stream {
		return [self ref].save([stream ref]);
	}
	-(BOOL)save_5: (TSStream*)stream compact: (BOOL)compact {
		return [self ref].save([stream ref], (bool)compact);
	}
	-(BOOL)save_5_: (TSStream*)stream compact: (BOOL)compact {
		return [self ref].save([stream ref], (bool)compact);
	}
	-(const TSJson*)getRoot {
		return [[TSJson alloc] init_ref:([self ref].getRoot())];
	}
	-(uint32_t)setParent: (TSJson*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(uint32_t)setParent_: (TSJson*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(uint32_t)setParent_1: (TSJson*)parent check: (BOOL)check {
		return [self ref].setParent([parent ref], (bool)check);
	}
	-(uint32_t)setParent_1_: (TSJson*)parent check: (BOOL)check {
		return [self ref].setParent([parent ref], (bool)check);
	}
	-(const TSJson*)getParent {
		return [[TSJson alloc] init_ref:([self ref].getParent())];
	}
	-(TSJson*)addChild: (const char*)name {
		return [[TSJson alloc] init_ref:([self ref].addChild(name))];
	}
	-(TSJson*)addChild_: (const char*)name {
		return [[TSJson alloc] init_ref:([self ref].addChild(name))];
	}
	-(TSJson*)addChild_1: (const char*)name type: (TS_JsonType)type {
		return [[TSJson alloc] init_ref:([self ref].addChild(name, (Tellusim::Json::Type)type))];
	}
	-(TSJson*)addChild_1_: (const char*)name type: (TS_JsonType)type {
		return [[TSJson alloc] init_ref:([self ref].addChild(name, (Tellusim::Json::Type)type))];
	}
	-(TSJson*)addChild_2: (const char*)name type: (TS_JsonType)type check: (BOOL)check {
		return [[TSJson alloc] init_ref:([self ref].addChild(name, (Tellusim::Json::Type)type, (bool)check))];
	}
	-(TSJson*)addChild_2_: (const char*)name type: (TS_JsonType)type check: (BOOL)check {
		return [[TSJson alloc] init_ref:([self ref].addChild(name, (Tellusim::Json::Type)type, (bool)check))];
	}
	-(uint32_t)addChild_3: (TSJson*)child {
		return [self ref].addChild([child ref]);
	}
	-(uint32_t)addChild_3_: (TSJson*)child {
		return [self ref].addChild([child ref]);
	}
	-(uint32_t)addChild_4: (TSJson*)child check: (BOOL)check {
		return [self ref].addChild([child ref], (bool)check);
	}
	-(uint32_t)addChild_4_: (TSJson*)child check: (BOOL)check {
		return [self ref].addChild([child ref], (bool)check);
	}
	-(BOOL)removeChild: (TSJson*)child {
		return [self ref].removeChild([child ref]);
	}
	-(BOOL)removeChild_: (TSJson*)child {
		return [self ref].removeChild([child ref]);
	}
	-(void)releaseChildren {
		[self ref].releaseChildren();
	}
	-(uint32_t)findChild: (const char*)name {
		return [self ref].findChild(name);
	}
	-(uint32_t)findChild_: (const char*)name {
		return [self ref].findChild(name);
	}
	-(BOOL)isChild: (const char*)name {
		return [self ref].isChild(name);
	}
	-(BOOL)isChild_: (const char*)name {
		return [self ref].isChild(name);
	}
	-(const TSJson*)getChild: (const char*)name {
		return [[TSJson alloc] init_ref:([self ref].getChild(name))];
	}
	-(const TSJson*)getChild_: (const char*)name {
		return [[TSJson alloc] init_ref:([self ref].getChild(name))];
	}
	-(uint32_t)getNumChildren {
		return [self ref].getNumChildren();
	}
	-(NSArray<TSJson*>*)getChildren {
		const auto &ret = [self ref].getChildren();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSJson alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSJson*)getChild_1: (uint32_t)index {
		return [[TSJson alloc] init_ref:([self ref].getChild(index))];
	}
	-(const TSJson*)getChild_1_: (uint32_t)index {
		return [[TSJson alloc] init_ref:([self ref].getChild(index))];
	}
	-(NSString*)getPathName {
		return [NSString stringWithUTF8String:[self ref].getPathName().get()];
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_1: (const TSString*)name {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setName_1_: (const TSString*)name {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(void)setType: (TS_JsonType)type {
		[self ref].setType((Tellusim::Json::Type)type);
	}
	-(void)setType_: (TS_JsonType)type {
		[self ref].setType((Tellusim::Json::Type)type);
	}
	-(TS_JsonType)getType {
		return (TS_JsonType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_JsonType)type {
		return [NSString stringWithUTF8String:Tellusim::Json::getTypeName((Tellusim::Json::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_JsonType)type {
		return [NSString stringWithUTF8String:Tellusim::Json::getTypeName((Tellusim::Json::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)isUnknown {
		return [self ref].isUnknown();
	}
	-(BOOL)isNull {
		return [self ref].isNull();
	}
	-(BOOL)isBool {
		return [self ref].isBool();
	}
	-(BOOL)isNumber {
		return [self ref].isNumber();
	}
	-(BOOL)isString {
		return [self ref].isString();
	}
	-(BOOL)isObject {
		return [self ref].isObject();
	}
	-(BOOL)isArray {
		return [self ref].isArray();
	}
	-(void)setData: (BOOL)value {
		[self ref].setData((bool)value);
	}
	-(void)setData_: (BOOL)value {
		[self ref].setData((bool)value);
	}
	-(void)setData_1: (int32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_1_: (int32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_2: (int32_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_2_: (int32_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_3: (uint32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_3_: (uint32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_4: (uint32_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_4_: (uint32_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_5: (uint64_t)value {
		[self ref].setData(value);
	}
	-(void)setData_5_: (uint64_t)value {
		[self ref].setData(value);
	}
	-(void)setData_6: (uint64_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_6_: (uint64_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_7: (float32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_7_: (float32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_8: (float32_t)value digits: (uint32_t)digits {
		[self ref].setData(value, digits);
	}
	-(void)setData_8_: (float32_t)value digits: (uint32_t)digits {
		[self ref].setData(value, digits);
	}
	-(void)setData_9: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(value, digits, (bool)compact);
	}
	-(void)setData_9_: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(value, digits, (bool)compact);
	}
	-(void)setData_10: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_10_: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_11: (float64_t)value {
		[self ref].setData(value);
	}
	-(void)setData_11_: (float64_t)value {
		[self ref].setData(value);
	}
	-(void)setData_12: (float64_t)value digits: (uint32_t)digits {
		[self ref].setData(value, digits);
	}
	-(void)setData_12_: (float64_t)value digits: (uint32_t)digits {
		[self ref].setData(value, digits);
	}
	-(void)setData_13: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(value, digits, (bool)compact);
	}
	-(void)setData_13_: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(value, digits, (bool)compact);
	}
	-(void)setData_14: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_14_: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_15: (const char*)value {
		[self ref].setData(value);
	}
	-(void)setData_15_: (const char*)value {
		[self ref].setData(value);
	}
	-(void)setData_16: (const TSString*)value {
		[self ref].setData((value) ? [value ref] : Tellusim::String::null);
	}
	-(void)setData_16_: (const TSString*)value {
		[self ref].setData((value) ? [value ref] : Tellusim::String::null);
	}
	-(NSString*)getData {
		return [NSString stringWithUTF8String:[self ref].getData().get()];
	}
	-(BOOL)getDataBool {
		return [self ref].getDataBool();
	}
	-(int32_t)getDatai32 {
		return [self ref].getDatai32();
	}
	-(int32_t)getDatai32_1: (uint32_t)radix {
		return [self ref].getDatai32(radix);
	}
	-(int32_t)getDatai32_1_: (uint32_t)radix {
		return [self ref].getDatai32(radix);
	}
	-(uint32_t)getDatau32 {
		return [self ref].getDatau32();
	}
	-(uint32_t)getDatau32_1: (uint32_t)radix {
		return [self ref].getDatau32(radix);
	}
	-(uint32_t)getDatau32_1_: (uint32_t)radix {
		return [self ref].getDatau32(radix);
	}
	-(uint64_t)getDatau64 {
		return [self ref].getDatau64();
	}
	-(uint64_t)getDatau64_1: (uint32_t)radix {
		return [self ref].getDatau64(radix);
	}
	-(uint64_t)getDatau64_1_: (uint32_t)radix {
		return [self ref].getDatau64(radix);
	}
	-(float32_t)getDataf32 {
		return [self ref].getDataf32();
	}
	-(float64_t)getDataf64 {
		return [self ref].getDataf64();
	}
	-(NSString*)getNumber {
		return [NSString stringWithUTF8String:[self ref].getNumber().get()];
	}
	-(NSString*)getString {
		return [NSString stringWithUTF8String:[self ref].getString().get()];
	}
	-(BOOL)getData_1: (const char*)name value: (BOOL)value {
		return [self ref].getData(name, (bool)value);
	}
	-(BOOL)getData_1_: (const char*)name value: (BOOL)value {
		return [self ref].getData(name, (bool)value);
	}
	-(int32_t)getData_2: (const char*)name value: (int32_t)value {
		return [self ref].getData(name, value);
	}
	-(int32_t)getData_2_: (const char*)name value: (int32_t)value {
		return [self ref].getData(name, value);
	}
	-(int32_t)getData_3: (const char*)name value: (int32_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(int32_t)getData_3_: (const char*)name value: (int32_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(uint32_t)getData_4: (const char*)name value: (uint32_t)value {
		return [self ref].getData(name, value);
	}
	-(uint32_t)getData_4_: (const char*)name value: (uint32_t)value {
		return [self ref].getData(name, value);
	}
	-(uint32_t)getData_5: (const char*)name value: (uint32_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(uint32_t)getData_5_: (const char*)name value: (uint32_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(uint64_t)getData_6: (const char*)name value: (uint64_t)value {
		return [self ref].getData(name, value);
	}
	-(uint64_t)getData_6_: (const char*)name value: (uint64_t)value {
		return [self ref].getData(name, value);
	}
	-(uint64_t)getData_7: (const char*)name value: (uint64_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(uint64_t)getData_7_: (const char*)name value: (uint64_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(float32_t)getData_8: (const char*)name value: (float32_t)value {
		return [self ref].getData(name, value);
	}
	-(float32_t)getData_8_: (const char*)name value: (float32_t)value {
		return [self ref].getData(name, value);
	}
	-(float64_t)getData_9: (const char*)name value: (float64_t)value {
		return [self ref].getData(name, value);
	}
	-(float64_t)getData_9_: (const char*)name value: (float64_t)value {
		return [self ref].getData(name, value);
	}
	-(NSString*)getData_10: (const char*)name {
		return [NSString stringWithUTF8String:[self ref].getData(name).get()];
	}
	-(NSString*)getData_10_: (const char*)name {
		return [NSString stringWithUTF8String:[self ref].getData(name).get()];
	}
	-(NSString*)getData_11: (const char*)name value: (const TSString*)value {
		return [NSString stringWithUTF8String:[self ref].getData(name, (value) ? [value ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getData_11_: (const char*)name value: (const TSString*)value {
		return [NSString stringWithUTF8String:[self ref].getData(name, (value) ? [value ref] : Tellusim::String::null).get()];
	}
	-(void)setData_17: (const char**)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_17_: (const char**)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_18: (const TSString**)values size: (uint32_t)size {
		[self ref].setData((values) ? [*values pointer] : nullptr, size);
	}
	-(void)setData_18_: (const TSString**)values size: (uint32_t)size {
		[self ref].setData((values) ? [*values pointer] : nullptr, size);
	}
	-(void)setData_19: (const int32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_19_: (const int32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_20: (const int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setData(values, size, radix);
	}
	-(void)setData_20_: (const int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setData(values, size, radix);
	}
	-(void)setData_21: (const uint32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_21_: (const uint32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_22: (const uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setData(values, size, radix);
	}
	-(void)setData_22_: (const uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setData(values, size, radix);
	}
	-(void)setData_23: (const float32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_23_: (const float32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_24: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setData(values, size, digits);
	}
	-(void)setData_24_: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setData(values, size, digits);
	}
	-(void)setData_25: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(values, size, digits, (bool)compact);
	}
	-(void)setData_25_: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(values, size, digits, (bool)compact);
	}
	-(void)setData_26: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_26_: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_27: (const float64_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_27_: (const float64_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_28: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setData(values, size, digits);
	}
	-(void)setData_28_: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setData(values, size, digits);
	}
	-(void)setData_29: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(values, size, digits, (bool)compact);
	}
	-(void)setData_29_: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(values, size, digits, (bool)compact);
	}
	-(void)setData_30: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_30_: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent);
	}
	-(uint32_t)getData_12: (TSString**)values size: (uint32_t)size {
		return [self ref].getData((values) ? [*values pointer] : nullptr, size);
	}
	-(uint32_t)getData_12_: (TSString**)values size: (uint32_t)size {
		return [self ref].getData((values) ? [*values pointer] : nullptr, size);
	}
	-(uint32_t)getData_13: (int32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_13_: (int32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_14: (int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getData(values, size, radix);
	}
	-(uint32_t)getData_14_: (int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getData(values, size, radix);
	}
	-(uint32_t)getData_15: (uint32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_15_: (uint32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_16: (uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getData(values, size, radix);
	}
	-(uint32_t)getData_16_: (uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getData(values, size, radix);
	}
	-(uint32_t)getData_17: (float32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_17_: (float32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_18: (float64_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_18_: (float64_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
@end

// Tellusim::Xml
@implementation TSXml
	-(id)init {
		self = [super init];
		impl = new Tellusim::Xml();
		return self;
	}
	-(id)init_1: (const char*)name {
		self = [super init];
		impl = new Tellusim::Xml(name);
		return self;
	}
	-(id)init_1_: (const char*)name {
		self = [super init];
		impl = new Tellusim::Xml(name);
		return self;
	}
	-(id)init_2: (const char*)name attributes: (const char*)attributes {
		self = [super init];
		impl = new Tellusim::Xml(name, attributes);
		return self;
	}
	-(id)init_2_: (const char*)name attributes: (const char*)attributes {
		self = [super init];
		impl = new Tellusim::Xml(name, attributes);
		return self;
	}
	-(id)init_3: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::Xml((name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_3_: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::Xml((name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4: (const TSString*)name attributes: (const char*)attributes {
		self = [super init];
		impl = new Tellusim::Xml((name) ? [name ref] : Tellusim::String::null, attributes);
		return self;
	}
	-(id)init_4_: (const TSString*)name attributes: (const char*)attributes {
		self = [super init];
		impl = new Tellusim::Xml((name) ? [name ref] : Tellusim::String::null, attributes);
		return self;
	}
	-(id)init_5: (TSXml*)parent name: (const char*)name {
		self = [super init];
		impl = new Tellusim::Xml([parent pointer], name);
		return self;
	}
	-(id)init_5_: (TSXml*)parent name: (const char*)name {
		self = [super init];
		impl = new Tellusim::Xml([parent pointer], name);
		return self;
	}
	-(id)init_6: (TSXml*)parent name: (const char*)name attributes: (const char*)attributes {
		self = [super init];
		impl = new Tellusim::Xml([parent pointer], name, attributes);
		return self;
	}
	-(id)init_6_: (TSXml*)parent name: (const char*)name attributes: (const char*)attributes {
		self = [super init];
		impl = new Tellusim::Xml([parent pointer], name, attributes);
		return self;
	}
	-(id)init_7: (TSXml*)parent name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::Xml([parent pointer], (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_7_: (TSXml*)parent name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::Xml([parent pointer], (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_8: (TSXml*)parent name: (const TSString*)name attributes: (const char*)attributes {
		self = [super init];
		impl = new Tellusim::Xml([parent pointer], (name) ? [name ref] : Tellusim::String::null, attributes);
		return self;
	}
	-(id)init_8_: (TSXml*)parent name: (const TSString*)name attributes: (const char*)attributes {
		self = [super init];
		impl = new Tellusim::Xml([parent pointer], (name) ? [name ref] : Tellusim::String::null, attributes);
		return self;
	}
	-(id)init_ptr: (Tellusim::Xml*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Xml&)ref {
		self = [super init];
		impl = new Tellusim::Xml((Tellusim::Xml&)ref);
		return self;
	}
	-(Tellusim::Xml*)pointer {
		return (Tellusim::Xml*)impl;
	}
	-(Tellusim::Xml&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Xml*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Xml*)impl;
	}
	-(BOOL)equalPtr: (const TSXml*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSXml*)copyPtr {
		return [[TSXml alloc] init_ref:[self ref]];
	}
	-(TSXml*)clonePtr {
		return [[TSXml alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSXml*)null {
		return [[TSXml alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)create: (const char*)str {
		return [self ref].create(str);
	}
	-(BOOL)create_: (const char*)str {
		return [self ref].create(str);
	}
	-(BOOL)create_1: (const char*)str size: (size_t)size {
		return [self ref].create(str, size);
	}
	-(BOOL)create_1_: (const char*)str size: (size_t)size {
		return [self ref].create(str, size);
	}
	-(BOOL)create_2: (const char*)str size: (size_t)size owner: (BOOL)owner {
		return [self ref].create(str, size, (bool)owner);
	}
	-(BOOL)create_2_: (const char*)str size: (size_t)size owner: (BOOL)owner {
		return [self ref].create(str, size, (bool)owner);
	}
	-(BOOL)create_3: (const TSString*)str {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null);
	}
	-(BOOL)create_3_: (const TSString*)str {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null);
	}
	-(BOOL)create_4: (const TSString*)str size: (size_t)size {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null, size);
	}
	-(BOOL)create_4_: (const TSString*)str size: (size_t)size {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null, size);
	}
	-(BOOL)create_5: (const TSString*)str size: (size_t)size owner: (BOOL)owner {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null, size, (bool)owner);
	}
	-(BOOL)create_5_: (const TSString*)str size: (size_t)size owner: (BOOL)owner {
		return [self ref].create((str) ? [str ref] : Tellusim::String::null, size, (bool)owner);
	}
	-(BOOL)load: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_1: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)load_1_: (const TSString*)name {
		return [self ref].load((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)load_2: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)load_2_: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)save: (const char*)name {
		return [self ref].save(name);
	}
	-(BOOL)save_: (const char*)name {
		return [self ref].save(name);
	}
	-(BOOL)save_1: (const char*)name compact: (BOOL)compact {
		return [self ref].save(name, (bool)compact);
	}
	-(BOOL)save_1_: (const char*)name compact: (BOOL)compact {
		return [self ref].save(name, (bool)compact);
	}
	-(BOOL)save_2: (const TSString*)name {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)save_2_: (const TSString*)name {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)save_3: (const TSString*)name compact: (BOOL)compact {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (bool)compact);
	}
	-(BOOL)save_3_: (const TSString*)name compact: (BOOL)compact {
		return [self ref].save((name) ? [name ref] : Tellusim::String::null, (bool)compact);
	}
	-(BOOL)save_4: (TSStream*)stream {
		return [self ref].save([stream ref]);
	}
	-(BOOL)save_4_: (TSStream*)stream {
		return [self ref].save([stream ref]);
	}
	-(BOOL)save_5: (TSStream*)stream compact: (BOOL)compact {
		return [self ref].save([stream ref], (bool)compact);
	}
	-(BOOL)save_5_: (TSStream*)stream compact: (BOOL)compact {
		return [self ref].save([stream ref], (bool)compact);
	}
	-(const TSXml*)getRoot {
		return [[TSXml alloc] init_ref:([self ref].getRoot())];
	}
	-(uint32_t)setParent: (TSXml*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(uint32_t)setParent_: (TSXml*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(uint32_t)setParent_1: (TSXml*)parent check: (BOOL)check {
		return [self ref].setParent([parent ref], (bool)check);
	}
	-(uint32_t)setParent_1_: (TSXml*)parent check: (BOOL)check {
		return [self ref].setParent([parent ref], (bool)check);
	}
	-(const TSXml*)getParent {
		return [[TSXml alloc] init_ref:([self ref].getParent())];
	}
	-(TSXml*)addChild: (const char*)name {
		return [[TSXml alloc] init_ref:([self ref].addChild(name))];
	}
	-(TSXml*)addChild_: (const char*)name {
		return [[TSXml alloc] init_ref:([self ref].addChild(name))];
	}
	-(TSXml*)addChild_1: (const char*)name check: (BOOL)check {
		return [[TSXml alloc] init_ref:([self ref].addChild(name, (bool)check))];
	}
	-(TSXml*)addChild_1_: (const char*)name check: (BOOL)check {
		return [[TSXml alloc] init_ref:([self ref].addChild(name, (bool)check))];
	}
	-(uint32_t)addChild_2: (TSXml*)child {
		return [self ref].addChild([child ref]);
	}
	-(uint32_t)addChild_2_: (TSXml*)child {
		return [self ref].addChild([child ref]);
	}
	-(uint32_t)addChild_3: (TSXml*)child check: (BOOL)check {
		return [self ref].addChild([child ref], (bool)check);
	}
	-(uint32_t)addChild_3_: (TSXml*)child check: (BOOL)check {
		return [self ref].addChild([child ref], (bool)check);
	}
	-(BOOL)removeChild: (TSXml*)child {
		return [self ref].removeChild([child ref]);
	}
	-(BOOL)removeChild_: (TSXml*)child {
		return [self ref].removeChild([child ref]);
	}
	-(void)releaseChildren {
		[self ref].releaseChildren();
	}
	-(uint32_t)findChild: (const char*)name {
		return [self ref].findChild(name);
	}
	-(uint32_t)findChild_: (const char*)name {
		return [self ref].findChild(name);
	}
	-(BOOL)isChild: (const char*)name {
		return [self ref].isChild(name);
	}
	-(BOOL)isChild_: (const char*)name {
		return [self ref].isChild(name);
	}
	-(const TSXml*)getChild: (const char*)name {
		return [[TSXml alloc] init_ref:([self ref].getChild(name))];
	}
	-(const TSXml*)getChild_: (const char*)name {
		return [[TSXml alloc] init_ref:([self ref].getChild(name))];
	}
	-(uint32_t)getNumChildren {
		return [self ref].getNumChildren();
	}
	-(NSArray<TSXml*>*)getChildren {
		const auto &ret = [self ref].getChildren();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSXml alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSXml*)getChild_1: (uint32_t)index {
		return [[TSXml alloc] init_ref:([self ref].getChild(index))];
	}
	-(const TSXml*)getChild_1_: (uint32_t)index {
		return [[TSXml alloc] init_ref:([self ref].getChild(index))];
	}
	-(NSString*)getPathName {
		return [NSString stringWithUTF8String:[self ref].getPathName().get()];
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_1: (const TSString*)name {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setName_1_: (const TSString*)name {
		[self ref].setName((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(void)setData: (BOOL)value {
		[self ref].setData((bool)value);
	}
	-(void)setData_: (BOOL)value {
		[self ref].setData((bool)value);
	}
	-(void)setData_1: (const char*)value {
		[self ref].setData(value);
	}
	-(void)setData_1_: (const char*)value {
		[self ref].setData(value);
	}
	-(void)setData_2: (const TSString*)value {
		[self ref].setData((value) ? [value ref] : Tellusim::String::null);
	}
	-(void)setData_2_: (const TSString*)value {
		[self ref].setData((value) ? [value ref] : Tellusim::String::null);
	}
	-(void)setData_3: (int32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_3_: (int32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_4: (int32_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_4_: (int32_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_5: (uint32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_5_: (uint32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_6: (uint32_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_6_: (uint32_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_7: (uint64_t)value {
		[self ref].setData(value);
	}
	-(void)setData_7_: (uint64_t)value {
		[self ref].setData(value);
	}
	-(void)setData_8: (uint64_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_8_: (uint64_t)value radix: (uint32_t)radix {
		[self ref].setData(value, radix);
	}
	-(void)setData_9: (float32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_9_: (float32_t)value {
		[self ref].setData(value);
	}
	-(void)setData_10: (float32_t)value digits: (uint32_t)digits {
		[self ref].setData(value, digits);
	}
	-(void)setData_10_: (float32_t)value digits: (uint32_t)digits {
		[self ref].setData(value, digits);
	}
	-(void)setData_11: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(value, digits, (bool)compact);
	}
	-(void)setData_11_: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(value, digits, (bool)compact);
	}
	-(void)setData_12: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_12_: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_13: (float64_t)value {
		[self ref].setData(value);
	}
	-(void)setData_13_: (float64_t)value {
		[self ref].setData(value);
	}
	-(void)setData_14: (float64_t)value digits: (uint32_t)digits {
		[self ref].setData(value, digits);
	}
	-(void)setData_14_: (float64_t)value digits: (uint32_t)digits {
		[self ref].setData(value, digits);
	}
	-(void)setData_15: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(value, digits, (bool)compact);
	}
	-(void)setData_15_: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(value, digits, (bool)compact);
	}
	-(void)setData_16: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_16_: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(value, digits, (bool)compact, (bool)exponent);
	}
	-(NSString*)getData {
		return [NSString stringWithUTF8String:[self ref].getData().get()];
	}
	-(BOOL)getDataBool {
		return [self ref].getDataBool();
	}
	-(int32_t)getDatai32 {
		return [self ref].getDatai32();
	}
	-(int32_t)getDatai32_1: (uint32_t)radix {
		return [self ref].getDatai32(radix);
	}
	-(int32_t)getDatai32_1_: (uint32_t)radix {
		return [self ref].getDatai32(radix);
	}
	-(uint32_t)getDatau32 {
		return [self ref].getDatau32();
	}
	-(uint32_t)getDatau32_1: (uint32_t)radix {
		return [self ref].getDatau32(radix);
	}
	-(uint32_t)getDatau32_1_: (uint32_t)radix {
		return [self ref].getDatau32(radix);
	}
	-(uint64_t)getDatau64 {
		return [self ref].getDatau64();
	}
	-(uint64_t)getDatau64_1: (uint32_t)radix {
		return [self ref].getDatau64(radix);
	}
	-(uint64_t)getDatau64_1_: (uint32_t)radix {
		return [self ref].getDatau64(radix);
	}
	-(float32_t)getDataf32 {
		return [self ref].getDataf32();
	}
	-(float64_t)getDataf64 {
		return [self ref].getDataf64();
	}
	-(NSString*)getData_1: (const char*)name {
		return [NSString stringWithUTF8String:[self ref].getData(name).get()];
	}
	-(NSString*)getData_1_: (const char*)name {
		return [NSString stringWithUTF8String:[self ref].getData(name).get()];
	}
	-(NSString*)getData_2: (const char*)name value: (const TSString*)value {
		return [NSString stringWithUTF8String:[self ref].getData(name, (value) ? [value ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getData_2_: (const char*)name value: (const TSString*)value {
		return [NSString stringWithUTF8String:[self ref].getData(name, (value) ? [value ref] : Tellusim::String::null).get()];
	}
	-(BOOL)getData_3: (const char*)name value: (BOOL)value {
		return [self ref].getData(name, (bool)value);
	}
	-(BOOL)getData_3_: (const char*)name value: (BOOL)value {
		return [self ref].getData(name, (bool)value);
	}
	-(int32_t)getData_4: (const char*)name value: (int32_t)value {
		return [self ref].getData(name, value);
	}
	-(int32_t)getData_4_: (const char*)name value: (int32_t)value {
		return [self ref].getData(name, value);
	}
	-(int32_t)getData_5: (const char*)name value: (int32_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(int32_t)getData_5_: (const char*)name value: (int32_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(uint32_t)getData_6: (const char*)name value: (uint32_t)value {
		return [self ref].getData(name, value);
	}
	-(uint32_t)getData_6_: (const char*)name value: (uint32_t)value {
		return [self ref].getData(name, value);
	}
	-(uint32_t)getData_7: (const char*)name value: (uint32_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(uint32_t)getData_7_: (const char*)name value: (uint32_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(uint64_t)getData_8: (const char*)name value: (uint64_t)value {
		return [self ref].getData(name, value);
	}
	-(uint64_t)getData_8_: (const char*)name value: (uint64_t)value {
		return [self ref].getData(name, value);
	}
	-(uint64_t)getData_9: (const char*)name value: (uint64_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(uint64_t)getData_9_: (const char*)name value: (uint64_t)value radix: (uint32_t)radix {
		return [self ref].getData(name, value, radix);
	}
	-(float32_t)getData_10: (const char*)name value: (float32_t)value {
		return [self ref].getData(name, value);
	}
	-(float32_t)getData_10_: (const char*)name value: (float32_t)value {
		return [self ref].getData(name, value);
	}
	-(float64_t)getData_11: (const char*)name value: (float64_t)value {
		return [self ref].getData(name, value);
	}
	-(float64_t)getData_11_: (const char*)name value: (float64_t)value {
		return [self ref].getData(name, value);
	}
	-(void)setData_17: (const char**)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_17_: (const char**)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_18: (const char**)values size: (uint32_t)size wrap: (uint32_t)wrap {
		[self ref].setData(values, size, wrap);
	}
	-(void)setData_18_: (const char**)values size: (uint32_t)size wrap: (uint32_t)wrap {
		[self ref].setData(values, size, wrap);
	}
	-(void)setData_19: (const TSString**)values size: (uint32_t)size {
		[self ref].setData((values) ? [*values pointer] : nullptr, size);
	}
	-(void)setData_19_: (const TSString**)values size: (uint32_t)size {
		[self ref].setData((values) ? [*values pointer] : nullptr, size);
	}
	-(void)setData_20: (const TSString**)values size: (uint32_t)size wrap: (uint32_t)wrap {
		[self ref].setData((values) ? [*values pointer] : nullptr, size, wrap);
	}
	-(void)setData_20_: (const TSString**)values size: (uint32_t)size wrap: (uint32_t)wrap {
		[self ref].setData((values) ? [*values pointer] : nullptr, size, wrap);
	}
	-(void)setData_21: (const int32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_21_: (const int32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_22: (const int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setData(values, size, radix);
	}
	-(void)setData_22_: (const int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setData(values, size, radix);
	}
	-(void)setData_23: (const int32_t*)values size: (uint32_t)size radix: (uint32_t)radix wrap: (uint32_t)wrap {
		[self ref].setData(values, size, radix, wrap);
	}
	-(void)setData_23_: (const int32_t*)values size: (uint32_t)size radix: (uint32_t)radix wrap: (uint32_t)wrap {
		[self ref].setData(values, size, radix, wrap);
	}
	-(void)setData_24: (const uint32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_24_: (const uint32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_25: (const uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setData(values, size, radix);
	}
	-(void)setData_25_: (const uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setData(values, size, radix);
	}
	-(void)setData_26: (const uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix wrap: (uint32_t)wrap {
		[self ref].setData(values, size, radix, wrap);
	}
	-(void)setData_26_: (const uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix wrap: (uint32_t)wrap {
		[self ref].setData(values, size, radix, wrap);
	}
	-(void)setData_27: (const float32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_27_: (const float32_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_28: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setData(values, size, digits);
	}
	-(void)setData_28_: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setData(values, size, digits);
	}
	-(void)setData_29: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(values, size, digits, (bool)compact);
	}
	-(void)setData_29_: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(values, size, digits, (bool)compact);
	}
	-(void)setData_30: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_30_: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_31: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent wrap: (uint32_t)wrap {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent, wrap);
	}
	-(void)setData_31_: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent wrap: (uint32_t)wrap {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent, wrap);
	}
	-(void)setData_32: (const float64_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_32_: (const float64_t*)values size: (uint32_t)size {
		[self ref].setData(values, size);
	}
	-(void)setData_33: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setData(values, size, digits);
	}
	-(void)setData_33_: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setData(values, size, digits);
	}
	-(void)setData_34: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(values, size, digits, (bool)compact);
	}
	-(void)setData_34_: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setData(values, size, digits, (bool)compact);
	}
	-(void)setData_35: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_35_: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setData_36: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent wrap: (uint32_t)wrap {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent, wrap);
	}
	-(void)setData_36_: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent wrap: (uint32_t)wrap {
		[self ref].setData(values, size, digits, (bool)compact, (bool)exponent, wrap);
	}
	-(uint32_t)getData_12: (TSString**)values size: (uint32_t)size {
		return [self ref].getData((values) ? [*values pointer] : nullptr, size);
	}
	-(uint32_t)getData_12_: (TSString**)values size: (uint32_t)size {
		return [self ref].getData((values) ? [*values pointer] : nullptr, size);
	}
	-(uint32_t)getData_13: (int32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_13_: (int32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_14: (int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getData(values, size, radix);
	}
	-(uint32_t)getData_14_: (int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getData(values, size, radix);
	}
	-(uint32_t)getData_15: (uint32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_15_: (uint32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_16: (uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getData(values, size, radix);
	}
	-(uint32_t)getData_16_: (uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getData(values, size, radix);
	}
	-(uint32_t)getData_17: (float32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_17_: (float32_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_18: (float64_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)getData_18_: (float64_t*)values size: (uint32_t)size {
		return [self ref].getData(values, size);
	}
	-(uint32_t)addAttribute: (const char*)name {
		return [self ref].addAttribute(name);
	}
	-(uint32_t)addAttribute_: (const char*)name {
		return [self ref].addAttribute(name);
	}
	-(BOOL)removeAttribute: (const char*)name {
		return [self ref].removeAttribute(name);
	}
	-(BOOL)removeAttribute_: (const char*)name {
		return [self ref].removeAttribute(name);
	}
	-(uint32_t)findAttribute: (const char*)name {
		return [self ref].findAttribute(name);
	}
	-(uint32_t)findAttribute_: (const char*)name {
		return [self ref].findAttribute(name);
	}
	-(BOOL)isAttribute: (const char*)name {
		return [self ref].isAttribute(name);
	}
	-(BOOL)isAttribute_: (const char*)name {
		return [self ref].isAttribute(name);
	}
	-(void)removeAttributes {
		[self ref].removeAttributes();
	}
	-(uint32_t)getNumAttributes {
		return [self ref].getNumAttributes();
	}
	-(NSString*)getAttributeName: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getAttributeName(index).get()];
	}
	-(NSString*)getAttributeName_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getAttributeName(index).get()];
	}
	-(BOOL)setAttributes: (const char*)str {
		return [self ref].setAttributes(str);
	}
	-(BOOL)setAttributes_: (const char*)str {
		return [self ref].setAttributes(str);
	}
	-(void)setAttribute: (uint32_t)index value: (BOOL)value {
		[self ref].setAttribute(index, (bool)value);
	}
	-(void)setAttribute_: (uint32_t)index value: (BOOL)value {
		[self ref].setAttribute(index, (bool)value);
	}
	-(void)setAttribute_1: (uint32_t)index value: (const char*)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_1_: (uint32_t)index value: (const char*)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_2: (uint32_t)index value: (const TSString*)value {
		[self ref].setAttribute(index, (value) ? [value ref] : Tellusim::String::null);
	}
	-(void)setAttribute_2_: (uint32_t)index value: (const TSString*)value {
		[self ref].setAttribute(index, (value) ? [value ref] : Tellusim::String::null);
	}
	-(void)setAttribute_3: (uint32_t)index value: (int32_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_3_: (uint32_t)index value: (int32_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_4: (uint32_t)index value: (int32_t)value radix: (uint32_t)radix {
		[self ref].setAttribute(index, value, radix);
	}
	-(void)setAttribute_4_: (uint32_t)index value: (int32_t)value radix: (uint32_t)radix {
		[self ref].setAttribute(index, value, radix);
	}
	-(void)setAttribute_5: (uint32_t)index value: (uint32_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_5_: (uint32_t)index value: (uint32_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_6: (uint32_t)index value: (uint32_t)value radix: (uint32_t)radix {
		[self ref].setAttribute(index, value, radix);
	}
	-(void)setAttribute_6_: (uint32_t)index value: (uint32_t)value radix: (uint32_t)radix {
		[self ref].setAttribute(index, value, radix);
	}
	-(void)setAttribute_7: (uint32_t)index value: (uint64_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_7_: (uint32_t)index value: (uint64_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_8: (uint32_t)index value: (uint64_t)value radix: (uint32_t)radix {
		[self ref].setAttribute(index, value, radix);
	}
	-(void)setAttribute_8_: (uint32_t)index value: (uint64_t)value radix: (uint32_t)radix {
		[self ref].setAttribute(index, value, radix);
	}
	-(void)setAttribute_9: (uint32_t)index value: (float32_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_9_: (uint32_t)index value: (float32_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_10: (uint32_t)index value: (float32_t)value digits: (uint32_t)digits {
		[self ref].setAttribute(index, value, digits);
	}
	-(void)setAttribute_10_: (uint32_t)index value: (float32_t)value digits: (uint32_t)digits {
		[self ref].setAttribute(index, value, digits);
	}
	-(void)setAttribute_11: (uint32_t)index value: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setAttribute(index, value, digits, (bool)compact);
	}
	-(void)setAttribute_11_: (uint32_t)index value: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setAttribute(index, value, digits, (bool)compact);
	}
	-(void)setAttribute_12: (uint32_t)index value: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setAttribute(index, value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setAttribute_12_: (uint32_t)index value: (float32_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setAttribute(index, value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setAttribute_13: (uint32_t)index value: (float64_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_13_: (uint32_t)index value: (float64_t)value {
		[self ref].setAttribute(index, value);
	}
	-(void)setAttribute_14: (uint32_t)index value: (float64_t)value digits: (uint32_t)digits {
		[self ref].setAttribute(index, value, digits);
	}
	-(void)setAttribute_14_: (uint32_t)index value: (float64_t)value digits: (uint32_t)digits {
		[self ref].setAttribute(index, value, digits);
	}
	-(void)setAttribute_15: (uint32_t)index value: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setAttribute(index, value, digits, (bool)compact);
	}
	-(void)setAttribute_15_: (uint32_t)index value: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setAttribute(index, value, digits, (bool)compact);
	}
	-(void)setAttribute_16: (uint32_t)index value: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setAttribute(index, value, digits, (bool)compact, (bool)exponent);
	}
	-(void)setAttribute_16_: (uint32_t)index value: (float64_t)value digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setAttribute(index, value, digits, (bool)compact, (bool)exponent);
	}
	-(NSString*)getAttribute: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getAttribute(index).get()];
	}
	-(NSString*)getAttribute_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getAttribute(index).get()];
	}
	-(int32_t)getAttributei32: (uint32_t)index {
		return [self ref].getAttributei32(index);
	}
	-(int32_t)getAttributei32_: (uint32_t)index {
		return [self ref].getAttributei32(index);
	}
	-(int32_t)getAttributei32_1: (uint32_t)index radix: (uint32_t)radix {
		return [self ref].getAttributei32(index, radix);
	}
	-(int32_t)getAttributei32_1_: (uint32_t)index radix: (uint32_t)radix {
		return [self ref].getAttributei32(index, radix);
	}
	-(uint32_t)getAttributeu32: (uint32_t)index {
		return [self ref].getAttributeu32(index);
	}
	-(uint32_t)getAttributeu32_: (uint32_t)index {
		return [self ref].getAttributeu32(index);
	}
	-(uint32_t)getAttributeu32_1: (uint32_t)index radix: (uint32_t)radix {
		return [self ref].getAttributeu32(index, radix);
	}
	-(uint32_t)getAttributeu32_1_: (uint32_t)index radix: (uint32_t)radix {
		return [self ref].getAttributeu32(index, radix);
	}
	-(uint64_t)getAttributeu64: (uint32_t)index {
		return [self ref].getAttributeu64(index);
	}
	-(uint64_t)getAttributeu64_: (uint32_t)index {
		return [self ref].getAttributeu64(index);
	}
	-(uint64_t)getAttributeu64_1: (uint32_t)index radix: (uint32_t)radix {
		return [self ref].getAttributeu64(index, radix);
	}
	-(uint64_t)getAttributeu64_1_: (uint32_t)index radix: (uint32_t)radix {
		return [self ref].getAttributeu64(index, radix);
	}
	-(float32_t)getAttributef32: (uint32_t)index {
		return [self ref].getAttributef32(index);
	}
	-(float32_t)getAttributef32_: (uint32_t)index {
		return [self ref].getAttributef32(index);
	}
	-(float64_t)getAttributef64: (uint32_t)index {
		return [self ref].getAttributef64(index);
	}
	-(float64_t)getAttributef64_: (uint32_t)index {
		return [self ref].getAttributef64(index);
	}
	-(NSString*)getAttribute_1: (const char*)name {
		return [NSString stringWithUTF8String:[self ref].getAttribute(name).get()];
	}
	-(NSString*)getAttribute_1_: (const char*)name {
		return [NSString stringWithUTF8String:[self ref].getAttribute(name).get()];
	}
	-(NSString*)getAttribute_2: (const char*)name value: (const TSString*)value {
		return [NSString stringWithUTF8String:[self ref].getAttribute(name, (value) ? [value ref] : Tellusim::String::null).get()];
	}
	-(NSString*)getAttribute_2_: (const char*)name value: (const TSString*)value {
		return [NSString stringWithUTF8String:[self ref].getAttribute(name, (value) ? [value ref] : Tellusim::String::null).get()];
	}
	-(BOOL)getAttribute_3: (const char*)name value: (BOOL)value {
		return [self ref].getAttribute(name, (bool)value);
	}
	-(BOOL)getAttribute_3_: (const char*)name value: (BOOL)value {
		return [self ref].getAttribute(name, (bool)value);
	}
	-(int32_t)getAttribute_4: (const char*)name value: (int32_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(int32_t)getAttribute_4_: (const char*)name value: (int32_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(int32_t)getAttribute_5: (const char*)name value: (int32_t)value radix: (uint32_t)radix {
		return [self ref].getAttribute(name, value, radix);
	}
	-(int32_t)getAttribute_5_: (const char*)name value: (int32_t)value radix: (uint32_t)radix {
		return [self ref].getAttribute(name, value, radix);
	}
	-(uint32_t)getAttribute_6: (const char*)name value: (uint32_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(uint32_t)getAttribute_6_: (const char*)name value: (uint32_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(uint32_t)getAttribute_7: (const char*)name value: (uint32_t)value radix: (uint32_t)radix {
		return [self ref].getAttribute(name, value, radix);
	}
	-(uint32_t)getAttribute_7_: (const char*)name value: (uint32_t)value radix: (uint32_t)radix {
		return [self ref].getAttribute(name, value, radix);
	}
	-(uint64_t)getAttribute_8: (const char*)name value: (uint64_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(uint64_t)getAttribute_8_: (const char*)name value: (uint64_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(uint64_t)getAttribute_9: (const char*)name value: (uint64_t)value radix: (uint32_t)radix {
		return [self ref].getAttribute(name, value, radix);
	}
	-(uint64_t)getAttribute_9_: (const char*)name value: (uint64_t)value radix: (uint32_t)radix {
		return [self ref].getAttribute(name, value, radix);
	}
	-(float32_t)getAttribute_10: (const char*)name value: (float32_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(float32_t)getAttribute_10_: (const char*)name value: (float32_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(float64_t)getAttribute_11: (const char*)name value: (float64_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(float64_t)getAttribute_11_: (const char*)name value: (float64_t)value {
		return [self ref].getAttribute(name, value);
	}
	-(void)setAttribute_17: (uint32_t)index values: (const char**)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_17_: (uint32_t)index values: (const char**)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_18: (uint32_t)index values: (const char**)values size: (uint32_t)size delimiter: (const char*)delimiter {
		[self ref].setAttribute(index, values, size, delimiter);
	}
	-(void)setAttribute_18_: (uint32_t)index values: (const char**)values size: (uint32_t)size delimiter: (const char*)delimiter {
		[self ref].setAttribute(index, values, size, delimiter);
	}
	-(void)setAttribute_19: (uint32_t)index values: (const TSString**)values size: (uint32_t)size {
		[self ref].setAttribute(index, (values) ? [*values pointer] : nullptr, size);
	}
	-(void)setAttribute_19_: (uint32_t)index values: (const TSString**)values size: (uint32_t)size {
		[self ref].setAttribute(index, (values) ? [*values pointer] : nullptr, size);
	}
	-(void)setAttribute_20: (uint32_t)index values: (const TSString**)values size: (uint32_t)size delimiter: (const char*)delimiter {
		[self ref].setAttribute(index, (values) ? [*values pointer] : nullptr, size, delimiter);
	}
	-(void)setAttribute_20_: (uint32_t)index values: (const TSString**)values size: (uint32_t)size delimiter: (const char*)delimiter {
		[self ref].setAttribute(index, (values) ? [*values pointer] : nullptr, size, delimiter);
	}
	-(void)setAttribute_21: (uint32_t)index values: (const int32_t*)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_21_: (uint32_t)index values: (const int32_t*)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_22: (uint32_t)index values: (const int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setAttribute(index, values, size, radix);
	}
	-(void)setAttribute_22_: (uint32_t)index values: (const int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setAttribute(index, values, size, radix);
	}
	-(void)setAttribute_23: (uint32_t)index values: (const uint32_t*)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_23_: (uint32_t)index values: (const uint32_t*)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_24: (uint32_t)index values: (const uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setAttribute(index, values, size, radix);
	}
	-(void)setAttribute_24_: (uint32_t)index values: (const uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		[self ref].setAttribute(index, values, size, radix);
	}
	-(void)setAttribute_25: (uint32_t)index values: (const float32_t*)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_25_: (uint32_t)index values: (const float32_t*)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_26: (uint32_t)index values: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setAttribute(index, values, size, digits);
	}
	-(void)setAttribute_26_: (uint32_t)index values: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setAttribute(index, values, size, digits);
	}
	-(void)setAttribute_27: (uint32_t)index values: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setAttribute(index, values, size, digits, (bool)compact);
	}
	-(void)setAttribute_27_: (uint32_t)index values: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setAttribute(index, values, size, digits, (bool)compact);
	}
	-(void)setAttribute_28: (uint32_t)index values: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setAttribute(index, values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setAttribute_28_: (uint32_t)index values: (const float32_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setAttribute(index, values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setAttribute_29: (uint32_t)index values: (const float64_t*)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_29_: (uint32_t)index values: (const float64_t*)values size: (uint32_t)size {
		[self ref].setAttribute(index, values, size);
	}
	-(void)setAttribute_30: (uint32_t)index values: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setAttribute(index, values, size, digits);
	}
	-(void)setAttribute_30_: (uint32_t)index values: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits {
		[self ref].setAttribute(index, values, size, digits);
	}
	-(void)setAttribute_31: (uint32_t)index values: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setAttribute(index, values, size, digits, (bool)compact);
	}
	-(void)setAttribute_31_: (uint32_t)index values: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact {
		[self ref].setAttribute(index, values, size, digits, (bool)compact);
	}
	-(void)setAttribute_32: (uint32_t)index values: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setAttribute(index, values, size, digits, (bool)compact, (bool)exponent);
	}
	-(void)setAttribute_32_: (uint32_t)index values: (const float64_t*)values size: (uint32_t)size digits: (uint32_t)digits compact: (BOOL)compact exponent: (BOOL)exponent {
		[self ref].setAttribute(index, values, size, digits, (bool)compact, (bool)exponent);
	}
	-(uint32_t)getAttribute_12: (uint32_t)index values: (TSString**)values size: (uint32_t)size {
		return [self ref].getAttribute(index, (values) ? [*values pointer] : nullptr, size);
	}
	-(uint32_t)getAttribute_12_: (uint32_t)index values: (TSString**)values size: (uint32_t)size {
		return [self ref].getAttribute(index, (values) ? [*values pointer] : nullptr, size);
	}
	-(uint32_t)getAttribute_13: (uint32_t)index values: (TSString**)values size: (uint32_t)size delimiter: (const char*)delimiter {
		return [self ref].getAttribute(index, (values) ? [*values pointer] : nullptr, size, delimiter);
	}
	-(uint32_t)getAttribute_13_: (uint32_t)index values: (TSString**)values size: (uint32_t)size delimiter: (const char*)delimiter {
		return [self ref].getAttribute(index, (values) ? [*values pointer] : nullptr, size, delimiter);
	}
	-(uint32_t)getAttribute_14: (uint32_t)index values: (int32_t*)values size: (uint32_t)size {
		return [self ref].getAttribute(index, values, size);
	}
	-(uint32_t)getAttribute_14_: (uint32_t)index values: (int32_t*)values size: (uint32_t)size {
		return [self ref].getAttribute(index, values, size);
	}
	-(uint32_t)getAttribute_15: (uint32_t)index values: (int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getAttribute(index, values, size, radix);
	}
	-(uint32_t)getAttribute_15_: (uint32_t)index values: (int32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getAttribute(index, values, size, radix);
	}
	-(uint32_t)getAttribute_16: (uint32_t)index values: (uint32_t*)values size: (uint32_t)size {
		return [self ref].getAttribute(index, values, size);
	}
	-(uint32_t)getAttribute_16_: (uint32_t)index values: (uint32_t*)values size: (uint32_t)size {
		return [self ref].getAttribute(index, values, size);
	}
	-(uint32_t)getAttribute_17: (uint32_t)index values: (uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getAttribute(index, values, size, radix);
	}
	-(uint32_t)getAttribute_17_: (uint32_t)index values: (uint32_t*)values size: (uint32_t)size radix: (uint32_t)radix {
		return [self ref].getAttribute(index, values, size, radix);
	}
	-(uint32_t)getAttribute_18: (uint32_t)index values: (float32_t*)values size: (uint32_t)size {
		return [self ref].getAttribute(index, values, size);
	}
	-(uint32_t)getAttribute_18_: (uint32_t)index values: (float32_t*)values size: (uint32_t)size {
		return [self ref].getAttribute(index, values, size);
	}
	-(uint32_t)getAttribute_19: (uint32_t)index values: (float64_t*)values size: (uint32_t)size {
		return [self ref].getAttribute(index, values, size);
	}
	-(uint32_t)getAttribute_19_: (uint32_t)index values: (float64_t*)values size: (uint32_t)size {
		return [self ref].getAttribute(index, values, size);
	}
@end

// Tellusim::Buffer
@implementation TSBuffer
	-(id)init {
		self = [super init];
		impl = new Tellusim::Buffer();
		return self;
	}
	-(id)init_ptr: (Tellusim::Buffer*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Buffer&)ref {
		self = [super init];
		impl = new Tellusim::Buffer((Tellusim::Buffer&)ref);
		return self;
	}
	-(Tellusim::Buffer*)pointer {
		return (Tellusim::Buffer*)impl;
	}
	-(Tellusim::Buffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Buffer*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Buffer*)impl;
	}
	-(BOOL)equalPtr: (const TSBuffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSBuffer*)copyPtr {
		return [[TSBuffer alloc] init_ref:[self ref]];
	}
	-(TSBuffer*)clonePtr {
		return [[TSBuffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSBuffer*)null {
		return [[TSBuffer alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(BOOL)create: (TS_BufferFlags)flags size: (size_t)size {
		return [self ref].create((Tellusim::Buffer::Flags)flags, size);
	}
	-(BOOL)create_: (TS_BufferFlags)flags size: (size_t)size {
		return [self ref].create((Tellusim::Buffer::Flags)flags, size);
	}
	-(BOOL)create_1: (TS_BufferFlags)flags size: (size_t)size format: (TS_Format)format {
		return [self ref].create((Tellusim::Buffer::Flags)flags, size, (Tellusim::Format)format);
	}
	-(BOOL)create_1_: (TS_BufferFlags)flags size: (size_t)size format: (TS_Format)format {
		return [self ref].create((Tellusim::Buffer::Flags)flags, size, (Tellusim::Format)format);
	}
	-(BOOL)isMapped {
		return [self ref].isMapped();
	}
	-(TS_BufferFlags)getFlags {
		return (TS_BufferFlags)[self ref].getFlags();
	}
	-(BOOL)hasFlag: (TS_BufferFlags)flags {
		return [self ref].hasFlag((Tellusim::Buffer::Flags)flags);
	}
	-(BOOL)hasFlag_: (TS_BufferFlags)flags {
		return [self ref].hasFlag((Tellusim::Buffer::Flags)flags);
	}
	-(BOOL)hasFlags: (TS_BufferFlags)flags {
		return [self ref].hasFlags((Tellusim::Buffer::Flags)flags);
	}
	-(BOOL)hasFlags_: (TS_BufferFlags)flags {
		return [self ref].hasFlags((Tellusim::Buffer::Flags)flags);
	}
	-(NSString*)getFlagsName {
		return [NSString stringWithUTF8String:[self ref].getFlagsName().get()];
	}
	-(TS_Format)getFormat {
		return (TS_Format)[self ref].getFormat();
	}
	-(NSString*)getFormatName {
		return [NSString stringWithUTF8String:[self ref].getFormatName()];
	}
	-(uint32_t)getComponents {
		return [self ref].getComponents();
	}
	-(uint32_t)getPixelSize {
		return [self ref].getPixelSize();
	}
	-(size_t)getSize {
		return [self ref].getSize();
	}
	-(size_t)getPageSize {
		return [self ref].getPageSize();
	}
	-(NSString*)getDescription {
		return [NSString stringWithUTF8String:[self ref].getDescription().get()];
	}
@end

// Tellusim::BufferTable
@implementation TSBufferTable
	-(id)init {
		self = [super init];
		impl = new Tellusim::BufferTable();
		return self;
	}
	-(id)init_ptr: (Tellusim::BufferTable*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::BufferTable&)ref {
		self = [super init];
		impl = new Tellusim::BufferTable((Tellusim::BufferTable&)ref);
		return self;
	}
	-(Tellusim::BufferTable*)pointer {
		return (Tellusim::BufferTable*)impl;
	}
	-(Tellusim::BufferTable&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::BufferTable*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::BufferTable*)impl;
	}
	-(BOOL)equalPtr: (const TSBufferTable*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSBufferTable*)copyPtr {
		return [[TSBufferTable alloc] init_ref:[self ref]];
	}
	-(TSBufferTable*)clonePtr {
		return [[TSBufferTable alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSBufferTable*)null {
		return [[TSBufferTable alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(BOOL)create: (uint32_t)size {
		return [self ref].create(size);
	}
	-(BOOL)create_: (uint32_t)size {
		return [self ref].create(size);
	}
	-(uint32_t)getSize {
		return [self ref].getSize();
	}
	-(TSBuffer*)get: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].get(index))];
	}
	-(TSBuffer*)get_: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].get(index))];
	}
	-(BOOL)isOwner: (uint32_t)index {
		return [self ref].isOwner(index);
	}
	-(BOOL)isOwner_: (uint32_t)index {
		return [self ref].isOwner(index);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::D3D12Buffer
@implementation TSD3D12Buffer
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Buffer();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Buffer*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Buffer&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Buffer((Tellusim::D3D12Buffer&)ref);
		return self;
	}
	-(Tellusim::D3D12Buffer*)pointer {
		return (Tellusim::D3D12Buffer*)impl;
	}
	-(Tellusim::D3D12Buffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Buffer*)impl;
	}
	-(id)initBuffer: (TSBuffer*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Buffer([base ref]);
		return self;
	}
	-(TSBuffer*)getBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer())];
	}
	-(BOOL)equalPtr: (const TSD3D12Buffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Buffer*)copyPtr {
		return [[TSD3D12Buffer alloc] init_ref:[self ref]];
	}
	-(TSD3D12Buffer*)clonePtr {
		return [[TSD3D12Buffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Buffer*)null {
		return [[TSD3D12Buffer alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (TS_BufferFlags)flags buffer: (ID3D12Resource*)buffer state: (uint32_t)state {
		return [self ref].create((Tellusim::Buffer::Flags)flags, buffer, state);
	}
	-(BOOL)create_2_: (TS_BufferFlags)flags buffer: (ID3D12Resource*)buffer state: (uint32_t)state {
		return [self ref].create((Tellusim::Buffer::Flags)flags, buffer, state);
	}
	-(ID3D12Resource*)getD3D12Buffer {
		return [self ref].getD3D12Buffer();
	}
	-(size_t)getUnorderedAccessView {
		return [self ref].getUnorderedAccessView();
	}
	-(size_t)getShaderResourceView {
		return [self ref].getShaderResourceView();
	}
	-(uint64_t)getBufferAddress {
		return [self ref].getBufferAddress();
	}
	-(void)setBufferState: (uint32_t)state {
		[self ref].setBufferState(state);
	}
	-(void)setBufferState_: (uint32_t)state {
		[self ref].setBufferState(state);
	}
	-(uint32_t)getBufferState {
		return [self ref].getBufferState();
	}
	-(void*)getSharedHandle {
		return [self ref].getSharedHandle();
	}
	-(void*)getInteropHandle {
		return [self ref].getInteropHandle();
	}
@end

// Tellusim::D3D11Buffer
@implementation TSD3D11Buffer
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Buffer();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D11Buffer*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D11Buffer&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Buffer((Tellusim::D3D11Buffer&)ref);
		return self;
	}
	-(Tellusim::D3D11Buffer*)pointer {
		return (Tellusim::D3D11Buffer*)impl;
	}
	-(Tellusim::D3D11Buffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D11Buffer*)impl;
	}
	-(id)initBuffer: (TSBuffer*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Buffer([base ref]);
		return self;
	}
	-(TSBuffer*)getBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer())];
	}
	-(BOOL)equalPtr: (const TSD3D11Buffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D11Buffer*)copyPtr {
		return [[TSD3D11Buffer alloc] init_ref:[self ref]];
	}
	-(TSD3D11Buffer*)clonePtr {
		return [[TSD3D11Buffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D11Buffer*)null {
		return [[TSD3D11Buffer alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (TS_BufferFlags)flags buffer: (ID3D11Buffer*)buffer {
		return [self ref].create((Tellusim::Buffer::Flags)flags, buffer);
	}
	-(BOOL)create_2_: (TS_BufferFlags)flags buffer: (ID3D11Buffer*)buffer {
		return [self ref].create((Tellusim::Buffer::Flags)flags, buffer);
	}
	-(ID3D11Buffer*)getD3D11Buffer {
		return [self ref].getD3D11Buffer();
	}
	-(ID3D11UnorderedAccessView*)getUnorderedAccessView {
		return [self ref].getUnorderedAccessView();
	}
	-(ID3D11ShaderResourceView*)getShaderResourceView {
		return [self ref].getShaderResourceView();
	}
	-(void*)getInteropHandle {
		return [self ref].getInteropHandle();
	}
@end

// Tellusim::MTLBuffer
@implementation TSMTLBuffer
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLBuffer();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLBuffer*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLBuffer&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLBuffer((Tellusim::MTLBuffer&)ref);
		return self;
	}
	-(Tellusim::MTLBuffer*)pointer {
		return (Tellusim::MTLBuffer*)impl;
	}
	-(Tellusim::MTLBuffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLBuffer*)impl;
	}
	-(id)initBuffer: (TSBuffer*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLBuffer([base ref]);
		return self;
	}
	-(TSBuffer*)getBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer())];
	}
	-(BOOL)equalPtr: (const TSMTLBuffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLBuffer*)copyPtr {
		return [[TSMTLBuffer alloc] init_ref:[self ref]];
	}
	-(TSMTLBuffer*)clonePtr {
		return [[TSMTLBuffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLBuffer*)null {
		return [[TSMTLBuffer alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (TS_BufferFlags)flags buffer: (void*)buffer {
		return [self ref].create((Tellusim::Buffer::Flags)flags, buffer);
	}
	-(BOOL)create_2_: (TS_BufferFlags)flags buffer: (void*)buffer {
		return [self ref].create((Tellusim::Buffer::Flags)flags, buffer);
	}
	-(void*)getMTLBuffer {
		return [self ref].getMTLBuffer();
	}
	-(void*)getSharedPtr {
		return [self ref].getSharedPtr();
	}
@end

// Tellusim::VKBuffer
@implementation TSVKBuffer
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKBuffer();
		return self;
	}
	-(id)init_ptr: (Tellusim::VKBuffer*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKBuffer&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKBuffer((Tellusim::VKBuffer&)ref);
		return self;
	}
	-(Tellusim::VKBuffer*)pointer {
		return (Tellusim::VKBuffer*)impl;
	}
	-(Tellusim::VKBuffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKBuffer*)impl;
	}
	-(id)initBuffer: (TSBuffer*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKBuffer([base ref]);
		return self;
	}
	-(TSBuffer*)getBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer())];
	}
	-(BOOL)equalPtr: (const TSVKBuffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKBuffer*)copyPtr {
		return [[TSVKBuffer alloc] init_ref:[self ref]];
	}
	-(TSVKBuffer*)clonePtr {
		return [[TSVKBuffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKBuffer*)null {
		return [[TSVKBuffer alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (TS_BufferFlags)flags size: (size_t)size buffer: (VkBuffer)buffer access: (uint32_t)access {
		return [self ref].create((Tellusim::Buffer::Flags)flags, size, buffer, access);
	}
	-(BOOL)create_2_: (TS_BufferFlags)flags size: (size_t)size buffer: (VkBuffer)buffer access: (uint32_t)access {
		return [self ref].create((Tellusim::Buffer::Flags)flags, size, buffer, access);
	}
	-(VkBuffer)getVKBuffer {
		return [self ref].getVKBuffer();
	}
	-(VkBufferView)getBufferView {
		return [self ref].getBufferView();
	}
	-(uint64_t)getBufferAddress {
		return [self ref].getBufferAddress();
	}
	-(void)setBufferAccess: (uint32_t)access {
		[self ref].setBufferAccess(access);
	}
	-(void)setBufferAccess_: (uint32_t)access {
		[self ref].setBufferAccess(access);
	}
	-(uint32_t)getBufferAccess {
		return [self ref].getBufferAccess();
	}
	-(void*)getSharedPtr {
		return [self ref].getSharedPtr();
	}
	-(void*)getInteropHandle {
		return [self ref].getInteropHandle();
	}
@end

// Tellusim::GLBuffer
@implementation TSGLBuffer
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLBuffer();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLBuffer*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLBuffer&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLBuffer((Tellusim::GLBuffer&)ref);
		return self;
	}
	-(Tellusim::GLBuffer*)pointer {
		return (Tellusim::GLBuffer*)impl;
	}
	-(Tellusim::GLBuffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLBuffer*)impl;
	}
	-(id)initBuffer: (TSBuffer*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLBuffer([base ref]);
		return self;
	}
	-(TSBuffer*)getBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer())];
	}
	-(BOOL)equalPtr: (const TSGLBuffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLBuffer*)copyPtr {
		return [[TSGLBuffer alloc] init_ref:[self ref]];
	}
	-(TSGLBuffer*)clonePtr {
		return [[TSGLBuffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLBuffer*)null {
		return [[TSGLBuffer alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (TS_BufferFlags)flags target: (uint32_t)target buffer_id: (uint32_t)buffer_id {
		return [self ref].create((Tellusim::Buffer::Flags)flags, target, buffer_id);
	}
	-(BOOL)create_2_: (TS_BufferFlags)flags target: (uint32_t)target buffer_id: (uint32_t)buffer_id {
		return [self ref].create((Tellusim::Buffer::Flags)flags, target, buffer_id);
	}
	-(uint32_t)getTarget {
		return [self ref].getTarget();
	}
	-(uint32_t)getBufferID {
		return [self ref].getBufferID();
	}
@end

// Tellusim::GLESBuffer
@implementation TSGLESBuffer
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESBuffer();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLESBuffer*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLESBuffer&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESBuffer((Tellusim::GLESBuffer&)ref);
		return self;
	}
	-(Tellusim::GLESBuffer*)pointer {
		return (Tellusim::GLESBuffer*)impl;
	}
	-(Tellusim::GLESBuffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLESBuffer*)impl;
	}
	-(id)initBuffer: (TSBuffer*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESBuffer([base ref]);
		return self;
	}
	-(TSBuffer*)getBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer())];
	}
	-(BOOL)equalPtr: (const TSGLESBuffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLESBuffer*)copyPtr {
		return [[TSGLESBuffer alloc] init_ref:[self ref]];
	}
	-(TSGLESBuffer*)clonePtr {
		return [[TSGLESBuffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLESBuffer*)null {
		return [[TSGLESBuffer alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (TS_BufferFlags)flags target: (uint32_t)target buffer_id: (uint32_t)buffer_id {
		return [self ref].create((Tellusim::Buffer::Flags)flags, target, buffer_id);
	}
	-(BOOL)create_2_: (TS_BufferFlags)flags target: (uint32_t)target buffer_id: (uint32_t)buffer_id {
		return [self ref].create((Tellusim::Buffer::Flags)flags, target, buffer_id);
	}
	-(uint32_t)getTarget {
		return [self ref].getTarget();
	}
	-(uint32_t)getBufferID {
		return [self ref].getBufferID();
	}
@end

// Tellusim::CUBuffer
@implementation TSCUBuffer
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUBuffer();
		return self;
	}
	-(id)init_ptr: (Tellusim::CUBuffer*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CUBuffer&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUBuffer((Tellusim::CUBuffer&)ref);
		return self;
	}
	-(Tellusim::CUBuffer*)pointer {
		return (Tellusim::CUBuffer*)impl;
	}
	-(Tellusim::CUBuffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CUBuffer*)impl;
	}
	-(id)initBuffer: (TSBuffer*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUBuffer([base ref]);
		return self;
	}
	-(TSBuffer*)getBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer())];
	}
	-(BOOL)equalPtr: (const TSCUBuffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCUBuffer*)copyPtr {
		return [[TSCUBuffer alloc] init_ref:[self ref]];
	}
	-(TSCUBuffer*)clonePtr {
		return [[TSCUBuffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCUBuffer*)null {
		return [[TSCUBuffer alloc] init_ptr:nullptr];
	}
	-(size_t)getBufferPtr {
		return [self ref].getBufferPtr();
	}
	-(uint8_t*)getBufferData {
		return [self ref].getBufferData();
	}
	-(CUevent)getBufferEvent {
		return [self ref].getBufferEvent();
	}
	-(uint32_t)getArrayFormat {
		return [self ref].getArrayFormat();
	}
	-(uint32_t)getArrayChannels {
		return [self ref].getArrayChannels();
	}
	-(CUexternalMemory)getSharedMemory {
		return [self ref].getSharedMemory();
	}
@end

// Tellusim::HIPBuffer
@implementation TSHIPBuffer
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPBuffer();
		return self;
	}
	-(id)init_ptr: (Tellusim::HIPBuffer*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::HIPBuffer&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPBuffer((Tellusim::HIPBuffer&)ref);
		return self;
	}
	-(Tellusim::HIPBuffer*)pointer {
		return (Tellusim::HIPBuffer*)impl;
	}
	-(Tellusim::HIPBuffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::HIPBuffer*)impl;
	}
	-(id)initBuffer: (TSBuffer*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPBuffer([base ref]);
		return self;
	}
	-(TSBuffer*)getBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer())];
	}
	-(BOOL)equalPtr: (const TSHIPBuffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSHIPBuffer*)copyPtr {
		return [[TSHIPBuffer alloc] init_ref:[self ref]];
	}
	-(TSHIPBuffer*)clonePtr {
		return [[TSHIPBuffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSHIPBuffer*)null {
		return [[TSHIPBuffer alloc] init_ptr:nullptr];
	}
	-(void*)getBufferPtr {
		return [self ref].getBufferPtr();
	}
	-(uint8_t*)getBufferData {
		return [self ref].getBufferData();
	}
	-(void*)getBufferEvent {
		return [self ref].getBufferEvent();
	}
	-(uint32_t)getArrayFormat {
		return [self ref].getArrayFormat();
	}
	-(uint32_t)getArrayChannels {
		return [self ref].getArrayChannels();
	}
	-(void*)getSharedMemory {
		return [self ref].getSharedMemory();
	}
@end

// Tellusim::FUBuffer
@implementation TSFUBuffer
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUBuffer();
		return self;
	}
	-(id)init_2: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		impl = new Tellusim::FUBuffer(buffers_);
		return self;
	}
	-(id)init_2_: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		impl = new Tellusim::FUBuffer(buffers_);
		return self;
	}
	-(id)init_3: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		impl = new Tellusim::FUBuffer(buffers_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		impl = new Tellusim::FUBuffer(buffers_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUBuffer*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUBuffer&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUBuffer((Tellusim::FUBuffer&)ref);
		return self;
	}
	-(Tellusim::FUBuffer*)pointer {
		return (Tellusim::FUBuffer*)impl;
	}
	-(Tellusim::FUBuffer&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUBuffer*)impl;
	}
	-(id)initBuffer: (TSBuffer*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUBuffer([base ref]);
		return self;
	}
	-(TSBuffer*)getBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer())];
	}
	-(BOOL)equalPtr: (const TSFUBuffer*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUBuffer*)copyPtr {
		return [[TSFUBuffer alloc] init_ref:[self ref]];
	}
	-(TSFUBuffer*)clonePtr {
		return [[TSFUBuffer alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUBuffer*)null {
		return [[TSFUBuffer alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumBuffers {
		return [self ref].getNumBuffers();
	}
	-(const TSBuffer*)getBuffer: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer(index))];
	}
	-(const TSBuffer*)getBuffer_: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].getBuffer(index))];
	}
@end

// Tellusim::Command
@implementation TSCommand
	-(id)init {
		self = [super init];
		impl = new Tellusim::Command();
		return self;
	}
	-(id)init_ptr: (Tellusim::Command*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Command&)ref {
		self = [super init];
		impl = new Tellusim::Command((Tellusim::Command&)ref);
		return self;
	}
	-(Tellusim::Command*)pointer {
		return (Tellusim::Command*)impl;
	}
	-(Tellusim::Command&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Command*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Command*)impl;
	}
	-(BOOL)equalPtr: (const TSCommand*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCommand*)copyPtr {
		return [[TSCommand alloc] init_ref:[self ref]];
	}
	-(TSCommand*)clonePtr {
		return [[TSCommand alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCommand*)null {
		return [[TSCommand alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)setPipeline: (TSPipeline*)pipeline {
		[self ref].setPipeline([pipeline ref]);
	}
	-(void)setPipeline_: (TSPipeline*)pipeline {
		[self ref].setPipeline([pipeline ref]);
	}
	-(TSPipeline*)getPipeline {
		return [[TSPipeline alloc] init_ref:([self ref].getPipeline())];
	}
	-(void)setViewport: (uint32_t)index viewport: (TSViewport)viewport {
		[self ref].setViewport(index, *(Tellusim::Viewport*)&viewport);
	}
	-(void)setViewport_: (uint32_t)index viewport: (TSViewport)viewport {
		[self ref].setViewport(index, *(Tellusim::Viewport*)&viewport);
	}
	-(void)setViewports: (const TSViewport*)viewports num_viewports: (uint32_t)num_viewports {
		[self ref].setViewports(*(const Tellusim::Viewport**)&viewports, num_viewports);
	}
	-(void)setViewports_: (const TSViewport*)viewports num_viewports: (uint32_t)num_viewports {
		[self ref].setViewports(*(const Tellusim::Viewport**)&viewports, num_viewports);
	}
	-(void)setScissor: (uint32_t)index scissor: (TSScissor)scissor {
		[self ref].setScissor(index, *(Tellusim::Scissor*)&scissor);
	}
	-(void)setScissor_: (uint32_t)index scissor: (TSScissor)scissor {
		[self ref].setScissor(index, *(Tellusim::Scissor*)&scissor);
	}
	-(void)setScissors: (const TSScissor*)scissors num_scissors: (uint32_t)num_scissors {
		[self ref].setScissors(*(const Tellusim::Scissor**)&scissors, num_scissors);
	}
	-(void)setScissors_: (const TSScissor*)scissors num_scissors: (uint32_t)num_scissors {
		[self ref].setScissors(*(const Tellusim::Scissor**)&scissors, num_scissors);
	}
	-(void)setSampler: (uint32_t)index sampler: (TSSampler*)sampler {
		[self ref].setSampler(index, [sampler ref]);
	}
	-(void)setSampler_: (uint32_t)index sampler: (TSSampler*)sampler {
		[self ref].setSampler(index, [sampler ref]);
	}
	-(void)setSamplers: (uint32_t)index samplers: (TSSampler**)samplers samplers_size: (uint32_t)samplers_size {
		Tellusim::Array<Tellusim::Sampler> samplers_(samplers_size);
		for(uint32_t i = 0; i < samplers_size; i++) if(samplers[i]) samplers_[i] = [samplers[i] ref];
		[self ref].setSamplers(index, samplers_);
	}
	-(void)setSamplers_: (uint32_t)index samplers: (TSSampler**)samplers samplers_size: (uint32_t)samplers_size {
		Tellusim::Array<Tellusim::Sampler> samplers_(samplers_size);
		for(uint32_t i = 0; i < samplers_size; i++) if(samplers[i]) samplers_[i] = [samplers[i] ref];
		[self ref].setSamplers(index, samplers_);
	}
	-(void)setTexture: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setTexture(index, [texture ref]);
	}
	-(void)setTexture_: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setTexture(index, [texture ref]);
	}
	-(void)setTexture_1: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setTexture(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setTexture_1_: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setTexture(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setTextures: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].setTextures(index, textures_);
	}
	-(void)setTextures_: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].setTextures(index, textures_);
	}
	-(void)setSurfaceTexture: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setSurfaceTexture(index, [texture ref]);
	}
	-(void)setSurfaceTexture_: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setSurfaceTexture(index, [texture ref]);
	}
	-(void)setSurfaceTexture_1: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setSurfaceTexture(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setSurfaceTexture_1_: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setSurfaceTexture(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setSurfaceTexture_2: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice format: (TS_Format)format {
		[self ref].setSurfaceTexture(index, [texture ref], *(Tellusim::Slice*)&slice, (Tellusim::Format)format);
	}
	-(void)setSurfaceTexture_2_: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice format: (TS_Format)format {
		[self ref].setSurfaceTexture(index, [texture ref], *(Tellusim::Slice*)&slice, (Tellusim::Format)format);
	}
	-(void)setSurfaceTextures: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].setSurfaceTextures(index, textures_);
	}
	-(void)setSurfaceTextures_: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].setSurfaceTextures(index, textures_);
	}
	-(void*)getUniformData: (uint32_t)index size: (size_t)size {
		return [self ref].getUniformData(index, size);
	}
	-(void*)getUniformData_: (uint32_t)index size: (size_t)size {
		return [self ref].getUniformData(index, size);
	}
	-(void)setUniformData: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setUniformData(index, src, size);
	}
	-(void)setUniformData_: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setUniformData(index, src, size);
	}
	-(void)setUniformBuffer: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setUniformBuffer(index, [buffer ref]);
	}
	-(void)setUniformBuffer_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setUniformBuffer(index, [buffer ref]);
	}
	-(void)setUniformBuffer_1: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setUniformBuffer(index, [buffer ref], offset);
	}
	-(void)setUniformBuffer_1_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setUniformBuffer(index, [buffer ref], offset);
	}
	-(void)setUniformBuffer_2: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		[self ref].setUniformBuffer(index, [buffer ref], offset, size);
	}
	-(void)setUniformBuffer_2_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		[self ref].setUniformBuffer(index, [buffer ref], offset, size);
	}
	-(void)setUniformOffset: (uint32_t)index offset: (size_t)offset {
		[self ref].setUniformOffset(index, offset);
	}
	-(void)setUniformOffset_: (uint32_t)index offset: (size_t)offset {
		[self ref].setUniformOffset(index, offset);
	}
	-(void)setUniformOffset_1: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setUniformOffset(index, offset, (bool)relative);
	}
	-(void)setUniformOffset_1_: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setUniformOffset(index, offset, (bool)relative);
	}
	-(void)setUniformBuffers: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setUniformBuffers(index, buffers_);
	}
	-(void)setUniformBuffers_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setUniformBuffers(index, buffers_);
	}
	-(void)setUniformBuffers_1: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setUniformBuffers(index, buffers_, offsets_);
	}
	-(void)setUniformBuffers_1_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setUniformBuffers(index, buffers_, offsets_);
	}
	-(void*)getStorageData: (uint32_t)index size: (size_t)size {
		return [self ref].getStorageData(index, size);
	}
	-(void*)getStorageData_: (uint32_t)index size: (size_t)size {
		return [self ref].getStorageData(index, size);
	}
	-(void)setStorageData: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setStorageData(index, src, size);
	}
	-(void)setStorageData_: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setStorageData(index, src, size);
	}
	-(void)setStorageBuffer: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setStorageBuffer(index, [buffer ref]);
	}
	-(void)setStorageBuffer_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setStorageBuffer(index, [buffer ref]);
	}
	-(void)setStorageBuffer_1: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setStorageBuffer(index, [buffer ref], offset);
	}
	-(void)setStorageBuffer_1_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setStorageBuffer(index, [buffer ref], offset);
	}
	-(void)setStorageBuffer_2: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		[self ref].setStorageBuffer(index, [buffer ref], offset, size);
	}
	-(void)setStorageBuffer_2_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		[self ref].setStorageBuffer(index, [buffer ref], offset, size);
	}
	-(void)setStorageOffset: (uint32_t)index offset: (size_t)offset {
		[self ref].setStorageOffset(index, offset);
	}
	-(void)setStorageOffset_: (uint32_t)index offset: (size_t)offset {
		[self ref].setStorageOffset(index, offset);
	}
	-(void)setStorageOffset_1: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setStorageOffset(index, offset, (bool)relative);
	}
	-(void)setStorageOffset_1_: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setStorageOffset(index, offset, (bool)relative);
	}
	-(void)setStorageBuffers: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setStorageBuffers(index, buffers_);
	}
	-(void)setStorageBuffers_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setStorageBuffers(index, buffers_);
	}
	-(void)setStorageBuffers_1: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setStorageBuffers(index, buffers_, offsets_);
	}
	-(void)setStorageBuffers_1_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setStorageBuffers(index, buffers_, offsets_);
	}
	-(void)setTracing: (uint32_t)index tracing: (TSTracing*)tracing {
		[self ref].setTracing(index, [tracing ref]);
	}
	-(void)setTracing_: (uint32_t)index tracing: (TSTracing*)tracing {
		[self ref].setTracing(index, [tracing ref]);
	}
	-(void)setTracings: (uint32_t)index tracings: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		[self ref].setTracings(index, tracings_);
	}
	-(void)setTracings_: (uint32_t)index tracings: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		[self ref].setTracings(index, tracings_);
	}
	-(void)setTexelBuffer: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setTexelBuffer(index, [buffer ref]);
	}
	-(void)setTexelBuffer_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setTexelBuffer(index, [buffer ref]);
	}
	-(void)setTexelBuffers: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setTexelBuffers(index, buffers_);
	}
	-(void)setTexelBuffers_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setTexelBuffers(index, buffers_);
	}
	-(void)setTextureTable: (uint32_t)index table: (TSTextureTable*)table {
		[self ref].setTextureTable(index, [table ref]);
	}
	-(void)setTextureTable_: (uint32_t)index table: (TSTextureTable*)table {
		[self ref].setTextureTable(index, [table ref]);
	}
	-(void)setTextureTables: (uint32_t)index tables: (TSTextureTable**)tables tables_size: (uint32_t)tables_size {
		Tellusim::Array<Tellusim::TextureTable> tables_(tables_size);
		for(uint32_t i = 0; i < tables_size; i++) if(tables[i]) tables_[i] = [tables[i] ref];
		[self ref].setTextureTables(index, tables_);
	}
	-(void)setTextureTables_: (uint32_t)index tables: (TSTextureTable**)tables tables_size: (uint32_t)tables_size {
		Tellusim::Array<Tellusim::TextureTable> tables_(tables_size);
		for(uint32_t i = 0; i < tables_size; i++) if(tables[i]) tables_[i] = [tables[i] ref];
		[self ref].setTextureTables(index, tables_);
	}
	-(void)setStorageTable: (uint32_t)index table: (TSBufferTable*)table {
		[self ref].setStorageTable(index, [table ref]);
	}
	-(void)setStorageTable_: (uint32_t)index table: (TSBufferTable*)table {
		[self ref].setStorageTable(index, [table ref]);
	}
	-(void)setStorageTables: (uint32_t)index tables: (TSBufferTable**)tables tables_size: (uint32_t)tables_size {
		Tellusim::Array<Tellusim::BufferTable> tables_(tables_size);
		for(uint32_t i = 0; i < tables_size; i++) if(tables[i]) tables_[i] = [tables[i] ref];
		[self ref].setStorageTables(index, tables_);
	}
	-(void)setStorageTables_: (uint32_t)index tables: (TSBufferTable**)tables tables_size: (uint32_t)tables_size {
		Tellusim::Array<Tellusim::BufferTable> tables_(tables_size);
		for(uint32_t i = 0; i < tables_size; i++) if(tables[i]) tables_[i] = [tables[i] ref];
		[self ref].setStorageTables(index, tables_);
	}
	-(void*)getVertexData: (uint32_t)index size: (size_t)size {
		return [self ref].getVertexData(index, size);
	}
	-(void*)getVertexData_: (uint32_t)index size: (size_t)size {
		return [self ref].getVertexData(index, size);
	}
	-(void)setVertexData: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setVertexData(index, src, size);
	}
	-(void)setVertexData_: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setVertexData(index, src, size);
	}
	-(void)setVertexBuffer: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setVertexBuffer(index, [buffer ref]);
	}
	-(void)setVertexBuffer_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setVertexBuffer(index, [buffer ref]);
	}
	-(void)setVertexBuffer_1: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setVertexBuffer(index, [buffer ref], offset);
	}
	-(void)setVertexBuffer_1_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setVertexBuffer(index, [buffer ref], offset);
	}
	-(void)setVertexOffset: (uint32_t)index offset: (size_t)offset {
		[self ref].setVertexOffset(index, offset);
	}
	-(void)setVertexOffset_: (uint32_t)index offset: (size_t)offset {
		[self ref].setVertexOffset(index, offset);
	}
	-(void)setVertexOffset_1: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setVertexOffset(index, offset, (bool)relative);
	}
	-(void)setVertexOffset_1_: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setVertexOffset(index, offset, (bool)relative);
	}
	-(void)setVertexBuffers: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setVertexBuffers(index, buffers_);
	}
	-(void)setVertexBuffers_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setVertexBuffers(index, buffers_);
	}
	-(void)setVertexBuffers_1: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setVertexBuffers(index, buffers_, offsets_);
	}
	-(void)setVertexBuffers_1_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setVertexBuffers(index, buffers_, offsets_);
	}
	-(void*)getIndexData: (TS_Format)format size: (size_t)size {
		return [self ref].getIndexData((Tellusim::Format)format, size);
	}
	-(void*)getIndexData_: (TS_Format)format size: (size_t)size {
		return [self ref].getIndexData((Tellusim::Format)format, size);
	}
	-(void)setIndexData: (TS_Format)format src: (const void*)src size: (size_t)size {
		[self ref].setIndexData((Tellusim::Format)format, src, size);
	}
	-(void)setIndexData_: (TS_Format)format src: (const void*)src size: (size_t)size {
		[self ref].setIndexData((Tellusim::Format)format, src, size);
	}
	-(void)setIndexBuffer: (TS_Format)format buffer: (TSBuffer*)buffer {
		[self ref].setIndexBuffer((Tellusim::Format)format, [buffer ref]);
	}
	-(void)setIndexBuffer_: (TS_Format)format buffer: (TSBuffer*)buffer {
		[self ref].setIndexBuffer((Tellusim::Format)format, [buffer ref]);
	}
	-(void)setIndexBuffer_1: (TS_Format)format buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndexBuffer((Tellusim::Format)format, [buffer ref], offset);
	}
	-(void)setIndexBuffer_1_: (TS_Format)format buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndexBuffer((Tellusim::Format)format, [buffer ref], offset);
	}
	-(void)setIndexOffset: (size_t)offset {
		[self ref].setIndexOffset(offset);
	}
	-(void)setIndexOffset_: (size_t)offset {
		[self ref].setIndexOffset(offset);
	}
	-(void)setIndexOffset_1: (size_t)offset relative: (BOOL)relative {
		[self ref].setIndexOffset(offset, (bool)relative);
	}
	-(void)setIndexOffset_1_: (size_t)offset relative: (BOOL)relative {
		[self ref].setIndexOffset(offset, (bool)relative);
	}
	-(void*)getIndirectData: (size_t)size {
		return [self ref].getIndirectData(size);
	}
	-(void*)getIndirectData_: (size_t)size {
		return [self ref].getIndirectData(size);
	}
	-(void)setIndirectData: (const void*)src size: (size_t)size {
		[self ref].setIndirectData(src, size);
	}
	-(void)setIndirectData_: (const void*)src size: (size_t)size {
		[self ref].setIndirectData(src, size);
	}
	-(void)setIndirectBuffer: (TSBuffer*)buffer {
		[self ref].setIndirectBuffer([buffer ref]);
	}
	-(void)setIndirectBuffer_: (TSBuffer*)buffer {
		[self ref].setIndirectBuffer([buffer ref]);
	}
	-(void)setIndirectBuffer_1: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndirectBuffer([buffer ref], offset);
	}
	-(void)setIndirectBuffer_1_: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndirectBuffer([buffer ref], offset);
	}
	-(void)setIndirectOffset: (size_t)offset {
		[self ref].setIndirectOffset(offset);
	}
	-(void)setIndirectOffset_: (size_t)offset {
		[self ref].setIndirectOffset(offset);
	}
	-(void)setIndirectOffset_1: (size_t)offset relative: (BOOL)relative {
		[self ref].setIndirectOffset(offset, (bool)relative);
	}
	-(void)setIndirectOffset_1_: (size_t)offset relative: (BOOL)relative {
		[self ref].setIndirectOffset(offset, (bool)relative);
	}
	-(void)setBlendColor: (TSColor)color {
		[self ref].setBlendColor(*(Tellusim::Color*)&color);
	}
	-(void)setBlendColor_: (TSColor)color {
		[self ref].setBlendColor(*(Tellusim::Color*)&color);
	}
	-(void)setBlendColor_1: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setBlendColor(r, g, b, a);
	}
	-(void)setBlendColor_1_: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setBlendColor(r, g, b, a);
	}
	-(void)setStencilRef: (uint32_t)ref {
		[self ref].setStencilRef(ref);
	}
	-(void)setStencilRef_: (uint32_t)ref {
		[self ref].setStencilRef(ref);
	}
	-(void)drawArrays: (uint32_t)num_vertices {
		[self ref].drawArrays(num_vertices);
	}
	-(void)drawArrays_: (uint32_t)num_vertices {
		[self ref].drawArrays(num_vertices);
	}
	-(void)drawArrays_1: (uint32_t)num_vertices base_vertex: (uint32_t)base_vertex {
		[self ref].drawArrays(num_vertices, base_vertex);
	}
	-(void)drawArrays_1_: (uint32_t)num_vertices base_vertex: (uint32_t)base_vertex {
		[self ref].drawArrays(num_vertices, base_vertex);
	}
	-(void)drawArraysInstanced: (uint32_t)num_vertices base_vertex: (uint32_t)base_vertex num_instances: (uint32_t)num_instances {
		[self ref].drawArraysInstanced(num_vertices, base_vertex, num_instances);
	}
	-(void)drawArraysInstanced_: (uint32_t)num_vertices base_vertex: (uint32_t)base_vertex num_instances: (uint32_t)num_instances {
		[self ref].drawArraysInstanced(num_vertices, base_vertex, num_instances);
	}
	-(void)drawArraysInstanced_1: (uint32_t)num_vertices base_vertex: (uint32_t)base_vertex num_instances: (uint32_t)num_instances base_instance: (uint32_t)base_instance {
		[self ref].drawArraysInstanced(num_vertices, base_vertex, num_instances, base_instance);
	}
	-(void)drawArraysInstanced_1_: (uint32_t)num_vertices base_vertex: (uint32_t)base_vertex num_instances: (uint32_t)num_instances base_instance: (uint32_t)base_instance {
		[self ref].drawArraysInstanced(num_vertices, base_vertex, num_instances, base_instance);
	}
	-(void)drawArraysIndirect: (uint32_t)num_draws {
		[self ref].drawArraysIndirect(num_draws);
	}
	-(void)drawArraysIndirect_: (uint32_t)num_draws {
		[self ref].drawArraysIndirect(num_draws);
	}
	-(void)drawArraysIndirect_1: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawArraysIndirect(num_draws, stride);
	}
	-(void)drawArraysIndirect_1_: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawArraysIndirect(num_draws, stride);
	}
	-(void)drawArraysIndirect_2: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws {
		[self ref].drawArraysIndirect([buffer ref], offset, num_draws);
	}
	-(void)drawArraysIndirect_2_: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws {
		[self ref].drawArraysIndirect([buffer ref], offset, num_draws);
	}
	-(void)drawArraysIndirect_3: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawArraysIndirect([buffer ref], offset, num_draws, stride);
	}
	-(void)drawArraysIndirect_3_: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawArraysIndirect([buffer ref], offset, num_draws, stride);
	}
	-(void)drawElements: (uint32_t)num_indices {
		[self ref].drawElements(num_indices);
	}
	-(void)drawElements_: (uint32_t)num_indices {
		[self ref].drawElements(num_indices);
	}
	-(void)drawElements_1: (uint32_t)num_indices base_index: (uint32_t)base_index {
		[self ref].drawElements(num_indices, base_index);
	}
	-(void)drawElements_1_: (uint32_t)num_indices base_index: (uint32_t)base_index {
		[self ref].drawElements(num_indices, base_index);
	}
	-(void)drawElements_2: (uint32_t)num_indices base_index: (uint32_t)base_index base_vertex: (int32_t)base_vertex {
		[self ref].drawElements(num_indices, base_index, base_vertex);
	}
	-(void)drawElements_2_: (uint32_t)num_indices base_index: (uint32_t)base_index base_vertex: (int32_t)base_vertex {
		[self ref].drawElements(num_indices, base_index, base_vertex);
	}
	-(void)drawElementsInstanced: (uint32_t)num_indices base_index: (uint32_t)base_index num_instances: (uint32_t)num_instances {
		[self ref].drawElementsInstanced(num_indices, base_index, num_instances);
	}
	-(void)drawElementsInstanced_: (uint32_t)num_indices base_index: (uint32_t)base_index num_instances: (uint32_t)num_instances {
		[self ref].drawElementsInstanced(num_indices, base_index, num_instances);
	}
	-(void)drawElementsInstanced_1: (uint32_t)num_indices base_index: (uint32_t)base_index base_vertex: (int32_t)base_vertex num_instances: (uint32_t)num_instances {
		[self ref].drawElementsInstanced(num_indices, base_index, base_vertex, num_instances);
	}
	-(void)drawElementsInstanced_1_: (uint32_t)num_indices base_index: (uint32_t)base_index base_vertex: (int32_t)base_vertex num_instances: (uint32_t)num_instances {
		[self ref].drawElementsInstanced(num_indices, base_index, base_vertex, num_instances);
	}
	-(void)drawElementsInstanced_2: (uint32_t)num_indices base_index: (uint32_t)base_index base_vertex: (int32_t)base_vertex num_instances: (uint32_t)num_instances base_instance: (uint32_t)base_instance {
		[self ref].drawElementsInstanced(num_indices, base_index, base_vertex, num_instances, base_instance);
	}
	-(void)drawElementsInstanced_2_: (uint32_t)num_indices base_index: (uint32_t)base_index base_vertex: (int32_t)base_vertex num_instances: (uint32_t)num_instances base_instance: (uint32_t)base_instance {
		[self ref].drawElementsInstanced(num_indices, base_index, base_vertex, num_instances, base_instance);
	}
	-(void)drawElementsIndirect: (uint32_t)num_draws {
		[self ref].drawElementsIndirect(num_draws);
	}
	-(void)drawElementsIndirect_: (uint32_t)num_draws {
		[self ref].drawElementsIndirect(num_draws);
	}
	-(void)drawElementsIndirect_1: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawElementsIndirect(num_draws, stride);
	}
	-(void)drawElementsIndirect_1_: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawElementsIndirect(num_draws, stride);
	}
	-(void)drawElementsIndirect_2: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws {
		[self ref].drawElementsIndirect([buffer ref], offset, num_draws);
	}
	-(void)drawElementsIndirect_2_: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws {
		[self ref].drawElementsIndirect([buffer ref], offset, num_draws);
	}
	-(void)drawElementsIndirect_3: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawElementsIndirect([buffer ref], offset, num_draws, stride);
	}
	-(void)drawElementsIndirect_3_: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawElementsIndirect([buffer ref], offset, num_draws, stride);
	}
	-(void)drawMesh: (uint32_t)width {
		[self ref].drawMesh(width);
	}
	-(void)drawMesh_: (uint32_t)width {
		[self ref].drawMesh(width);
	}
	-(void)drawMesh_1: (uint32_t)width height: (uint32_t)height {
		[self ref].drawMesh(width, height);
	}
	-(void)drawMesh_1_: (uint32_t)width height: (uint32_t)height {
		[self ref].drawMesh(width, height);
	}
	-(void)drawMesh_2: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		[self ref].drawMesh(width, height, depth);
	}
	-(void)drawMesh_2_: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		[self ref].drawMesh(width, height, depth);
	}
	-(void)drawMeshIndirect: (uint32_t)num_draws {
		[self ref].drawMeshIndirect(num_draws);
	}
	-(void)drawMeshIndirect_: (uint32_t)num_draws {
		[self ref].drawMeshIndirect(num_draws);
	}
	-(void)drawMeshIndirect_1: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawMeshIndirect(num_draws, stride);
	}
	-(void)drawMeshIndirect_1_: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawMeshIndirect(num_draws, stride);
	}
	-(void)drawMeshIndirect_2: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws {
		[self ref].drawMeshIndirect([buffer ref], offset, num_draws);
	}
	-(void)drawMeshIndirect_2_: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws {
		[self ref].drawMeshIndirect([buffer ref], offset, num_draws);
	}
	-(void)drawMeshIndirect_3: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawMeshIndirect([buffer ref], offset, num_draws, stride);
	}
	-(void)drawMeshIndirect_3_: (TSBuffer*)buffer offset: (size_t)offset num_draws: (uint32_t)num_draws stride: (size_t)stride {
		[self ref].drawMeshIndirect([buffer ref], offset, num_draws, stride);
	}
	-(void)beginConditional: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].beginConditional([buffer ref], offset);
	}
	-(void)beginConditional_: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].beginConditional([buffer ref], offset);
	}
	-(void)endConditional {
		[self ref].endConditional();
	}
	-(BOOL)beginQuery: (TSQuery*)query {
		return [self ref].beginQuery([query ref]);
	}
	-(BOOL)beginQuery_: (TSQuery*)query {
		return [self ref].beginQuery([query ref]);
	}
	-(void)endQuery: (TSQuery*)query {
		[self ref].endQuery([query ref]);
	}
	-(void)endQuery_: (TSQuery*)query {
		[self ref].endQuery([query ref]);
	}
@end

// Tellusim::D3D12Command
@implementation TSD3D12Command
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Command();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Command*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Command&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Command((Tellusim::D3D12Command&)ref);
		return self;
	}
	-(Tellusim::D3D12Command*)pointer {
		return (Tellusim::D3D12Command*)impl;
	}
	-(Tellusim::D3D12Command&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Command*)impl;
	}
	-(id)initCommand: (TSCommand*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Command([base ref]);
		return self;
	}
	-(TSCommand*)getCommand {
		return [[TSCommand alloc] init_ref:([self ref].getCommand())];
	}
	-(BOOL)equalPtr: (const TSD3D12Command*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Command*)copyPtr {
		return [[TSD3D12Command alloc] init_ref:[self ref]];
	}
	-(TSD3D12Command*)clonePtr {
		return [[TSD3D12Command alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Command*)null {
		return [[TSD3D12Command alloc] init_ptr:nullptr];
	}
	-(ID3D12GraphicsCommandList*)getD3D12Command {
		return [self ref].getD3D12Command();
	}
	-(void)update {
		[self ref].update();
	}
@end

// Tellusim::MTLCommand
@implementation TSMTLCommand
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLCommand();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLCommand*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLCommand&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLCommand((Tellusim::MTLCommand&)ref);
		return self;
	}
	-(Tellusim::MTLCommand*)pointer {
		return (Tellusim::MTLCommand*)impl;
	}
	-(Tellusim::MTLCommand&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLCommand*)impl;
	}
	-(id)initCommand: (TSCommand*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLCommand([base ref]);
		return self;
	}
	-(TSCommand*)getCommand {
		return [[TSCommand alloc] init_ref:([self ref].getCommand())];
	}
	-(BOOL)equalPtr: (const TSMTLCommand*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLCommand*)copyPtr {
		return [[TSMTLCommand alloc] init_ref:[self ref]];
	}
	-(TSMTLCommand*)clonePtr {
		return [[TSMTLCommand alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLCommand*)null {
		return [[TSMTLCommand alloc] init_ptr:nullptr];
	}
	-(void*)getEncoder {
		return [self ref].getEncoder();
	}
	-(void)flush: (void*)encoder {
		[self ref].flush(encoder);
	}
	-(void)flush_: (void*)encoder {
		[self ref].flush(encoder);
	}
	-(void)flush_1: (void*)encoder enqueue: (BOOL)enqueue {
		[self ref].flush(encoder, (bool)enqueue);
	}
	-(void)flush_1_: (void*)encoder enqueue: (BOOL)enqueue {
		[self ref].flush(encoder, (bool)enqueue);
	}
	-(void)flush_2 {
		[self ref].flush();
	}
	-(void)flush_3: (BOOL)create {
		[self ref].flush((bool)create);
	}
	-(void)flush_3_: (BOOL)create {
		[self ref].flush((bool)create);
	}
	-(void)flush_4: (BOOL)create enqueue: (BOOL)enqueue {
		[self ref].flush((bool)create, (bool)enqueue);
	}
	-(void)flush_4_: (BOOL)create enqueue: (BOOL)enqueue {
		[self ref].flush((bool)create, (bool)enqueue);
	}
	-(void)update {
		[self ref].update();
	}
@end

// Tellusim::VKCommand
@implementation TSVKCommand
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKCommand();
		return self;
	}
	-(id)init_ptr: (Tellusim::VKCommand*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKCommand&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKCommand((Tellusim::VKCommand&)ref);
		return self;
	}
	-(Tellusim::VKCommand*)pointer {
		return (Tellusim::VKCommand*)impl;
	}
	-(Tellusim::VKCommand&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKCommand*)impl;
	}
	-(id)initCommand: (TSCommand*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKCommand([base ref]);
		return self;
	}
	-(TSCommand*)getCommand {
		return [[TSCommand alloc] init_ref:([self ref].getCommand())];
	}
	-(BOOL)equalPtr: (const TSVKCommand*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKCommand*)copyPtr {
		return [[TSVKCommand alloc] init_ref:[self ref]];
	}
	-(TSVKCommand*)clonePtr {
		return [[TSVKCommand alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKCommand*)null {
		return [[TSVKCommand alloc] init_ptr:nullptr];
	}
	-(VkCommandBuffer)getVKCommand {
		return [self ref].getVKCommand();
	}
	-(VkDescriptorSet)getSamplerDescriptor {
		return [self ref].getSamplerDescriptor();
	}
	-(VkDescriptorSet)getImageDescriptor {
		return [self ref].getImageDescriptor();
	}
	-(VkDescriptorSet)getBufferDescriptor {
		return [self ref].getBufferDescriptor();
	}
	-(VkDescriptorSet)getTracingDescriptor {
		return [self ref].getTracingDescriptor();
	}
	-(VkDescriptorSet)getTexelDescriptor {
		return [self ref].getTexelDescriptor();
	}
	-(void)update {
		[self ref].update();
	}
@end

// Tellusim::FUCommand
@implementation TSFUCommand
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUCommand();
		return self;
	}
	-(id)init_2: (TSCommand**)commands commands_size: (uint32_t)commands_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Command> commands_(commands_size);
		for(uint32_t i = 0; i < commands_size; i++) if(commands[i]) commands_[i] = [commands[i] ref];
		impl = new Tellusim::FUCommand(commands_);
		return self;
	}
	-(id)init_2_: (TSCommand**)commands commands_size: (uint32_t)commands_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Command> commands_(commands_size);
		for(uint32_t i = 0; i < commands_size; i++) if(commands[i]) commands_[i] = [commands[i] ref];
		impl = new Tellusim::FUCommand(commands_);
		return self;
	}
	-(id)init_3: (TSCommand**)commands commands_size: (uint32_t)commands_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Command> commands_(commands_size);
		for(uint32_t i = 0; i < commands_size; i++) if(commands[i]) commands_[i] = [commands[i] ref];
		impl = new Tellusim::FUCommand(commands_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSCommand**)commands commands_size: (uint32_t)commands_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Command> commands_(commands_size);
		for(uint32_t i = 0; i < commands_size; i++) if(commands[i]) commands_[i] = [commands[i] ref];
		impl = new Tellusim::FUCommand(commands_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUCommand*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUCommand&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUCommand((Tellusim::FUCommand&)ref);
		return self;
	}
	-(Tellusim::FUCommand*)pointer {
		return (Tellusim::FUCommand*)impl;
	}
	-(Tellusim::FUCommand&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUCommand*)impl;
	}
	-(id)initCommand: (TSCommand*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUCommand([base ref]);
		return self;
	}
	-(TSCommand*)getCommand {
		return [[TSCommand alloc] init_ref:([self ref].getCommand())];
	}
	-(BOOL)equalPtr: (const TSFUCommand*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUCommand*)copyPtr {
		return [[TSFUCommand alloc] init_ref:[self ref]];
	}
	-(TSFUCommand*)clonePtr {
		return [[TSFUCommand alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUCommand*)null {
		return [[TSFUCommand alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumCommands {
		return [self ref].getNumCommands();
	}
	-(const TSCommand*)getCommand: (uint32_t)index {
		return [[TSCommand alloc] init_ref:([self ref].getCommand(index))];
	}
	-(const TSCommand*)getCommand_: (uint32_t)index {
		return [[TSCommand alloc] init_ref:([self ref].getCommand(index))];
	}
@end

// Tellusim::Compute
@implementation TSCompute
	-(id)init {
		self = [super init];
		impl = new Tellusim::Compute();
		return self;
	}
	-(id)init_ptr: (Tellusim::Compute*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Compute&)ref {
		self = [super init];
		impl = new Tellusim::Compute((Tellusim::Compute&)ref);
		return self;
	}
	-(Tellusim::Compute*)pointer {
		return (Tellusim::Compute*)impl;
	}
	-(Tellusim::Compute&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Compute*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Compute*)impl;
	}
	-(BOOL)equalPtr: (const TSCompute*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCompute*)copyPtr {
		return [[TSCompute alloc] init_ref:[self ref]];
	}
	-(TSCompute*)clonePtr {
		return [[TSCompute alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCompute*)null {
		return [[TSCompute alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)setKernel: (TSKernel*)kernel {
		[self ref].setKernel([kernel ref]);
	}
	-(void)setKernel_: (TSKernel*)kernel {
		[self ref].setKernel([kernel ref]);
	}
	-(TSKernel*)getKernel {
		return [[TSKernel alloc] init_ref:([self ref].getKernel())];
	}
	-(void)setTraversal: (TSTraversal*)traversal {
		[self ref].setTraversal([traversal ref]);
	}
	-(void)setTraversal_: (TSTraversal*)traversal {
		[self ref].setTraversal([traversal ref]);
	}
	-(TSTraversal*)getTraversal {
		return [[TSTraversal alloc] init_ref:([self ref].getTraversal())];
	}
	-(void)setSampler: (uint32_t)index sampler: (TSSampler*)sampler {
		[self ref].setSampler(index, [sampler ref]);
	}
	-(void)setSampler_: (uint32_t)index sampler: (TSSampler*)sampler {
		[self ref].setSampler(index, [sampler ref]);
	}
	-(void)setSamplers: (uint32_t)index samplers: (TSSampler**)samplers samplers_size: (uint32_t)samplers_size {
		Tellusim::Array<Tellusim::Sampler> samplers_(samplers_size);
		for(uint32_t i = 0; i < samplers_size; i++) if(samplers[i]) samplers_[i] = [samplers[i] ref];
		[self ref].setSamplers(index, samplers_);
	}
	-(void)setSamplers_: (uint32_t)index samplers: (TSSampler**)samplers samplers_size: (uint32_t)samplers_size {
		Tellusim::Array<Tellusim::Sampler> samplers_(samplers_size);
		for(uint32_t i = 0; i < samplers_size; i++) if(samplers[i]) samplers_[i] = [samplers[i] ref];
		[self ref].setSamplers(index, samplers_);
	}
	-(void)setTexture: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setTexture(index, [texture ref]);
	}
	-(void)setTexture_: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setTexture(index, [texture ref]);
	}
	-(void)setTexture_1: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setTexture(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setTexture_1_: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setTexture(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setTextures: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].setTextures(index, textures_);
	}
	-(void)setTextures_: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].setTextures(index, textures_);
	}
	-(void)setSurfaceTexture: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setSurfaceTexture(index, [texture ref]);
	}
	-(void)setSurfaceTexture_: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setSurfaceTexture(index, [texture ref]);
	}
	-(void)setSurfaceTexture_1: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setSurfaceTexture(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setSurfaceTexture_1_: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setSurfaceTexture(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setSurfaceTexture_2: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice format: (TS_Format)format {
		[self ref].setSurfaceTexture(index, [texture ref], *(Tellusim::Slice*)&slice, (Tellusim::Format)format);
	}
	-(void)setSurfaceTexture_2_: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice format: (TS_Format)format {
		[self ref].setSurfaceTexture(index, [texture ref], *(Tellusim::Slice*)&slice, (Tellusim::Format)format);
	}
	-(void)setSurfaceTextures: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].setSurfaceTextures(index, textures_);
	}
	-(void)setSurfaceTextures_: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].setSurfaceTextures(index, textures_);
	}
	-(void*)getUniformData: (uint32_t)index size: (size_t)size {
		return [self ref].getUniformData(index, size);
	}
	-(void*)getUniformData_: (uint32_t)index size: (size_t)size {
		return [self ref].getUniformData(index, size);
	}
	-(void)setUniformData: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setUniformData(index, src, size);
	}
	-(void)setUniformData_: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setUniformData(index, src, size);
	}
	-(void)setUniformBuffer: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setUniformBuffer(index, [buffer ref]);
	}
	-(void)setUniformBuffer_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setUniformBuffer(index, [buffer ref]);
	}
	-(void)setUniformBuffer_1: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setUniformBuffer(index, [buffer ref], offset);
	}
	-(void)setUniformBuffer_1_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setUniformBuffer(index, [buffer ref], offset);
	}
	-(void)setUniformBuffer_2: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		[self ref].setUniformBuffer(index, [buffer ref], offset, size);
	}
	-(void)setUniformBuffer_2_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		[self ref].setUniformBuffer(index, [buffer ref], offset, size);
	}
	-(void)setUniformOffset: (uint32_t)index offset: (size_t)offset {
		[self ref].setUniformOffset(index, offset);
	}
	-(void)setUniformOffset_: (uint32_t)index offset: (size_t)offset {
		[self ref].setUniformOffset(index, offset);
	}
	-(void)setUniformOffset_1: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setUniformOffset(index, offset, (bool)relative);
	}
	-(void)setUniformOffset_1_: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setUniformOffset(index, offset, (bool)relative);
	}
	-(void)setUniformBuffers: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setUniformBuffers(index, buffers_);
	}
	-(void)setUniformBuffers_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setUniformBuffers(index, buffers_);
	}
	-(void)setUniformBuffers_1: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setUniformBuffers(index, buffers_, offsets_);
	}
	-(void)setUniformBuffers_1_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setUniformBuffers(index, buffers_, offsets_);
	}
	-(void*)getStorageData: (uint32_t)index size: (size_t)size {
		return [self ref].getStorageData(index, size);
	}
	-(void*)getStorageData_: (uint32_t)index size: (size_t)size {
		return [self ref].getStorageData(index, size);
	}
	-(void)setStorageData: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setStorageData(index, src, size);
	}
	-(void)setStorageData_: (uint32_t)index src: (const void*)src size: (size_t)size {
		[self ref].setStorageData(index, src, size);
	}
	-(void)setStorageBuffer: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setStorageBuffer(index, [buffer ref]);
	}
	-(void)setStorageBuffer_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setStorageBuffer(index, [buffer ref]);
	}
	-(void)setStorageBuffer_1: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setStorageBuffer(index, [buffer ref], offset);
	}
	-(void)setStorageBuffer_1_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setStorageBuffer(index, [buffer ref], offset);
	}
	-(void)setStorageBuffer_2: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		[self ref].setStorageBuffer(index, [buffer ref], offset, size);
	}
	-(void)setStorageBuffer_2_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		[self ref].setStorageBuffer(index, [buffer ref], offset, size);
	}
	-(void)setStorageOffset: (uint32_t)index offset: (size_t)offset {
		[self ref].setStorageOffset(index, offset);
	}
	-(void)setStorageOffset_: (uint32_t)index offset: (size_t)offset {
		[self ref].setStorageOffset(index, offset);
	}
	-(void)setStorageOffset_1: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setStorageOffset(index, offset, (bool)relative);
	}
	-(void)setStorageOffset_1_: (uint32_t)index offset: (size_t)offset relative: (BOOL)relative {
		[self ref].setStorageOffset(index, offset, (bool)relative);
	}
	-(void)setStorageBuffers: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setStorageBuffers(index, buffers_);
	}
	-(void)setStorageBuffers_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setStorageBuffers(index, buffers_);
	}
	-(void)setStorageBuffers_1: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setStorageBuffers(index, buffers_, offsets_);
	}
	-(void)setStorageBuffers_1_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size offsets: (size_t*)offsets offsets_size: (uint32_t)offsets_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		Tellusim::Array<size_t> offsets_(offsets_size, offsets);
		[self ref].setStorageBuffers(index, buffers_, offsets_);
	}
	-(void)setTracing: (uint32_t)index tracing: (TSTracing*)tracing {
		[self ref].setTracing(index, [tracing ref]);
	}
	-(void)setTracing_: (uint32_t)index tracing: (TSTracing*)tracing {
		[self ref].setTracing(index, [tracing ref]);
	}
	-(void)setTracings: (uint32_t)index tracings: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		[self ref].setTracings(index, tracings_);
	}
	-(void)setTracings_: (uint32_t)index tracings: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		[self ref].setTracings(index, tracings_);
	}
	-(void)setTexelBuffer: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setTexelBuffer(index, [buffer ref]);
	}
	-(void)setTexelBuffer_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setTexelBuffer(index, [buffer ref]);
	}
	-(void)setTexelBuffers: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setTexelBuffers(index, buffers_);
	}
	-(void)setTexelBuffers_: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].setTexelBuffers(index, buffers_);
	}
	-(void)setTextureTable: (uint32_t)index table: (TSTextureTable*)table {
		[self ref].setTextureTable(index, [table ref]);
	}
	-(void)setTextureTable_: (uint32_t)index table: (TSTextureTable*)table {
		[self ref].setTextureTable(index, [table ref]);
	}
	-(void)setTextureTables: (uint32_t)index tables: (TSTextureTable**)tables tables_size: (uint32_t)tables_size {
		Tellusim::Array<Tellusim::TextureTable> tables_(tables_size);
		for(uint32_t i = 0; i < tables_size; i++) if(tables[i]) tables_[i] = [tables[i] ref];
		[self ref].setTextureTables(index, tables_);
	}
	-(void)setTextureTables_: (uint32_t)index tables: (TSTextureTable**)tables tables_size: (uint32_t)tables_size {
		Tellusim::Array<Tellusim::TextureTable> tables_(tables_size);
		for(uint32_t i = 0; i < tables_size; i++) if(tables[i]) tables_[i] = [tables[i] ref];
		[self ref].setTextureTables(index, tables_);
	}
	-(void)setStorageTable: (uint32_t)index table: (TSBufferTable*)table {
		[self ref].setStorageTable(index, [table ref]);
	}
	-(void)setStorageTable_: (uint32_t)index table: (TSBufferTable*)table {
		[self ref].setStorageTable(index, [table ref]);
	}
	-(void)setStorageTables: (uint32_t)index tables: (TSBufferTable**)tables tables_size: (uint32_t)tables_size {
		Tellusim::Array<Tellusim::BufferTable> tables_(tables_size);
		for(uint32_t i = 0; i < tables_size; i++) if(tables[i]) tables_[i] = [tables[i] ref];
		[self ref].setStorageTables(index, tables_);
	}
	-(void)setStorageTables_: (uint32_t)index tables: (TSBufferTable**)tables tables_size: (uint32_t)tables_size {
		Tellusim::Array<Tellusim::BufferTable> tables_(tables_size);
		for(uint32_t i = 0; i < tables_size; i++) if(tables[i]) tables_[i] = [tables[i] ref];
		[self ref].setStorageTables(index, tables_);
	}
	-(void*)getIndirectData: (size_t)size {
		return [self ref].getIndirectData(size);
	}
	-(void*)getIndirectData_: (size_t)size {
		return [self ref].getIndirectData(size);
	}
	-(void)setIndirectData: (const void*)src size: (size_t)size {
		[self ref].setIndirectData(src, size);
	}
	-(void)setIndirectData_: (const void*)src size: (size_t)size {
		[self ref].setIndirectData(src, size);
	}
	-(void)setIndirectBuffer: (TSBuffer*)buffer {
		[self ref].setIndirectBuffer([buffer ref]);
	}
	-(void)setIndirectBuffer_: (TSBuffer*)buffer {
		[self ref].setIndirectBuffer([buffer ref]);
	}
	-(void)setIndirectBuffer_1: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndirectBuffer([buffer ref], offset);
	}
	-(void)setIndirectBuffer_1_: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndirectBuffer([buffer ref], offset);
	}
	-(void)setIndirectOffset: (size_t)offset {
		[self ref].setIndirectOffset(offset);
	}
	-(void)setIndirectOffset_: (size_t)offset {
		[self ref].setIndirectOffset(offset);
	}
	-(void)setIndirectOffset_1: (size_t)offset relative: (BOOL)relative {
		[self ref].setIndirectOffset(offset, (bool)relative);
	}
	-(void)setIndirectOffset_1_: (size_t)offset relative: (BOOL)relative {
		[self ref].setIndirectOffset(offset, (bool)relative);
	}
	-(void)dispatch: (uint32_t)width {
		[self ref].dispatch(width);
	}
	-(void)dispatch_: (uint32_t)width {
		[self ref].dispatch(width);
	}
	-(void)dispatch_1: (uint32_t)width height: (uint32_t)height {
		[self ref].dispatch(width, height);
	}
	-(void)dispatch_1_: (uint32_t)width height: (uint32_t)height {
		[self ref].dispatch(width, height);
	}
	-(void)dispatch_2: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		[self ref].dispatch(width, height, depth);
	}
	-(void)dispatch_2_: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		[self ref].dispatch(width, height, depth);
	}
	-(void)dispatch_3: (const TSTexture*)texture {
		[self ref].dispatch([texture ref]);
	}
	-(void)dispatch_3_: (const TSTexture*)texture {
		[self ref].dispatch([texture ref]);
	}
	-(void)dispatch_4: (TSSize)size {
		[self ref].dispatch(*(Tellusim::Size*)&size);
	}
	-(void)dispatch_4_: (TSSize)size {
		[self ref].dispatch(*(Tellusim::Size*)&size);
	}
	-(void)dispatchIndirect {
		[self ref].dispatchIndirect();
	}
	-(BOOL)setBuffer: (TSBuffer*)buffer offset: (size_t)offset src: (const void*)src size: (size_t)size {
		return [self ref].setBuffer([buffer ref], offset, src, size);
	}
	-(BOOL)setBuffer_: (TSBuffer*)buffer offset: (size_t)offset src: (const void*)src size: (size_t)size {
		return [self ref].setBuffer([buffer ref], offset, src, size);
	}
	-(BOOL)setBuffer_1: (TSBuffer*)buffer src: (const void*)src size: (size_t)size {
		return [self ref].setBuffer([buffer ref], src, size);
	}
	-(BOOL)setBuffer_1_: (TSBuffer*)buffer src: (const void*)src size: (size_t)size {
		return [self ref].setBuffer([buffer ref], src, size);
	}
	-(BOOL)setBuffer_2: (TSBuffer*)buffer src: (const void*)src {
		return [self ref].setBuffer([buffer ref], src);
	}
	-(BOOL)setBuffer_2_: (TSBuffer*)buffer src: (const void*)src {
		return [self ref].setBuffer([buffer ref], src);
	}
	-(BOOL)copyBuffer: (TSBuffer*)buffer dest_offset: (size_t)dest_offset src: (TSBuffer*)src src_offset: (size_t)src_offset size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], dest_offset, [src ref], src_offset, size);
	}
	-(BOOL)copyBuffer_: (TSBuffer*)buffer dest_offset: (size_t)dest_offset src: (TSBuffer*)src src_offset: (size_t)src_offset size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], dest_offset, [src ref], src_offset, size);
	}
	-(BOOL)copyBuffer_1: (TSBuffer*)buffer dest_offset: (size_t)dest_offset src: (TSBuffer*)src size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], dest_offset, [src ref], size);
	}
	-(BOOL)copyBuffer_1_: (TSBuffer*)buffer dest_offset: (size_t)dest_offset src: (TSBuffer*)src size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], dest_offset, [src ref], size);
	}
	-(BOOL)copyBuffer_2: (TSBuffer*)buffer src: (TSBuffer*)src size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], [src ref], size);
	}
	-(BOOL)copyBuffer_2_: (TSBuffer*)buffer src: (TSBuffer*)src size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], [src ref], size);
	}
	-(BOOL)copyBuffer_3: (TSBuffer*)buffer src: (TSBuffer*)src {
		return [self ref].copyBuffer([buffer ref], [src ref]);
	}
	-(BOOL)copyBuffer_3_: (TSBuffer*)buffer src: (TSBuffer*)src {
		return [self ref].copyBuffer([buffer ref], [src ref]);
	}
	-(BOOL)clearBuffer: (TSBuffer*)buffer format: (TS_Format)format offset: (size_t)offset src: (const void*)src size: (size_t)size {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, offset, src, size);
	}
	-(BOOL)clearBuffer_: (TSBuffer*)buffer format: (TS_Format)format offset: (size_t)offset src: (const void*)src size: (size_t)size {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, offset, src, size);
	}
	-(BOOL)clearBuffer_1: (TSBuffer*)buffer format: (TS_Format)format src: (const void*)src size: (size_t)size {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, src, size);
	}
	-(BOOL)clearBuffer_1_: (TSBuffer*)buffer format: (TS_Format)format src: (const void*)src size: (size_t)size {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, src, size);
	}
	-(BOOL)clearBuffer_2: (TSBuffer*)buffer format: (TS_Format)format src: (const void*)src {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, src);
	}
	-(BOOL)clearBuffer_2_: (TSBuffer*)buffer format: (TS_Format)format src: (const void*)src {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, src);
	}
	-(BOOL)clearBuffer_3: (TSBuffer*)buffer {
		return [self ref].clearBuffer([buffer ref]);
	}
	-(BOOL)clearBuffer_3_: (TSBuffer*)buffer {
		return [self ref].clearBuffer([buffer ref]);
	}
	-(BOOL)setTexture_2: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice image: (const TSImage*)image src_slice: (TSSlice)src_slice {
		return [self ref].setTexture([texture ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice, [image ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)setTexture_2_: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice image: (const TSImage*)image src_slice: (TSSlice)src_slice {
		return [self ref].setTexture([texture ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice, [image ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)setTexture_3: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], *(Tellusim::Origin*)&dest_origin, [image ref]);
	}
	-(BOOL)setTexture_3_: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], *(Tellusim::Origin*)&dest_origin, [image ref]);
	}
	-(BOOL)setTexture_4: (TSTexture*)texture dest_slice: (TSSlice)dest_slice image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], *(Tellusim::Slice*)&dest_slice, [image ref]);
	}
	-(BOOL)setTexture_4_: (TSTexture*)texture dest_slice: (TSSlice)dest_slice image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], *(Tellusim::Slice*)&dest_slice, [image ref]);
	}
	-(BOOL)setTexture_5: (TSTexture*)texture image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], [image ref]);
	}
	-(BOOL)setTexture_5_: (TSTexture*)texture image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], [image ref]);
	}
	-(BOOL)copyTexture: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice src: (TSTexture*)src src_region: (TSRegion)src_region src_slice: (TSSlice)src_slice {
		return [self ref].copyTexture([texture ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice, [src ref], *(Tellusim::Region*)&src_region, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copyTexture_: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice src: (TSTexture*)src src_region: (TSRegion)src_region src_slice: (TSSlice)src_slice {
		return [self ref].copyTexture([texture ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice, [src ref], *(Tellusim::Region*)&src_region, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copyTexture_1: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin src: (TSTexture*)src src_region: (TSRegion)src_region {
		return [self ref].copyTexture([texture ref], *(Tellusim::Origin*)&dest_origin, [src ref], *(Tellusim::Region*)&src_region);
	}
	-(BOOL)copyTexture_1_: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin src: (TSTexture*)src src_region: (TSRegion)src_region {
		return [self ref].copyTexture([texture ref], *(Tellusim::Origin*)&dest_origin, [src ref], *(Tellusim::Region*)&src_region);
	}
	-(BOOL)copyTexture_2: (TSTexture*)texture dest_slice: (TSSlice)dest_slice src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].copyTexture([texture ref], *(Tellusim::Slice*)&dest_slice, [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copyTexture_2_: (TSTexture*)texture dest_slice: (TSSlice)dest_slice src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].copyTexture([texture ref], *(Tellusim::Slice*)&dest_slice, [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copyTexture_3: (TSTexture*)texture src: (TSTexture*)src {
		return [self ref].copyTexture([texture ref], [src ref]);
	}
	-(BOOL)copyTexture_3_: (TSTexture*)texture src: (TSTexture*)src {
		return [self ref].copyTexture([texture ref], [src ref]);
	}
	-(BOOL)clearTexture: (TSTexture*)texture region: (TSRegion)region slice: (TSSlice)slice src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice, src);
	}
	-(BOOL)clearTexture_: (TSTexture*)texture region: (TSRegion)region slice: (TSSlice)slice src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice, src);
	}
	-(BOOL)clearTexture_1: (TSTexture*)texture region: (TSRegion)region src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Region*)&region, src);
	}
	-(BOOL)clearTexture_1_: (TSTexture*)texture region: (TSRegion)region src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Region*)&region, src);
	}
	-(BOOL)clearTexture_2: (TSTexture*)texture slice: (TSSlice)slice src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Slice*)&slice, src);
	}
	-(BOOL)clearTexture_2_: (TSTexture*)texture slice: (TSSlice)slice src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Slice*)&slice, src);
	}
	-(BOOL)clearTexture_3: (TSTexture*)texture src: (const void*)src {
		return [self ref].clearTexture([texture ref], src);
	}
	-(BOOL)clearTexture_3_: (TSTexture*)texture src: (const void*)src {
		return [self ref].clearTexture([texture ref], src);
	}
	-(void)barrier: (TSTexture*)texture {
		[self ref].barrier([texture ref]);
	}
	-(void)barrier_: (TSTexture*)texture {
		[self ref].barrier([texture ref]);
	}
	-(void)barrier_1: (TSBuffer*)buffer {
		[self ref].barrier([buffer ref]);
	}
	-(void)barrier_1_: (TSBuffer*)buffer {
		[self ref].barrier([buffer ref]);
	}
	-(void)barrier_2: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].barrier(textures_);
	}
	-(void)barrier_2_: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		[self ref].barrier(textures_);
	}
	-(void)barrier_3: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].barrier(buffers_);
	}
	-(void)barrier_3_: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		[self ref].barrier(buffers_);
	}
	-(void)beginConditional: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].beginConditional([buffer ref], offset);
	}
	-(void)beginConditional_: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].beginConditional([buffer ref], offset);
	}
	-(void)endConditional {
		[self ref].endConditional();
	}
	-(BOOL)beginQuery: (TSQuery*)query {
		return [self ref].beginQuery([query ref]);
	}
	-(BOOL)beginQuery_: (TSQuery*)query {
		return [self ref].beginQuery([query ref]);
	}
	-(void)endQuery: (TSQuery*)query {
		[self ref].endQuery([query ref]);
	}
	-(void)endQuery_: (TSQuery*)query {
		[self ref].endQuery([query ref]);
	}
@end

// Tellusim::D3D12Compute
@implementation TSD3D12Compute
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Compute();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Compute*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Compute&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Compute((Tellusim::D3D12Compute&)ref);
		return self;
	}
	-(Tellusim::D3D12Compute*)pointer {
		return (Tellusim::D3D12Compute*)impl;
	}
	-(Tellusim::D3D12Compute&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Compute*)impl;
	}
	-(id)initCompute: (TSCompute*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Compute([base ref]);
		return self;
	}
	-(TSCompute*)getCompute {
		return [[TSCompute alloc] init_ref:([self ref].getCompute())];
	}
	-(BOOL)equalPtr: (const TSD3D12Compute*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Compute*)copyPtr {
		return [[TSD3D12Compute alloc] init_ref:[self ref]];
	}
	-(TSD3D12Compute*)clonePtr {
		return [[TSD3D12Compute alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Compute*)null {
		return [[TSD3D12Compute alloc] init_ptr:nullptr];
	}
	-(ID3D12GraphicsCommandList*)getCommand {
		return [self ref].getCommand();
	}
	-(void)update {
		[self ref].update();
	}
@end

// Tellusim::MTLCompute
@implementation TSMTLCompute
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLCompute();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLCompute*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLCompute&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLCompute((Tellusim::MTLCompute&)ref);
		return self;
	}
	-(Tellusim::MTLCompute*)pointer {
		return (Tellusim::MTLCompute*)impl;
	}
	-(Tellusim::MTLCompute&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLCompute*)impl;
	}
	-(id)initCompute: (TSCompute*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLCompute([base ref]);
		return self;
	}
	-(TSCompute*)getCompute {
		return [[TSCompute alloc] init_ref:([self ref].getCompute())];
	}
	-(BOOL)equalPtr: (const TSMTLCompute*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLCompute*)copyPtr {
		return [[TSMTLCompute alloc] init_ref:[self ref]];
	}
	-(TSMTLCompute*)clonePtr {
		return [[TSMTLCompute alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLCompute*)null {
		return [[TSMTLCompute alloc] init_ptr:nullptr];
	}
	-(void*)getEncoder {
		return [self ref].getEncoder();
	}
	-(void)flush: (void*)encoder {
		[self ref].flush(encoder);
	}
	-(void)flush_: (void*)encoder {
		[self ref].flush(encoder);
	}
	-(void)flush_1: (void*)encoder enqueue: (BOOL)enqueue {
		[self ref].flush(encoder, (bool)enqueue);
	}
	-(void)flush_1_: (void*)encoder enqueue: (BOOL)enqueue {
		[self ref].flush(encoder, (bool)enqueue);
	}
	-(void)flush_2 {
		[self ref].flush();
	}
	-(void)flush_3: (BOOL)create {
		[self ref].flush((bool)create);
	}
	-(void)flush_3_: (BOOL)create {
		[self ref].flush((bool)create);
	}
	-(void)flush_4: (BOOL)create enqueue: (BOOL)enqueue {
		[self ref].flush((bool)create, (bool)enqueue);
	}
	-(void)flush_4_: (BOOL)create enqueue: (BOOL)enqueue {
		[self ref].flush((bool)create, (bool)enqueue);
	}
	-(void)update {
		[self ref].update();
	}
@end

// Tellusim::VKCompute
@implementation TSVKCompute
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKCompute();
		return self;
	}
	-(id)init_ptr: (Tellusim::VKCompute*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKCompute&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKCompute((Tellusim::VKCompute&)ref);
		return self;
	}
	-(Tellusim::VKCompute*)pointer {
		return (Tellusim::VKCompute*)impl;
	}
	-(Tellusim::VKCompute&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKCompute*)impl;
	}
	-(id)initCompute: (TSCompute*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKCompute([base ref]);
		return self;
	}
	-(TSCompute*)getCompute {
		return [[TSCompute alloc] init_ref:([self ref].getCompute())];
	}
	-(BOOL)equalPtr: (const TSVKCompute*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKCompute*)copyPtr {
		return [[TSVKCompute alloc] init_ref:[self ref]];
	}
	-(TSVKCompute*)clonePtr {
		return [[TSVKCompute alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKCompute*)null {
		return [[TSVKCompute alloc] init_ptr:nullptr];
	}
	-(VkCommandBuffer)getCommand {
		return [self ref].getCommand();
	}
	-(VkDescriptorSet)getSamplerDescriptor {
		return [self ref].getSamplerDescriptor();
	}
	-(VkDescriptorSet)getImageDescriptor {
		return [self ref].getImageDescriptor();
	}
	-(VkDescriptorSet)getBufferDescriptor {
		return [self ref].getBufferDescriptor();
	}
	-(VkDescriptorSet)getTracingDescriptor {
		return [self ref].getTracingDescriptor();
	}
	-(VkDescriptorSet)getTexelDescriptor {
		return [self ref].getTexelDescriptor();
	}
	-(void)update {
		[self ref].update();
	}
@end

// Tellusim::FUCompute
@implementation TSFUCompute
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUCompute();
		return self;
	}
	-(id)init_2: (TSCompute**)computes computes_size: (uint32_t)computes_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Compute> computes_(computes_size);
		for(uint32_t i = 0; i < computes_size; i++) if(computes[i]) computes_[i] = [computes[i] ref];
		impl = new Tellusim::FUCompute(computes_);
		return self;
	}
	-(id)init_2_: (TSCompute**)computes computes_size: (uint32_t)computes_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Compute> computes_(computes_size);
		for(uint32_t i = 0; i < computes_size; i++) if(computes[i]) computes_[i] = [computes[i] ref];
		impl = new Tellusim::FUCompute(computes_);
		return self;
	}
	-(id)init_3: (TSCompute**)computes computes_size: (uint32_t)computes_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Compute> computes_(computes_size);
		for(uint32_t i = 0; i < computes_size; i++) if(computes[i]) computes_[i] = [computes[i] ref];
		impl = new Tellusim::FUCompute(computes_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSCompute**)computes computes_size: (uint32_t)computes_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Compute> computes_(computes_size);
		for(uint32_t i = 0; i < computes_size; i++) if(computes[i]) computes_[i] = [computes[i] ref];
		impl = new Tellusim::FUCompute(computes_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUCompute*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUCompute&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUCompute((Tellusim::FUCompute&)ref);
		return self;
	}
	-(Tellusim::FUCompute*)pointer {
		return (Tellusim::FUCompute*)impl;
	}
	-(Tellusim::FUCompute&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUCompute*)impl;
	}
	-(id)initCompute: (TSCompute*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUCompute([base ref]);
		return self;
	}
	-(TSCompute*)getCompute {
		return [[TSCompute alloc] init_ref:([self ref].getCompute())];
	}
	-(BOOL)equalPtr: (const TSFUCompute*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUCompute*)copyPtr {
		return [[TSFUCompute alloc] init_ref:[self ref]];
	}
	-(TSFUCompute*)clonePtr {
		return [[TSFUCompute alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUCompute*)null {
		return [[TSFUCompute alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumComputes {
		return [self ref].getNumComputes();
	}
	-(const TSCompute*)getCompute: (uint32_t)index {
		return [[TSCompute alloc] init_ref:([self ref].getCompute(index))];
	}
	-(const TSCompute*)getCompute_: (uint32_t)index {
		return [[TSCompute alloc] init_ref:([self ref].getCompute(index))];
	}
@end

// Tellusim::Context
@implementation TSContext
	-(id)init {
		self = [super init];
		impl = new Tellusim::Context();
		return self;
	}
	-(id)init_1: (TS_Platform)platform {
		self = [super init];
		impl = new Tellusim::Context((Tellusim::Platform)platform);
		return self;
	}
	-(id)init_1_: (TS_Platform)platform {
		self = [super init];
		impl = new Tellusim::Context((Tellusim::Platform)platform);
		return self;
	}
	-(id)init_2: (TS_Platform)platform index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::Context((Tellusim::Platform)platform, index);
		return self;
	}
	-(id)init_2_: (TS_Platform)platform index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::Context((Tellusim::Platform)platform, index);
		return self;
	}
	-(id)init_ptr: (Tellusim::Context*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Context&)ref {
		self = [super init];
		impl = new Tellusim::Context((Tellusim::Context&)ref);
		return self;
	}
	-(Tellusim::Context*)pointer {
		return (Tellusim::Context*)impl;
	}
	-(Tellusim::Context&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Context*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Context*)impl;
	}
	-(BOOL)equalPtr: (const TSContext*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSContext*)copyPtr {
		return [[TSContext alloc] init_ref:[self ref]];
	}
	-(TSContext*)clonePtr {
		return [[TSContext alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSContext*)null {
		return [[TSContext alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(BOOL)create {
		return [self ref].create();
	}
	-(BOOL)flush {
		return [self ref].flush();
	}
	-(BOOL)finish {
		return [self ref].finish();
	}
@end

// Tellusim::D3D12Context
@implementation TSD3D12Context
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Context();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Context*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Context&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Context((Tellusim::D3D12Context&)ref);
		return self;
	}
	-(Tellusim::D3D12Context*)pointer {
		return (Tellusim::D3D12Context*)impl;
	}
	-(Tellusim::D3D12Context&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Context*)impl;
	}
	-(id)initContext: (TSContext*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Context([base ref]);
		return self;
	}
	-(TSContext*)getContext {
		return [[TSContext alloc] init_ref:([self ref].getContext())];
	}
	-(BOOL)equalPtr: (const TSD3D12Context*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Context*)copyPtr {
		return [[TSD3D12Context alloc] init_ref:[self ref]];
	}
	-(TSD3D12Context*)clonePtr {
		return [[TSD3D12Context alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Context*)null {
		return [[TSD3D12Context alloc] init_ptr:nullptr];
	}
	-(BOOL)create_1: (ID3D12Device*)device queue: (ID3D12CommandQueue*)queue {
		return [self ref].create(device, queue);
	}
	-(BOOL)create_1_: (ID3D12Device*)device queue: (ID3D12CommandQueue*)queue {
		return [self ref].create(device, queue);
	}
	-(IDXGIFactory4*)getFactory {
		return [self ref].getFactory();
	}
	-(ID3D12Device*)getDevice {
		return [self ref].getDevice();
	}
	-(ID3D12CommandQueue*)getQueue {
		return [self ref].getQueue();
	}
	-(ID3D12GraphicsCommandList*)getCommand {
		return [self ref].getCommand();
	}
	+(void*)getProcAddress: (const char*)name {
		return Tellusim::D3D12Context::getProcAddress(name);
	}
	+(void*)getProcAddress_: (const char*)name {
		return Tellusim::D3D12Context::getProcAddress(name);
	}
	+(BOOL)error: (uint32_t)result {
		return Tellusim::D3D12Context::error(result);
	}
	+(BOOL)error_: (uint32_t)result {
		return Tellusim::D3D12Context::error(result);
	}
@end

// Tellusim::D3D11Context
@implementation TSD3D11Context
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Context();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D11Context*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D11Context&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Context((Tellusim::D3D11Context&)ref);
		return self;
	}
	-(Tellusim::D3D11Context*)pointer {
		return (Tellusim::D3D11Context*)impl;
	}
	-(Tellusim::D3D11Context&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D11Context*)impl;
	}
	-(id)initContext: (TSContext*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Context([base ref]);
		return self;
	}
	-(TSContext*)getContext {
		return [[TSContext alloc] init_ref:([self ref].getContext())];
	}
	-(BOOL)equalPtr: (const TSD3D11Context*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D11Context*)copyPtr {
		return [[TSD3D11Context alloc] init_ref:[self ref]];
	}
	-(TSD3D11Context*)clonePtr {
		return [[TSD3D11Context alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D11Context*)null {
		return [[TSD3D11Context alloc] init_ptr:nullptr];
	}
	-(BOOL)create_1: (ID3D11Device*)device {
		return [self ref].create(device);
	}
	-(BOOL)create_1_: (ID3D11Device*)device {
		return [self ref].create(device);
	}
	-(IDXGIFactory*)getFactory {
		return [self ref].getFactory();
	}
	-(ID3D11Device*)getDevice {
		return [self ref].getDevice();
	}
	-(ID3D11DeviceContext*)getD3D11Context {
		return [self ref].getD3D11Context();
	}
	+(void*)getProcAddress: (const char*)name {
		return Tellusim::D3D11Context::getProcAddress(name);
	}
	+(void*)getProcAddress_: (const char*)name {
		return Tellusim::D3D11Context::getProcAddress(name);
	}
	+(BOOL)error: (uint32_t)result {
		return Tellusim::D3D11Context::error(result);
	}
	+(BOOL)error_: (uint32_t)result {
		return Tellusim::D3D11Context::error(result);
	}
@end

// Tellusim::MTLContext
@implementation TSMTLContext
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLContext();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLContext*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLContext&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLContext((Tellusim::MTLContext&)ref);
		return self;
	}
	-(Tellusim::MTLContext*)pointer {
		return (Tellusim::MTLContext*)impl;
	}
	-(Tellusim::MTLContext&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLContext*)impl;
	}
	-(id)initContext: (TSContext*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLContext([base ref]);
		return self;
	}
	-(TSContext*)getContext {
		return [[TSContext alloc] init_ref:([self ref].getContext())];
	}
	-(BOOL)equalPtr: (const TSMTLContext*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLContext*)copyPtr {
		return [[TSMTLContext alloc] init_ref:[self ref]];
	}
	-(TSMTLContext*)clonePtr {
		return [[TSMTLContext alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLContext*)null {
		return [[TSMTLContext alloc] init_ptr:nullptr];
	}
	-(BOOL)create_1: (void*)device queue: (void*)queue {
		return [self ref].create(device, queue);
	}
	-(BOOL)create_1_: (void*)device queue: (void*)queue {
		return [self ref].create(device, queue);
	}
	-(void*)getDevice {
		return [self ref].getDevice();
	}
	-(void*)getQueue {
		return [self ref].getQueue();
	}
	-(void*)getCommand {
		return [self ref].getCommand();
	}
	-(void*)getEncoder {
		return [self ref].getEncoder();
	}
	-(void*)getRenderEncoder: (void*)descriptor {
		return [self ref].getRenderEncoder(descriptor);
	}
	-(void*)getRenderEncoder_: (void*)descriptor {
		return [self ref].getRenderEncoder(descriptor);
	}
	-(void*)getComputeEncoder {
		return [self ref].getComputeEncoder();
	}
	-(void*)getTracingEncoder {
		return [self ref].getTracingEncoder();
	}
	-(void*)getBlitEncoder {
		return [self ref].getBlitEncoder();
	}
	-(void)endEncoder {
		[self ref].endEncoder();
	}
@end

// Tellusim::VKContext
@implementation TSVKContext
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKContext();
		return self;
	}
	-(id)init_ptr: (Tellusim::VKContext*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKContext&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKContext((Tellusim::VKContext&)ref);
		return self;
	}
	-(Tellusim::VKContext*)pointer {
		return (Tellusim::VKContext*)impl;
	}
	-(Tellusim::VKContext&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKContext*)impl;
	}
	-(id)initContext: (TSContext*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKContext([base ref]);
		return self;
	}
	-(TSContext*)getContext {
		return [[TSContext alloc] init_ref:([self ref].getContext())];
	}
	-(BOOL)equalPtr: (const TSVKContext*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKContext*)copyPtr {
		return [[TSVKContext alloc] init_ref:[self ref]];
	}
	-(TSVKContext*)clonePtr {
		return [[TSVKContext alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKContext*)null {
		return [[TSVKContext alloc] init_ptr:nullptr];
	}
	-(BOOL)create_1: (VkInstance)instance func: (PFN_vkGetInstanceProcAddr)func adapter: (VkPhysicalDevice)adapter device: (VkDevice)device family: (uint32_t)family index: (uint32_t)index {
		return [self ref].create(instance, func, adapter, device, family, index);
	}
	-(BOOL)create_1_: (VkInstance)instance func: (PFN_vkGetInstanceProcAddr)func adapter: (VkPhysicalDevice)adapter device: (VkDevice)device family: (uint32_t)family index: (uint32_t)index {
		return [self ref].create(instance, func, adapter, device, family, index);
	}
	-(VkInstance)getInstance {
		return [self ref].getInstance();
	}
	-(VkPhysicalDevice)getAdapter {
		return [self ref].getAdapter();
	}
	-(VkDevice)getDevice {
		return [self ref].getDevice();
	}
	-(VkQueue)getQueue {
		return [self ref].getQueue();
	}
	-(VkCommandBuffer)getCommand {
		return [self ref].getCommand();
	}
	-(uint32_t)getFamily {
		return [self ref].getFamily();
	}
	-(uint32_t)getNumQueues {
		return [self ref].getNumQueues();
	}
	-(uint32_t)getQueueFlags: (uint32_t)index {
		return [self ref].getQueueFlags(index);
	}
	-(uint32_t)getQueueFlags_: (uint32_t)index {
		return [self ref].getQueueFlags(index);
	}
	-(uint32_t)getQueueFamily: (uint32_t)index {
		return [self ref].getQueueFamily(index);
	}
	-(uint32_t)getQueueFamily_: (uint32_t)index {
		return [self ref].getQueueFamily(index);
	}
	+(void)addContextExtension: (const char*)name {
		Tellusim::VKContext::addContextExtension(name);
	}
	+(void)addContextExtension_: (const char*)name {
		Tellusim::VKContext::addContextExtension(name);
	}
	+(void)addAdapterExtension: (const char*)name {
		Tellusim::VKContext::addAdapterExtension(name);
	}
	+(void)addAdapterExtension_: (const char*)name {
		Tellusim::VKContext::addAdapterExtension(name);
	}
	+(void)addAdapterFeatures: (void*)features {
		Tellusim::VKContext::addAdapterFeatures(features);
	}
	+(void)addAdapterFeatures_: (void*)features {
		Tellusim::VKContext::addAdapterFeatures(features);
	}
	+(PFN_vkGetInstanceProcAddr)getInstanceProcAddress {
		return Tellusim::VKContext::getInstanceProcAddress();
	}
	+(PFN_vkGetDeviceProcAddr)getDeviceProcAddress {
		return Tellusim::VKContext::getDeviceProcAddress();
	}
	+(void*)getProcAddress: (const char*)name {
		return Tellusim::VKContext::getProcAddress(name);
	}
	+(void*)getProcAddress_: (const char*)name {
		return Tellusim::VKContext::getProcAddress(name);
	}
	+(BOOL)error: (uint32_t)result {
		return Tellusim::VKContext::error(result);
	}
	+(BOOL)error_: (uint32_t)result {
		return Tellusim::VKContext::error(result);
	}
@end

// Tellusim::GLContext
@implementation TSGLContext
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLContext();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLContext*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLContext&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLContext((Tellusim::GLContext&)ref);
		return self;
	}
	-(Tellusim::GLContext*)pointer {
		return (Tellusim::GLContext*)impl;
	}
	-(Tellusim::GLContext&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLContext*)impl;
	}
	-(id)initContext: (TSContext*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLContext([base ref]);
		return self;
	}
	-(TSContext*)getContext {
		return [[TSContext alloc] init_ref:([self ref].getContext())];
	}
	-(BOOL)equalPtr: (const TSGLContext*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLContext*)copyPtr {
		return [[TSGLContext alloc] init_ref:[self ref]];
	}
	-(TSGLContext*)clonePtr {
		return [[TSGLContext alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLContext*)null {
		return [[TSGLContext alloc] init_ptr:nullptr];
	}
	-(BOOL)create_1: (void*)context {
		return [self ref].create(context);
	}
	-(BOOL)create_1_: (void*)context {
		return [self ref].create(context);
	}
	-(void*)getGLDisplay {
		return [self ref].getGLDisplay();
	}
	-(void*)getGLVisual {
		return [self ref].getGLVisual();
	}
	-(void*)getGLConfig {
		return [self ref].getGLConfig();
	}
	-(void*)getGLSurface {
		return [self ref].getGLSurface();
	}
	-(void*)getGLContext {
		return [self ref].getGLContext();
	}
	+(void*)getProcAddress: (const char*)name {
		return Tellusim::GLContext::getProcAddress(name);
	}
	+(void*)getProcAddress_: (const char*)name {
		return Tellusim::GLContext::getProcAddress(name);
	}
	+(BOOL)error: (uint32_t)result {
		return Tellusim::GLContext::error(result);
	}
	+(BOOL)error_: (uint32_t)result {
		return Tellusim::GLContext::error(result);
	}
	+(BOOL)check {
		return Tellusim::GLContext::check();
	}
@end

// Tellusim::GLESContext
@implementation TSGLESContext
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESContext();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLESContext*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLESContext&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESContext((Tellusim::GLESContext&)ref);
		return self;
	}
	-(Tellusim::GLESContext*)pointer {
		return (Tellusim::GLESContext*)impl;
	}
	-(Tellusim::GLESContext&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLESContext*)impl;
	}
	-(id)initContext: (TSContext*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESContext([base ref]);
		return self;
	}
	-(TSContext*)getContext {
		return [[TSContext alloc] init_ref:([self ref].getContext())];
	}
	-(BOOL)equalPtr: (const TSGLESContext*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLESContext*)copyPtr {
		return [[TSGLESContext alloc] init_ref:[self ref]];
	}
	-(TSGLESContext*)clonePtr {
		return [[TSGLESContext alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLESContext*)null {
		return [[TSGLESContext alloc] init_ptr:nullptr];
	}
	-(BOOL)create_1: (void*)context {
		return [self ref].create(context);
	}
	-(BOOL)create_1_: (void*)context {
		return [self ref].create(context);
	}
	-(void*)getGLESDisplay {
		return [self ref].getGLESDisplay();
	}
	-(void*)getGLESConfig {
		return [self ref].getGLESConfig();
	}
	-(void*)getGLESContext {
		return [self ref].getGLESContext();
	}
	+(void*)getProcAddress: (const char*)name {
		return Tellusim::GLESContext::getProcAddress(name);
	}
	+(void*)getProcAddress_: (const char*)name {
		return Tellusim::GLESContext::getProcAddress(name);
	}
	+(BOOL)error: (uint32_t)result {
		return Tellusim::GLESContext::error(result);
	}
	+(BOOL)error_: (uint32_t)result {
		return Tellusim::GLESContext::error(result);
	}
	+(BOOL)check {
		return Tellusim::GLESContext::check();
	}
@end

// Tellusim::WGContext
@implementation TSWGContext
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::WGContext();
		return self;
	}
	-(id)init_ptr: (Tellusim::WGContext*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::WGContext&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::WGContext((Tellusim::WGContext&)ref);
		return self;
	}
	-(Tellusim::WGContext*)pointer {
		return (Tellusim::WGContext*)impl;
	}
	-(Tellusim::WGContext&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::WGContext*)impl;
	}
	-(id)initContext: (TSContext*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::WGContext([base ref]);
		return self;
	}
	-(TSContext*)getContext {
		return [[TSContext alloc] init_ref:([self ref].getContext())];
	}
	-(BOOL)equalPtr: (const TSWGContext*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSWGContext*)copyPtr {
		return [[TSWGContext alloc] init_ref:[self ref]];
	}
	-(TSWGContext*)clonePtr {
		return [[TSWGContext alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSWGContext*)null {
		return [[TSWGContext alloc] init_ptr:nullptr];
	}
	+(BOOL)open: (WGPUInstance)instance adapter: (WGPUAdapter)adapter device: (WGPUDevice)device {
		return Tellusim::WGContext::open(instance, adapter, device);
	}
	+(BOOL)open_: (WGPUInstance)instance adapter: (WGPUAdapter)adapter device: (WGPUDevice)device {
		return Tellusim::WGContext::open(instance, adapter, device);
	}
	-(BOOL)create_1: (WGPUInstance)instance adapter: (WGPUAdapter)adapter device: (WGPUDevice)device {
		return [self ref].create(instance, adapter, device);
	}
	-(BOOL)create_1_: (WGPUInstance)instance adapter: (WGPUAdapter)adapter device: (WGPUDevice)device {
		return [self ref].create(instance, adapter, device);
	}
	-(WGPUInstance)getInstance {
		return [self ref].getInstance();
	}
	-(WGPUAdapter)getAdapter {
		return [self ref].getAdapter();
	}
	-(WGPUDevice)getDevice {
		return [self ref].getDevice();
	}
@end

// Tellusim::CUContext
@implementation TSCUContext
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUContext();
		return self;
	}
	-(id)init_ptr: (Tellusim::CUContext*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CUContext&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUContext((Tellusim::CUContext&)ref);
		return self;
	}
	-(Tellusim::CUContext*)pointer {
		return (Tellusim::CUContext*)impl;
	}
	-(Tellusim::CUContext&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CUContext*)impl;
	}
	-(id)initContext: (TSContext*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUContext([base ref]);
		return self;
	}
	-(TSContext*)getContext {
		return [[TSContext alloc] init_ref:([self ref].getContext())];
	}
	-(BOOL)equalPtr: (const TSCUContext*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCUContext*)copyPtr {
		return [[TSCUContext alloc] init_ref:[self ref]];
	}
	-(TSCUContext*)clonePtr {
		return [[TSCUContext alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCUContext*)null {
		return [[TSCUContext alloc] init_ptr:nullptr];
	}
	-(int32_t)getDevice {
		return [self ref].getDevice();
	}
	-(CUcontext)getCUContext {
		return [self ref].getCUContext();
	}
	-(CUstream)getStream {
		return [self ref].getStream();
	}
	+(void*)getProcAddress: (const char*)name {
		return Tellusim::CUContext::getProcAddress(name);
	}
	+(void*)getProcAddress_: (const char*)name {
		return Tellusim::CUContext::getProcAddress(name);
	}
	+(BOOL)error: (uint32_t)result {
		return Tellusim::CUContext::error(result);
	}
	+(BOOL)error_: (uint32_t)result {
		return Tellusim::CUContext::error(result);
	}
@end

// Tellusim::HIPContext
@implementation TSHIPContext
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPContext();
		return self;
	}
	-(id)init_ptr: (Tellusim::HIPContext*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::HIPContext&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPContext((Tellusim::HIPContext&)ref);
		return self;
	}
	-(Tellusim::HIPContext*)pointer {
		return (Tellusim::HIPContext*)impl;
	}
	-(Tellusim::HIPContext&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::HIPContext*)impl;
	}
	-(id)initContext: (TSContext*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPContext([base ref]);
		return self;
	}
	-(TSContext*)getContext {
		return [[TSContext alloc] init_ref:([self ref].getContext())];
	}
	-(BOOL)equalPtr: (const TSHIPContext*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSHIPContext*)copyPtr {
		return [[TSHIPContext alloc] init_ref:[self ref]];
	}
	-(TSHIPContext*)clonePtr {
		return [[TSHIPContext alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSHIPContext*)null {
		return [[TSHIPContext alloc] init_ptr:nullptr];
	}
	-(int32_t)getDevice {
		return [self ref].getDevice();
	}
	-(void*)getHIPContext {
		return [self ref].getHIPContext();
	}
	-(void*)getStream {
		return [self ref].getStream();
	}
	+(void*)getProcAddress: (const char*)name {
		return Tellusim::HIPContext::getProcAddress(name);
	}
	+(void*)getProcAddress_: (const char*)name {
		return Tellusim::HIPContext::getProcAddress(name);
	}
	+(BOOL)error: (uint32_t)result {
		return Tellusim::HIPContext::error(result);
	}
	+(BOOL)error_: (uint32_t)result {
		return Tellusim::HIPContext::error(result);
	}
@end

// Tellusim::Query
@implementation TSQuery
	-(id)init {
		self = [super init];
		impl = new Tellusim::Query();
		return self;
	}
	-(id)init_ptr: (Tellusim::Query*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Query&)ref {
		self = [super init];
		impl = new Tellusim::Query((Tellusim::Query&)ref);
		return self;
	}
	-(Tellusim::Query*)pointer {
		return (Tellusim::Query*)impl;
	}
	-(Tellusim::Query&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Query*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Query*)impl;
	}
	-(BOOL)equalPtr: (const TSQuery*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSQuery*)copyPtr {
		return [[TSQuery alloc] init_ref:[self ref]];
	}
	-(TSQuery*)clonePtr {
		return [[TSQuery alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSQuery*)null {
		return [[TSQuery alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(BOOL)isAvailable {
		return [self ref].isAvailable();
	}
	-(BOOL)isBegan {
		return [self ref].isBegan();
	}
	-(BOOL)isEnded {
		return [self ref].isEnded();
	}
	-(BOOL)create: (TS_QueryType)type {
		return [self ref].create((Tellusim::Query::Type)type);
	}
	-(BOOL)create_: (TS_QueryType)type {
		return [self ref].create((Tellusim::Query::Type)type);
	}
	-(TS_QueryType)getType {
		return (TS_QueryType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_QueryType)type {
		return [NSString stringWithUTF8String:Tellusim::Query::getTypeName((Tellusim::Query::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_QueryType)type {
		return [NSString stringWithUTF8String:Tellusim::Query::getTypeName((Tellusim::Query::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(size_t)getTypeSize {
		return [self ref].getTypeSize();
	}
	-(BOOL)isTime {
		return [self ref].isTime();
	}
	-(BOOL)isClock {
		return [self ref].isClock();
	}
	-(BOOL)isSamples {
		return [self ref].isSamples();
	}
	-(BOOL)isSamples1 {
		return [self ref].isSamples1();
	}
	-(BOOL)isStatistics {
		return [self ref].isStatistics();
	}
	-(BOOL)isTimeType {
		return [self ref].isTimeType();
	}
	-(BOOL)isSamplesType {
		return [self ref].isSamplesType();
	}
	-(BOOL)get: (void*)dest size: (size_t)size {
		return [self ref].get(dest, size);
	}
	-(BOOL)get_: (void*)dest size: (size_t)size {
		return [self ref].get(dest, size);
	}
	-(BOOL)get_1: (void*)dest size: (size_t)size wait: (BOOL)wait {
		return [self ref].get(dest, size, (bool)wait);
	}
	-(BOOL)get_1_: (void*)dest size: (size_t)size wait: (BOOL)wait {
		return [self ref].get(dest, size, (bool)wait);
	}
	-(uint64_t)getTime {
		return [self ref].getTime();
	}
	-(uint64_t)getTime_1: (BOOL)wait {
		return [self ref].getTime((bool)wait);
	}
	-(uint64_t)getTime_1_: (BOOL)wait {
		return [self ref].getTime((bool)wait);
	}
	-(uint64_t)getTime_2: (BOOL)wait status: (BOOL*)status {
		return [self ref].getTime((bool)wait, (bool*)status);
	}
	-(uint64_t)getTime_2_: (BOOL)wait status: (BOOL*)status {
		return [self ref].getTime((bool)wait, (bool*)status);
	}
	-(uint32_t)getSamples {
		return [self ref].getSamples();
	}
	-(uint32_t)getSamples_1: (BOOL)wait {
		return [self ref].getSamples((bool)wait);
	}
	-(uint32_t)getSamples_1_: (BOOL)wait {
		return [self ref].getSamples((bool)wait);
	}
	-(uint32_t)getSamples_2: (BOOL)wait status: (BOOL*)status {
		return [self ref].getSamples((bool)wait, (bool*)status);
	}
	-(uint32_t)getSamples_2_: (BOOL)wait status: (BOOL*)status {
		return [self ref].getSamples((bool)wait, (bool*)status);
	}
	-(TSQueryStatistics)getStatistics {
		Tellusim::Query::Statistics ret = [self ref].getStatistics();
		return *(TSQueryStatistics*)&ret;
	}
	-(TSQueryStatistics)getStatistics_1: (BOOL)wait {
		Tellusim::Query::Statistics ret = [self ref].getStatistics((bool)wait);
		return *(TSQueryStatistics*)&ret;
	}
	-(TSQueryStatistics)getStatistics_1_: (BOOL)wait {
		Tellusim::Query::Statistics ret = [self ref].getStatistics((bool)wait);
		return *(TSQueryStatistics*)&ret;
	}
	-(TSQueryStatistics)getStatistics_2: (BOOL)wait status: (BOOL*)status {
		Tellusim::Query::Statistics ret = [self ref].getStatistics((bool)wait, (bool*)status);
		return *(TSQueryStatistics*)&ret;
	}
	-(TSQueryStatistics)getStatistics_2_: (BOOL)wait status: (BOOL*)status {
		Tellusim::Query::Statistics ret = [self ref].getStatistics((bool)wait, (bool*)status);
		return *(TSQueryStatistics*)&ret;
	}
@end

// Tellusim::FUQuery
@implementation TSFUQuery
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUQuery();
		return self;
	}
	-(id)init_2: (TSQuery**)queries queries_size: (uint32_t)queries_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		impl = new Tellusim::FUQuery(queries_);
		return self;
	}
	-(id)init_2_: (TSQuery**)queries queries_size: (uint32_t)queries_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		impl = new Tellusim::FUQuery(queries_);
		return self;
	}
	-(id)init_3: (TSQuery**)queries queries_size: (uint32_t)queries_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		impl = new Tellusim::FUQuery(queries_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSQuery**)queries queries_size: (uint32_t)queries_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		impl = new Tellusim::FUQuery(queries_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUQuery*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUQuery&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUQuery((Tellusim::FUQuery&)ref);
		return self;
	}
	-(Tellusim::FUQuery*)pointer {
		return (Tellusim::FUQuery*)impl;
	}
	-(Tellusim::FUQuery&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUQuery*)impl;
	}
	-(id)initQuery: (TSQuery*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUQuery([base ref]);
		return self;
	}
	-(TSQuery*)getQuery {
		return [[TSQuery alloc] init_ref:([self ref].getQuery())];
	}
	-(BOOL)equalPtr: (const TSFUQuery*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUQuery*)copyPtr {
		return [[TSFUQuery alloc] init_ref:[self ref]];
	}
	-(TSFUQuery*)clonePtr {
		return [[TSFUQuery alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUQuery*)null {
		return [[TSFUQuery alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumQueries {
		return [self ref].getNumQueries();
	}
	-(const TSQuery*)getQuery: (uint32_t)index {
		return [[TSQuery alloc] init_ref:([self ref].getQuery(index))];
	}
	-(const TSQuery*)getQuery_: (uint32_t)index {
		return [[TSQuery alloc] init_ref:([self ref].getQuery(index))];
	}
@end

// Tellusim::Fence
@implementation TSFence
	-(id)init {
		self = [super init];
		impl = new Tellusim::Fence();
		return self;
	}
	-(id)init_ptr: (Tellusim::Fence*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Fence&)ref {
		self = [super init];
		impl = new Tellusim::Fence((Tellusim::Fence&)ref);
		return self;
	}
	-(Tellusim::Fence*)pointer {
		return (Tellusim::Fence*)impl;
	}
	-(Tellusim::Fence&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Fence*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Fence*)impl;
	}
	-(BOOL)equalPtr: (const TSFence*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFence*)copyPtr {
		return [[TSFence alloc] init_ref:[self ref]];
	}
	-(TSFence*)clonePtr {
		return [[TSFence alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFence*)null {
		return [[TSFence alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(BOOL)create {
		return [self ref].create();
	}
	-(BOOL)create_1: (TS_FenceFlags)flags {
		return [self ref].create((Tellusim::Fence::Flags)flags);
	}
	-(BOOL)create_1_: (TS_FenceFlags)flags {
		return [self ref].create((Tellusim::Fence::Flags)flags);
	}
	-(TS_FenceFlags)getFlags {
		return (TS_FenceFlags)[self ref].getFlags();
	}
	-(BOOL)hasFlag: (TS_FenceFlags)flags {
		return [self ref].hasFlag((Tellusim::Fence::Flags)flags);
	}
	-(BOOL)hasFlag_: (TS_FenceFlags)flags {
		return [self ref].hasFlag((Tellusim::Fence::Flags)flags);
	}
	-(BOOL)hasFlags: (TS_FenceFlags)flags {
		return [self ref].hasFlags((Tellusim::Fence::Flags)flags);
	}
	-(BOOL)hasFlags_: (TS_FenceFlags)flags {
		return [self ref].hasFlags((Tellusim::Fence::Flags)flags);
	}
	-(NSString*)getFlagsName {
		return [NSString stringWithUTF8String:[self ref].getFlagsName().get()];
	}
	-(NSString*)getDescription {
		return [NSString stringWithUTF8String:[self ref].getDescription().get()];
	}
@end

// Tellusim::VKFence
@implementation TSVKFence
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKFence();
		return self;
	}
	-(id)init_ptr: (Tellusim::VKFence*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKFence&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKFence((Tellusim::VKFence&)ref);
		return self;
	}
	-(Tellusim::VKFence*)pointer {
		return (Tellusim::VKFence*)impl;
	}
	-(Tellusim::VKFence&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKFence*)impl;
	}
	-(id)initFence: (TSFence*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKFence([base ref]);
		return self;
	}
	-(TSFence*)getFence {
		return [[TSFence alloc] init_ref:([self ref].getFence())];
	}
	-(BOOL)equalPtr: (const TSVKFence*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKFence*)copyPtr {
		return [[TSVKFence alloc] init_ref:[self ref]];
	}
	-(TSVKFence*)clonePtr {
		return [[TSVKFence alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKFence*)null {
		return [[TSVKFence alloc] init_ptr:nullptr];
	}
	-(VkFence)getVKFence {
		return [self ref].getVKFence();
	}
	-(VkSemaphore)getSemaphore {
		return [self ref].getSemaphore();
	}
	-(void*)getSharedHandle {
		return [self ref].getSharedHandle();
	}
@end

// Tellusim::FUFence
@implementation TSFUFence
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUFence();
		return self;
	}
	-(id)init_2: (TSFence**)fences fences_size: (uint32_t)fences_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Fence> fences_(fences_size);
		for(uint32_t i = 0; i < fences_size; i++) if(fences[i]) fences_[i] = [fences[i] ref];
		impl = new Tellusim::FUFence(fences_);
		return self;
	}
	-(id)init_2_: (TSFence**)fences fences_size: (uint32_t)fences_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Fence> fences_(fences_size);
		for(uint32_t i = 0; i < fences_size; i++) if(fences[i]) fences_[i] = [fences[i] ref];
		impl = new Tellusim::FUFence(fences_);
		return self;
	}
	-(id)init_3: (TSFence**)fences fences_size: (uint32_t)fences_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Fence> fences_(fences_size);
		for(uint32_t i = 0; i < fences_size; i++) if(fences[i]) fences_[i] = [fences[i] ref];
		impl = new Tellusim::FUFence(fences_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSFence**)fences fences_size: (uint32_t)fences_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Fence> fences_(fences_size);
		for(uint32_t i = 0; i < fences_size; i++) if(fences[i]) fences_[i] = [fences[i] ref];
		impl = new Tellusim::FUFence(fences_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUFence*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUFence&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUFence((Tellusim::FUFence&)ref);
		return self;
	}
	-(Tellusim::FUFence*)pointer {
		return (Tellusim::FUFence*)impl;
	}
	-(Tellusim::FUFence&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUFence*)impl;
	}
	-(id)initFence: (TSFence*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUFence([base ref]);
		return self;
	}
	-(TSFence*)getFence {
		return [[TSFence alloc] init_ref:([self ref].getFence())];
	}
	-(BOOL)equalPtr: (const TSFUFence*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUFence*)copyPtr {
		return [[TSFUFence alloc] init_ref:[self ref]];
	}
	-(TSFUFence*)clonePtr {
		return [[TSFUFence alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUFence*)null {
		return [[TSFUFence alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumFences {
		return [self ref].getNumFences();
	}
	-(const TSFence*)getFence: (uint32_t)index {
		return [[TSFence alloc] init_ref:([self ref].getFence(index))];
	}
	-(const TSFence*)getFence_: (uint32_t)index {
		return [[TSFence alloc] init_ref:([self ref].getFence(index))];
	}
@end

// Tellusim::Shader
@implementation TSShader
	-(id)init {
		self = [super init];
		impl = new Tellusim::Shader();
		return self;
	}
	-(id)init_ptr: (Tellusim::Shader*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Shader&)ref {
		self = [super init];
		impl = new Tellusim::Shader((Tellusim::Shader&)ref);
		return self;
	}
	-(Tellusim::Shader*)pointer {
		return (Tellusim::Shader*)impl;
	}
	-(Tellusim::Shader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Shader*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Shader*)impl;
	}
	-(BOOL)equalPtr: (const TSShader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSShader*)copyPtr {
		return [[TSShader alloc] init_ref:[self ref]];
	}
	-(TSShader*)clonePtr {
		return [[TSShader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSShader*)null {
		return [[TSShader alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(BOOL)saveState: (TSStream*)stream {
		return [self ref].saveState([stream ref]);
	}
	-(BOOL)saveState_: (TSStream*)stream {
		return [self ref].saveState([stream ref]);
	}
	-(TS_ShaderType)getType {
		return (TS_ShaderType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_ShaderType)type {
		return [NSString stringWithUTF8String:Tellusim::Shader::getTypeName((Tellusim::Shader::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_ShaderType)type {
		return [NSString stringWithUTF8String:Tellusim::Shader::getTypeName((Tellusim::Shader::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)isVertex {
		return [self ref].isVertex();
	}
	-(BOOL)isControl {
		return [self ref].isControl();
	}
	-(BOOL)isEvaluate {
		return [self ref].isEvaluate();
	}
	-(BOOL)isGeometry {
		return [self ref].isGeometry();
	}
	-(BOOL)isFragment {
		return [self ref].isFragment();
	}
	-(BOOL)isCompute {
		return [self ref].isCompute();
	}
	-(BOOL)isTask {
		return [self ref].isTask();
	}
	-(BOOL)isMesh {
		return [self ref].isMesh();
	}
	-(BOOL)isRayGen {
		return [self ref].isRayGen();
	}
	-(BOOL)isRayMiss {
		return [self ref].isRayMiss();
	}
	-(BOOL)isClosest {
		return [self ref].isClosest();
	}
	-(BOOL)isFirstHit {
		return [self ref].isFirstHit();
	}
	-(BOOL)isIntersection {
		return [self ref].isIntersection();
	}
	-(BOOL)isCallable {
		return [self ref].isCallable();
	}
	-(BOOL)isGraphicsType {
		return [self ref].isGraphicsType();
	}
	-(BOOL)isTessellationType {
		return [self ref].isTessellationType();
	}
	-(BOOL)isTracingType {
		return [self ref].isTracingType();
	}
	-(BOOL)isMeshType {
		return [self ref].isMeshType();
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(NSString*)getMacros {
		return [NSString stringWithUTF8String:[self ref].getMacros().get()];
	}
	-(void)setSamplerOffset: (int32_t)offset {
		[self ref].setSamplerOffset(offset);
	}
	-(void)setSamplerOffset_: (int32_t)offset {
		[self ref].setSamplerOffset(offset);
	}
	-(int32_t)getSamplerOffset {
		return [self ref].getSamplerOffset();
	}
	-(void)setTextureOffset: (int32_t)offset {
		[self ref].setTextureOffset(offset);
	}
	-(void)setTextureOffset_: (int32_t)offset {
		[self ref].setTextureOffset(offset);
	}
	-(int32_t)getTextureOffset {
		return [self ref].getTextureOffset();
	}
	-(void)setSurfaceOffset: (int32_t)offset {
		[self ref].setSurfaceOffset(offset);
	}
	-(void)setSurfaceOffset_: (int32_t)offset {
		[self ref].setSurfaceOffset(offset);
	}
	-(int32_t)getSurfaceOffset {
		return [self ref].getSurfaceOffset();
	}
	-(void)setUniformOffset: (int32_t)offset {
		[self ref].setUniformOffset(offset);
	}
	-(void)setUniformOffset_: (int32_t)offset {
		[self ref].setUniformOffset(offset);
	}
	-(int32_t)getUniformOffset {
		return [self ref].getUniformOffset();
	}
	-(void)setStorageOffset: (int32_t)offset {
		[self ref].setStorageOffset(offset);
	}
	-(void)setStorageOffset_: (int32_t)offset {
		[self ref].setStorageOffset(offset);
	}
	-(int32_t)getStorageOffset {
		return [self ref].getStorageOffset();
	}
	-(void)setTracingOffset: (int32_t)offset {
		[self ref].setTracingOffset(offset);
	}
	-(void)setTracingOffset_: (int32_t)offset {
		[self ref].setTracingOffset(offset);
	}
	-(int32_t)getTracingOffset {
		return [self ref].getTracingOffset();
	}
	-(void)setTexelOffset: (int32_t)offset {
		[self ref].setTexelOffset(offset);
	}
	-(void)setTexelOffset_: (int32_t)offset {
		[self ref].setTexelOffset(offset);
	}
	-(int32_t)getTexelOffset {
		return [self ref].getTexelOffset();
	}
	-(void)setTableOffset: (int32_t)offset {
		[self ref].setTableOffset(offset);
	}
	-(void)setTableOffset_: (int32_t)offset {
		[self ref].setTableOffset(offset);
	}
	-(int32_t)getTableOffset {
		return [self ref].getTableOffset();
	}
	-(void)setPatchSize: (uint32_t)size {
		[self ref].setPatchSize(size);
	}
	-(void)setPatchSize_: (uint32_t)size {
		[self ref].setPatchSize(size);
	}
	-(uint32_t)getPatchSize {
		return [self ref].getPatchSize();
	}
	-(void)setInputSize: (uint32_t)size {
		[self ref].setInputSize(size);
	}
	-(void)setInputSize_: (uint32_t)size {
		[self ref].setInputSize(size);
	}
	-(uint32_t)getInputSize {
		return [self ref].getInputSize();
	}
	-(void)setOutputSize: (uint32_t)size {
		[self ref].setOutputSize(size);
	}
	-(void)setOutputSize_: (uint32_t)size {
		[self ref].setOutputSize(size);
	}
	-(uint32_t)getOutputSize {
		return [self ref].getOutputSize();
	}
	-(BOOL)load: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].load((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)load_: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].load((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)create: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].create((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)create_: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].create((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)load_1: (TS_ShaderType)type name: (const char*)name {
		return [self ref].load((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)load_1_: (TS_ShaderType)type name: (const char*)name {
		return [self ref].load((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)load_2: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].load((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)load_2_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].load((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)load_3: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].load((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)load_3_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].load((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)load_4: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].load((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)load_4_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].load((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)create_1: (TS_ShaderType)type src: (const char*)src {
		return [self ref].create((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)create_1_: (TS_ShaderType)type src: (const char*)src {
		return [self ref].create((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)create_2: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].create((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)create_2_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].create((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)create_3: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].create((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)create_3_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].create((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)create_4: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].create((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)create_4_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].create((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadGLSL: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)loadGLSL_: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)createGLSL: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)createGLSL_: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)loadGLSL_1: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadGLSL_1_: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadGLSL_2: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadGLSL_2_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadGLSL_3: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadGLSL_3_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadGLSL_4: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadGLSL_4_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createGLSL_1: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createGLSL_1_: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createGLSL_2: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createGLSL_2_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createGLSL_3: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createGLSL_3_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createGLSL_4: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createGLSL_4_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadSPIRV: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadSPIRV((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadSPIRV_: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadSPIRV((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)createSPIRV: (TS_ShaderType)type data: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [self ref].createSPIRV((Tellusim::Shader::Type)type, data_);
	}
	-(BOOL)createSPIRV_: (TS_ShaderType)type data: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [self ref].createSPIRV((Tellusim::Shader::Type)type, data_);
	}
	+(BOOL)hasCache {
		return Tellusim::Shader::hasCache();
	}
	+(BOOL)setCache: (const char*)name {
		return Tellusim::Shader::setCache(name);
	}
	+(BOOL)setCache_: (const char*)name {
		return Tellusim::Shader::setCache(name);
	}
	+(BOOL)loadCache: (const TSString*)hash stream: (TSStream*)stream {
		return Tellusim::Shader::loadCache((hash) ? [hash ref] : Tellusim::String::null, [stream ref]);
	}
	+(BOOL)loadCache_: (const TSString*)hash stream: (TSStream*)stream {
		return Tellusim::Shader::loadCache((hash) ? [hash ref] : Tellusim::String::null, [stream ref]);
	}
	+(BOOL)saveCache: (const TSString*)hash stream: (TSStream*)stream {
		return Tellusim::Shader::saveCache((hash) ? [hash ref] : Tellusim::String::null, [stream ref]);
	}
	+(BOOL)saveCache_: (const TSString*)hash stream: (TSStream*)stream {
		return Tellusim::Shader::saveCache((hash) ? [hash ref] : Tellusim::String::null, [stream ref]);
	}
	+(void)clearCache {
		Tellusim::Shader::clearCache();
	}
	+(BOOL)isMacro: (const char*)name {
		return Tellusim::Shader::isMacro(name);
	}
	+(BOOL)isMacro_: (const char*)name {
		return Tellusim::Shader::isMacro(name);
	}
	+(BOOL)setMacro: (const char*)name value: (int32_t)value {
		return Tellusim::Shader::setMacro(name, value);
	}
	+(BOOL)setMacro_: (const char*)name value: (int32_t)value {
		return Tellusim::Shader::setMacro(name, value);
	}
	+(BOOL)setMacro_1: (const char*)name value: (uint32_t)value {
		return Tellusim::Shader::setMacro(name, value);
	}
	+(BOOL)setMacro_1_: (const char*)name value: (uint32_t)value {
		return Tellusim::Shader::setMacro(name, value);
	}
	+(BOOL)setMacro_2: (const char*)name {
		return Tellusim::Shader::setMacro(name);
	}
	+(BOOL)setMacro_2_: (const char*)name {
		return Tellusim::Shader::setMacro(name);
	}
	+(BOOL)setMacro_3: (const char*)name value: (const char*)value {
		return Tellusim::Shader::setMacro(name, value);
	}
	+(BOOL)setMacro_3_: (const char*)name value: (const char*)value {
		return Tellusim::Shader::setMacro(name, value);
	}
	+(BOOL)setMacros: (const char*)macros {
		return Tellusim::Shader::setMacros(macros);
	}
	+(BOOL)setMacros_: (const char*)macros {
		return Tellusim::Shader::setMacros(macros);
	}
	+(BOOL)removeMacro: (const char*)name {
		return Tellusim::Shader::removeMacro(name);
	}
	+(BOOL)removeMacro_: (const char*)name {
		return Tellusim::Shader::removeMacro(name);
	}
	+(void)clearMacros {
		Tellusim::Shader::clearMacros();
	}
	+(BOOL)isInclude: (const char*)name {
		return Tellusim::Shader::isInclude(name);
	}
	+(BOOL)isInclude_: (const char*)name {
		return Tellusim::Shader::isInclude(name);
	}
	+(BOOL)setInclude: (const char*)name src: (const TSString*)src {
		return Tellusim::Shader::setInclude(name, (src) ? [src ref] : Tellusim::String::null);
	}
	+(BOOL)setInclude_: (const char*)name src: (const TSString*)src {
		return Tellusim::Shader::setInclude(name, (src) ? [src ref] : Tellusim::String::null);
	}
	+(BOOL)removeInclude: (const char*)name {
		return Tellusim::Shader::removeInclude(name);
	}
	+(BOOL)removeInclude_: (const char*)name {
		return Tellusim::Shader::removeInclude(name);
	}
	+(void)clearIncludes {
		Tellusim::Shader::clearIncludes();
	}
	+(NSString*)preprocessor: (const char*)src format: (const char*)format {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src, "%s", format).get()];
	}
	+(NSString*)preprocessor_: (const char*)src format: (const char*)format {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src, "%s", format).get()];
	}
	+(NSString*)preprocessor_1: (const char*)src {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src).get()];
	}
	+(NSString*)preprocessor_1_: (const char*)src {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src).get()];
	}
	+(NSString*)preprocessor_2: (const char*)src macros: (const TSString*)macros {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src, (macros) ? [macros ref] : Tellusim::String::null).get()];
	}
	+(NSString*)preprocessor_2_: (const char*)src macros: (const TSString*)macros {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src, (macros) ? [macros ref] : Tellusim::String::null).get()];
	}
	+(NSString*)preprocessor_3: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src, (macros) ? [macros ref] : Tellusim::String::null, includes).get()];
	}
	+(NSString*)preprocessor_3_: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src, (macros) ? [macros ref] : Tellusim::String::null, includes).get()];
	}
	+(NSString*)preprocessor_4: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src, (macros) ? [macros ref] : Tellusim::String::null, includes, size).get()];
	}
	+(NSString*)preprocessor_4_: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [NSString stringWithUTF8String:Tellusim::Shader::preprocessor(src, (macros) ? [macros ref] : Tellusim::String::null, includes, size).get()];
	}
@end

// Tellusim::ShaderCompiler
@implementation TSShaderCompiler
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ShaderCompiler();
		return self;
	}
	-(id)init_ptr: (Tellusim::ShaderCompiler*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ShaderCompiler&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ShaderCompiler((Tellusim::ShaderCompiler&)ref);
		return self;
	}
	-(Tellusim::ShaderCompiler*)pointer {
		return (Tellusim::ShaderCompiler*)impl;
	}
	-(Tellusim::ShaderCompiler&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ShaderCompiler*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ShaderCompiler([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSShaderCompiler*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSShaderCompiler*)copyPtr {
		return [[TSShaderCompiler alloc] init_ref:[self ref]];
	}
	-(TSShaderCompiler*)clonePtr {
		return [[TSShaderCompiler alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSShaderCompiler*)null {
		return [[TSShaderCompiler alloc] init_ptr:nullptr];
	}
	-(void)setFlags: (TS_ShaderCompilerFlags)flags {
		[self ref].setFlags((Tellusim::ShaderCompiler::Flags)flags);
	}
	-(void)setFlags_: (TS_ShaderCompilerFlags)flags {
		[self ref].setFlags((Tellusim::ShaderCompiler::Flags)flags);
	}
	-(TS_ShaderCompilerFlags)getFlags {
		return (TS_ShaderCompilerFlags)[self ref].getFlags();
	}
	-(BOOL)getBinary: (TSStream*)stream {
		return [self ref].getBinary([stream ref]);
	}
	-(BOOL)getBinary_: (TSStream*)stream {
		return [self ref].getBinary([stream ref]);
	}
	-(BOOL)getBinary_1: (TSStream*)stream platform: (TS_Platform)platform {
		return [self ref].getBinary([stream ref], (Tellusim::Platform)platform);
	}
	-(BOOL)getBinary_1_: (TSStream*)stream platform: (TS_Platform)platform {
		return [self ref].getBinary([stream ref], (Tellusim::Platform)platform);
	}
	-(NSString*)getSource {
		return [NSString stringWithUTF8String:[self ref].getSource().get()];
	}
	-(NSString*)getSource_1: (TS_Platform)platform {
		return [NSString stringWithUTF8String:[self ref].getSource((Tellusim::Platform)platform).get()];
	}
	-(NSString*)getSource_1_: (TS_Platform)platform {
		return [NSString stringWithUTF8String:[self ref].getSource((Tellusim::Platform)platform).get()];
	}
@end

// Tellusim::D3D12Shader
@implementation TSD3D12Shader
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Shader();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Shader*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Shader&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Shader((Tellusim::D3D12Shader&)ref);
		return self;
	}
	-(Tellusim::D3D12Shader*)pointer {
		return (Tellusim::D3D12Shader*)impl;
	}
	-(Tellusim::D3D12Shader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Shader*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Shader([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSD3D12Shader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Shader*)copyPtr {
		return [[TSD3D12Shader alloc] init_ref:[self ref]];
	}
	-(TSD3D12Shader*)clonePtr {
		return [[TSD3D12Shader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Shader*)null {
		return [[TSD3D12Shader alloc] init_ptr:nullptr];
	}
	-(ID3DBlob*)getShaderBlob {
		return [self ref].getShaderBlob();
	}
@end

// Tellusim::D3D11Shader
@implementation TSD3D11Shader
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Shader();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D11Shader*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D11Shader&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Shader((Tellusim::D3D11Shader&)ref);
		return self;
	}
	-(Tellusim::D3D11Shader*)pointer {
		return (Tellusim::D3D11Shader*)impl;
	}
	-(Tellusim::D3D11Shader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D11Shader*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Shader([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSD3D11Shader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D11Shader*)copyPtr {
		return [[TSD3D11Shader alloc] init_ref:[self ref]];
	}
	-(TSD3D11Shader*)clonePtr {
		return [[TSD3D11Shader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D11Shader*)null {
		return [[TSD3D11Shader alloc] init_ptr:nullptr];
	}
	-(void*)getD3D11Shader {
		return [self ref].getD3D11Shader();
	}
	-(ID3DBlob*)getShaderBlob {
		return [self ref].getShaderBlob();
	}
@end

// Tellusim::MTLShader
@implementation TSMTLShader
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLShader();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLShader*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLShader&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLShader((Tellusim::MTLShader&)ref);
		return self;
	}
	-(Tellusim::MTLShader*)pointer {
		return (Tellusim::MTLShader*)impl;
	}
	-(Tellusim::MTLShader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLShader*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLShader([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSMTLShader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLShader*)copyPtr {
		return [[TSMTLShader alloc] init_ref:[self ref]];
	}
	-(TSMTLShader*)clonePtr {
		return [[TSMTLShader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLShader*)null {
		return [[TSMTLShader alloc] init_ptr:nullptr];
	}
	-(void)setIndirect: (BOOL)enabled {
		[self ref].setIndirect((bool)enabled);
	}
	-(void)setIndirect_: (BOOL)enabled {
		[self ref].setIndirect((bool)enabled);
	}
	-(BOOL)isIndirect {
		return [self ref].isIndirect();
	}
	-(void*)getLibrary {
		return [self ref].getLibrary();
	}
	-(void*)getFunction {
		return [self ref].getFunction();
	}
@end

// Tellusim::VKShader
@implementation TSVKShader
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKShader();
		return self;
	}
	-(id)init_ptr: (Tellusim::VKShader*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKShader&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKShader((Tellusim::VKShader&)ref);
		return self;
	}
	-(Tellusim::VKShader*)pointer {
		return (Tellusim::VKShader*)impl;
	}
	-(Tellusim::VKShader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKShader*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKShader([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSVKShader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKShader*)copyPtr {
		return [[TSVKShader alloc] init_ref:[self ref]];
	}
	-(TSVKShader*)clonePtr {
		return [[TSVKShader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKShader*)null {
		return [[TSVKShader alloc] init_ptr:nullptr];
	}
	-(VkShaderModule)getModule {
		return [self ref].getModule();
	}
@end

// Tellusim::GLShader
@implementation TSGLShader
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLShader();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLShader*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLShader&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLShader((Tellusim::GLShader&)ref);
		return self;
	}
	-(Tellusim::GLShader*)pointer {
		return (Tellusim::GLShader*)impl;
	}
	-(Tellusim::GLShader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLShader*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLShader([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSGLShader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLShader*)copyPtr {
		return [[TSGLShader alloc] init_ref:[self ref]];
	}
	-(TSGLShader*)clonePtr {
		return [[TSGLShader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLShader*)null {
		return [[TSGLShader alloc] init_ptr:nullptr];
	}
	-(BOOL)attachShader: (uint32_t)program_id {
		return [self ref].attachShader(program_id);
	}
	-(BOOL)attachShader_: (uint32_t)program_id {
		return [self ref].attachShader(program_id);
	}
	-(uint32_t)getShaderType {
		return [self ref].getShaderType();
	}
	-(uint32_t)getShaderID {
		return [self ref].getShaderID();
	}
@end

// Tellusim::GLESShader
@implementation TSGLESShader
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESShader();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLESShader*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLESShader&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESShader((Tellusim::GLESShader&)ref);
		return self;
	}
	-(Tellusim::GLESShader*)pointer {
		return (Tellusim::GLESShader*)impl;
	}
	-(Tellusim::GLESShader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLESShader*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESShader([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSGLESShader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLESShader*)copyPtr {
		return [[TSGLESShader alloc] init_ref:[self ref]];
	}
	-(TSGLESShader*)clonePtr {
		return [[TSGLESShader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLESShader*)null {
		return [[TSGLESShader alloc] init_ptr:nullptr];
	}
	-(BOOL)attachShader: (uint32_t)program_id {
		return [self ref].attachShader(program_id);
	}
	-(BOOL)attachShader_: (uint32_t)program_id {
		return [self ref].attachShader(program_id);
	}
	-(uint32_t)getShaderType {
		return [self ref].getShaderType();
	}
	-(uint32_t)getShaderID {
		return [self ref].getShaderID();
	}
@end

// Tellusim::CUShader
@implementation TSCUShader
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUShader();
		return self;
	}
	-(id)init_ptr: (Tellusim::CUShader*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CUShader&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUShader((Tellusim::CUShader&)ref);
		return self;
	}
	-(Tellusim::CUShader*)pointer {
		return (Tellusim::CUShader*)impl;
	}
	-(Tellusim::CUShader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CUShader*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUShader([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSCUShader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCUShader*)copyPtr {
		return [[TSCUShader alloc] init_ref:[self ref]];
	}
	-(TSCUShader*)clonePtr {
		return [[TSCUShader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCUShader*)null {
		return [[TSCUShader alloc] init_ptr:nullptr];
	}
	-(CUmodule)getModule {
		return [self ref].getModule();
	}
	-(CUfunction)getFunction {
		return [self ref].getFunction();
	}
@end

// Tellusim::HIPShader
@implementation TSHIPShader
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPShader();
		return self;
	}
	-(id)init_ptr: (Tellusim::HIPShader*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::HIPShader&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPShader((Tellusim::HIPShader&)ref);
		return self;
	}
	-(Tellusim::HIPShader*)pointer {
		return (Tellusim::HIPShader*)impl;
	}
	-(Tellusim::HIPShader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::HIPShader*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPShader([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSHIPShader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSHIPShader*)copyPtr {
		return [[TSHIPShader alloc] init_ref:[self ref]];
	}
	-(TSHIPShader*)clonePtr {
		return [[TSHIPShader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSHIPShader*)null {
		return [[TSHIPShader alloc] init_ptr:nullptr];
	}
	-(void*)getModule {
		return [self ref].getModule();
	}
	-(void*)getFunction {
		return [self ref].getFunction();
	}
@end

// Tellusim::FUShader
@implementation TSFUShader
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUShader();
		return self;
	}
	-(id)init_2: (TSShader**)shaders shaders_size: (uint32_t)shaders_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Shader> shaders_(shaders_size);
		for(uint32_t i = 0; i < shaders_size; i++) if(shaders[i]) shaders_[i] = [shaders[i] ref];
		impl = new Tellusim::FUShader(shaders_);
		return self;
	}
	-(id)init_2_: (TSShader**)shaders shaders_size: (uint32_t)shaders_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Shader> shaders_(shaders_size);
		for(uint32_t i = 0; i < shaders_size; i++) if(shaders[i]) shaders_[i] = [shaders[i] ref];
		impl = new Tellusim::FUShader(shaders_);
		return self;
	}
	-(id)init_3: (TSShader**)shaders shaders_size: (uint32_t)shaders_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Shader> shaders_(shaders_size);
		for(uint32_t i = 0; i < shaders_size; i++) if(shaders[i]) shaders_[i] = [shaders[i] ref];
		impl = new Tellusim::FUShader(shaders_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSShader**)shaders shaders_size: (uint32_t)shaders_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Shader> shaders_(shaders_size);
		for(uint32_t i = 0; i < shaders_size; i++) if(shaders[i]) shaders_[i] = [shaders[i] ref];
		impl = new Tellusim::FUShader(shaders_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUShader*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUShader&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUShader((Tellusim::FUShader&)ref);
		return self;
	}
	-(Tellusim::FUShader*)pointer {
		return (Tellusim::FUShader*)impl;
	}
	-(Tellusim::FUShader&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUShader*)impl;
	}
	-(id)initShader: (TSShader*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUShader([base ref]);
		return self;
	}
	-(TSShader*)getShader {
		return [[TSShader alloc] init_ref:([self ref].getShader())];
	}
	-(BOOL)equalPtr: (const TSFUShader*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUShader*)copyPtr {
		return [[TSFUShader alloc] init_ref:[self ref]];
	}
	-(TSFUShader*)clonePtr {
		return [[TSFUShader alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUShader*)null {
		return [[TSFUShader alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumShaders {
		return [self ref].getNumShaders();
	}
	-(const TSShader*)getShader: (uint32_t)index {
		return [[TSShader alloc] init_ref:([self ref].getShader(index))];
	}
	-(const TSShader*)getShader_: (uint32_t)index {
		return [[TSShader alloc] init_ref:([self ref].getShader(index))];
	}
@end

// Tellusim::Sampler
@implementation TSSampler
	-(id)init {
		self = [super init];
		impl = new Tellusim::Sampler();
		return self;
	}
	-(id)init_ptr: (Tellusim::Sampler*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Sampler&)ref {
		self = [super init];
		impl = new Tellusim::Sampler((Tellusim::Sampler&)ref);
		return self;
	}
	-(Tellusim::Sampler*)pointer {
		return (Tellusim::Sampler*)impl;
	}
	-(Tellusim::Sampler&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Sampler*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Sampler*)impl;
	}
	-(BOOL)equalPtr: (const TSSampler*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSSampler*)copyPtr {
		return [[TSSampler alloc] init_ref:[self ref]];
	}
	-(TSSampler*)clonePtr {
		return [[TSSampler alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSSampler*)null {
		return [[TSSampler alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(BOOL)create {
		return [self ref].create();
	}
	-(void)setParameters: (const TSSampler*)sampler {
		[self ref].setParameters([sampler ref]);
	}
	-(void)setParameters_: (const TSSampler*)sampler {
		[self ref].setParameters([sampler ref]);
	}
	-(void)setFilter: (TS_SamplerFilter)filter {
		[self ref].setFilter((Tellusim::Sampler::Filter)filter);
	}
	-(void)setFilter_: (TS_SamplerFilter)filter {
		[self ref].setFilter((Tellusim::Sampler::Filter)filter);
	}
	-(TS_SamplerFilter)getFilter {
		return (TS_SamplerFilter)[self ref].getFilter();
	}
	-(BOOL)isPointFilter {
		return [self ref].isPointFilter();
	}
	-(void)setAnisotropy: (uint32_t)anisotropy {
		[self ref].setAnisotropy(anisotropy);
	}
	-(void)setAnisotropy_: (uint32_t)anisotropy {
		[self ref].setAnisotropy(anisotropy);
	}
	-(uint32_t)getAnisotropy {
		return [self ref].getAnisotropy();
	}
	-(BOOL)hasAnisotropy {
		return [self ref].hasAnisotropy();
	}
	-(void)setWrapMode: (TS_SamplerWrapMode)mode {
		[self ref].setWrapMode((Tellusim::Sampler::WrapMode)mode);
	}
	-(void)setWrapMode_: (TS_SamplerWrapMode)mode {
		[self ref].setWrapMode((Tellusim::Sampler::WrapMode)mode);
	}
	-(void)setWrapMode_1: (TS_SamplerWrapMode)mode_s mode_t: (TS_SamplerWrapMode)mode_t mode_r: (TS_SamplerWrapMode)mode_r {
		[self ref].setWrapMode((Tellusim::Sampler::WrapMode)mode_s, (Tellusim::Sampler::WrapMode)mode_t, (Tellusim::Sampler::WrapMode)mode_r);
	}
	-(void)setWrapMode_1_: (TS_SamplerWrapMode)mode_s mode_t: (TS_SamplerWrapMode)mode_t mode_r: (TS_SamplerWrapMode)mode_r {
		[self ref].setWrapMode((Tellusim::Sampler::WrapMode)mode_s, (Tellusim::Sampler::WrapMode)mode_t, (Tellusim::Sampler::WrapMode)mode_r);
	}
	-(void)setWrapModeS: (TS_SamplerWrapMode)mode {
		[self ref].setWrapModeS((Tellusim::Sampler::WrapMode)mode);
	}
	-(void)setWrapModeS_: (TS_SamplerWrapMode)mode {
		[self ref].setWrapModeS((Tellusim::Sampler::WrapMode)mode);
	}
	-(TS_SamplerWrapMode)getWrapModeS {
		return (TS_SamplerWrapMode)[self ref].getWrapModeS();
	}
	-(void)setWrapModeT: (TS_SamplerWrapMode)mode {
		[self ref].setWrapModeT((Tellusim::Sampler::WrapMode)mode);
	}
	-(void)setWrapModeT_: (TS_SamplerWrapMode)mode {
		[self ref].setWrapModeT((Tellusim::Sampler::WrapMode)mode);
	}
	-(TS_SamplerWrapMode)getWrapModeT {
		return (TS_SamplerWrapMode)[self ref].getWrapModeT();
	}
	-(void)setWrapModeR: (TS_SamplerWrapMode)mode {
		[self ref].setWrapModeR((Tellusim::Sampler::WrapMode)mode);
	}
	-(void)setWrapModeR_: (TS_SamplerWrapMode)mode {
		[self ref].setWrapModeR((Tellusim::Sampler::WrapMode)mode);
	}
	-(TS_SamplerWrapMode)getWrapModeR {
		return (TS_SamplerWrapMode)[self ref].getWrapModeR();
	}
	-(void)setLod: (float32_t)min max: (float32_t)max bias: (float32_t)bias {
		[self ref].setLod(min, max, bias);
	}
	-(void)setLod_: (float32_t)min max: (float32_t)max bias: (float32_t)bias {
		[self ref].setLod(min, max, bias);
	}
	-(void)setLodMin: (float32_t)min {
		[self ref].setLodMin(min);
	}
	-(void)setLodMin_: (float32_t)min {
		[self ref].setLodMin(min);
	}
	-(float32_t)getLodMin {
		return [self ref].getLodMin();
	}
	-(void)setLodMax: (float32_t)max {
		[self ref].setLodMax(max);
	}
	-(void)setLodMax_: (float32_t)max {
		[self ref].setLodMax(max);
	}
	-(float32_t)getLodMax {
		return [self ref].getLodMax();
	}
	-(void)setLodBias: (float32_t)bias {
		[self ref].setLodBias(bias);
	}
	-(void)setLodBias_: (float32_t)bias {
		[self ref].setLodBias(bias);
	}
	-(float32_t)getLodBias {
		return [self ref].getLodBias();
	}
	-(void)setBorderColor: (TSColor)color {
		[self ref].setBorderColor(*(Tellusim::Color*)&color);
	}
	-(void)setBorderColor_: (TSColor)color {
		[self ref].setBorderColor(*(Tellusim::Color*)&color);
	}
	-(void)setBorderColor_1: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setBorderColor(r, g, b, a);
	}
	-(void)setBorderColor_1_: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setBorderColor(r, g, b, a);
	}
	-(TSColor)getBorderColor {
		Tellusim::Color ret = [self ref].getBorderColor();
		return *(TSColor*)&ret;
	}
	-(void)setCompareFunc: (TS_SamplerCompareFunc)func {
		[self ref].setCompareFunc((Tellusim::Sampler::CompareFunc)func);
	}
	-(void)setCompareFunc_: (TS_SamplerCompareFunc)func {
		[self ref].setCompareFunc((Tellusim::Sampler::CompareFunc)func);
	}
	-(TS_SamplerCompareFunc)getCompareFunc {
		return (TS_SamplerCompareFunc)[self ref].getCompareFunc();
	}
	-(void)setReductionMode: (TS_SamplerReductionMode)mode {
		[self ref].setReductionMode((Tellusim::Sampler::ReductionMode)mode);
	}
	-(void)setReductionMode_: (TS_SamplerReductionMode)mode {
		[self ref].setReductionMode((Tellusim::Sampler::ReductionMode)mode);
	}
	-(TS_SamplerReductionMode)getReductionMode {
		return (TS_SamplerReductionMode)[self ref].getReductionMode();
	}
@end

// Tellusim::MTLSampler
@implementation TSMTLSampler
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLSampler();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLSampler*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLSampler&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLSampler((Tellusim::MTLSampler&)ref);
		return self;
	}
	-(Tellusim::MTLSampler*)pointer {
		return (Tellusim::MTLSampler*)impl;
	}
	-(Tellusim::MTLSampler&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLSampler*)impl;
	}
	-(id)initSampler: (TSSampler*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLSampler([base ref]);
		return self;
	}
	-(TSSampler*)getSampler {
		return [[TSSampler alloc] init_ref:([self ref].getSampler())];
	}
	-(BOOL)equalPtr: (const TSMTLSampler*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLSampler*)copyPtr {
		return [[TSMTLSampler alloc] init_ref:[self ref]];
	}
	-(TSMTLSampler*)clonePtr {
		return [[TSMTLSampler alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLSampler*)null {
		return [[TSMTLSampler alloc] init_ptr:nullptr];
	}
	-(void)setIndirect: (BOOL)enabled {
		[self ref].setIndirect((bool)enabled);
	}
	-(void)setIndirect_: (BOOL)enabled {
		[self ref].setIndirect((bool)enabled);
	}
	-(BOOL)isIndirect {
		return [self ref].isIndirect();
	}
@end

// Tellusim::FUSampler
@implementation TSFUSampler
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUSampler();
		return self;
	}
	-(id)init_2: (TSSampler**)samplers samplers_size: (uint32_t)samplers_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Sampler> samplers_(samplers_size);
		for(uint32_t i = 0; i < samplers_size; i++) if(samplers[i]) samplers_[i] = [samplers[i] ref];
		impl = new Tellusim::FUSampler(samplers_);
		return self;
	}
	-(id)init_2_: (TSSampler**)samplers samplers_size: (uint32_t)samplers_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Sampler> samplers_(samplers_size);
		for(uint32_t i = 0; i < samplers_size; i++) if(samplers[i]) samplers_[i] = [samplers[i] ref];
		impl = new Tellusim::FUSampler(samplers_);
		return self;
	}
	-(id)init_3: (TSSampler**)samplers samplers_size: (uint32_t)samplers_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Sampler> samplers_(samplers_size);
		for(uint32_t i = 0; i < samplers_size; i++) if(samplers[i]) samplers_[i] = [samplers[i] ref];
		impl = new Tellusim::FUSampler(samplers_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSSampler**)samplers samplers_size: (uint32_t)samplers_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Sampler> samplers_(samplers_size);
		for(uint32_t i = 0; i < samplers_size; i++) if(samplers[i]) samplers_[i] = [samplers[i] ref];
		impl = new Tellusim::FUSampler(samplers_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUSampler*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUSampler&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUSampler((Tellusim::FUSampler&)ref);
		return self;
	}
	-(Tellusim::FUSampler*)pointer {
		return (Tellusim::FUSampler*)impl;
	}
	-(Tellusim::FUSampler&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUSampler*)impl;
	}
	-(id)initSampler: (TSSampler*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUSampler([base ref]);
		return self;
	}
	-(TSSampler*)getSampler {
		return [[TSSampler alloc] init_ref:([self ref].getSampler())];
	}
	-(BOOL)equalPtr: (const TSFUSampler*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUSampler*)copyPtr {
		return [[TSFUSampler alloc] init_ref:[self ref]];
	}
	-(TSFUSampler*)clonePtr {
		return [[TSFUSampler alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUSampler*)null {
		return [[TSFUSampler alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumSamplers {
		return [self ref].getNumSamplers();
	}
	-(const TSSampler*)getSampler: (uint32_t)index {
		return [[TSSampler alloc] init_ref:([self ref].getSampler(index))];
	}
	-(const TSSampler*)getSampler_: (uint32_t)index {
		return [[TSSampler alloc] init_ref:([self ref].getSampler(index))];
	}
@end

// Tellusim::Texture
@implementation TSTexture
	-(id)init {
		self = [super init];
		impl = new Tellusim::Texture();
		return self;
	}
	-(id)init_ptr: (Tellusim::Texture*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Texture&)ref {
		self = [super init];
		impl = new Tellusim::Texture((Tellusim::Texture&)ref);
		return self;
	}
	-(Tellusim::Texture*)pointer {
		return (Tellusim::Texture*)impl;
	}
	-(Tellusim::Texture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Texture*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Texture*)impl;
	}
	-(BOOL)equalPtr: (const TSTexture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSTexture*)copyPtr {
		return [[TSTexture alloc] init_ref:[self ref]];
	}
	-(TSTexture*)clonePtr {
		return [[TSTexture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSTexture*)null {
		return [[TSTexture alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(BOOL)create: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers {
		return [self ref].create((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers);
	}
	-(BOOL)create_: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers {
		return [self ref].create((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers);
	}
	-(BOOL)create_1: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [self ref].create((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_1_: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [self ref].create((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create2D: (TS_Format)format size: (uint32_t)size {
		return [self ref].create2D((Tellusim::Format)format, size);
	}
	-(BOOL)create2D_: (TS_Format)format size: (uint32_t)size {
		return [self ref].create2D((Tellusim::Format)format, size);
	}
	-(BOOL)create2D_1: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create2D_1_: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create3D: (TS_Format)format size: (uint32_t)size {
		return [self ref].create3D((Tellusim::Format)format, size);
	}
	-(BOOL)create3D_: (TS_Format)format size: (uint32_t)size {
		return [self ref].create3D((Tellusim::Format)format, size);
	}
	-(BOOL)create3D_1: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [self ref].create3D((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create3D_1_: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [self ref].create3D((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)createCube: (TS_Format)format size: (uint32_t)size {
		return [self ref].createCube((Tellusim::Format)format, size);
	}
	-(BOOL)createCube_: (TS_Format)format size: (uint32_t)size {
		return [self ref].createCube((Tellusim::Format)format, size);
	}
	-(BOOL)createCube_1: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [self ref].createCube((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)createCube_1_: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [self ref].createCube((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create2D_2: (TS_Format)format width: (uint32_t)width height: (uint32_t)height {
		return [self ref].create2D((Tellusim::Format)format, width, height);
	}
	-(BOOL)create2D_2_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height {
		return [self ref].create2D((Tellusim::Format)format, width, height);
	}
	-(BOOL)create2D_3: (TS_Format)format width: (uint32_t)width height: (uint32_t)height flags: (TS_TextureFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, width, height, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create2D_3_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height flags: (TS_TextureFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, width, height, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create3D_2: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		return [self ref].create3D((Tellusim::Format)format, width, height, depth);
	}
	-(BOOL)create3D_2_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		return [self ref].create3D((Tellusim::Format)format, width, height, depth);
	}
	-(BOOL)create3D_3: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth flags: (TS_TextureFlags)flags {
		return [self ref].create3D((Tellusim::Format)format, width, height, depth, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create3D_3_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth flags: (TS_TextureFlags)flags {
		return [self ref].create3D((Tellusim::Format)format, width, height, depth, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create2D_4: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers {
		return [self ref].create2D((Tellusim::Format)format, width, height, layers);
	}
	-(BOOL)create2D_4_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers {
		return [self ref].create2D((Tellusim::Format)format, width, height, layers);
	}
	-(BOOL)create2D_5: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, width, height, layers, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create2D_5_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [self ref].create2D((Tellusim::Format)format, width, height, layers, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)createCube_2: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers {
		return [self ref].createCube((Tellusim::Format)format, size, layers);
	}
	-(BOOL)createCube_2_: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers {
		return [self ref].createCube((Tellusim::Format)format, size, layers);
	}
	-(BOOL)createCube_3: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [self ref].createCube((Tellusim::Format)format, size, layers, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)createCube_3_: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [self ref].createCube((Tellusim::Format)format, size, layers, (Tellusim::Texture::Flags)flags);
	}
	-(TS_TextureType)getType {
		return (TS_TextureType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_TextureType)type {
		return [NSString stringWithUTF8String:Tellusim::Texture::getTypeName((Tellusim::Texture::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_TextureType)type {
		return [NSString stringWithUTF8String:Tellusim::Texture::getTypeName((Tellusim::Texture::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)is2DType {
		return [self ref].is2DType();
	}
	-(BOOL)is3DType {
		return [self ref].is3DType();
	}
	-(BOOL)isCubeType {
		return [self ref].isCubeType();
	}
	-(TS_Format)getFormat {
		return (TS_Format)[self ref].getFormat();
	}
	-(NSString*)getFormatName {
		return [NSString stringWithUTF8String:[self ref].getFormatName()];
	}
	-(BOOL)isColorFormat {
		return [self ref].isColorFormat();
	}
	-(BOOL)isDepthFormat {
		return [self ref].isDepthFormat();
	}
	-(BOOL)isPixelFormat {
		return [self ref].isPixelFormat();
	}
	-(BOOL)isPlainFormat {
		return [self ref].isPlainFormat();
	}
	-(BOOL)isMixedFormat {
		return [self ref].isMixedFormat();
	}
	-(BOOL)isBlockFormat {
		return [self ref].isBlockFormat();
	}
	-(BOOL)isStencilFormat {
		return [self ref].isStencilFormat();
	}
	-(BOOL)isNormFormat {
		return [self ref].isNormFormat();
	}
	-(BOOL)isSRGBFormat {
		return [self ref].isSRGBFormat();
	}
	-(BOOL)isFloatFormat {
		return [self ref].isFloatFormat();
	}
	-(BOOL)isSignedFormat {
		return [self ref].isSignedFormat();
	}
	-(BOOL)isUnsignedFormat {
		return [self ref].isUnsignedFormat();
	}
	-(BOOL)isIntegerFormat {
		return [self ref].isIntegerFormat();
	}
	-(BOOL)isi8Format {
		return [self ref].isi8Format();
	}
	-(BOOL)isu8Format {
		return [self ref].isu8Format();
	}
	-(BOOL)is8BitFormat {
		return [self ref].is8BitFormat();
	}
	-(BOOL)isi16Format {
		return [self ref].isi16Format();
	}
	-(BOOL)isu16Format {
		return [self ref].isu16Format();
	}
	-(BOOL)isf16Format {
		return [self ref].isf16Format();
	}
	-(BOOL)is16BitFormat {
		return [self ref].is16BitFormat();
	}
	-(BOOL)isi32Format {
		return [self ref].isi32Format();
	}
	-(BOOL)isu32Format {
		return [self ref].isu32Format();
	}
	-(BOOL)isf32Format {
		return [self ref].isf32Format();
	}
	-(BOOL)is32BitFormat {
		return [self ref].is32BitFormat();
	}
	-(BOOL)isi64Format {
		return [self ref].isi64Format();
	}
	-(BOOL)isu64Format {
		return [self ref].isu64Format();
	}
	-(BOOL)isf64Format {
		return [self ref].isf64Format();
	}
	-(BOOL)is64BitFormat {
		return [self ref].is64BitFormat();
	}
	-(BOOL)isBC15Format {
		return [self ref].isBC15Format();
	}
	-(BOOL)isBC67Format {
		return [self ref].isBC67Format();
	}
	-(BOOL)isETC2Format {
		return [self ref].isETC2Format();
	}
	-(BOOL)isASTCFormat {
		return [self ref].isASTCFormat();
	}
	-(uint32_t)getComponents {
		return [self ref].getComponents();
	}
	-(uint32_t)getPixelSize {
		return [self ref].getPixelSize();
	}
	-(uint32_t)getBlockSize {
		return [self ref].getBlockSize();
	}
	-(uint32_t)getBlockWidth {
		return [self ref].getBlockWidth();
	}
	-(uint32_t)getBlockHeight {
		return [self ref].getBlockHeight();
	}
	-(TS_TextureFlags)getFlags {
		return (TS_TextureFlags)[self ref].getFlags();
	}
	-(BOOL)hasFlag: (TS_TextureFlags)flags {
		return [self ref].hasFlag((Tellusim::Texture::Flags)flags);
	}
	-(BOOL)hasFlag_: (TS_TextureFlags)flags {
		return [self ref].hasFlag((Tellusim::Texture::Flags)flags);
	}
	-(BOOL)hasFlags: (TS_TextureFlags)flags {
		return [self ref].hasFlags((Tellusim::Texture::Flags)flags);
	}
	-(BOOL)hasFlags_: (TS_TextureFlags)flags {
		return [self ref].hasFlags((Tellusim::Texture::Flags)flags);
	}
	-(NSString*)getFlagsName {
		return [NSString stringWithUTF8String:[self ref].getFlagsName().get()];
	}
	-(uint32_t)getMultisample {
		return [self ref].getMultisample();
	}
	-(BOOL)hasMultisample {
		return [self ref].hasMultisample();
	}
	-(uint32_t)getWidth {
		return [self ref].getWidth();
	}
	-(uint32_t)getHeight {
		return [self ref].getHeight();
	}
	-(uint32_t)getDepth {
		return [self ref].getDepth();
	}
	-(uint32_t)getFaces {
		return [self ref].getFaces();
	}
	-(uint32_t)getLayers {
		return [self ref].getLayers();
	}
	-(uint32_t)getMipmaps {
		return [self ref].getMipmaps();
	}
	-(uint32_t)findMipmap: (TSSize)size {
		return [self ref].findMipmap(*(Tellusim::Size*)&size);
	}
	-(uint32_t)findMipmap_: (TSSize)size {
		return [self ref].findMipmap(*(Tellusim::Size*)&size);
	}
	-(uint32_t)getWidth_1: (uint32_t)mipmap {
		return [self ref].getWidth(mipmap);
	}
	-(uint32_t)getWidth_1_: (uint32_t)mipmap {
		return [self ref].getWidth(mipmap);
	}
	-(uint32_t)getHeight_1: (uint32_t)mipmap {
		return [self ref].getHeight(mipmap);
	}
	-(uint32_t)getHeight_1_: (uint32_t)mipmap {
		return [self ref].getHeight(mipmap);
	}
	-(uint32_t)getDepth_1: (uint32_t)mipmap {
		return [self ref].getDepth(mipmap);
	}
	-(uint32_t)getDepth_1_: (uint32_t)mipmap {
		return [self ref].getDepth(mipmap);
	}
	-(BOOL)hasFaces {
		return [self ref].hasFaces();
	}
	-(BOOL)hasLayers {
		return [self ref].hasLayers();
	}
	-(BOOL)hasMipmaps {
		return [self ref].hasMipmaps();
	}
	-(TSSize)getSize {
		Tellusim::Size ret = [self ref].getSize();
		return *(TSSize*)&ret;
	}
	-(TSRegion)getRegion {
		Tellusim::Region ret = [self ref].getRegion();
		return *(TSRegion*)&ret;
	}
	-(TSSlice)getSlice {
		Tellusim::Slice ret = [self ref].getSlice();
		return *(TSSlice*)&ret;
	}
	-(TSSize)getSize_1: (uint32_t)mipmap {
		Tellusim::Size ret = [self ref].getSize(mipmap);
		return *(TSSize*)&ret;
	}
	-(TSSize)getSize_1_: (uint32_t)mipmap {
		Tellusim::Size ret = [self ref].getSize(mipmap);
		return *(TSSize*)&ret;
	}
	-(TSRegion)getRegion_1: (uint32_t)mipmap {
		Tellusim::Region ret = [self ref].getRegion(mipmap);
		return *(TSRegion*)&ret;
	}
	-(TSRegion)getRegion_1_: (uint32_t)mipmap {
		Tellusim::Region ret = [self ref].getRegion(mipmap);
		return *(TSRegion*)&ret;
	}
	-(TSSlice)getSlice_1: (uint32_t)mipmap {
		Tellusim::Slice ret = [self ref].getSlice(mipmap);
		return *(TSSlice*)&ret;
	}
	-(TSSlice)getSlice_1_: (uint32_t)mipmap {
		Tellusim::Slice ret = [self ref].getSlice(mipmap);
		return *(TSSlice*)&ret;
	}
	-(uint32_t)getTileWidth {
		return [self ref].getTileWidth();
	}
	-(uint32_t)getTileHeight {
		return [self ref].getTileHeight();
	}
	-(uint32_t)getTileDepth {
		return [self ref].getTileDepth();
	}
	-(uint32_t)getTileMipmaps {
		return [self ref].getTileMipmaps();
	}
	-(TSSize)getTileSize {
		Tellusim::Size ret = [self ref].getTileSize();
		return *(TSSize*)&ret;
	}
	-(NSString*)getDescription {
		return [NSString stringWithUTF8String:[self ref].getDescription().get()];
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::TextureTable
@implementation TSTextureTable
	-(id)init {
		self = [super init];
		impl = new Tellusim::TextureTable();
		return self;
	}
	-(id)init_ptr: (Tellusim::TextureTable*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::TextureTable&)ref {
		self = [super init];
		impl = new Tellusim::TextureTable((Tellusim::TextureTable&)ref);
		return self;
	}
	-(Tellusim::TextureTable*)pointer {
		return (Tellusim::TextureTable*)impl;
	}
	-(Tellusim::TextureTable&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::TextureTable*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::TextureTable*)impl;
	}
	-(BOOL)equalPtr: (const TSTextureTable*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSTextureTable*)copyPtr {
		return [[TSTextureTable alloc] init_ref:[self ref]];
	}
	-(TSTextureTable*)clonePtr {
		return [[TSTextureTable alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSTextureTable*)null {
		return [[TSTextureTable alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(BOOL)create: (TS_TextureType)type size: (uint32_t)size {
		return [self ref].create((Tellusim::Texture::Type)type, size);
	}
	-(BOOL)create_: (TS_TextureType)type size: (uint32_t)size {
		return [self ref].create((Tellusim::Texture::Type)type, size);
	}
	-(TS_TextureType)getType {
		return (TS_TextureType)[self ref].getType();
	}
	-(NSString*)getTypeName {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(uint32_t)getSize {
		return [self ref].getSize();
	}
	-(TSTexture*)get: (uint32_t)index {
		return [[TSTexture alloc] init_ref:([self ref].get(index))];
	}
	-(TSTexture*)get_: (uint32_t)index {
		return [[TSTexture alloc] init_ref:([self ref].get(index))];
	}
	-(BOOL)isOwner: (uint32_t)index {
		return [self ref].isOwner(index);
	}
	-(BOOL)isOwner_: (uint32_t)index {
		return [self ref].isOwner(index);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::D3D12Texture
@implementation TSD3D12Texture
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Texture();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Texture*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Texture&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Texture((Tellusim::D3D12Texture&)ref);
		return self;
	}
	-(Tellusim::D3D12Texture*)pointer {
		return (Tellusim::D3D12Texture*)impl;
	}
	-(Tellusim::D3D12Texture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Texture*)impl;
	}
	-(id)initTexture: (TSTexture*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Texture([base ref]);
		return self;
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)equalPtr: (const TSD3D12Texture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Texture*)copyPtr {
		return [[TSD3D12Texture alloc] init_ref:[self ref]];
	}
	-(TSD3D12Texture*)clonePtr {
		return [[TSD3D12Texture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Texture*)null {
		return [[TSD3D12Texture alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (TS_TextureType)type texture: (ID3D12Resource*)texture state: (uint32_t)state {
		return [self ref].create((Tellusim::Texture::Type)type, texture, state);
	}
	-(BOOL)create_2_: (TS_TextureType)type texture: (ID3D12Resource*)texture state: (uint32_t)state {
		return [self ref].create((Tellusim::Texture::Type)type, texture, state);
	}
	-(BOOL)create_3: (TS_TextureType)type texture: (ID3D12Resource*)texture state: (uint32_t)state flags: (TS_TextureFlags)flags {
		return [self ref].create((Tellusim::Texture::Type)type, texture, state, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_3_: (TS_TextureType)type texture: (ID3D12Resource*)texture state: (uint32_t)state flags: (TS_TextureFlags)flags {
		return [self ref].create((Tellusim::Texture::Type)type, texture, state, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_4: (TS_TextureType)type texture: (ID3D12Resource*)texture state: (uint32_t)state flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create((Tellusim::Texture::Type)type, texture, state, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(BOOL)create_4_: (TS_TextureType)type texture: (ID3D12Resource*)texture state: (uint32_t)state flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create((Tellusim::Texture::Type)type, texture, state, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(uint32_t)getDXGIFormat {
		return [self ref].getDXGIFormat();
	}
	-(ID3D12Resource*)getD3D12Texture {
		return [self ref].getD3D12Texture();
	}
	-(size_t)getShaderResourceView {
		return [self ref].getShaderResourceView();
	}
	-(size_t)getRenderTargetView {
		return [self ref].getRenderTargetView();
	}
	-(size_t)getDepthStencilView {
		return [self ref].getDepthStencilView();
	}
	-(size_t)getUnorderedAccessView {
		return [self ref].getUnorderedAccessView();
	}
	-(void)setTextureState: (uint32_t)state {
		[self ref].setTextureState(state);
	}
	-(void)setTextureState_: (uint32_t)state {
		[self ref].setTextureState(state);
	}
	-(uint32_t)getTextureState {
		return [self ref].getTextureState();
	}
	-(void*)getSharedHandle {
		return [self ref].getSharedHandle();
	}
	-(void*)getInteropHandle {
		return [self ref].getInteropHandle();
	}
@end

// Tellusim::D3D11Texture
@implementation TSD3D11Texture
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Texture();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D11Texture*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D11Texture&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Texture((Tellusim::D3D11Texture&)ref);
		return self;
	}
	-(Tellusim::D3D11Texture*)pointer {
		return (Tellusim::D3D11Texture*)impl;
	}
	-(Tellusim::D3D11Texture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D11Texture*)impl;
	}
	-(id)initTexture: (TSTexture*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Texture([base ref]);
		return self;
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)equalPtr: (const TSD3D11Texture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D11Texture*)copyPtr {
		return [[TSD3D11Texture alloc] init_ref:[self ref]];
	}
	-(TSD3D11Texture*)clonePtr {
		return [[TSD3D11Texture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D11Texture*)null {
		return [[TSD3D11Texture alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (TS_TextureType)type texture: (ID3D11Texture2D*)texture {
		return [self ref].create((Tellusim::Texture::Type)type, texture);
	}
	-(BOOL)create_2_: (TS_TextureType)type texture: (ID3D11Texture2D*)texture {
		return [self ref].create((Tellusim::Texture::Type)type, texture);
	}
	-(BOOL)create_3: (TS_TextureType)type texture: (ID3D11Texture2D*)texture flags: (TS_TextureFlags)flags {
		return [self ref].create((Tellusim::Texture::Type)type, texture, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_3_: (TS_TextureType)type texture: (ID3D11Texture2D*)texture flags: (TS_TextureFlags)flags {
		return [self ref].create((Tellusim::Texture::Type)type, texture, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_4: (TS_TextureType)type texture: (ID3D11Texture2D*)texture flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create((Tellusim::Texture::Type)type, texture, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(BOOL)create_4_: (TS_TextureType)type texture: (ID3D11Texture2D*)texture flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create((Tellusim::Texture::Type)type, texture, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(uint32_t)getDXGIFormat {
		return [self ref].getDXGIFormat();
	}
	-(ID3D11Texture2D*)getD3D11Texture {
		return [self ref].getD3D11Texture();
	}
	-(ID3D11ShaderResourceView*)getShaderResourceView {
		return [self ref].getShaderResourceView();
	}
	-(ID3D11RenderTargetView*)getRenderTargetView {
		return [self ref].getRenderTargetView();
	}
	-(ID3D11DepthStencilView*)getDepthStencilView {
		return [self ref].getDepthStencilView();
	}
	-(ID3D11UnorderedAccessView*)getUnorderedAccessView {
		return [self ref].getUnorderedAccessView();
	}
	-(void*)getInteropHandle {
		return [self ref].getInteropHandle();
	}
@end

// Tellusim::MTLTexture
@implementation TSMTLTexture
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLTexture();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLTexture*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLTexture&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLTexture((Tellusim::MTLTexture&)ref);
		return self;
	}
	-(Tellusim::MTLTexture*)pointer {
		return (Tellusim::MTLTexture*)impl;
	}
	-(Tellusim::MTLTexture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLTexture*)impl;
	}
	-(id)initTexture: (TSTexture*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLTexture([base ref]);
		return self;
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)equalPtr: (const TSMTLTexture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLTexture*)copyPtr {
		return [[TSMTLTexture alloc] init_ref:[self ref]];
	}
	-(TSMTLTexture*)clonePtr {
		return [[TSMTLTexture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLTexture*)null {
		return [[TSMTLTexture alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (void*)texture {
		return [self ref].create(texture);
	}
	-(BOOL)create_2_: (void*)texture {
		return [self ref].create(texture);
	}
	-(BOOL)create_3: (void*)texture flags: (TS_TextureFlags)flags {
		return [self ref].create(texture, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_3_: (void*)texture flags: (TS_TextureFlags)flags {
		return [self ref].create(texture, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_4: (void*)texture flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create(texture, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(BOOL)create_4_: (void*)texture flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create(texture, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(uint32_t)getPixelFormat {
		return [self ref].getPixelFormat();
	}
	-(uint32_t)getTextureType {
		return [self ref].getTextureType();
	}
	-(void*)getMTLTexture {
		return [self ref].getMTLTexture();
	}
	-(void*)getMTLBuffer {
		return [self ref].getMTLBuffer();
	}
	-(void*)getSharedPtr {
		return [self ref].getSharedPtr();
	}
@end

// Tellusim::VKTexture
@implementation TSVKTexture
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKTexture();
		return self;
	}
	-(id)init_ptr: (Tellusim::VKTexture*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKTexture&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKTexture((Tellusim::VKTexture&)ref);
		return self;
	}
	-(Tellusim::VKTexture*)pointer {
		return (Tellusim::VKTexture*)impl;
	}
	-(Tellusim::VKTexture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKTexture*)impl;
	}
	-(id)initTexture: (TSTexture*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKTexture([base ref]);
		return self;
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)equalPtr: (const TSVKTexture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKTexture*)copyPtr {
		return [[TSVKTexture alloc] init_ref:[self ref]];
	}
	-(TSVKTexture*)clonePtr {
		return [[TSVKTexture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKTexture*)null {
		return [[TSVKTexture alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (TS_TextureType)type format: (uint32_t)format texture: (VkImage)texture layout: (uint32_t)layout {
		return [self ref].create((Tellusim::Texture::Type)type, format, texture, layout);
	}
	-(BOOL)create_2_: (TS_TextureType)type format: (uint32_t)format texture: (VkImage)texture layout: (uint32_t)layout {
		return [self ref].create((Tellusim::Texture::Type)type, format, texture, layout);
	}
	-(BOOL)create_3: (TS_TextureType)type format: (uint32_t)format texture: (VkImage)texture layout: (uint32_t)layout flags: (TS_TextureFlags)flags {
		return [self ref].create((Tellusim::Texture::Type)type, format, texture, layout, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_3_: (TS_TextureType)type format: (uint32_t)format texture: (VkImage)texture layout: (uint32_t)layout flags: (TS_TextureFlags)flags {
		return [self ref].create((Tellusim::Texture::Type)type, format, texture, layout, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_4: (TS_TextureType)type format: (uint32_t)format texture: (VkImage)texture layout: (uint32_t)layout flags: (TS_TextureFlags)flags texture_format: (TS_Format)texture_format {
		return [self ref].create((Tellusim::Texture::Type)type, format, texture, layout, (Tellusim::Texture::Flags)flags, (Tellusim::Format)texture_format);
	}
	-(BOOL)create_4_: (TS_TextureType)type format: (uint32_t)format texture: (VkImage)texture layout: (uint32_t)layout flags: (TS_TextureFlags)flags texture_format: (TS_Format)texture_format {
		return [self ref].create((Tellusim::Texture::Type)type, format, texture, layout, (Tellusim::Texture::Flags)flags, (Tellusim::Format)texture_format);
	}
	-(uint32_t)getPixelFormat {
		return [self ref].getPixelFormat();
	}
	-(VkImage)getVKTexture {
		return [self ref].getVKTexture();
	}
	-(VkImageView)getTextureView {
		return [self ref].getTextureView();
	}
	-(void)setTextureLayout: (uint32_t)layout {
		[self ref].setTextureLayout(layout);
	}
	-(void)setTextureLayout_: (uint32_t)layout {
		[self ref].setTextureLayout(layout);
	}
	-(uint32_t)getTextureLayout {
		return [self ref].getTextureLayout();
	}
	-(void)getTextureRange: (void*)range slice: (TSSlice)slice {
		[self ref].getTextureRange(range, *(Tellusim::Slice*)&slice);
	}
	-(void)getTextureRange_: (void*)range slice: (TSSlice)slice {
		[self ref].getTextureRange(range, *(Tellusim::Slice*)&slice);
	}
	-(void*)getSharedPtr {
		return [self ref].getSharedPtr();
	}
	-(void*)getInteropHandle {
		return [self ref].getInteropHandle();
	}
@end

// Tellusim::GLTexture
@implementation TSGLTexture
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLTexture();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLTexture*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLTexture&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLTexture((Tellusim::GLTexture&)ref);
		return self;
	}
	-(Tellusim::GLTexture*)pointer {
		return (Tellusim::GLTexture*)impl;
	}
	-(Tellusim::GLTexture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLTexture*)impl;
	}
	-(id)initTexture: (TSTexture*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLTexture([base ref]);
		return self;
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)equalPtr: (const TSGLTexture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLTexture*)copyPtr {
		return [[TSGLTexture alloc] init_ref:[self ref]];
	}
	-(TSGLTexture*)clonePtr {
		return [[TSGLTexture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLTexture*)null {
		return [[TSGLTexture alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (uint32_t)target texture_id: (uint32_t)texture_id {
		return [self ref].create(target, texture_id);
	}
	-(BOOL)create_2_: (uint32_t)target texture_id: (uint32_t)texture_id {
		return [self ref].create(target, texture_id);
	}
	-(BOOL)create_3: (uint32_t)target texture_id: (uint32_t)texture_id flags: (TS_TextureFlags)flags {
		return [self ref].create(target, texture_id, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_3_: (uint32_t)target texture_id: (uint32_t)texture_id flags: (TS_TextureFlags)flags {
		return [self ref].create(target, texture_id, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_4: (uint32_t)target texture_id: (uint32_t)texture_id flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create(target, texture_id, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(BOOL)create_4_: (uint32_t)target texture_id: (uint32_t)texture_id flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create(target, texture_id, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(uint32_t)getTarget {
		return [self ref].getTarget();
	}
	-(uint32_t)getInternalFormat {
		return [self ref].getInternalFormat();
	}
	-(uint32_t)getTextureID {
		return [self ref].getTextureID();
	}
@end

// Tellusim::GLESTexture
@implementation TSGLESTexture
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESTexture();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLESTexture*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLESTexture&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESTexture((Tellusim::GLESTexture&)ref);
		return self;
	}
	-(Tellusim::GLESTexture*)pointer {
		return (Tellusim::GLESTexture*)impl;
	}
	-(Tellusim::GLESTexture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLESTexture*)impl;
	}
	-(id)initTexture: (TSTexture*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESTexture([base ref]);
		return self;
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)equalPtr: (const TSGLESTexture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLESTexture*)copyPtr {
		return [[TSGLESTexture alloc] init_ref:[self ref]];
	}
	-(TSGLESTexture*)clonePtr {
		return [[TSGLESTexture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLESTexture*)null {
		return [[TSGLESTexture alloc] init_ptr:nullptr];
	}
	-(BOOL)create_2: (uint32_t)target texture_id: (uint32_t)texture_id {
		return [self ref].create(target, texture_id);
	}
	-(BOOL)create_2_: (uint32_t)target texture_id: (uint32_t)texture_id {
		return [self ref].create(target, texture_id);
	}
	-(BOOL)create_3: (uint32_t)target texture_id: (uint32_t)texture_id flags: (TS_TextureFlags)flags {
		return [self ref].create(target, texture_id, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_3_: (uint32_t)target texture_id: (uint32_t)texture_id flags: (TS_TextureFlags)flags {
		return [self ref].create(target, texture_id, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)create_4: (uint32_t)target texture_id: (uint32_t)texture_id flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create(target, texture_id, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(BOOL)create_4_: (uint32_t)target texture_id: (uint32_t)texture_id flags: (TS_TextureFlags)flags format: (TS_Format)format {
		return [self ref].create(target, texture_id, (Tellusim::Texture::Flags)flags, (Tellusim::Format)format);
	}
	-(uint32_t)getTarget {
		return [self ref].getTarget();
	}
	-(uint32_t)getInternalFormat {
		return [self ref].getInternalFormat();
	}
	-(uint32_t)getTextureID {
		return [self ref].getTextureID();
	}
@end

// Tellusim::CUTexture
@implementation TSCUTexture
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUTexture();
		return self;
	}
	-(id)init_ptr: (Tellusim::CUTexture*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CUTexture&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUTexture((Tellusim::CUTexture&)ref);
		return self;
	}
	-(Tellusim::CUTexture*)pointer {
		return (Tellusim::CUTexture*)impl;
	}
	-(Tellusim::CUTexture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CUTexture*)impl;
	}
	-(id)initTexture: (TSTexture*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CUTexture([base ref]);
		return self;
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)equalPtr: (const TSCUTexture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCUTexture*)copyPtr {
		return [[TSCUTexture alloc] init_ref:[self ref]];
	}
	-(TSCUTexture*)clonePtr {
		return [[TSCUTexture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCUTexture*)null {
		return [[TSCUTexture alloc] init_ptr:nullptr];
	}
	-(CUmipmappedArray)getTextureArray {
		return [self ref].getTextureArray();
	}
	-(CUarray)getTextureLevel: (uint32_t)index {
		return [self ref].getTextureLevel(index);
	}
	-(CUarray)getTextureLevel_: (uint32_t)index {
		return [self ref].getTextureLevel(index);
	}
	-(uint32_t)getArrayFormat {
		return [self ref].getArrayFormat();
	}
	-(uint32_t)getArrayChannels {
		return [self ref].getArrayChannels();
	}
	-(CUexternalMemory)getSharedMemory {
		return [self ref].getSharedMemory();
	}
@end

// Tellusim::HIPTexture
@implementation TSHIPTexture
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPTexture();
		return self;
	}
	-(id)init_ptr: (Tellusim::HIPTexture*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::HIPTexture&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPTexture((Tellusim::HIPTexture&)ref);
		return self;
	}
	-(Tellusim::HIPTexture*)pointer {
		return (Tellusim::HIPTexture*)impl;
	}
	-(Tellusim::HIPTexture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::HIPTexture*)impl;
	}
	-(id)initTexture: (TSTexture*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::HIPTexture([base ref]);
		return self;
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)equalPtr: (const TSHIPTexture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSHIPTexture*)copyPtr {
		return [[TSHIPTexture alloc] init_ref:[self ref]];
	}
	-(TSHIPTexture*)clonePtr {
		return [[TSHIPTexture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSHIPTexture*)null {
		return [[TSHIPTexture alloc] init_ptr:nullptr];
	}
	-(void*)getTextureArray {
		return [self ref].getTextureArray();
	}
	-(void*)getTextureLevel: (uint32_t)index {
		return [self ref].getTextureLevel(index);
	}
	-(void*)getTextureLevel_: (uint32_t)index {
		return [self ref].getTextureLevel(index);
	}
	-(const void*)getChannelFormat {
		return [self ref].getChannelFormat();
	}
@end

// Tellusim::FUTexture
@implementation TSFUTexture
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTexture();
		return self;
	}
	-(id)init_2: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		impl = new Tellusim::FUTexture(textures_);
		return self;
	}
	-(id)init_2_: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		impl = new Tellusim::FUTexture(textures_);
		return self;
	}
	-(id)init_3: (TSTexture**)textures textures_size: (uint32_t)textures_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		impl = new Tellusim::FUTexture(textures_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSTexture**)textures textures_size: (uint32_t)textures_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		impl = new Tellusim::FUTexture(textures_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUTexture*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUTexture&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTexture((Tellusim::FUTexture&)ref);
		return self;
	}
	-(Tellusim::FUTexture*)pointer {
		return (Tellusim::FUTexture*)impl;
	}
	-(Tellusim::FUTexture&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUTexture*)impl;
	}
	-(id)initTexture: (TSTexture*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTexture([base ref]);
		return self;
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)equalPtr: (const TSFUTexture*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUTexture*)copyPtr {
		return [[TSFUTexture alloc] init_ref:[self ref]];
	}
	-(TSFUTexture*)clonePtr {
		return [[TSFUTexture alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUTexture*)null {
		return [[TSFUTexture alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumTextures {
		return [self ref].getNumTextures();
	}
	-(const TSTexture*)getTexture: (uint32_t)index {
		return [[TSTexture alloc] init_ref:([self ref].getTexture(index))];
	}
	-(const TSTexture*)getTexture_: (uint32_t)index {
		return [[TSTexture alloc] init_ref:([self ref].getTexture(index))];
	}
@end

// Tellusim::Tracing
@implementation TSTracing
	-(id)init {
		self = [super init];
		impl = new Tellusim::Tracing();
		return self;
	}
	-(id)init_ptr: (Tellusim::Tracing*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Tracing&)ref {
		self = [super init];
		impl = new Tellusim::Tracing((Tellusim::Tracing&)ref);
		return self;
	}
	-(Tellusim::Tracing*)pointer {
		return (Tellusim::Tracing*)impl;
	}
	-(Tellusim::Tracing&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Tracing*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Tracing*)impl;
	}
	-(BOOL)equalPtr: (const TSTracing*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSTracing*)copyPtr {
		return [[TSTracing alloc] init_ref:[self ref]];
	}
	-(TSTracing*)clonePtr {
		return [[TSTracing alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSTracing*)null {
		return [[TSTracing alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(BOOL)isBuilt {
		return [self ref].isBuilt();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(BOOL)create: (TS_TracingType)type {
		return [self ref].create((Tellusim::Tracing::Type)type);
	}
	-(BOOL)create_: (TS_TracingType)type {
		return [self ref].create((Tellusim::Tracing::Type)type);
	}
	-(BOOL)create_1: (TS_TracingType)type flags: (TS_TracingFlags)flags {
		return [self ref].create((Tellusim::Tracing::Type)type, (Tellusim::Tracing::Flags)flags);
	}
	-(BOOL)create_1_: (TS_TracingType)type flags: (TS_TracingFlags)flags {
		return [self ref].create((Tellusim::Tracing::Type)type, (Tellusim::Tracing::Flags)flags);
	}
	-(TS_TracingType)getType {
		return (TS_TracingType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_TracingType)type {
		return [NSString stringWithUTF8String:Tellusim::Tracing::getTypeName((Tellusim::Tracing::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_TracingType)type {
		return [NSString stringWithUTF8String:Tellusim::Tracing::getTypeName((Tellusim::Tracing::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)isInstanceType {
		return [self ref].isInstanceType();
	}
	-(BOOL)isTriangleType {
		return [self ref].isTriangleType();
	}
	-(BOOL)isBoundType {
		return [self ref].isBoundType();
	}
	-(BOOL)isGeometryType {
		return [self ref].isGeometryType();
	}
	-(void)setParameters: (const TSTracing*)tracing {
		[self ref].setParameters([tracing ref]);
	}
	-(void)setParameters_: (const TSTracing*)tracing {
		[self ref].setParameters([tracing ref]);
	}
	-(uint32_t)getNumGeometries {
		return [self ref].getNumGeometries();
	}
	-(void)setInstanceBuffer: (uint32_t)num_instances buffer: (TSBuffer*)buffer {
		[self ref].setInstanceBuffer(num_instances, [buffer ref]);
	}
	-(void)setInstanceBuffer_: (uint32_t)num_instances buffer: (TSBuffer*)buffer {
		[self ref].setInstanceBuffer(num_instances, [buffer ref]);
	}
	-(void)setInstanceBuffer_1: (uint32_t)num_instances buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setInstanceBuffer(num_instances, [buffer ref], offset);
	}
	-(void)setInstanceBuffer_1_: (uint32_t)num_instances buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setInstanceBuffer(num_instances, [buffer ref], offset);
	}
	-(void)setInstanceBuffer_2: (TSBuffer*)buffer {
		[self ref].setInstanceBuffer([buffer ref]);
	}
	-(void)setInstanceBuffer_2_: (TSBuffer*)buffer {
		[self ref].setInstanceBuffer([buffer ref]);
	}
	-(void)setInstanceBuffer_3: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setInstanceBuffer([buffer ref], offset);
	}
	-(void)setInstanceBuffer_3_: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setInstanceBuffer([buffer ref], offset);
	}
	-(void)setNumInstances: (uint32_t)num_instances {
		[self ref].setNumInstances(num_instances);
	}
	-(void)setNumInstances_: (uint32_t)num_instances {
		[self ref].setNumInstances(num_instances);
	}
	-(uint32_t)getNumInstances {
		return [self ref].getNumInstances();
	}
	-(TSBuffer*)getInstanceBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getInstanceBuffer())];
	}
	-(size_t)getInstanceOffset {
		return [self ref].getInstanceOffset();
	}
	-(void)setIndirectBuffer: (TSBuffer*)buffer {
		[self ref].setIndirectBuffer([buffer ref]);
	}
	-(void)setIndirectBuffer_: (TSBuffer*)buffer {
		[self ref].setIndirectBuffer([buffer ref]);
	}
	-(void)setIndirectBuffer_1: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndirectBuffer([buffer ref], offset);
	}
	-(void)setIndirectBuffer_1_: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndirectBuffer([buffer ref], offset);
	}
	-(TSBuffer*)getIndirectBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getIndirectBuffer())];
	}
	-(size_t)getIndirectOffset {
		return [self ref].getIndirectOffset();
	}
	-(uint32_t)addVertexBuffer: (uint32_t)num_vertices format: (TS_Format)format stride: (size_t)stride {
		return [self ref].addVertexBuffer(num_vertices, (Tellusim::Format)format, stride);
	}
	-(uint32_t)addVertexBuffer_: (uint32_t)num_vertices format: (TS_Format)format stride: (size_t)stride {
		return [self ref].addVertexBuffer(num_vertices, (Tellusim::Format)format, stride);
	}
	-(uint32_t)addVertexBuffer_1: (uint32_t)num_vertices format: (TS_Format)format stride: (size_t)stride buffer: (TSBuffer*)buffer {
		return [self ref].addVertexBuffer(num_vertices, (Tellusim::Format)format, stride, [buffer ref]);
	}
	-(uint32_t)addVertexBuffer_1_: (uint32_t)num_vertices format: (TS_Format)format stride: (size_t)stride buffer: (TSBuffer*)buffer {
		return [self ref].addVertexBuffer(num_vertices, (Tellusim::Format)format, stride, [buffer ref]);
	}
	-(uint32_t)addVertexBuffer_2: (uint32_t)num_vertices format: (TS_Format)format stride: (size_t)stride buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].addVertexBuffer(num_vertices, (Tellusim::Format)format, stride, [buffer ref], offset);
	}
	-(uint32_t)addVertexBuffer_2_: (uint32_t)num_vertices format: (TS_Format)format stride: (size_t)stride buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].addVertexBuffer(num_vertices, (Tellusim::Format)format, stride, [buffer ref], offset);
	}
	-(void)setVertexBuffer: (uint32_t)index num_vertices: (uint32_t)num_vertices buffer: (TSBuffer*)buffer {
		[self ref].setVertexBuffer(index, num_vertices, [buffer ref]);
	}
	-(void)setVertexBuffer_: (uint32_t)index num_vertices: (uint32_t)num_vertices buffer: (TSBuffer*)buffer {
		[self ref].setVertexBuffer(index, num_vertices, [buffer ref]);
	}
	-(void)setVertexBuffer_1: (uint32_t)index num_vertices: (uint32_t)num_vertices buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setVertexBuffer(index, num_vertices, [buffer ref], offset);
	}
	-(void)setVertexBuffer_1_: (uint32_t)index num_vertices: (uint32_t)num_vertices buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setVertexBuffer(index, num_vertices, [buffer ref], offset);
	}
	-(void)setVertexBuffer_2: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setVertexBuffer(index, [buffer ref]);
	}
	-(void)setVertexBuffer_2_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setVertexBuffer(index, [buffer ref]);
	}
	-(void)setVertexBuffer_3: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setVertexBuffer(index, [buffer ref], offset);
	}
	-(void)setVertexBuffer_3_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setVertexBuffer(index, [buffer ref], offset);
	}
	-(void)setNumVertices: (uint32_t)index num_vertices: (uint32_t)num_vertices {
		[self ref].setNumVertices(index, num_vertices);
	}
	-(void)setNumVertices_: (uint32_t)index num_vertices: (uint32_t)num_vertices {
		[self ref].setNumVertices(index, num_vertices);
	}
	-(uint32_t)getNumVertices: (uint32_t)index {
		return [self ref].getNumVertices(index);
	}
	-(uint32_t)getNumVertices_: (uint32_t)index {
		return [self ref].getNumVertices(index);
	}
	-(TS_Format)getVertexFormat: (uint32_t)index {
		return (TS_Format)[self ref].getVertexFormat(index);
	}
	-(TS_Format)getVertexFormat_: (uint32_t)index {
		return (TS_Format)[self ref].getVertexFormat(index);
	}
	-(uint32_t)getVertexStride: (uint32_t)index {
		return [self ref].getVertexStride(index);
	}
	-(uint32_t)getVertexStride_: (uint32_t)index {
		return [self ref].getVertexStride(index);
	}
	-(TSBuffer*)getVertexBuffer: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].getVertexBuffer(index))];
	}
	-(TSBuffer*)getVertexBuffer_: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].getVertexBuffer(index))];
	}
	-(size_t)getVertexOffset: (uint32_t)index {
		return [self ref].getVertexOffset(index);
	}
	-(size_t)getVertexOffset_: (uint32_t)index {
		return [self ref].getVertexOffset(index);
	}
	-(uint32_t)addIndexBuffer: (uint32_t)num_indices format: (TS_Format)format {
		return [self ref].addIndexBuffer(num_indices, (Tellusim::Format)format);
	}
	-(uint32_t)addIndexBuffer_: (uint32_t)num_indices format: (TS_Format)format {
		return [self ref].addIndexBuffer(num_indices, (Tellusim::Format)format);
	}
	-(uint32_t)addIndexBuffer_1: (uint32_t)num_indices format: (TS_Format)format buffer: (TSBuffer*)buffer {
		return [self ref].addIndexBuffer(num_indices, (Tellusim::Format)format, [buffer ref]);
	}
	-(uint32_t)addIndexBuffer_1_: (uint32_t)num_indices format: (TS_Format)format buffer: (TSBuffer*)buffer {
		return [self ref].addIndexBuffer(num_indices, (Tellusim::Format)format, [buffer ref]);
	}
	-(uint32_t)addIndexBuffer_2: (uint32_t)num_indices format: (TS_Format)format buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].addIndexBuffer(num_indices, (Tellusim::Format)format, [buffer ref], offset);
	}
	-(uint32_t)addIndexBuffer_2_: (uint32_t)num_indices format: (TS_Format)format buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].addIndexBuffer(num_indices, (Tellusim::Format)format, [buffer ref], offset);
	}
	-(void)setIndexBuffer: (uint32_t)index num_indices: (uint32_t)num_indices buffer: (TSBuffer*)buffer {
		[self ref].setIndexBuffer(index, num_indices, [buffer ref]);
	}
	-(void)setIndexBuffer_: (uint32_t)index num_indices: (uint32_t)num_indices buffer: (TSBuffer*)buffer {
		[self ref].setIndexBuffer(index, num_indices, [buffer ref]);
	}
	-(void)setIndexBuffer_1: (uint32_t)index num_indices: (uint32_t)num_indices buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndexBuffer(index, num_indices, [buffer ref], offset);
	}
	-(void)setIndexBuffer_1_: (uint32_t)index num_indices: (uint32_t)num_indices buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndexBuffer(index, num_indices, [buffer ref], offset);
	}
	-(void)setIndexBuffer_2: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setIndexBuffer(index, [buffer ref]);
	}
	-(void)setIndexBuffer_2_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setIndexBuffer(index, [buffer ref]);
	}
	-(void)setIndexBuffer_3: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndexBuffer(index, [buffer ref], offset);
	}
	-(void)setIndexBuffer_3_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setIndexBuffer(index, [buffer ref], offset);
	}
	-(void)setNumIndices: (uint32_t)index num_indices: (uint32_t)num_indices {
		[self ref].setNumIndices(index, num_indices);
	}
	-(void)setNumIndices_: (uint32_t)index num_indices: (uint32_t)num_indices {
		[self ref].setNumIndices(index, num_indices);
	}
	-(uint32_t)getNumIndices: (uint32_t)index {
		return [self ref].getNumIndices(index);
	}
	-(uint32_t)getNumIndices_: (uint32_t)index {
		return [self ref].getNumIndices(index);
	}
	-(TS_Format)getIndexFormat: (uint32_t)index {
		return (TS_Format)[self ref].getIndexFormat(index);
	}
	-(TS_Format)getIndexFormat_: (uint32_t)index {
		return (TS_Format)[self ref].getIndexFormat(index);
	}
	-(TSBuffer*)getIndexBuffer: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].getIndexBuffer(index))];
	}
	-(TSBuffer*)getIndexBuffer_: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].getIndexBuffer(index))];
	}
	-(size_t)getIndexOffset: (uint32_t)index {
		return [self ref].getIndexOffset(index);
	}
	-(size_t)getIndexOffset_: (uint32_t)index {
		return [self ref].getIndexOffset(index);
	}
	-(uint32_t)addBoundBuffer: (uint32_t)num_bounds stride: (size_t)stride {
		return [self ref].addBoundBuffer(num_bounds, stride);
	}
	-(uint32_t)addBoundBuffer_: (uint32_t)num_bounds stride: (size_t)stride {
		return [self ref].addBoundBuffer(num_bounds, stride);
	}
	-(uint32_t)addBoundBuffer_1: (uint32_t)num_bounds stride: (size_t)stride buffer: (TSBuffer*)buffer {
		return [self ref].addBoundBuffer(num_bounds, stride, [buffer ref]);
	}
	-(uint32_t)addBoundBuffer_1_: (uint32_t)num_bounds stride: (size_t)stride buffer: (TSBuffer*)buffer {
		return [self ref].addBoundBuffer(num_bounds, stride, [buffer ref]);
	}
	-(uint32_t)addBoundBuffer_2: (uint32_t)num_bounds stride: (size_t)stride buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].addBoundBuffer(num_bounds, stride, [buffer ref], offset);
	}
	-(uint32_t)addBoundBuffer_2_: (uint32_t)num_bounds stride: (size_t)stride buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].addBoundBuffer(num_bounds, stride, [buffer ref], offset);
	}
	-(void)setBoundBuffer: (uint32_t)index num_bounds: (uint32_t)num_bounds buffer: (TSBuffer*)buffer {
		[self ref].setBoundBuffer(index, num_bounds, [buffer ref]);
	}
	-(void)setBoundBuffer_: (uint32_t)index num_bounds: (uint32_t)num_bounds buffer: (TSBuffer*)buffer {
		[self ref].setBoundBuffer(index, num_bounds, [buffer ref]);
	}
	-(void)setBoundBuffer_1: (uint32_t)index num_bounds: (uint32_t)num_bounds buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setBoundBuffer(index, num_bounds, [buffer ref], offset);
	}
	-(void)setBoundBuffer_1_: (uint32_t)index num_bounds: (uint32_t)num_bounds buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setBoundBuffer(index, num_bounds, [buffer ref], offset);
	}
	-(void)setBoundBuffer_2: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setBoundBuffer(index, [buffer ref]);
	}
	-(void)setBoundBuffer_2_: (uint32_t)index buffer: (TSBuffer*)buffer {
		[self ref].setBoundBuffer(index, [buffer ref]);
	}
	-(void)setBoundBuffer_3: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setBoundBuffer(index, [buffer ref], offset);
	}
	-(void)setBoundBuffer_3_: (uint32_t)index buffer: (TSBuffer*)buffer offset: (size_t)offset {
		[self ref].setBoundBuffer(index, [buffer ref], offset);
	}
	-(void)setNumBounds: (uint32_t)index num_bounds: (uint32_t)num_bounds {
		[self ref].setNumBounds(index, num_bounds);
	}
	-(void)setNumBounds_: (uint32_t)index num_bounds: (uint32_t)num_bounds {
		[self ref].setNumBounds(index, num_bounds);
	}
	-(uint32_t)getNumBounds: (uint32_t)index {
		return [self ref].getNumBounds(index);
	}
	-(uint32_t)getNumBounds_: (uint32_t)index {
		return [self ref].getNumBounds(index);
	}
	-(uint32_t)getBoundStride: (uint32_t)index {
		return [self ref].getBoundStride(index);
	}
	-(uint32_t)getBoundStride_: (uint32_t)index {
		return [self ref].getBoundStride(index);
	}
	-(TSBuffer*)getBoundBuffer: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].getBoundBuffer(index))];
	}
	-(TSBuffer*)getBoundBuffer_: (uint32_t)index {
		return [[TSBuffer alloc] init_ref:([self ref].getBoundBuffer(index))];
	}
	-(size_t)getBoundOffset: (uint32_t)index {
		return [self ref].getBoundOffset(index);
	}
	-(size_t)getBoundOffset_: (uint32_t)index {
		return [self ref].getBoundOffset(index);
	}
	-(NSString*)getDescription {
		return [NSString stringWithUTF8String:[self ref].getDescription().get()];
	}
	-(uint64_t)getTracingAddress {
		return [self ref].getTracingAddress();
	}
	-(size_t)getBuildSize {
		return [self ref].getBuildSize();
	}
	-(size_t)getUpdateSize {
		return [self ref].getUpdateSize();
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::D3D12Tracing
@implementation TSD3D12Tracing
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Tracing();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Tracing*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Tracing&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Tracing((Tellusim::D3D12Tracing&)ref);
		return self;
	}
	-(Tellusim::D3D12Tracing*)pointer {
		return (Tellusim::D3D12Tracing*)impl;
	}
	-(Tellusim::D3D12Tracing&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Tracing*)impl;
	}
	-(id)initTracing: (TSTracing*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Tracing([base ref]);
		return self;
	}
	-(TSTracing*)getTracing {
		return [[TSTracing alloc] init_ref:([self ref].getTracing())];
	}
	-(BOOL)equalPtr: (const TSD3D12Tracing*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Tracing*)copyPtr {
		return [[TSD3D12Tracing alloc] init_ref:[self ref]];
	}
	-(TSD3D12Tracing*)clonePtr {
		return [[TSD3D12Tracing alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Tracing*)null {
		return [[TSD3D12Tracing alloc] init_ptr:nullptr];
	}
	-(void*)getGeometryDesc: (uint32_t)index {
		return [self ref].getGeometryDesc(index);
	}
	-(void*)getGeometryDesc_: (uint32_t)index {
		return [self ref].getGeometryDesc(index);
	}
	-(void*)getBuildInputs {
		return [self ref].getBuildInputs();
	}
	-(void*)getPrebuildInfo {
		return [self ref].getPrebuildInfo();
	}
	-(void*)getBuildDesc {
		return [self ref].getBuildDesc();
	}
	-(TSBuffer*)getTracingBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getTracingBuffer())];
	}
	-(size_t)getShaderResourceView {
		return [self ref].getShaderResourceView();
	}
@end

// Tellusim::MTLTracing
@implementation TSMTLTracing
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLTracing();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLTracing*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLTracing&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLTracing((Tellusim::MTLTracing&)ref);
		return self;
	}
	-(Tellusim::MTLTracing*)pointer {
		return (Tellusim::MTLTracing*)impl;
	}
	-(Tellusim::MTLTracing&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLTracing*)impl;
	}
	-(id)initTracing: (TSTracing*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLTracing([base ref]);
		return self;
	}
	-(TSTracing*)getTracing {
		return [[TSTracing alloc] init_ref:([self ref].getTracing())];
	}
	-(BOOL)equalPtr: (const TSMTLTracing*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLTracing*)copyPtr {
		return [[TSMTLTracing alloc] init_ref:[self ref]];
	}
	-(TSMTLTracing*)clonePtr {
		return [[TSMTLTracing alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLTracing*)null {
		return [[TSMTLTracing alloc] init_ptr:nullptr];
	}
	-(void*)getGeometryDesc: (uint32_t)index {
		return [self ref].getGeometryDesc(index);
	}
	-(void*)getGeometryDesc_: (uint32_t)index {
		return [self ref].getGeometryDesc(index);
	}
	-(void*)getPrimitiveDesc {
		return [self ref].getPrimitiveDesc();
	}
	-(void*)getInstanceDesc {
		return [self ref].getInstanceDesc();
	}
	-(void*)getAccelerationStructure {
		return [self ref].getAccelerationStructure();
	}
@end

// Tellusim::VKTracing
@implementation TSVKTracing
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKTracing();
		return self;
	}
	-(id)init_ptr: (Tellusim::VKTracing*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKTracing&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKTracing((Tellusim::VKTracing&)ref);
		return self;
	}
	-(Tellusim::VKTracing*)pointer {
		return (Tellusim::VKTracing*)impl;
	}
	-(Tellusim::VKTracing&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKTracing*)impl;
	}
	-(id)initTracing: (TSTracing*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKTracing([base ref]);
		return self;
	}
	-(TSTracing*)getTracing {
		return [[TSTracing alloc] init_ref:([self ref].getTracing())];
	}
	-(BOOL)equalPtr: (const TSVKTracing*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKTracing*)copyPtr {
		return [[TSVKTracing alloc] init_ref:[self ref]];
	}
	-(TSVKTracing*)clonePtr {
		return [[TSVKTracing alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKTracing*)null {
		return [[TSVKTracing alloc] init_ptr:nullptr];
	}
	-(void*)getBuildGeometryInfo {
		return [self ref].getBuildGeometryInfo();
	}
	-(void*)getBuildSizeInfo {
		return [self ref].getBuildSizeInfo();
	}
	-(TSBuffer*)getTracingBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getTracingBuffer())];
	}
	-(VkAccelerationStructureKHR)getAccelerationStructure {
		return [self ref].getAccelerationStructure();
	}
@end

// Tellusim::FUTracing
@implementation TSFUTracing
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTracing();
		return self;
	}
	-(id)init_2: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		impl = new Tellusim::FUTracing(tracings_);
		return self;
	}
	-(id)init_2_: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		impl = new Tellusim::FUTracing(tracings_);
		return self;
	}
	-(id)init_3: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		impl = new Tellusim::FUTracing(tracings_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		impl = new Tellusim::FUTracing(tracings_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUTracing*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUTracing&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTracing((Tellusim::FUTracing&)ref);
		return self;
	}
	-(Tellusim::FUTracing*)pointer {
		return (Tellusim::FUTracing*)impl;
	}
	-(Tellusim::FUTracing&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUTracing*)impl;
	}
	-(id)initTracing: (TSTracing*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTracing([base ref]);
		return self;
	}
	-(TSTracing*)getTracing {
		return [[TSTracing alloc] init_ref:([self ref].getTracing())];
	}
	-(BOOL)equalPtr: (const TSFUTracing*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUTracing*)copyPtr {
		return [[TSFUTracing alloc] init_ref:[self ref]];
	}
	-(TSFUTracing*)clonePtr {
		return [[TSFUTracing alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUTracing*)null {
		return [[TSFUTracing alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumTracings {
		return [self ref].getNumTracings();
	}
	-(const TSTracing*)getTracing: (uint32_t)index {
		return [[TSTracing alloc] init_ref:([self ref].getTracing(index))];
	}
	-(const TSTracing*)getTracing_: (uint32_t)index {
		return [[TSTracing alloc] init_ref:([self ref].getTracing(index))];
	}
@end

// Tellusim::Target
@implementation TSTarget
	-(id)init {
		self = [super init];
		impl = new Tellusim::Target();
		return self;
	}
	-(id)init_ptr: (Tellusim::Target*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Target&)ref {
		self = [super init];
		impl = new Tellusim::Target((Tellusim::Target&)ref);
		return self;
	}
	-(Tellusim::Target*)pointer {
		return (Tellusim::Target*)impl;
	}
	-(Tellusim::Target&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Target*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Target*)impl;
	}
	-(BOOL)equalPtr: (const TSTarget*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSTarget*)copyPtr {
		return [[TSTarget alloc] init_ref:[self ref]];
	}
	-(TSTarget*)clonePtr {
		return [[TSTarget alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSTarget*)null {
		return [[TSTarget alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(BOOL)begin: (TSFence*)fence {
		return [self ref].begin([fence ref]);
	}
	-(BOOL)begin_: (TSFence*)fence {
		return [self ref].begin([fence ref]);
	}
	-(BOOL)begin_1 {
		return [self ref].begin();
	}
	-(void)end: (TSFence*)fence {
		[self ref].end([fence ref]);
	}
	-(void)end_: (TSFence*)fence {
		[self ref].end([fence ref]);
	}
	-(void)end_1 {
		[self ref].end();
	}
	-(void)swap: (TSSurface*)surface {
		[self ref].swap([surface ref]);
	}
	-(void)swap_: (TSSurface*)surface {
		[self ref].swap([surface ref]);
	}
	-(BOOL)isEnabled {
		return [self ref].isEnabled();
	}
	-(TS_Format)getColorFormat {
		return (TS_Format)[self ref].getColorFormat();
	}
	-(TS_Format)getColorFormat_1: (uint32_t)index {
		return (TS_Format)[self ref].getColorFormat(index);
	}
	-(TS_Format)getColorFormat_1_: (uint32_t)index {
		return (TS_Format)[self ref].getColorFormat(index);
	}
	-(TS_Format)getDepthFormat {
		return (TS_Format)[self ref].getDepthFormat();
	}
	-(uint32_t)getMultisample {
		return [self ref].getMultisample();
	}
	-(BOOL)hasMultisample {
		return [self ref].hasMultisample();
	}
	-(BOOL)isFlipped {
		return [self ref].isFlipped();
	}
	-(BOOL)isAtomic {
		return [self ref].isAtomic();
	}
	-(uint32_t)getWidth {
		return [self ref].getWidth();
	}
	-(uint32_t)getHeight {
		return [self ref].getHeight();
	}
	-(uint32_t)getDepth {
		return [self ref].getDepth();
	}
	-(uint32_t)getFaces {
		return [self ref].getFaces();
	}
	-(uint32_t)getLayers {
		return [self ref].getLayers();
	}
	-(uint32_t)getMipmaps {
		return [self ref].getMipmaps();
	}
	-(void)setClearColor: (TSColor)color {
		[self ref].setClearColor(*(Tellusim::Color*)&color);
	}
	-(void)setClearColor_: (TSColor)color {
		[self ref].setClearColor(*(Tellusim::Color*)&color);
	}
	-(void)setClearColor_1: (uint32_t)index color: (TSColor)color {
		[self ref].setClearColor(index, *(Tellusim::Color*)&color);
	}
	-(void)setClearColor_1_: (uint32_t)index color: (TSColor)color {
		[self ref].setClearColor(index, *(Tellusim::Color*)&color);
	}
	-(void)setClearColor_2: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setClearColor(r, g, b, a);
	}
	-(void)setClearColor_2_: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setClearColor(r, g, b, a);
	}
	-(void)setClearColor_3: (uint32_t)index r: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setClearColor(index, r, g, b, a);
	}
	-(void)setClearColor_3_: (uint32_t)index r: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setClearColor(index, r, g, b, a);
	}
	-(void)setColorTexture: (TSTexture*)texture {
		[self ref].setColorTexture([texture ref]);
	}
	-(void)setColorTexture_: (TSTexture*)texture {
		[self ref].setColorTexture([texture ref]);
	}
	-(void)setColorTexture_1: (TSTexture*)texture op: (TS_TargetOperation)op {
		[self ref].setColorTexture([texture ref], (Tellusim::Target::Operation)op);
	}
	-(void)setColorTexture_1_: (TSTexture*)texture op: (TS_TargetOperation)op {
		[self ref].setColorTexture([texture ref], (Tellusim::Target::Operation)op);
	}
	-(void)setColorTexture_2: (TSTexture*)texture op: (TS_TargetOperation)op slice: (TSSlice)slice {
		[self ref].setColorTexture([texture ref], (Tellusim::Target::Operation)op, *(Tellusim::Slice*)&slice);
	}
	-(void)setColorTexture_2_: (TSTexture*)texture op: (TS_TargetOperation)op slice: (TSSlice)slice {
		[self ref].setColorTexture([texture ref], (Tellusim::Target::Operation)op, *(Tellusim::Slice*)&slice);
	}
	-(void)setColorTexture_3: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setColorTexture(index, [texture ref]);
	}
	-(void)setColorTexture_3_: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setColorTexture(index, [texture ref]);
	}
	-(void)setColorTexture_4: (uint32_t)index texture: (TSTexture*)texture op: (TS_TargetOperation)op {
		[self ref].setColorTexture(index, [texture ref], (Tellusim::Target::Operation)op);
	}
	-(void)setColorTexture_4_: (uint32_t)index texture: (TSTexture*)texture op: (TS_TargetOperation)op {
		[self ref].setColorTexture(index, [texture ref], (Tellusim::Target::Operation)op);
	}
	-(void)setColorTexture_5: (uint32_t)index texture: (TSTexture*)texture op: (TS_TargetOperation)op slice: (TSSlice)slice {
		[self ref].setColorTexture(index, [texture ref], (Tellusim::Target::Operation)op, *(Tellusim::Slice*)&slice);
	}
	-(void)setColorTexture_5_: (uint32_t)index texture: (TSTexture*)texture op: (TS_TargetOperation)op slice: (TSSlice)slice {
		[self ref].setColorTexture(index, [texture ref], (Tellusim::Target::Operation)op, *(Tellusim::Slice*)&slice);
	}
	-(void)setColorResolve: (TSTexture*)texture {
		[self ref].setColorResolve([texture ref]);
	}
	-(void)setColorResolve_: (TSTexture*)texture {
		[self ref].setColorResolve([texture ref]);
	}
	-(void)setColorResolve_1: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setColorResolve([texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setColorResolve_1_: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setColorResolve([texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setColorResolve_2: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setColorResolve(index, [texture ref]);
	}
	-(void)setColorResolve_2_: (uint32_t)index texture: (TSTexture*)texture {
		[self ref].setColorResolve(index, [texture ref]);
	}
	-(void)setColorResolve_3: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setColorResolve(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setColorResolve_3_: (uint32_t)index texture: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setColorResolve(index, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(uint32_t)getNumTargets {
		return [self ref].getNumTargets();
	}
	-(TSColor)getClearColor {
		Tellusim::Color ret = [self ref].getClearColor();
		return *(TSColor*)&ret;
	}
	-(TSColor)getClearColor_1: (uint32_t)index {
		Tellusim::Color ret = [self ref].getClearColor(index);
		return *(TSColor*)&ret;
	}
	-(TSColor)getClearColor_1_: (uint32_t)index {
		Tellusim::Color ret = [self ref].getClearColor(index);
		return *(TSColor*)&ret;
	}
	-(TS_TargetOperation)getColorOp {
		return (TS_TargetOperation)[self ref].getColorOp();
	}
	-(TS_TargetOperation)getColorOp_1: (uint32_t)index {
		return (TS_TargetOperation)[self ref].getColorOp(index);
	}
	-(TS_TargetOperation)getColorOp_1_: (uint32_t)index {
		return (TS_TargetOperation)[self ref].getColorOp(index);
	}
	-(TSTexture*)getColorTexture: (uint32_t)index {
		return [[TSTexture alloc] init_ref:([self ref].getColorTexture(index))];
	}
	-(TSTexture*)getColorTexture_: (uint32_t)index {
		return [[TSTexture alloc] init_ref:([self ref].getColorTexture(index))];
	}
	-(TSTexture*)getColorResolve: (uint32_t)index {
		return [[TSTexture alloc] init_ref:([self ref].getColorResolve(index))];
	}
	-(TSTexture*)getColorResolve_: (uint32_t)index {
		return [[TSTexture alloc] init_ref:([self ref].getColorResolve(index))];
	}
	-(TSSlice)getColorTextureSlice: (uint32_t)index {
		Tellusim::Slice ret = [self ref].getColorTextureSlice(index);
		return *(TSSlice*)&ret;
	}
	-(TSSlice)getColorTextureSlice_: (uint32_t)index {
		Tellusim::Slice ret = [self ref].getColorTextureSlice(index);
		return *(TSSlice*)&ret;
	}
	-(TSSlice)getColorResolveSlice: (uint32_t)index {
		Tellusim::Slice ret = [self ref].getColorResolveSlice(index);
		return *(TSSlice*)&ret;
	}
	-(TSSlice)getColorResolveSlice_: (uint32_t)index {
		Tellusim::Slice ret = [self ref].getColorResolveSlice(index);
		return *(TSSlice*)&ret;
	}
	-(void)setClearDepth: (float32_t)depth {
		[self ref].setClearDepth(depth);
	}
	-(void)setClearDepth_: (float32_t)depth {
		[self ref].setClearDepth(depth);
	}
	-(void)setClearDepth_1: (float32_t)depth stencil: (uint32_t)stencil {
		[self ref].setClearDepth(depth, stencil);
	}
	-(void)setClearDepth_1_: (float32_t)depth stencil: (uint32_t)stencil {
		[self ref].setClearDepth(depth, stencil);
	}
	-(void)setDepthTexture: (TSTexture*)texture {
		[self ref].setDepthTexture([texture ref]);
	}
	-(void)setDepthTexture_: (TSTexture*)texture {
		[self ref].setDepthTexture([texture ref]);
	}
	-(void)setDepthTexture_1: (TSTexture*)texture op: (TS_TargetOperation)op {
		[self ref].setDepthTexture([texture ref], (Tellusim::Target::Operation)op);
	}
	-(void)setDepthTexture_1_: (TSTexture*)texture op: (TS_TargetOperation)op {
		[self ref].setDepthTexture([texture ref], (Tellusim::Target::Operation)op);
	}
	-(void)setDepthTexture_2: (TSTexture*)texture op: (TS_TargetOperation)op slice: (TSSlice)slice {
		[self ref].setDepthTexture([texture ref], (Tellusim::Target::Operation)op, *(Tellusim::Slice*)&slice);
	}
	-(void)setDepthTexture_2_: (TSTexture*)texture op: (TS_TargetOperation)op slice: (TSSlice)slice {
		[self ref].setDepthTexture([texture ref], (Tellusim::Target::Operation)op, *(Tellusim::Slice*)&slice);
	}
	-(void)setDepthResolve: (TSTexture*)texture {
		[self ref].setDepthResolve([texture ref]);
	}
	-(void)setDepthResolve_: (TSTexture*)texture {
		[self ref].setDepthResolve([texture ref]);
	}
	-(void)setDepthResolve_1: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setDepthResolve([texture ref], *(Tellusim::Slice*)&slice);
	}
	-(void)setDepthResolve_1_: (TSTexture*)texture slice: (TSSlice)slice {
		[self ref].setDepthResolve([texture ref], *(Tellusim::Slice*)&slice);
	}
	-(float32_t)getClearDepth {
		return [self ref].getClearDepth();
	}
	-(uint32_t)getClearStencil {
		return [self ref].getClearStencil();
	}
	-(TS_TargetOperation)getDepthOp {
		return (TS_TargetOperation)[self ref].getDepthOp();
	}
	-(TSTexture*)getDepthTexture {
		return [[TSTexture alloc] init_ref:([self ref].getDepthTexture())];
	}
	-(TSTexture*)getDepthResolve {
		return [[TSTexture alloc] init_ref:([self ref].getDepthResolve())];
	}
	-(TSSlice)getDepthTextureSlice {
		Tellusim::Slice ret = [self ref].getDepthTextureSlice();
		return *(TSSlice*)&ret;
	}
	-(TSSlice)getDepthResolveSlice {
		Tellusim::Slice ret = [self ref].getDepthResolveSlice();
		return *(TSSlice*)&ret;
	}
@end

// Tellusim::D3D12Target
@implementation TSD3D12Target
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Target();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Target*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Target&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Target((Tellusim::D3D12Target&)ref);
		return self;
	}
	-(Tellusim::D3D12Target*)pointer {
		return (Tellusim::D3D12Target*)impl;
	}
	-(Tellusim::D3D12Target&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Target*)impl;
	}
	-(id)initTarget: (TSTarget*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Target([base ref]);
		return self;
	}
	-(TSTarget*)getTarget {
		return [[TSTarget alloc] init_ref:([self ref].getTarget())];
	}
	-(BOOL)equalPtr: (const TSD3D12Target*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Target*)copyPtr {
		return [[TSD3D12Target alloc] init_ref:[self ref]];
	}
	-(TSD3D12Target*)clonePtr {
		return [[TSD3D12Target alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Target*)null {
		return [[TSD3D12Target alloc] init_ptr:nullptr];
	}
	-(size_t*)getRenderTargetViews {
		return [self ref].getRenderTargetViews();
	}
	-(size_t)getDepthStencilView {
		return [self ref].getDepthStencilView();
	}
@end

// Tellusim::D3D11Target
@implementation TSD3D11Target
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Target();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D11Target*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D11Target&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Target((Tellusim::D3D11Target&)ref);
		return self;
	}
	-(Tellusim::D3D11Target*)pointer {
		return (Tellusim::D3D11Target*)impl;
	}
	-(Tellusim::D3D11Target&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D11Target*)impl;
	}
	-(id)initTarget: (TSTarget*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Target([base ref]);
		return self;
	}
	-(TSTarget*)getTarget {
		return [[TSTarget alloc] init_ref:([self ref].getTarget())];
	}
	-(BOOL)equalPtr: (const TSD3D11Target*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D11Target*)copyPtr {
		return [[TSD3D11Target alloc] init_ref:[self ref]];
	}
	-(TSD3D11Target*)clonePtr {
		return [[TSD3D11Target alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D11Target*)null {
		return [[TSD3D11Target alloc] init_ptr:nullptr];
	}
	-(ID3D11RenderTargetView**)getRenderTargetViews {
		return [self ref].getRenderTargetViews();
	}
	-(ID3D11DepthStencilView*)getDepthStencilView {
		return [self ref].getDepthStencilView();
	}
@end

// Tellusim::MTLTarget
@implementation TSMTLTarget
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLTarget();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLTarget*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLTarget&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLTarget((Tellusim::MTLTarget&)ref);
		return self;
	}
	-(Tellusim::MTLTarget*)pointer {
		return (Tellusim::MTLTarget*)impl;
	}
	-(Tellusim::MTLTarget&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLTarget*)impl;
	}
	-(id)initTarget: (TSTarget*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLTarget([base ref]);
		return self;
	}
	-(TSTarget*)getTarget {
		return [[TSTarget alloc] init_ref:([self ref].getTarget())];
	}
	-(BOOL)equalPtr: (const TSMTLTarget*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLTarget*)copyPtr {
		return [[TSMTLTarget alloc] init_ref:[self ref]];
	}
	-(TSMTLTarget*)clonePtr {
		return [[TSMTLTarget alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLTarget*)null {
		return [[TSMTLTarget alloc] init_ptr:nullptr];
	}
	-(void*)getDescriptor {
		return [self ref].getDescriptor();
	}
@end

// Tellusim::VKTarget
@implementation TSVKTarget
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKTarget();
		return self;
	}
	-(id)init_ptr: (Tellusim::VKTarget*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKTarget&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKTarget((Tellusim::VKTarget&)ref);
		return self;
	}
	-(Tellusim::VKTarget*)pointer {
		return (Tellusim::VKTarget*)impl;
	}
	-(Tellusim::VKTarget&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKTarget*)impl;
	}
	-(id)initTarget: (TSTarget*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKTarget([base ref]);
		return self;
	}
	-(TSTarget*)getTarget {
		return [[TSTarget alloc] init_ref:([self ref].getTarget())];
	}
	-(BOOL)equalPtr: (const TSVKTarget*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKTarget*)copyPtr {
		return [[TSVKTarget alloc] init_ref:[self ref]];
	}
	-(TSVKTarget*)clonePtr {
		return [[TSVKTarget alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKTarget*)null {
		return [[TSVKTarget alloc] init_ptr:nullptr];
	}
	-(VkRenderPass)getRenderPass {
		return [self ref].getRenderPass();
	}
	-(VkFramebuffer)getFramebuffer {
		return [self ref].getFramebuffer();
	}
@end

// Tellusim::GLTarget
@implementation TSGLTarget
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLTarget();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLTarget*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLTarget&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLTarget((Tellusim::GLTarget&)ref);
		return self;
	}
	-(Tellusim::GLTarget*)pointer {
		return (Tellusim::GLTarget*)impl;
	}
	-(Tellusim::GLTarget&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLTarget*)impl;
	}
	-(id)initTarget: (TSTarget*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLTarget([base ref]);
		return self;
	}
	-(TSTarget*)getTarget {
		return [[TSTarget alloc] init_ref:([self ref].getTarget())];
	}
	-(BOOL)equalPtr: (const TSGLTarget*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLTarget*)copyPtr {
		return [[TSGLTarget alloc] init_ref:[self ref]];
	}
	-(TSGLTarget*)clonePtr {
		return [[TSGLTarget alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLTarget*)null {
		return [[TSGLTarget alloc] init_ptr:nullptr];
	}
	-(uint32_t)getFramebufferID {
		return [self ref].getFramebufferID();
	}
@end

// Tellusim::GLESTarget
@implementation TSGLESTarget
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESTarget();
		return self;
	}
	-(id)init_ptr: (Tellusim::GLESTarget*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLESTarget&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESTarget((Tellusim::GLESTarget&)ref);
		return self;
	}
	-(Tellusim::GLESTarget*)pointer {
		return (Tellusim::GLESTarget*)impl;
	}
	-(Tellusim::GLESTarget&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLESTarget*)impl;
	}
	-(id)initTarget: (TSTarget*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESTarget([base ref]);
		return self;
	}
	-(TSTarget*)getTarget {
		return [[TSTarget alloc] init_ref:([self ref].getTarget())];
	}
	-(BOOL)equalPtr: (const TSGLESTarget*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLESTarget*)copyPtr {
		return [[TSGLESTarget alloc] init_ref:[self ref]];
	}
	-(TSGLESTarget*)clonePtr {
		return [[TSGLESTarget alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLESTarget*)null {
		return [[TSGLESTarget alloc] init_ptr:nullptr];
	}
	-(uint32_t)getFramebufferID {
		return [self ref].getFramebufferID();
	}
@end

// Tellusim::FUTarget
@implementation TSFUTarget
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTarget();
		return self;
	}
	-(id)init_2: (TSTarget**)targets targets_size: (uint32_t)targets_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Target> targets_(targets_size);
		for(uint32_t i = 0; i < targets_size; i++) if(targets[i]) targets_[i] = [targets[i] ref];
		impl = new Tellusim::FUTarget(targets_);
		return self;
	}
	-(id)init_2_: (TSTarget**)targets targets_size: (uint32_t)targets_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Target> targets_(targets_size);
		for(uint32_t i = 0; i < targets_size; i++) if(targets[i]) targets_[i] = [targets[i] ref];
		impl = new Tellusim::FUTarget(targets_);
		return self;
	}
	-(id)init_3: (TSTarget**)targets targets_size: (uint32_t)targets_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Target> targets_(targets_size);
		for(uint32_t i = 0; i < targets_size; i++) if(targets[i]) targets_[i] = [targets[i] ref];
		impl = new Tellusim::FUTarget(targets_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSTarget**)targets targets_size: (uint32_t)targets_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Target> targets_(targets_size);
		for(uint32_t i = 0; i < targets_size; i++) if(targets[i]) targets_[i] = [targets[i] ref];
		impl = new Tellusim::FUTarget(targets_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUTarget*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUTarget&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTarget((Tellusim::FUTarget&)ref);
		return self;
	}
	-(Tellusim::FUTarget*)pointer {
		return (Tellusim::FUTarget*)impl;
	}
	-(Tellusim::FUTarget&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUTarget*)impl;
	}
	-(id)initTarget: (TSTarget*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTarget([base ref]);
		return self;
	}
	-(TSTarget*)getTarget {
		return [[TSTarget alloc] init_ref:([self ref].getTarget())];
	}
	-(BOOL)equalPtr: (const TSFUTarget*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUTarget*)copyPtr {
		return [[TSFUTarget alloc] init_ref:[self ref]];
	}
	-(TSFUTarget*)clonePtr {
		return [[TSFUTarget alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUTarget*)null {
		return [[TSFUTarget alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumTargets_1 {
		return [self ref].getNumTargets();
	}
	-(const TSTarget*)getTarget: (uint32_t)index {
		return [[TSTarget alloc] init_ref:([self ref].getTarget(index))];
	}
	-(const TSTarget*)getTarget_: (uint32_t)index {
		return [[TSTarget alloc] init_ref:([self ref].getTarget(index))];
	}
@end

// Tellusim::Device
@implementation TSDevice
	-(id)init {
		self = [super init];
		impl = new Tellusim::Device();
		return self;
	}
	-(id)init_1: (TSContext*)context {
		self = [super init];
		impl = new Tellusim::Device([context ref]);
		return self;
	}
	-(id)init_1_: (TSContext*)context {
		self = [super init];
		impl = new Tellusim::Device([context ref]);
		return self;
	}
	-(id)init_2: (TSSurface*)surface {
		self = [super init];
		impl = new Tellusim::Device([surface ref]);
		return self;
	}
	-(id)init_2_: (TSSurface*)surface {
		self = [super init];
		impl = new Tellusim::Device([surface ref]);
		return self;
	}
	-(id)init_3: (TSWindow*)window {
		self = [super init];
		impl = new Tellusim::Device([window ref]);
		return self;
	}
	-(id)init_3_: (TSWindow*)window {
		self = [super init];
		impl = new Tellusim::Device([window ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::Device*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Device&)ref {
		self = [super init];
		impl = new Tellusim::Device((Tellusim::Device&)ref);
		return self;
	}
	-(Tellusim::Device*)pointer {
		return (Tellusim::Device*)impl;
	}
	-(Tellusim::Device&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Device*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Device*)impl;
	}
	-(BOOL)equalPtr: (const TSDevice*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDevice*)copyPtr {
		return [[TSDevice alloc] init_ref:[self ref]];
	}
	-(TSDevice*)clonePtr {
		return [[TSDevice alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDevice*)null {
		return [[TSDevice alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(NSString*)getVendor {
		return [NSString stringWithUTF8String:[self ref].getVendor().get()];
	}
	-(NSString*)getVersion {
		return [NSString stringWithUTF8String:[self ref].getVersion().get()];
	}
	-(TSDeviceFeatures)getFeatures {
		Tellusim::Device::Features ret = [self ref].getFeatures();
		return *(TSDeviceFeatures*)&ret;
	}
	-(BOOL)hasQuery: (TS_QueryType)type {
		return [self ref].hasQuery((Tellusim::Query::Type)type);
	}
	-(BOOL)hasQuery_: (TS_QueryType)type {
		return [self ref].hasQuery((Tellusim::Query::Type)type);
	}
	-(BOOL)hasShader: (TS_ShaderType)type {
		return [self ref].hasShader((Tellusim::Shader::Type)type);
	}
	-(BOOL)hasShader_: (TS_ShaderType)type {
		return [self ref].hasShader((Tellusim::Shader::Type)type);
	}
	-(BOOL)hasTarget: (TS_Format)format {
		return [self ref].hasTarget((Tellusim::Format)format);
	}
	-(BOOL)hasTarget_: (TS_Format)format {
		return [self ref].hasTarget((Tellusim::Format)format);
	}
	-(BOOL)hasTexture: (TS_Format)format {
		return [self ref].hasTexture((Tellusim::Format)format);
	}
	-(BOOL)hasTexture_: (TS_Format)format {
		return [self ref].hasTexture((Tellusim::Format)format);
	}
	-(BOOL)hasSurface: (TS_Format)format {
		return [self ref].hasSurface((Tellusim::Format)format);
	}
	-(BOOL)hasSurface_: (TS_Format)format {
		return [self ref].hasSurface((Tellusim::Format)format);
	}
	-(TSDevice*)createDevice: (uint32_t)index {
		return [[TSDevice alloc] init_ref:([self ref].createDevice(index))];
	}
	-(TSDevice*)createDevice_: (uint32_t)index {
		return [[TSDevice alloc] init_ref:([self ref].createDevice(index))];
	}
	-(TSDevice*)createDevice_1: (uint32_t)index frames: (uint32_t)frames {
		return [[TSDevice alloc] init_ref:([self ref].createDevice(index, frames))];
	}
	-(TSDevice*)createDevice_1_: (uint32_t)index frames: (uint32_t)frames {
		return [[TSDevice alloc] init_ref:([self ref].createDevice(index, frames))];
	}
	-(TSDevice*)createCommandDevice {
		return [[TSDevice alloc] init_ref:([self ref].createCommandDevice())];
	}
	-(TSDevice*)createCommandDevice_1: (uint32_t)frames {
		return [[TSDevice alloc] init_ref:([self ref].createCommandDevice(frames))];
	}
	-(TSDevice*)createCommandDevice_1_: (uint32_t)frames {
		return [[TSDevice alloc] init_ref:([self ref].createCommandDevice(frames))];
	}
	-(TSDevice*)createComputeDevice {
		return [[TSDevice alloc] init_ref:([self ref].createComputeDevice())];
	}
	-(TSDevice*)createComputeDevice_1: (uint32_t)frames {
		return [[TSDevice alloc] init_ref:([self ref].createComputeDevice(frames))];
	}
	-(TSDevice*)createComputeDevice_1_: (uint32_t)frames {
		return [[TSDevice alloc] init_ref:([self ref].createComputeDevice(frames))];
	}
	-(TSDevice*)createCopyDevice {
		return [[TSDevice alloc] init_ref:([self ref].createCopyDevice())];
	}
	-(TSDevice*)createCopyDevice_1: (uint32_t)frames {
		return [[TSDevice alloc] init_ref:([self ref].createCopyDevice(frames))];
	}
	-(TSDevice*)createCopyDevice_1_: (uint32_t)frames {
		return [[TSDevice alloc] init_ref:([self ref].createCopyDevice(frames))];
	}
	-(TSQuery*)createQuery {
		return [[TSQuery alloc] init_ref:([self ref].createQuery())];
	}
	-(TSQuery*)createQuery_1: (TS_QueryType)type {
		return [[TSQuery alloc] init_ref:([self ref].createQuery((Tellusim::Query::Type)type))];
	}
	-(TSQuery*)createQuery_1_: (TS_QueryType)type {
		return [[TSQuery alloc] init_ref:([self ref].createQuery((Tellusim::Query::Type)type))];
	}
	-(TSFence*)createFence {
		return [[TSFence alloc] init_ref:([self ref].createFence())];
	}
	-(TSFence*)createFence_1: (TSFence*)shared {
		return [[TSFence alloc] init_ref:([self ref].createFence([shared ref]))];
	}
	-(TSFence*)createFence_1_: (TSFence*)shared {
		return [[TSFence alloc] init_ref:([self ref].createFence([shared ref]))];
	}
	-(TSFence*)createFence_2: (TS_FenceFlags)flags {
		return [[TSFence alloc] init_ref:([self ref].createFence((Tellusim::Fence::Flags)flags))];
	}
	-(TSFence*)createFence_2_: (TS_FenceFlags)flags {
		return [[TSFence alloc] init_ref:([self ref].createFence((Tellusim::Fence::Flags)flags))];
	}
	-(TSBuffer*)createBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer())];
	}
	-(TSBuffer*)createBuffer_1: (TSBuffer*)shared {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer([shared ref]))];
	}
	-(TSBuffer*)createBuffer_1_: (TSBuffer*)shared {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer([shared ref]))];
	}
	-(TSBuffer*)createBuffer_2: (TS_BufferFlags)flags size: (size_t)size {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer((Tellusim::Buffer::Flags)flags, size))];
	}
	-(TSBuffer*)createBuffer_2_: (TS_BufferFlags)flags size: (size_t)size {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer((Tellusim::Buffer::Flags)flags, size))];
	}
	-(TSBuffer*)createBuffer_3: (TS_BufferFlags)flags size: (size_t)size format: (TS_Format)format {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer((Tellusim::Buffer::Flags)flags, size, (Tellusim::Format)format))];
	}
	-(TSBuffer*)createBuffer_3_: (TS_BufferFlags)flags size: (size_t)size format: (TS_Format)format {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer((Tellusim::Buffer::Flags)flags, size, (Tellusim::Format)format))];
	}
	-(TSBuffer*)createBuffer_4: (TS_BufferFlags)flags src: (const void*)src size: (size_t)size {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer((Tellusim::Buffer::Flags)flags, src, size))];
	}
	-(TSBuffer*)createBuffer_4_: (TS_BufferFlags)flags src: (const void*)src size: (size_t)size {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer((Tellusim::Buffer::Flags)flags, src, size))];
	}
	-(TSBuffer*)createBuffer_5: (TS_BufferFlags)flags src: (const void*)src size: (size_t)size format: (TS_Format)format {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer((Tellusim::Buffer::Flags)flags, src, size, (Tellusim::Format)format))];
	}
	-(TSBuffer*)createBuffer_5_: (TS_BufferFlags)flags src: (const void*)src size: (size_t)size format: (TS_Format)format {
		return [[TSBuffer alloc] init_ref:([self ref].createBuffer((Tellusim::Buffer::Flags)flags, src, size, (Tellusim::Format)format))];
	}
	-(TSSampler*)createSampler {
		return [[TSSampler alloc] init_ref:([self ref].createSampler())];
	}
	-(TSSampler*)createSampler_1: (const TSSampler*)sampler {
		return [[TSSampler alloc] init_ref:([self ref].createSampler([sampler ref]))];
	}
	-(TSSampler*)createSampler_1_: (const TSSampler*)sampler {
		return [[TSSampler alloc] init_ref:([self ref].createSampler([sampler ref]))];
	}
	-(TSSampler*)createSampler_2: (TS_SamplerFilter)filter {
		return [[TSSampler alloc] init_ref:([self ref].createSampler((Tellusim::Sampler::Filter)filter))];
	}
	-(TSSampler*)createSampler_2_: (TS_SamplerFilter)filter {
		return [[TSSampler alloc] init_ref:([self ref].createSampler((Tellusim::Sampler::Filter)filter))];
	}
	-(TSSampler*)createSampler_3: (TS_SamplerFilter)filter mode: (TS_SamplerWrapMode)mode {
		return [[TSSampler alloc] init_ref:([self ref].createSampler((Tellusim::Sampler::Filter)filter, (Tellusim::Sampler::WrapMode)mode))];
	}
	-(TSSampler*)createSampler_3_: (TS_SamplerFilter)filter mode: (TS_SamplerWrapMode)mode {
		return [[TSSampler alloc] init_ref:([self ref].createSampler((Tellusim::Sampler::Filter)filter, (Tellusim::Sampler::WrapMode)mode))];
	}
	-(TSSampler*)createSampler_4: (TS_SamplerFilter)filter mode: (TS_SamplerWrapMode)mode anisotropy: (uint32_t)anisotropy {
		return [[TSSampler alloc] init_ref:([self ref].createSampler((Tellusim::Sampler::Filter)filter, (Tellusim::Sampler::WrapMode)mode, anisotropy))];
	}
	-(TSSampler*)createSampler_4_: (TS_SamplerFilter)filter mode: (TS_SamplerWrapMode)mode anisotropy: (uint32_t)anisotropy {
		return [[TSSampler alloc] init_ref:([self ref].createSampler((Tellusim::Sampler::Filter)filter, (Tellusim::Sampler::WrapMode)mode, anisotropy))];
	}
	-(TSTexture*)createTexture {
		return [[TSTexture alloc] init_ref:([self ref].createTexture())];
	}
	-(TSTexture*)createTexture_1: (TSTexture*)shared {
		return [[TSTexture alloc] init_ref:([self ref].createTexture([shared ref]))];
	}
	-(TSTexture*)createTexture_1_: (TSTexture*)shared {
		return [[TSTexture alloc] init_ref:([self ref].createTexture([shared ref]))];
	}
	-(TSTexture*)createTexture_2: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers {
		return [[TSTexture alloc] init_ref:([self ref].createTexture((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers))];
	}
	-(TSTexture*)createTexture_2_: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers {
		return [[TSTexture alloc] init_ref:([self ref].createTexture((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers))];
	}
	-(TSTexture*)createTexture_3: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture_3_: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, layers, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture_4: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size {
		return [[TSTexture alloc] init_ref:([self ref].createTexture((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size))];
	}
	-(TSTexture*)createTexture_4_: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size {
		return [[TSTexture alloc] init_ref:([self ref].createTexture((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size))];
	}
	-(TSTexture*)createTexture_5: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture_5_: (TS_TextureType)type format: (TS_Format)format size: (TSSize)size flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture((Tellusim::Texture::Type)type, (Tellusim::Format)format, *(Tellusim::Size*)&size, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture_6: (const TSImage*)image {
		return [[TSTexture alloc] init_ref:([self ref].createTexture([image ref]))];
	}
	-(TSTexture*)createTexture_6_: (const TSImage*)image {
		return [[TSTexture alloc] init_ref:([self ref].createTexture([image ref]))];
	}
	-(TSTexture*)createTexture_7: (const TSImage*)image flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture([image ref], (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture_7_: (const TSImage*)image flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture([image ref], (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture_8: (const TSImage*)image flags: (TS_TextureFlags)flags async: (TSAsync**)async {
		return [[TSTexture alloc] init_ref:([self ref].createTexture([image ref], (Tellusim::Texture::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSTexture*)createTexture_8_: (const TSImage*)image flags: (TS_TextureFlags)flags async: (TSAsync**)async {
		return [[TSTexture alloc] init_ref:([self ref].createTexture([image ref], (Tellusim::Texture::Flags)flags, (async) ? [*async pointer] : nullptr))];
	}
	-(TSTexture*)createTexture2D: (TS_Format)format size: (uint32_t)size {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, size))];
	}
	-(TSTexture*)createTexture2D_: (TS_Format)format size: (uint32_t)size {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, size))];
	}
	-(TSTexture*)createTexture2D_1: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture2D_1_: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture3D: (TS_Format)format size: (uint32_t)size {
		return [[TSTexture alloc] init_ref:([self ref].createTexture3D((Tellusim::Format)format, size))];
	}
	-(TSTexture*)createTexture3D_: (TS_Format)format size: (uint32_t)size {
		return [[TSTexture alloc] init_ref:([self ref].createTexture3D((Tellusim::Format)format, size))];
	}
	-(TSTexture*)createTexture3D_1: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture3D((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture3D_1_: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture3D((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTextureCube: (TS_Format)format size: (uint32_t)size {
		return [[TSTexture alloc] init_ref:([self ref].createTextureCube((Tellusim::Format)format, size))];
	}
	-(TSTexture*)createTextureCube_: (TS_Format)format size: (uint32_t)size {
		return [[TSTexture alloc] init_ref:([self ref].createTextureCube((Tellusim::Format)format, size))];
	}
	-(TSTexture*)createTextureCube_1: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTextureCube((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTextureCube_1_: (TS_Format)format size: (uint32_t)size flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTextureCube((Tellusim::Format)format, size, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture2D_2: (TS_Format)format width: (uint32_t)width height: (uint32_t)height {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, width, height))];
	}
	-(TSTexture*)createTexture2D_2_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, width, height))];
	}
	-(TSTexture*)createTexture2D_3: (TS_Format)format width: (uint32_t)width height: (uint32_t)height flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, width, height, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture2D_3_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, width, height, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture3D_2: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		return [[TSTexture alloc] init_ref:([self ref].createTexture3D((Tellusim::Format)format, width, height, depth))];
	}
	-(TSTexture*)createTexture3D_2_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		return [[TSTexture alloc] init_ref:([self ref].createTexture3D((Tellusim::Format)format, width, height, depth))];
	}
	-(TSTexture*)createTexture3D_3: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture3D((Tellusim::Format)format, width, height, depth, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture3D_3_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture3D((Tellusim::Format)format, width, height, depth, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture2D_4: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, width, height, layers))];
	}
	-(TSTexture*)createTexture2D_4_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, width, height, layers))];
	}
	-(TSTexture*)createTexture2D_5: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, width, height, layers, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTexture2D_5_: (TS_Format)format width: (uint32_t)width height: (uint32_t)height layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTexture2D((Tellusim::Format)format, width, height, layers, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTextureCube_2: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers {
		return [[TSTexture alloc] init_ref:([self ref].createTextureCube((Tellusim::Format)format, size, layers))];
	}
	-(TSTexture*)createTextureCube_2_: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers {
		return [[TSTexture alloc] init_ref:([self ref].createTextureCube((Tellusim::Format)format, size, layers))];
	}
	-(TSTexture*)createTextureCube_3: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTextureCube((Tellusim::Format)format, size, layers, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)createTextureCube_3_: (TS_Format)format size: (uint32_t)size layers: (uint32_t)layers flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].createTextureCube((Tellusim::Format)format, size, layers, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture: (const char*)name {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name))];
	}
	-(TSTexture*)loadTexture_: (const char*)name {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name))];
	}
	-(TSTexture*)loadTexture_1: (const char*)name flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture_1_: (const char*)name flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture_2: (const char*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags))];
	}
	-(TSTexture*)loadTexture_2_: (const char*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags))];
	}
	-(TSTexture*)loadTexture_3: (const char*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset))];
	}
	-(TSTexture*)loadTexture_3_: (const char*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset))];
	}
	-(TSTexture*)loadTexture_4: (const char*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset, (async) ? [*async pointer] : nullptr))];
	}
	-(TSTexture*)loadTexture_4_: (const char*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture(name, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset, (async) ? [*async pointer] : nullptr))];
	}
	-(TSTexture*)loadTexture_5: (const TSString*)name {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null))];
	}
	-(TSTexture*)loadTexture_5_: (const TSString*)name {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null))];
	}
	-(TSTexture*)loadTexture_6: (const TSString*)name flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture_6_: (const TSString*)name flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture_7: (const TSString*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags))];
	}
	-(TSTexture*)loadTexture_7_: (const TSString*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags))];
	}
	-(TSTexture*)loadTexture_8: (const TSString*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset))];
	}
	-(TSTexture*)loadTexture_8_: (const TSString*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset))];
	}
	-(TSTexture*)loadTexture_9: (const TSString*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset, (async) ? [*async pointer] : nullptr))];
	}
	-(TSTexture*)loadTexture_9_: (const TSString*)name flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture((name) ? [name ref] : Tellusim::String::null, (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset, (async) ? [*async pointer] : nullptr))];
	}
	-(TSTexture*)loadTexture_10: (TSStream*)stream {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref]))];
	}
	-(TSTexture*)loadTexture_10_: (TSStream*)stream {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref]))];
	}
	-(TSTexture*)loadTexture_11: (TSStream*)stream flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref], (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture_11_: (TSStream*)stream flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref], (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture_12: (TSStream*)stream flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref], (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags))];
	}
	-(TSTexture*)loadTexture_12_: (TSStream*)stream flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref], (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags))];
	}
	-(TSTexture*)loadTexture_13: (TSStream*)stream flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref], (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset))];
	}
	-(TSTexture*)loadTexture_13_: (TSStream*)stream flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref], (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset))];
	}
	-(TSTexture*)loadTexture_14: (TSStream*)stream flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref], (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset, (async) ? [*async pointer] : nullptr))];
	}
	-(TSTexture*)loadTexture_14_: (TSStream*)stream flags: (TS_TextureFlags)flags image_flags: (TS_ImageFlags)image_flags offset: (uint32_t)offset async: (TSAsync**)async {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([stream ref], (Tellusim::Texture::Flags)flags, (Tellusim::Image::Flags)image_flags, offset, (async) ? [*async pointer] : nullptr))];
	}
	-(TSTracing*)createTracing {
		return [[TSTracing alloc] init_ref:([self ref].createTracing())];
	}
	-(TSTracing*)createTracing_1: (const TSTracing*)tracing {
		return [[TSTracing alloc] init_ref:([self ref].createTracing([tracing ref]))];
	}
	-(TSTracing*)createTracing_1_: (const TSTracing*)tracing {
		return [[TSTracing alloc] init_ref:([self ref].createTracing([tracing ref]))];
	}
	-(TSTracing*)createTracing_2: (uint32_t)num_instances {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_instances))];
	}
	-(TSTracing*)createTracing_2_: (uint32_t)num_instances {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_instances))];
	}
	-(TSTracing*)createTracing_3: (uint32_t)num_instances instance_buffer: (TSBuffer*)instance_buffer {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_instances, [instance_buffer ref]))];
	}
	-(TSTracing*)createTracing_3_: (uint32_t)num_instances instance_buffer: (TSBuffer*)instance_buffer {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_instances, [instance_buffer ref]))];
	}
	-(TSTracing*)createTracing_4: (uint32_t)num_instances instance_buffer: (TSBuffer*)instance_buffer instance_offset: (size_t)instance_offset {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_instances, [instance_buffer ref], instance_offset))];
	}
	-(TSTracing*)createTracing_4_: (uint32_t)num_instances instance_buffer: (TSBuffer*)instance_buffer instance_offset: (size_t)instance_offset {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_instances, [instance_buffer ref], instance_offset))];
	}
	-(TSTracing*)createTracing_5: (uint32_t)num_instances instance_buffer: (TSBuffer*)instance_buffer instance_offset: (size_t)instance_offset flags: (TS_TracingFlags)flags {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_instances, [instance_buffer ref], instance_offset, (Tellusim::Tracing::Flags)flags))];
	}
	-(TSTracing*)createTracing_5_: (uint32_t)num_instances instance_buffer: (TSBuffer*)instance_buffer instance_offset: (size_t)instance_offset flags: (TS_TracingFlags)flags {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_instances, [instance_buffer ref], instance_offset, (Tellusim::Tracing::Flags)flags))];
	}
	-(TSTracing*)createTracing_6: (uint32_t)num_vertices vertex_format: (TS_Format)vertex_format vertex_stride: (size_t)vertex_stride num_indices: (uint32_t)num_indices index_format: (TS_Format)index_format {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_vertices, (Tellusim::Format)vertex_format, vertex_stride, num_indices, (Tellusim::Format)index_format))];
	}
	-(TSTracing*)createTracing_6_: (uint32_t)num_vertices vertex_format: (TS_Format)vertex_format vertex_stride: (size_t)vertex_stride num_indices: (uint32_t)num_indices index_format: (TS_Format)index_format {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_vertices, (Tellusim::Format)vertex_format, vertex_stride, num_indices, (Tellusim::Format)index_format))];
	}
	-(TSTracing*)createTracing_7: (uint32_t)num_vertices vertex_format: (TS_Format)vertex_format vertex_stride: (size_t)vertex_stride num_indices: (uint32_t)num_indices index_format: (TS_Format)index_format flags: (TS_TracingFlags)flags {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_vertices, (Tellusim::Format)vertex_format, vertex_stride, num_indices, (Tellusim::Format)index_format, (Tellusim::Tracing::Flags)flags))];
	}
	-(TSTracing*)createTracing_7_: (uint32_t)num_vertices vertex_format: (TS_Format)vertex_format vertex_stride: (size_t)vertex_stride num_indices: (uint32_t)num_indices index_format: (TS_Format)index_format flags: (TS_TracingFlags)flags {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_vertices, (Tellusim::Format)vertex_format, vertex_stride, num_indices, (Tellusim::Format)index_format, (Tellusim::Tracing::Flags)flags))];
	}
	-(TSTracing*)createTracing_8: (uint32_t)num_bounds bound_stride: (size_t)bound_stride {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_bounds, bound_stride))];
	}
	-(TSTracing*)createTracing_8_: (uint32_t)num_bounds bound_stride: (size_t)bound_stride {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_bounds, bound_stride))];
	}
	-(TSTracing*)createTracing_9: (uint32_t)num_bounds bound_stride: (size_t)bound_stride bound_buffer: (TSBuffer*)bound_buffer {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_bounds, bound_stride, [bound_buffer ref]))];
	}
	-(TSTracing*)createTracing_9_: (uint32_t)num_bounds bound_stride: (size_t)bound_stride bound_buffer: (TSBuffer*)bound_buffer {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_bounds, bound_stride, [bound_buffer ref]))];
	}
	-(TSTracing*)createTracing_10: (uint32_t)num_bounds bound_stride: (size_t)bound_stride bound_buffer: (TSBuffer*)bound_buffer bound_offset: (size_t)bound_offset {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_bounds, bound_stride, [bound_buffer ref], bound_offset))];
	}
	-(TSTracing*)createTracing_10_: (uint32_t)num_bounds bound_stride: (size_t)bound_stride bound_buffer: (TSBuffer*)bound_buffer bound_offset: (size_t)bound_offset {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_bounds, bound_stride, [bound_buffer ref], bound_offset))];
	}
	-(TSTracing*)createTracing_11: (uint32_t)num_bounds bound_stride: (size_t)bound_stride bound_buffer: (TSBuffer*)bound_buffer bound_offset: (size_t)bound_offset flags: (TS_TracingFlags)flags {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_bounds, bound_stride, [bound_buffer ref], bound_offset, (Tellusim::Tracing::Flags)flags))];
	}
	-(TSTracing*)createTracing_11_: (uint32_t)num_bounds bound_stride: (size_t)bound_stride bound_buffer: (TSBuffer*)bound_buffer bound_offset: (size_t)bound_offset flags: (TS_TracingFlags)flags {
		return [[TSTracing alloc] init_ref:([self ref].createTracing(num_bounds, bound_stride, [bound_buffer ref], bound_offset, (Tellusim::Tracing::Flags)flags))];
	}
	-(TSBufferTable*)createBufferTable {
		return [[TSBufferTable alloc] init_ref:([self ref].createBufferTable())];
	}
	-(TSBufferTable*)createBufferTable_1: (uint32_t)size {
		return [[TSBufferTable alloc] init_ref:([self ref].createBufferTable(size))];
	}
	-(TSBufferTable*)createBufferTable_1_: (uint32_t)size {
		return [[TSBufferTable alloc] init_ref:([self ref].createBufferTable(size))];
	}
	-(TSBufferTable*)createBufferTable_2: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [[TSBufferTable alloc] init_ref:([self ref].createBufferTable(buffers_))];
	}
	-(TSBufferTable*)createBufferTable_2_: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [[TSBufferTable alloc] init_ref:([self ref].createBufferTable(buffers_))];
	}
	-(TSBufferTable*)createBufferTable_3: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size owner: (BOOL)owner {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [[TSBufferTable alloc] init_ref:([self ref].createBufferTable(buffers_, (bool)owner))];
	}
	-(TSBufferTable*)createBufferTable_3_: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size owner: (BOOL)owner {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [[TSBufferTable alloc] init_ref:([self ref].createBufferTable(buffers_, (bool)owner))];
	}
	-(TSTextureTable*)createTextureTable {
		return [[TSTextureTable alloc] init_ref:([self ref].createTextureTable())];
	}
	-(TSTextureTable*)createTextureTable_1: (TS_TextureType)type size: (uint32_t)size {
		return [[TSTextureTable alloc] init_ref:([self ref].createTextureTable((Tellusim::Texture::Type)type, size))];
	}
	-(TSTextureTable*)createTextureTable_1_: (TS_TextureType)type size: (uint32_t)size {
		return [[TSTextureTable alloc] init_ref:([self ref].createTextureTable((Tellusim::Texture::Type)type, size))];
	}
	-(TSTextureTable*)createTextureTable_2: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [[TSTextureTable alloc] init_ref:([self ref].createTextureTable(textures_))];
	}
	-(TSTextureTable*)createTextureTable_2_: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [[TSTextureTable alloc] init_ref:([self ref].createTextureTable(textures_))];
	}
	-(TSTextureTable*)createTextureTable_3: (TSTexture**)textures textures_size: (uint32_t)textures_size owner: (BOOL)owner {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [[TSTextureTable alloc] init_ref:([self ref].createTextureTable(textures_, (bool)owner))];
	}
	-(TSTextureTable*)createTextureTable_3_: (TSTexture**)textures textures_size: (uint32_t)textures_size owner: (BOOL)owner {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [[TSTextureTable alloc] init_ref:([self ref].createTextureTable(textures_, (bool)owner))];
	}
	-(TSShader*)createShader {
		return [[TSShader alloc] init_ref:([self ref].createShader())];
	}
	-(TSShader*)loadShader: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [[TSShader alloc] init_ref:([self ref].loadShader((Tellusim::Shader::Type)type, name, "%s", format))];
	}
	-(TSShader*)loadShader_: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [[TSShader alloc] init_ref:([self ref].loadShader((Tellusim::Shader::Type)type, name, "%s", format))];
	}
	-(TSShader*)loadShaderGLSL: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [[TSShader alloc] init_ref:([self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, "%s", format))];
	}
	-(TSShader*)loadShaderGLSL_: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [[TSShader alloc] init_ref:([self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, "%s", format))];
	}
	-(TSShader*)loadShader_1: (TS_ShaderType)type name: (const char*)name {
		return [[TSShader alloc] init_ref:([self ref].loadShader((Tellusim::Shader::Type)type, name))];
	}
	-(TSShader*)loadShader_1_: (TS_ShaderType)type name: (const char*)name {
		return [[TSShader alloc] init_ref:([self ref].loadShader((Tellusim::Shader::Type)type, name))];
	}
	-(TSShader*)loadShader_2: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [[TSShader alloc] init_ref:([self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null))];
	}
	-(TSShader*)loadShader_2_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [[TSShader alloc] init_ref:([self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null))];
	}
	-(TSShader*)loadShaderGLSL_1: (TS_ShaderType)type name: (const char*)name {
		return [[TSShader alloc] init_ref:([self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name))];
	}
	-(TSShader*)loadShaderGLSL_1_: (TS_ShaderType)type name: (const char*)name {
		return [[TSShader alloc] init_ref:([self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name))];
	}
	-(TSShader*)loadShaderGLSL_2: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [[TSShader alloc] init_ref:([self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null))];
	}
	-(TSShader*)loadShaderGLSL_2_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [[TSShader alloc] init_ref:([self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null))];
	}
	-(TSShader*)loadShaderSPIRV: (TS_ShaderType)type name: (const char*)name {
		return [[TSShader alloc] init_ref:([self ref].loadShaderSPIRV((Tellusim::Shader::Type)type, name))];
	}
	-(TSShader*)loadShaderSPIRV_: (TS_ShaderType)type name: (const char*)name {
		return [[TSShader alloc] init_ref:([self ref].loadShaderSPIRV((Tellusim::Shader::Type)type, name))];
	}
	-(TSShader*)createShader_1: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [[TSShader alloc] init_ref:([self ref].createShader((Tellusim::Shader::Type)type, src, "%s", format))];
	}
	-(TSShader*)createShader_1_: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [[TSShader alloc] init_ref:([self ref].createShader((Tellusim::Shader::Type)type, src, "%s", format))];
	}
	-(TSShader*)createShaderGLSL: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [[TSShader alloc] init_ref:([self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, "%s", format))];
	}
	-(TSShader*)createShaderGLSL_: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [[TSShader alloc] init_ref:([self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, "%s", format))];
	}
	-(TSShader*)createShader_2: (TS_ShaderType)type src: (const char*)src {
		return [[TSShader alloc] init_ref:([self ref].createShader((Tellusim::Shader::Type)type, src))];
	}
	-(TSShader*)createShader_2_: (TS_ShaderType)type src: (const char*)src {
		return [[TSShader alloc] init_ref:([self ref].createShader((Tellusim::Shader::Type)type, src))];
	}
	-(TSShader*)createShader_3: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [[TSShader alloc] init_ref:([self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null))];
	}
	-(TSShader*)createShader_3_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [[TSShader alloc] init_ref:([self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null))];
	}
	-(TSShader*)createShaderGLSL_1: (TS_ShaderType)type src: (const char*)src {
		return [[TSShader alloc] init_ref:([self ref].createShaderGLSL((Tellusim::Shader::Type)type, src))];
	}
	-(TSShader*)createShaderGLSL_1_: (TS_ShaderType)type src: (const char*)src {
		return [[TSShader alloc] init_ref:([self ref].createShaderGLSL((Tellusim::Shader::Type)type, src))];
	}
	-(TSShader*)createShaderGLSL_2: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [[TSShader alloc] init_ref:([self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null))];
	}
	-(TSShader*)createShaderGLSL_2_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [[TSShader alloc] init_ref:([self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null))];
	}
	-(TSShader*)createShaderSPIRV: (TS_ShaderType)type data: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [[TSShader alloc] init_ref:([self ref].createShaderSPIRV((Tellusim::Shader::Type)type, data_))];
	}
	-(TSShader*)createShaderSPIRV_: (TS_ShaderType)type data: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [[TSShader alloc] init_ref:([self ref].createShaderSPIRV((Tellusim::Shader::Type)type, data_))];
	}
	-(TSKernel*)createKernel {
		return [[TSKernel alloc] init_ref:([self ref].createKernel())];
	}
	-(TSKernel*)createKernel_1: (const TSKernel*)kernel {
		return [[TSKernel alloc] init_ref:([self ref].createKernel([kernel ref]))];
	}
	-(TSKernel*)createKernel_1_: (const TSKernel*)kernel {
		return [[TSKernel alloc] init_ref:([self ref].createKernel([kernel ref]))];
	}
	-(void)releaseKernel: (TSKernel*)kernel {
		[self ref].releaseKernel([kernel ref]);
	}
	-(void)releaseKernel_: (TSKernel*)kernel {
		[self ref].releaseKernel([kernel ref]);
	}
	-(TSPipeline*)createPipeline {
		return [[TSPipeline alloc] init_ref:([self ref].createPipeline())];
	}
	-(TSPipeline*)createPipeline_1: (const TSPipeline*)pipeline {
		return [[TSPipeline alloc] init_ref:([self ref].createPipeline([pipeline ref]))];
	}
	-(TSPipeline*)createPipeline_1_: (const TSPipeline*)pipeline {
		return [[TSPipeline alloc] init_ref:([self ref].createPipeline([pipeline ref]))];
	}
	-(void)releasePipeline: (TSPipeline*)pipeline {
		[self ref].releasePipeline([pipeline ref]);
	}
	-(void)releasePipeline_: (TSPipeline*)pipeline {
		[self ref].releasePipeline([pipeline ref]);
	}
	-(TSTraversal*)createTraversal {
		return [[TSTraversal alloc] init_ref:([self ref].createTraversal())];
	}
	-(TSTraversal*)createTraversal_1: (const TSTraversal*)traversal {
		return [[TSTraversal alloc] init_ref:([self ref].createTraversal([traversal ref]))];
	}
	-(TSTraversal*)createTraversal_1_: (const TSTraversal*)traversal {
		return [[TSTraversal alloc] init_ref:([self ref].createTraversal([traversal ref]))];
	}
	-(void)releaseTraversal: (TSTraversal*)traversal {
		[self ref].releaseTraversal([traversal ref]);
	}
	-(void)releaseTraversal_: (TSTraversal*)traversal {
		[self ref].releaseTraversal([traversal ref]);
	}
	-(TSTarget*)createTarget {
		return [[TSTarget alloc] init_ref:([self ref].createTarget())];
	}
	-(TSTarget*)createTarget_1: (TSSurface*)surface {
		return [[TSTarget alloc] init_ref:([self ref].createTarget([surface ref]))];
	}
	-(TSTarget*)createTarget_1_: (TSSurface*)surface {
		return [[TSTarget alloc] init_ref:([self ref].createTarget([surface ref]))];
	}
	-(TSTarget*)createTarget_2: (TSWindow*)window {
		return [[TSTarget alloc] init_ref:([self ref].createTarget([window ref]))];
	}
	-(TSTarget*)createTarget_2_: (TSWindow*)window {
		return [[TSTarget alloc] init_ref:([self ref].createTarget([window ref]))];
	}
	-(TSCompute*)createCompute {
		return [[TSCompute alloc] init_ref:([self ref].createCompute())];
	}
	-(TSCommand*)createCommand {
		return [[TSCommand alloc] init_ref:([self ref].createCommand())];
	}
	-(TSCommand*)createCommand_1: (TSTarget*)target {
		return [[TSCommand alloc] init_ref:([self ref].createCommand([target ref]))];
	}
	-(TSCommand*)createCommand_1_: (TSTarget*)target {
		return [[TSCommand alloc] init_ref:([self ref].createCommand([target ref]))];
	}
	-(BOOL)setBuffer: (TSBuffer*)buffer offset: (size_t)offset src: (const void*)src size: (size_t)size {
		return [self ref].setBuffer([buffer ref], offset, src, size);
	}
	-(BOOL)setBuffer_: (TSBuffer*)buffer offset: (size_t)offset src: (const void*)src size: (size_t)size {
		return [self ref].setBuffer([buffer ref], offset, src, size);
	}
	-(BOOL)setBuffer_1: (TSBuffer*)buffer src: (const void*)src size: (size_t)size {
		return [self ref].setBuffer([buffer ref], src, size);
	}
	-(BOOL)setBuffer_1_: (TSBuffer*)buffer src: (const void*)src size: (size_t)size {
		return [self ref].setBuffer([buffer ref], src, size);
	}
	-(BOOL)setBuffer_2: (TSBuffer*)buffer src: (const void*)src {
		return [self ref].setBuffer([buffer ref], src);
	}
	-(BOOL)setBuffer_2_: (TSBuffer*)buffer src: (const void*)src {
		return [self ref].setBuffer([buffer ref], src);
	}
	-(BOOL)getBuffer: (TSBuffer*)buffer offset: (size_t)offset dest: (void*)dest size: (size_t)size {
		return [self ref].getBuffer([buffer ref], offset, dest, size);
	}
	-(BOOL)getBuffer_: (TSBuffer*)buffer offset: (size_t)offset dest: (void*)dest size: (size_t)size {
		return [self ref].getBuffer([buffer ref], offset, dest, size);
	}
	-(BOOL)getBuffer_1: (TSBuffer*)buffer dest: (void*)dest size: (size_t)size {
		return [self ref].getBuffer([buffer ref], dest, size);
	}
	-(BOOL)getBuffer_1_: (TSBuffer*)buffer dest: (void*)dest size: (size_t)size {
		return [self ref].getBuffer([buffer ref], dest, size);
	}
	-(BOOL)getBuffer_2: (TSBuffer*)buffer dest: (void*)dest {
		return [self ref].getBuffer([buffer ref], dest);
	}
	-(BOOL)getBuffer_2_: (TSBuffer*)buffer dest: (void*)dest {
		return [self ref].getBuffer([buffer ref], dest);
	}
	-(void*)mapBuffer: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		return [self ref].mapBuffer([buffer ref], offset, size);
	}
	-(void*)mapBuffer_: (TSBuffer*)buffer offset: (size_t)offset size: (size_t)size {
		return [self ref].mapBuffer([buffer ref], offset, size);
	}
	-(void*)mapBuffer_1: (TSBuffer*)buffer size: (size_t)size {
		return [self ref].mapBuffer([buffer ref], size);
	}
	-(void*)mapBuffer_1_: (TSBuffer*)buffer size: (size_t)size {
		return [self ref].mapBuffer([buffer ref], size);
	}
	-(void*)mapBuffer_2: (TSBuffer*)buffer {
		return [self ref].mapBuffer([buffer ref]);
	}
	-(void*)mapBuffer_2_: (TSBuffer*)buffer {
		return [self ref].mapBuffer([buffer ref]);
	}
	-(BOOL)unmapBuffer: (TSBuffer*)buffer {
		return [self ref].unmapBuffer([buffer ref]);
	}
	-(BOOL)unmapBuffer_: (TSBuffer*)buffer {
		return [self ref].unmapBuffer([buffer ref]);
	}
	-(BOOL)copyBuffer: (TSBuffer*)buffer dest_offset: (size_t)dest_offset src: (TSBuffer*)src src_offset: (size_t)src_offset size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], dest_offset, [src ref], src_offset, size);
	}
	-(BOOL)copyBuffer_: (TSBuffer*)buffer dest_offset: (size_t)dest_offset src: (TSBuffer*)src src_offset: (size_t)src_offset size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], dest_offset, [src ref], src_offset, size);
	}
	-(BOOL)copyBuffer_1: (TSBuffer*)buffer dest_offset: (size_t)dest_offset src: (TSBuffer*)src size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], dest_offset, [src ref], size);
	}
	-(BOOL)copyBuffer_1_: (TSBuffer*)buffer dest_offset: (size_t)dest_offset src: (TSBuffer*)src size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], dest_offset, [src ref], size);
	}
	-(BOOL)copyBuffer_2: (TSBuffer*)buffer src: (TSBuffer*)src size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], [src ref], size);
	}
	-(BOOL)copyBuffer_2_: (TSBuffer*)buffer src: (TSBuffer*)src size: (size_t)size {
		return [self ref].copyBuffer([buffer ref], [src ref], size);
	}
	-(BOOL)copyBuffer_3: (TSBuffer*)buffer src: (TSBuffer*)src {
		return [self ref].copyBuffer([buffer ref], [src ref]);
	}
	-(BOOL)copyBuffer_3_: (TSBuffer*)buffer src: (TSBuffer*)src {
		return [self ref].copyBuffer([buffer ref], [src ref]);
	}
	-(BOOL)clearBuffer: (TSBuffer*)buffer format: (TS_Format)format offset: (size_t)offset src: (const void*)src size: (size_t)size {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, offset, src, size);
	}
	-(BOOL)clearBuffer_: (TSBuffer*)buffer format: (TS_Format)format offset: (size_t)offset src: (const void*)src size: (size_t)size {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, offset, src, size);
	}
	-(BOOL)clearBuffer_1: (TSBuffer*)buffer format: (TS_Format)format src: (const void*)src size: (size_t)size {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, src, size);
	}
	-(BOOL)clearBuffer_1_: (TSBuffer*)buffer format: (TS_Format)format src: (const void*)src size: (size_t)size {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, src, size);
	}
	-(BOOL)clearBuffer_2: (TSBuffer*)buffer format: (TS_Format)format src: (const void*)src {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, src);
	}
	-(BOOL)clearBuffer_2_: (TSBuffer*)buffer format: (TS_Format)format src: (const void*)src {
		return [self ref].clearBuffer([buffer ref], (Tellusim::Format)format, src);
	}
	-(BOOL)clearBuffer_3: (TSBuffer*)buffer {
		return [self ref].clearBuffer([buffer ref]);
	}
	-(BOOL)clearBuffer_3_: (TSBuffer*)buffer {
		return [self ref].clearBuffer([buffer ref]);
	}
	-(BOOL)flushBuffer: (TSBuffer*)buffer {
		return [self ref].flushBuffer([buffer ref]);
	}
	-(BOOL)flushBuffer_: (TSBuffer*)buffer {
		return [self ref].flushBuffer([buffer ref]);
	}
	-(BOOL)flushBuffer_1: (TSBuffer*)buffer flags: (TS_BufferFlags)flags {
		return [self ref].flushBuffer([buffer ref], (Tellusim::Buffer::Flags)flags);
	}
	-(BOOL)flushBuffer_1_: (TSBuffer*)buffer flags: (TS_BufferFlags)flags {
		return [self ref].flushBuffer([buffer ref], (Tellusim::Buffer::Flags)flags);
	}
	-(BOOL)flushBuffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [self ref].flushBuffers(buffers_);
	}
	-(BOOL)flushBuffers_: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [self ref].flushBuffers(buffers_);
	}
	-(BOOL)flushBuffers_1: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size flags: (TS_BufferFlags)flags {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [self ref].flushBuffers(buffers_, (Tellusim::Buffer::Flags)flags);
	}
	-(BOOL)flushBuffers_1_: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size flags: (TS_BufferFlags)flags {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [self ref].flushBuffers(buffers_, (Tellusim::Buffer::Flags)flags);
	}
	-(void)releaseBuffer: (TSBuffer*)buffer {
		[self ref].releaseBuffer([buffer ref]);
	}
	-(void)releaseBuffer_: (TSBuffer*)buffer {
		[self ref].releaseBuffer([buffer ref]);
	}
	-(void)releaseSampler: (TSSampler*)sampler {
		[self ref].releaseSampler([sampler ref]);
	}
	-(void)releaseSampler_: (TSSampler*)sampler {
		[self ref].releaseSampler([sampler ref]);
	}
	-(BOOL)setTexture: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice image: (const TSImage*)image src_slice: (TSSlice)src_slice {
		return [self ref].setTexture([texture ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice, [image ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)setTexture_: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice image: (const TSImage*)image src_slice: (TSSlice)src_slice {
		return [self ref].setTexture([texture ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice, [image ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)setTexture_1: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], *(Tellusim::Origin*)&dest_origin, [image ref]);
	}
	-(BOOL)setTexture_1_: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], *(Tellusim::Origin*)&dest_origin, [image ref]);
	}
	-(BOOL)setTexture_2: (TSTexture*)texture dest_slice: (TSSlice)dest_slice image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], *(Tellusim::Slice*)&dest_slice, [image ref]);
	}
	-(BOOL)setTexture_2_: (TSTexture*)texture dest_slice: (TSSlice)dest_slice image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], *(Tellusim::Slice*)&dest_slice, [image ref]);
	}
	-(BOOL)setTexture_3: (TSTexture*)texture image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], [image ref]);
	}
	-(BOOL)setTexture_3_: (TSTexture*)texture image: (const TSImage*)image {
		return [self ref].setTexture([texture ref], [image ref]);
	}
	-(BOOL)getTexture: (TSTexture*)texture src_slice: (TSSlice)src_slice image: (TSImage*)image dest_slice: (TSSlice)dest_slice {
		return [self ref].getTexture([texture ref], *(Tellusim::Slice*)&src_slice, [image ref], *(Tellusim::Slice*)&dest_slice);
	}
	-(BOOL)getTexture_: (TSTexture*)texture src_slice: (TSSlice)src_slice image: (TSImage*)image dest_slice: (TSSlice)dest_slice {
		return [self ref].getTexture([texture ref], *(Tellusim::Slice*)&src_slice, [image ref], *(Tellusim::Slice*)&dest_slice);
	}
	-(BOOL)getTexture_1: (TSTexture*)texture image: (TSImage*)image dest_slice: (TSSlice)dest_slice {
		return [self ref].getTexture([texture ref], [image ref], *(Tellusim::Slice*)&dest_slice);
	}
	-(BOOL)getTexture_1_: (TSTexture*)texture image: (TSImage*)image dest_slice: (TSSlice)dest_slice {
		return [self ref].getTexture([texture ref], [image ref], *(Tellusim::Slice*)&dest_slice);
	}
	-(BOOL)getTexture_2: (TSTexture*)texture image: (TSImage*)image {
		return [self ref].getTexture([texture ref], [image ref]);
	}
	-(BOOL)getTexture_2_: (TSTexture*)texture image: (TSImage*)image {
		return [self ref].getTexture([texture ref], [image ref]);
	}
	-(BOOL)copyTexture: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice src: (TSTexture*)src src_region: (TSRegion)src_region src_slice: (TSSlice)src_slice {
		return [self ref].copyTexture([texture ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice, [src ref], *(Tellusim::Region*)&src_region, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copyTexture_: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin dest_slice: (TSSlice)dest_slice src: (TSTexture*)src src_region: (TSRegion)src_region src_slice: (TSSlice)src_slice {
		return [self ref].copyTexture([texture ref], *(Tellusim::Origin*)&dest_origin, *(Tellusim::Slice*)&dest_slice, [src ref], *(Tellusim::Region*)&src_region, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copyTexture_1: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin src: (TSTexture*)src src_region: (TSRegion)src_region {
		return [self ref].copyTexture([texture ref], *(Tellusim::Origin*)&dest_origin, [src ref], *(Tellusim::Region*)&src_region);
	}
	-(BOOL)copyTexture_1_: (TSTexture*)texture dest_origin: (TSOrigin)dest_origin src: (TSTexture*)src src_region: (TSRegion)src_region {
		return [self ref].copyTexture([texture ref], *(Tellusim::Origin*)&dest_origin, [src ref], *(Tellusim::Region*)&src_region);
	}
	-(BOOL)copyTexture_2: (TSTexture*)texture dest_slice: (TSSlice)dest_slice src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].copyTexture([texture ref], *(Tellusim::Slice*)&dest_slice, [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copyTexture_2_: (TSTexture*)texture dest_slice: (TSSlice)dest_slice src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].copyTexture([texture ref], *(Tellusim::Slice*)&dest_slice, [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)copyTexture_3: (TSTexture*)texture src: (TSTexture*)src {
		return [self ref].copyTexture([texture ref], [src ref]);
	}
	-(BOOL)copyTexture_3_: (TSTexture*)texture src: (TSTexture*)src {
		return [self ref].copyTexture([texture ref], [src ref]);
	}
	-(BOOL)clearTexture: (TSTexture*)texture region: (TSRegion)region slice: (TSSlice)slice src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice, src);
	}
	-(BOOL)clearTexture_: (TSTexture*)texture region: (TSRegion)region slice: (TSSlice)slice src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice, src);
	}
	-(BOOL)clearTexture_1: (TSTexture*)texture region: (TSRegion)region src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Region*)&region, src);
	}
	-(BOOL)clearTexture_1_: (TSTexture*)texture region: (TSRegion)region src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Region*)&region, src);
	}
	-(BOOL)clearTexture_2: (TSTexture*)texture slice: (TSSlice)slice src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Slice*)&slice, src);
	}
	-(BOOL)clearTexture_2_: (TSTexture*)texture slice: (TSSlice)slice src: (const void*)src {
		return [self ref].clearTexture([texture ref], *(Tellusim::Slice*)&slice, src);
	}
	-(BOOL)clearTexture_3: (TSTexture*)texture src: (const void*)src {
		return [self ref].clearTexture([texture ref], src);
	}
	-(BOOL)clearTexture_3_: (TSTexture*)texture src: (const void*)src {
		return [self ref].clearTexture([texture ref], src);
	}
	-(BOOL)bindTexture: (TSTexture*)texture regions: (const TSRegion*)regions num_regions: (uint32_t)num_regions slices: (const TSSlice*)slices num_slices: (uint32_t)num_slices commit: (BOOL)commit fence: (TSFence*)fence {
		return [self ref].bindTexture([texture ref], *(const Tellusim::Region**)&regions, num_regions, *(const Tellusim::Slice**)&slices, num_slices, (bool)commit, [fence ref]);
	}
	-(BOOL)bindTexture_: (TSTexture*)texture regions: (const TSRegion*)regions num_regions: (uint32_t)num_regions slices: (const TSSlice*)slices num_slices: (uint32_t)num_slices commit: (BOOL)commit fence: (TSFence*)fence {
		return [self ref].bindTexture([texture ref], *(const Tellusim::Region**)&regions, num_regions, *(const Tellusim::Slice**)&slices, num_slices, (bool)commit, [fence ref]);
	}
	-(BOOL)bindTexture_1: (TSTexture*)texture regions: (const TSRegion*)regions num_regions: (uint32_t)num_regions slices: (const TSSlice*)slices num_slices: (uint32_t)num_slices commit: (BOOL)commit {
		return [self ref].bindTexture([texture ref], *(const Tellusim::Region**)&regions, num_regions, *(const Tellusim::Slice**)&slices, num_slices, (bool)commit);
	}
	-(BOOL)bindTexture_1_: (TSTexture*)texture regions: (const TSRegion*)regions num_regions: (uint32_t)num_regions slices: (const TSSlice*)slices num_slices: (uint32_t)num_slices commit: (BOOL)commit {
		return [self ref].bindTexture([texture ref], *(const Tellusim::Region**)&regions, num_regions, *(const Tellusim::Slice**)&slices, num_slices, (bool)commit);
	}
	-(BOOL)bindTexture_2: (TSTexture*)texture region: (TSRegion)region slice: (TSSlice)slice commit: (BOOL)commit fence: (TSFence*)fence {
		return [self ref].bindTexture([texture ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice, (bool)commit, [fence ref]);
	}
	-(BOOL)bindTexture_2_: (TSTexture*)texture region: (TSRegion)region slice: (TSSlice)slice commit: (BOOL)commit fence: (TSFence*)fence {
		return [self ref].bindTexture([texture ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice, (bool)commit, [fence ref]);
	}
	-(BOOL)bindTexture_3: (TSTexture*)texture region: (TSRegion)region slice: (TSSlice)slice commit: (BOOL)commit {
		return [self ref].bindTexture([texture ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice, (bool)commit);
	}
	-(BOOL)bindTexture_3_: (TSTexture*)texture region: (TSRegion)region slice: (TSSlice)slice commit: (BOOL)commit {
		return [self ref].bindTexture([texture ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice, (bool)commit);
	}
	-(BOOL)createMipmaps: (TSTexture*)texture slice: (TSSlice)slice {
		return [self ref].createMipmaps([texture ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)createMipmaps_: (TSTexture*)texture slice: (TSSlice)slice {
		return [self ref].createMipmaps([texture ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)createMipmaps_1: (TSTexture*)texture {
		return [self ref].createMipmaps([texture ref]);
	}
	-(BOOL)createMipmaps_1_: (TSTexture*)texture {
		return [self ref].createMipmaps([texture ref]);
	}
	-(BOOL)flushTexture: (TSTexture*)texture {
		return [self ref].flushTexture([texture ref]);
	}
	-(BOOL)flushTexture_: (TSTexture*)texture {
		return [self ref].flushTexture([texture ref]);
	}
	-(BOOL)flushTexture_1: (TSTexture*)texture flags: (TS_TextureFlags)flags {
		return [self ref].flushTexture([texture ref], (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)flushTexture_1_: (TSTexture*)texture flags: (TS_TextureFlags)flags {
		return [self ref].flushTexture([texture ref], (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)flushTexture_2: (TSTexture*)texture slice: (TSSlice)slice {
		return [self ref].flushTexture([texture ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)flushTexture_2_: (TSTexture*)texture slice: (TSSlice)slice {
		return [self ref].flushTexture([texture ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)flushTexture_3: (TSTexture*)texture slice: (TSSlice)slice flags: (TS_TextureFlags)flags {
		return [self ref].flushTexture([texture ref], *(Tellusim::Slice*)&slice, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)flushTexture_3_: (TSTexture*)texture slice: (TSSlice)slice flags: (TS_TextureFlags)flags {
		return [self ref].flushTexture([texture ref], *(Tellusim::Slice*)&slice, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)flushTextures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [self ref].flushTextures(textures_);
	}
	-(BOOL)flushTextures_: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [self ref].flushTextures(textures_);
	}
	-(BOOL)flushTextures_1: (TSTexture**)textures textures_size: (uint32_t)textures_size flags: (TS_TextureFlags)flags {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [self ref].flushTextures(textures_, (Tellusim::Texture::Flags)flags);
	}
	-(BOOL)flushTextures_1_: (TSTexture**)textures textures_size: (uint32_t)textures_size flags: (TS_TextureFlags)flags {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [self ref].flushTextures(textures_, (Tellusim::Texture::Flags)flags);
	}
	-(void)releaseTexture: (TSTexture*)texture {
		[self ref].releaseTexture([texture ref]);
	}
	-(void)releaseTexture_: (TSTexture*)texture {
		[self ref].releaseTexture([texture ref]);
	}
	-(BOOL)setTracing: (TSTracing*)tracing instances: (const TSTracingInstance*)instances num_instances: (uint32_t)num_instances {
		return [self ref].setTracing([tracing ref], *(const Tellusim::Tracing::Instance**)&instances, num_instances);
	}
	-(BOOL)setTracing_: (TSTracing*)tracing instances: (const TSTracingInstance*)instances num_instances: (uint32_t)num_instances {
		return [self ref].setTracing([tracing ref], *(const Tellusim::Tracing::Instance**)&instances, num_instances);
	}
	-(BOOL)buildTracing: (TSTracing*)tracing buffer: (TSBuffer*)buffer {
		return [self ref].buildTracing([tracing ref], [buffer ref]);
	}
	-(BOOL)buildTracing_: (TSTracing*)tracing buffer: (TSBuffer*)buffer {
		return [self ref].buildTracing([tracing ref], [buffer ref]);
	}
	-(BOOL)buildTracing_1: (TSTracing*)tracing buffer: (TSBuffer*)buffer flags: (TS_TracingFlags)flags {
		return [self ref].buildTracing([tracing ref], [buffer ref], (Tellusim::Tracing::Flags)flags);
	}
	-(BOOL)buildTracing_1_: (TSTracing*)tracing buffer: (TSBuffer*)buffer flags: (TS_TracingFlags)flags {
		return [self ref].buildTracing([tracing ref], [buffer ref], (Tellusim::Tracing::Flags)flags);
	}
	-(BOOL)buildTracing_2: (TSTracing*)tracing buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].buildTracing([tracing ref], [buffer ref], offset);
	}
	-(BOOL)buildTracing_2_: (TSTracing*)tracing buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].buildTracing([tracing ref], [buffer ref], offset);
	}
	-(BOOL)buildTracing_3: (TSTracing*)tracing buffer: (TSBuffer*)buffer offset: (size_t)offset flags: (TS_TracingFlags)flags {
		return [self ref].buildTracing([tracing ref], [buffer ref], offset, (Tellusim::Tracing::Flags)flags);
	}
	-(BOOL)buildTracing_3_: (TSTracing*)tracing buffer: (TSBuffer*)buffer offset: (size_t)offset flags: (TS_TracingFlags)flags {
		return [self ref].buildTracing([tracing ref], [buffer ref], offset, (Tellusim::Tracing::Flags)flags);
	}
	-(BOOL)buildTracings: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].buildTracings(tracings_, [buffer ref]);
	}
	-(BOOL)buildTracings_: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].buildTracings(tracings_, [buffer ref]);
	}
	-(BOOL)buildTracings_1: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer flags: (TS_TracingFlags)flags {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].buildTracings(tracings_, [buffer ref], (Tellusim::Tracing::Flags)flags);
	}
	-(BOOL)buildTracings_1_: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer flags: (TS_TracingFlags)flags {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].buildTracings(tracings_, [buffer ref], (Tellusim::Tracing::Flags)flags);
	}
	-(BOOL)buildTracings_2: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer offset: (size_t)offset {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].buildTracings(tracings_, [buffer ref], offset);
	}
	-(BOOL)buildTracings_2_: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer offset: (size_t)offset {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].buildTracings(tracings_, [buffer ref], offset);
	}
	-(BOOL)buildTracings_3: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer offset: (size_t)offset flags: (TS_TracingFlags)flags {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].buildTracings(tracings_, [buffer ref], offset, (Tellusim::Tracing::Flags)flags);
	}
	-(BOOL)buildTracings_3_: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer offset: (size_t)offset flags: (TS_TracingFlags)flags {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].buildTracings(tracings_, [buffer ref], offset, (Tellusim::Tracing::Flags)flags);
	}
	-(BOOL)copyTracing: (TSTracing*)tracing buffer: (TSBuffer*)buffer {
		return [self ref].copyTracing([tracing ref], [buffer ref]);
	}
	-(BOOL)copyTracing_: (TSTracing*)tracing buffer: (TSBuffer*)buffer {
		return [self ref].copyTracing([tracing ref], [buffer ref]);
	}
	-(BOOL)copyTracing_1: (TSTracing*)tracing buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].copyTracing([tracing ref], [buffer ref], offset);
	}
	-(BOOL)copyTracing_1_: (TSTracing*)tracing buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].copyTracing([tracing ref], [buffer ref], offset);
	}
	-(BOOL)copyTracings: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer offset: (size_t)offset {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].copyTracings(tracings_, [buffer ref], offset);
	}
	-(BOOL)copyTracings_: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer offset: (size_t)offset {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].copyTracings(tracings_, [buffer ref], offset);
	}
	-(BOOL)copyTracings_1: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer offset: (size_t)offset stride: (size_t)stride {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].copyTracings(tracings_, [buffer ref], offset, stride);
	}
	-(BOOL)copyTracings_1_: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size buffer: (TSBuffer*)buffer offset: (size_t)offset stride: (size_t)stride {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].copyTracings(tracings_, [buffer ref], offset, stride);
	}
	-(BOOL)flushTracing: (TSTracing*)tracing {
		return [self ref].flushTracing([tracing ref]);
	}
	-(BOOL)flushTracing_: (TSTracing*)tracing {
		return [self ref].flushTracing([tracing ref]);
	}
	-(BOOL)flushTracings: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].flushTracings(tracings_);
	}
	-(BOOL)flushTracings_: (TSTracing**)tracings tracings_size: (uint32_t)tracings_size {
		Tellusim::Array<Tellusim::Tracing> tracings_(tracings_size);
		for(uint32_t i = 0; i < tracings_size; i++) if(tracings[i]) tracings_[i] = [tracings[i] ref];
		return [self ref].flushTracings(tracings_);
	}
	-(void)releaseTracing: (TSTracing*)tracing {
		[self ref].releaseTracing([tracing ref]);
	}
	-(void)releaseTracing_: (TSTracing*)tracing {
		[self ref].releaseTracing([tracing ref]);
	}
	-(BOOL)setBufferTable: (TSBufferTable*)table index: (uint32_t)index buffer: (TSBuffer*)buffer {
		return [self ref].setBufferTable([table ref], index, [buffer ref]);
	}
	-(BOOL)setBufferTable_: (TSBufferTable*)table index: (uint32_t)index buffer: (TSBuffer*)buffer {
		return [self ref].setBufferTable([table ref], index, [buffer ref]);
	}
	-(BOOL)setBufferTable_1: (TSBufferTable*)table index: (uint32_t)index buffer: (TSBuffer*)buffer owner: (BOOL)owner {
		return [self ref].setBufferTable([table ref], index, [buffer ref], (bool)owner);
	}
	-(BOOL)setBufferTable_1_: (TSBufferTable*)table index: (uint32_t)index buffer: (TSBuffer*)buffer owner: (BOOL)owner {
		return [self ref].setBufferTable([table ref], index, [buffer ref], (bool)owner);
	}
	-(BOOL)setBufferTable_2: (TSBufferTable*)table index: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [self ref].setBufferTable([table ref], index, buffers_);
	}
	-(BOOL)setBufferTable_2_: (TSBufferTable*)table index: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [self ref].setBufferTable([table ref], index, buffers_);
	}
	-(BOOL)setBufferTable_3: (TSBufferTable*)table index: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size owner: (BOOL)owner {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [self ref].setBufferTable([table ref], index, buffers_, (bool)owner);
	}
	-(BOOL)setBufferTable_3_: (TSBufferTable*)table index: (uint32_t)index buffers: (TSBuffer**)buffers buffers_size: (uint32_t)buffers_size owner: (BOOL)owner {
		Tellusim::Array<Tellusim::Buffer> buffers_(buffers_size);
		for(uint32_t i = 0; i < buffers_size; i++) if(buffers[i]) buffers_[i] = [buffers[i] ref];
		return [self ref].setBufferTable([table ref], index, buffers_, (bool)owner);
	}
	-(void)releaseBufferTable: (TSBufferTable*)table {
		[self ref].releaseBufferTable([table ref]);
	}
	-(void)releaseBufferTable_: (TSBufferTable*)table {
		[self ref].releaseBufferTable([table ref]);
	}
	-(BOOL)setTextureTable: (TSTextureTable*)table index: (uint32_t)index texture: (TSTexture*)texture {
		return [self ref].setTextureTable([table ref], index, [texture ref]);
	}
	-(BOOL)setTextureTable_: (TSTextureTable*)table index: (uint32_t)index texture: (TSTexture*)texture {
		return [self ref].setTextureTable([table ref], index, [texture ref]);
	}
	-(BOOL)setTextureTable_1: (TSTextureTable*)table index: (uint32_t)index texture: (TSTexture*)texture owner: (BOOL)owner {
		return [self ref].setTextureTable([table ref], index, [texture ref], (bool)owner);
	}
	-(BOOL)setTextureTable_1_: (TSTextureTable*)table index: (uint32_t)index texture: (TSTexture*)texture owner: (BOOL)owner {
		return [self ref].setTextureTable([table ref], index, [texture ref], (bool)owner);
	}
	-(BOOL)setTextureTable_2: (TSTextureTable*)table index: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [self ref].setTextureTable([table ref], index, textures_);
	}
	-(BOOL)setTextureTable_2_: (TSTextureTable*)table index: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [self ref].setTextureTable([table ref], index, textures_);
	}
	-(BOOL)setTextureTable_3: (TSTextureTable*)table index: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size owner: (BOOL)owner {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [self ref].setTextureTable([table ref], index, textures_, (bool)owner);
	}
	-(BOOL)setTextureTable_3_: (TSTextureTable*)table index: (uint32_t)index textures: (TSTexture**)textures textures_size: (uint32_t)textures_size owner: (BOOL)owner {
		Tellusim::Array<Tellusim::Texture> textures_(textures_size);
		for(uint32_t i = 0; i < textures_size; i++) if(textures[i]) textures_[i] = [textures[i] ref];
		return [self ref].setTextureTable([table ref], index, textures_, (bool)owner);
	}
	-(void)releaseTextureTable: (TSTextureTable*)table {
		[self ref].releaseTextureTable([table ref]);
	}
	-(void)releaseTextureTable_: (TSTextureTable*)table {
		[self ref].releaseTextureTable([table ref]);
	}
	-(BOOL)beginQuery: (TSQuery*)query {
		return [self ref].beginQuery([query ref]);
	}
	-(BOOL)beginQuery_: (TSQuery*)query {
		return [self ref].beginQuery([query ref]);
	}
	-(void)endQuery: (TSQuery*)query {
		[self ref].endQuery([query ref]);
	}
	-(void)endQuery_: (TSQuery*)query {
		[self ref].endQuery([query ref]);
	}
	-(BOOL)copyQuery: (TSQuery*)query buffer: (TSBuffer*)buffer {
		return [self ref].copyQuery([query ref], [buffer ref]);
	}
	-(BOOL)copyQuery_: (TSQuery*)query buffer: (TSBuffer*)buffer {
		return [self ref].copyQuery([query ref], [buffer ref]);
	}
	-(BOOL)copyQuery_1: (TSQuery*)query buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].copyQuery([query ref], [buffer ref], offset);
	}
	-(BOOL)copyQuery_1_: (TSQuery*)query buffer: (TSBuffer*)buffer offset: (size_t)offset {
		return [self ref].copyQuery([query ref], [buffer ref], offset);
	}
	-(BOOL)copyQueries: (TSQuery**)queries queries_size: (uint32_t)queries_size buffer: (TSBuffer*)buffer {
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		return [self ref].copyQueries(queries_, [buffer ref]);
	}
	-(BOOL)copyQueries_: (TSQuery**)queries queries_size: (uint32_t)queries_size buffer: (TSBuffer*)buffer {
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		return [self ref].copyQueries(queries_, [buffer ref]);
	}
	-(BOOL)copyQueries_1: (TSQuery**)queries queries_size: (uint32_t)queries_size buffer: (TSBuffer*)buffer offset: (size_t)offset {
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		return [self ref].copyQueries(queries_, [buffer ref], offset);
	}
	-(BOOL)copyQueries_1_: (TSQuery**)queries queries_size: (uint32_t)queries_size buffer: (TSBuffer*)buffer offset: (size_t)offset {
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		return [self ref].copyQueries(queries_, [buffer ref], offset);
	}
	-(BOOL)copyQueries_2: (TSQuery**)queries queries_size: (uint32_t)queries_size buffer: (TSBuffer*)buffer offset: (size_t)offset stride: (size_t)stride {
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		return [self ref].copyQueries(queries_, [buffer ref], offset, stride);
	}
	-(BOOL)copyQueries_2_: (TSQuery**)queries queries_size: (uint32_t)queries_size buffer: (TSBuffer*)buffer offset: (size_t)offset stride: (size_t)stride {
		Tellusim::Array<Tellusim::Query> queries_(queries_size);
		for(uint32_t i = 0; i < queries_size; i++) if(queries[i]) queries_[i] = [queries[i] ref];
		return [self ref].copyQueries(queries_, [buffer ref], offset, stride);
	}
	-(BOOL)waitFence: (TSFence*)fence {
		return [self ref].waitFence([fence ref]);
	}
	-(BOOL)waitFence_: (TSFence*)fence {
		return [self ref].waitFence([fence ref]);
	}
	-(BOOL)signalFence: (TSFence*)fence {
		return [self ref].signalFence([fence ref]);
	}
	-(BOOL)signalFence_: (TSFence*)fence {
		return [self ref].signalFence([fence ref]);
	}
	-(BOOL)execute: (TSDevice*)device {
		return [self ref].execute([device ref]);
	}
	-(BOOL)execute_: (TSDevice*)device {
		return [self ref].execute([device ref]);
	}
	-(BOOL)flip: (TSFence*)fence {
		return [self ref].flip([fence ref]);
	}
	-(BOOL)flip_: (TSFence*)fence {
		return [self ref].flip([fence ref]);
	}
	-(BOOL)flip_1 {
		return [self ref].flip();
	}
	-(BOOL)flush {
		return [self ref].flush();
	}
	-(BOOL)finish {
		return [self ref].finish();
	}
	-(BOOL)check {
		return [self ref].check();
	}
@end

// Tellusim::D3D12Device
@implementation TSD3D12Device
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Device();
		return self;
	}
	-(id)init_5: (TSContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Device([context ref]);
		return self;
	}
	-(id)init_5_: (TSContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Device([context ref]);
		return self;
	}
	-(id)init_6: (TSSurface*)surface {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Device([surface ref]);
		return self;
	}
	-(id)init_6_: (TSSurface*)surface {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Device([surface ref]);
		return self;
	}
	-(id)init_7: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Device([window ref]);
		return self;
	}
	-(id)init_7_: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Device([window ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Device*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Device&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Device((Tellusim::D3D12Device&)ref);
		return self;
	}
	-(Tellusim::D3D12Device*)pointer {
		return (Tellusim::D3D12Device*)impl;
	}
	-(Tellusim::D3D12Device&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Device*)impl;
	}
	-(id)initDevice: (TSDevice*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Device([base ref]);
		return self;
	}
	-(TSDevice*)getDevice {
		return [[TSDevice alloc] init_ref:([self ref].getDevice())];
	}
	-(BOOL)equalPtr: (const TSD3D12Device*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Device*)copyPtr {
		return [[TSD3D12Device alloc] init_ref:[self ref]];
	}
	-(TSD3D12Device*)clonePtr {
		return [[TSD3D12Device alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Device*)null {
		return [[TSD3D12Device alloc] init_ptr:nullptr];
	}
	-(void)setBufferState: (TSBuffer*)buffer state: (uint32_t)state {
		[self ref].setBufferState([buffer ref], state);
	}
	-(void)setBufferState_: (TSBuffer*)buffer state: (uint32_t)state {
		[self ref].setBufferState([buffer ref], state);
	}
	-(void)setTextureState: (TSTexture*)texture state: (uint32_t)state {
		[self ref].setTextureState([texture ref], state);
	}
	-(void)setTextureState_: (TSTexture*)texture state: (uint32_t)state {
		[self ref].setTextureState([texture ref], state);
	}
	-(ID3D12Device*)getD3D12Device {
		return [self ref].getD3D12Device();
	}
	-(ID3D12CommandQueue*)getQueue {
		return [self ref].getQueue();
	}
	-(ID3D12GraphicsCommandList*)getCommand {
		return [self ref].getCommand();
	}
@end

// Tellusim::D3D11Device
@implementation TSD3D11Device
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Device();
		return self;
	}
	-(id)init_5: (TSContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Device([context ref]);
		return self;
	}
	-(id)init_5_: (TSContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Device([context ref]);
		return self;
	}
	-(id)init_6: (TSSurface*)surface {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Device([surface ref]);
		return self;
	}
	-(id)init_6_: (TSSurface*)surface {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Device([surface ref]);
		return self;
	}
	-(id)init_7: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Device([window ref]);
		return self;
	}
	-(id)init_7_: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Device([window ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D11Device*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D11Device&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Device((Tellusim::D3D11Device&)ref);
		return self;
	}
	-(Tellusim::D3D11Device*)pointer {
		return (Tellusim::D3D11Device*)impl;
	}
	-(Tellusim::D3D11Device&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D11Device*)impl;
	}
	-(id)initDevice: (TSDevice*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Device([base ref]);
		return self;
	}
	-(TSDevice*)getDevice {
		return [[TSDevice alloc] init_ref:([self ref].getDevice())];
	}
	-(BOOL)equalPtr: (const TSD3D11Device*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D11Device*)copyPtr {
		return [[TSD3D11Device alloc] init_ref:[self ref]];
	}
	-(TSD3D11Device*)clonePtr {
		return [[TSD3D11Device alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D11Device*)null {
		return [[TSD3D11Device alloc] init_ptr:nullptr];
	}
	-(ID3D11Device*)getD3D11Device {
		return [self ref].getD3D11Device();
	}
	-(ID3D11DeviceContext*)getCommand {
		return [self ref].getCommand();
	}
@end

// Tellusim::MTLDevice
@implementation TSMTLDevice
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLDevice();
		return self;
	}
	-(id)init_5: (TSContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLDevice([context ref]);
		return self;
	}
	-(id)init_5_: (TSContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLDevice([context ref]);
		return self;
	}
	-(id)init_6: (TSSurface*)surface {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLDevice([surface ref]);
		return self;
	}
	-(id)init_6_: (TSSurface*)surface {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLDevice([surface ref]);
		return self;
	}
	-(id)init_7: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLDevice([window ref]);
		return self;
	}
	-(id)init_7_: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLDevice([window ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLDevice*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLDevice&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLDevice((Tellusim::MTLDevice&)ref);
		return self;
	}
	-(Tellusim::MTLDevice*)pointer {
		return (Tellusim::MTLDevice*)impl;
	}
	-(Tellusim::MTLDevice&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLDevice*)impl;
	}
	-(id)initDevice: (TSDevice*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLDevice([base ref]);
		return self;
	}
	-(TSDevice*)getDevice {
		return [[TSDevice alloc] init_ref:([self ref].getDevice())];
	}
	-(BOOL)equalPtr: (const TSMTLDevice*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLDevice*)copyPtr {
		return [[TSMTLDevice alloc] init_ref:[self ref]];
	}
	-(TSMTLDevice*)clonePtr {
		return [[TSMTLDevice alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLDevice*)null {
		return [[TSMTLDevice alloc] init_ptr:nullptr];
	}
	-(void*)getMTLDevice {
		return [self ref].getMTLDevice();
	}
	-(void*)getQueue {
		return [self ref].getQueue();
	}
	-(void*)getCommand {
		return [self ref].getCommand();
	}
	-(void*)getEncoder {
		return [self ref].getEncoder();
	}
	-(void*)getRenderEncoder: (void*)descriptor {
		return [self ref].getRenderEncoder(descriptor);
	}
	-(void*)getRenderEncoder_: (void*)descriptor {
		return [self ref].getRenderEncoder(descriptor);
	}
	-(void*)getComputeEncoder {
		return [self ref].getComputeEncoder();
	}
	-(void*)getTracingEncoder {
		return [self ref].getTracingEncoder();
	}
	-(void*)getBlitEncoder {
		return [self ref].getBlitEncoder();
	}
	-(void)endEncoder {
		[self ref].endEncoder();
	}
@end

// Tellusim::VKDevice
@implementation TSVKDevice
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKDevice();
		return self;
	}
	-(id)init_5: (TSContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKDevice([context ref]);
		return self;
	}
	-(id)init_5_: (TSContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKDevice([context ref]);
		return self;
	}
	-(id)init_6: (TSSurface*)surface {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKDevice([surface ref]);
		return self;
	}
	-(id)init_6_: (TSSurface*)surface {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKDevice([surface ref]);
		return self;
	}
	-(id)init_7: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKDevice([window ref]);
		return self;
	}
	-(id)init_7_: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKDevice([window ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::VKDevice*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKDevice&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKDevice((Tellusim::VKDevice&)ref);
		return self;
	}
	-(Tellusim::VKDevice*)pointer {
		return (Tellusim::VKDevice*)impl;
	}
	-(Tellusim::VKDevice&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKDevice*)impl;
	}
	-(id)initDevice: (TSDevice*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKDevice([base ref]);
		return self;
	}
	-(TSDevice*)getDevice {
		return [[TSDevice alloc] init_ref:([self ref].getDevice())];
	}
	-(BOOL)equalPtr: (const TSVKDevice*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKDevice*)copyPtr {
		return [[TSVKDevice alloc] init_ref:[self ref]];
	}
	-(TSVKDevice*)clonePtr {
		return [[TSVKDevice alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKDevice*)null {
		return [[TSVKDevice alloc] init_ptr:nullptr];
	}
	-(void)setBufferAccess: (TSBuffer*)buffer access: (uint32_t)access {
		[self ref].setBufferAccess([buffer ref], access);
	}
	-(void)setBufferAccess_: (TSBuffer*)buffer access: (uint32_t)access {
		[self ref].setBufferAccess([buffer ref], access);
	}
	-(void)setTextureLayout: (TSTexture*)texture layout: (uint32_t)layout {
		[self ref].setTextureLayout([texture ref], layout);
	}
	-(void)setTextureLayout_: (TSTexture*)texture layout: (uint32_t)layout {
		[self ref].setTextureLayout([texture ref], layout);
	}
	-(BOOL)waitVKFence: (void*)fence timeout: (uint64_t)timeout reset: (BOOL)reset {
		return [self ref].waitVKFence(fence, timeout, (bool)reset);
	}
	-(BOOL)waitVKFence_: (void*)fence timeout: (uint64_t)timeout reset: (BOOL)reset {
		return [self ref].waitVKFence(fence, timeout, (bool)reset);
	}
	-(BOOL)signalVKFence: (void*)fence {
		return [self ref].signalVKFence(fence);
	}
	-(BOOL)signalVKFence_: (void*)fence {
		return [self ref].signalVKFence(fence);
	}
	-(void)waitSemaphore: (void*)semaphore mask: (uint32_t)mask {
		[self ref].waitSemaphore(semaphore, mask);
	}
	-(void)waitSemaphore_: (void*)semaphore mask: (uint32_t)mask {
		[self ref].waitSemaphore(semaphore, mask);
	}
	-(void)signalSemaphore: (void*)semaphore {
		[self ref].signalSemaphore(semaphore);
	}
	-(void)signalSemaphore_: (void*)semaphore {
		[self ref].signalSemaphore(semaphore);
	}
	-(BOOL)hasMemoryType: (uint32_t)flags {
		return [self ref].hasMemoryType(flags);
	}
	-(BOOL)hasMemoryType_: (uint32_t)flags {
		return [self ref].hasMemoryType(flags);
	}
	-(uint32_t)getMemoryIndex: (uint32_t)types flags: (uint32_t)flags {
		return [self ref].getMemoryIndex(types, flags);
	}
	-(uint32_t)getMemoryIndex_: (uint32_t)types flags: (uint32_t)flags {
		return [self ref].getMemoryIndex(types, flags);
	}
	-(VkInstance)getInstance {
		return [self ref].getInstance();
	}
	-(VkPhysicalDevice)getAdapter {
		return [self ref].getAdapter();
	}
	-(VkDevice)getVKDevice {
		return [self ref].getVKDevice();
	}
	-(VkQueue)getQueue {
		return [self ref].getQueue();
	}
	-(VkCommandBuffer)getCommand {
		return [self ref].getCommand();
	}
	-(uint32_t)getFamily {
		return [self ref].getFamily();
	}
@end

// Tellusim::FUDevice
@implementation TSFUDevice
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUDevice();
		return self;
	}
	-(id)init_5: (TSDevice**)devices devices_size: (uint32_t)devices_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Device> devices_(devices_size);
		for(uint32_t i = 0; i < devices_size; i++) if(devices[i]) devices_[i] = [devices[i] ref];
		impl = new Tellusim::FUDevice(devices_);
		return self;
	}
	-(id)init_5_: (TSDevice**)devices devices_size: (uint32_t)devices_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Device> devices_(devices_size);
		for(uint32_t i = 0; i < devices_size; i++) if(devices[i]) devices_[i] = [devices[i] ref];
		impl = new Tellusim::FUDevice(devices_);
		return self;
	}
	-(id)init_6: (TSDevice**)devices devices_size: (uint32_t)devices_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Device> devices_(devices_size);
		for(uint32_t i = 0; i < devices_size; i++) if(devices[i]) devices_[i] = [devices[i] ref];
		impl = new Tellusim::FUDevice(devices_, (bool)owner);
		return self;
	}
	-(id)init_6_: (TSDevice**)devices devices_size: (uint32_t)devices_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Device> devices_(devices_size);
		for(uint32_t i = 0; i < devices_size; i++) if(devices[i]) devices_[i] = [devices[i] ref];
		impl = new Tellusim::FUDevice(devices_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUDevice*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUDevice&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUDevice((Tellusim::FUDevice&)ref);
		return self;
	}
	-(Tellusim::FUDevice*)pointer {
		return (Tellusim::FUDevice*)impl;
	}
	-(Tellusim::FUDevice&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUDevice*)impl;
	}
	-(id)initDevice: (TSDevice*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUDevice([base ref]);
		return self;
	}
	-(TSDevice*)getDevice {
		return [[TSDevice alloc] init_ref:([self ref].getDevice())];
	}
	-(BOOL)equalPtr: (const TSFUDevice*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUDevice*)copyPtr {
		return [[TSFUDevice alloc] init_ref:[self ref]];
	}
	-(TSFUDevice*)clonePtr {
		return [[TSFUDevice alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUDevice*)null {
		return [[TSFUDevice alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumDevices {
		return [self ref].getNumDevices();
	}
	-(const TSDevice*)getDevice: (uint32_t)index {
		return [[TSDevice alloc] init_ref:([self ref].getDevice(index))];
	}
	-(const TSDevice*)getDevice_: (uint32_t)index {
		return [[TSDevice alloc] init_ref:([self ref].getDevice(index))];
	}
@end

// Tellusim::Kernel
@implementation TSKernel
	-(id)init {
		self = [super init];
		impl = new Tellusim::Kernel();
		return self;
	}
	-(id)init_ptr: (Tellusim::Kernel*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Kernel&)ref {
		self = [super init];
		impl = new Tellusim::Kernel((Tellusim::Kernel&)ref);
		return self;
	}
	-(Tellusim::Kernel*)pointer {
		return (Tellusim::Kernel*)impl;
	}
	-(Tellusim::Kernel&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Kernel*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Kernel*)impl;
	}
	-(BOOL)equalPtr: (const TSKernel*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSKernel*)copyPtr {
		return [[TSKernel alloc] init_ref:[self ref]];
	}
	-(TSKernel*)clonePtr {
		return [[TSKernel alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSKernel*)null {
		return [[TSKernel alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(BOOL)create {
		return [self ref].create();
	}
	-(void)setParameters: (const TSKernel*)kernel {
		[self ref].setParameters([kernel ref]);
	}
	-(void)setParameters_: (const TSKernel*)kernel {
		[self ref].setParameters([kernel ref]);
	}
	-(BOOL)saveState: (TSStream*)stream {
		return [self ref].saveState([stream ref]);
	}
	-(BOOL)saveState_: (TSStream*)stream {
		return [self ref].saveState([stream ref]);
	}
	-(void)setShader: (TSShader*)shader {
		[self ref].setShader([shader ref]);
	}
	-(void)setShader_: (TSShader*)shader {
		[self ref].setShader([shader ref]);
	}
	-(void)setShader_1: (TSShader*)shader owner: (BOOL)owner {
		[self ref].setShader([shader ref], (bool)owner);
	}
	-(void)setShader_1_: (TSShader*)shader owner: (BOOL)owner {
		[self ref].setShader([shader ref], (bool)owner);
	}
	-(TSShader*)getComputeShader {
		return [[TSShader alloc] init_ref:([self ref].getComputeShader())];
	}
	-(BOOL)loadShader: (const char*)name format: (const char*)format {
		return [self ref].loadShader(name, "%s", format);
	}
	-(BOOL)loadShader_: (const char*)name format: (const char*)format {
		return [self ref].loadShader(name, "%s", format);
	}
	-(BOOL)loadShaderGLSL: (const char*)name format: (const char*)format {
		return [self ref].loadShaderGLSL(name, "%s", format);
	}
	-(BOOL)loadShaderGLSL_: (const char*)name format: (const char*)format {
		return [self ref].loadShaderGLSL(name, "%s", format);
	}
	-(BOOL)loadShader_1: (const char*)name {
		return [self ref].loadShader(name);
	}
	-(BOOL)loadShader_1_: (const char*)name {
		return [self ref].loadShader(name);
	}
	-(BOOL)loadShader_2: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShader(name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShader_2_: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShader(name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShader_3: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShader(name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShader_3_: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShader(name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShader_4: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShader(name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShader_4_: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShader(name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShaderGLSL_1: (const char*)name {
		return [self ref].loadShaderGLSL(name);
	}
	-(BOOL)loadShaderGLSL_1_: (const char*)name {
		return [self ref].loadShaderGLSL(name);
	}
	-(BOOL)loadShaderGLSL_2: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShaderGLSL(name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShaderGLSL_2_: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShaderGLSL(name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShaderGLSL_3: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShaderGLSL(name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShaderGLSL_3_: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShaderGLSL(name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShaderGLSL_4: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShaderGLSL(name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShaderGLSL_4_: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShaderGLSL(name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShaderSPIRV: (const char*)name {
		return [self ref].loadShaderSPIRV(name);
	}
	-(BOOL)loadShaderSPIRV_: (const char*)name {
		return [self ref].loadShaderSPIRV(name);
	}
	-(BOOL)createShader: (const char*)src format: (const char*)format {
		return [self ref].createShader(src, "%s", format);
	}
	-(BOOL)createShader_: (const char*)src format: (const char*)format {
		return [self ref].createShader(src, "%s", format);
	}
	-(BOOL)createShaderGLSL: (const char*)src format: (const char*)format {
		return [self ref].createShaderGLSL(src, "%s", format);
	}
	-(BOOL)createShaderGLSL_: (const char*)src format: (const char*)format {
		return [self ref].createShaderGLSL(src, "%s", format);
	}
	-(BOOL)createShader_1: (const char*)src {
		return [self ref].createShader(src);
	}
	-(BOOL)createShader_1_: (const char*)src {
		return [self ref].createShader(src);
	}
	-(BOOL)createShader_2: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShader(src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShader_2_: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShader(src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShader_3: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShader(src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShader_3_: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShader(src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShader_4: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShader(src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShader_4_: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShader(src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShaderGLSL_1: (const char*)src {
		return [self ref].createShaderGLSL(src);
	}
	-(BOOL)createShaderGLSL_1_: (const char*)src {
		return [self ref].createShaderGLSL(src);
	}
	-(BOOL)createShaderGLSL_2: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShaderGLSL(src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShaderGLSL_2_: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShaderGLSL(src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShaderGLSL_3: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShaderGLSL(src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShaderGLSL_3_: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShaderGLSL(src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShaderGLSL_4: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShaderGLSL(src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShaderGLSL_4_: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShaderGLSL(src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShaderSPIRV: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [self ref].createShaderSPIRV(data_);
	}
	-(BOOL)createShaderSPIRV_: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [self ref].createShaderSPIRV(data_);
	}
	-(uint32_t)addSampler {
		return [self ref].addSampler();
	}
	-(TSKernel*)setSamplers: (uint32_t)num {
		[self ref].setSamplers(num);
		return self;
	}
	-(TSKernel*)setSamplers_: (uint32_t)num {
		[self ref].setSamplers(num);
		return self;
	}
	-(uint32_t)getNumSamplers {
		return [self ref].getNumSamplers();
	}
	-(TSKernel*)setSamplerOffset: (uint32_t)offset {
		[self ref].setSamplerOffset(offset);
		return self;
	}
	-(TSKernel*)setSamplerOffset_: (uint32_t)offset {
		[self ref].setSamplerOffset(offset);
		return self;
	}
	-(uint32_t)getSamplerOffset {
		return [self ref].getSamplerOffset();
	}
	-(TSKernel*)setSamplerArray: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSamplerArray(index, num, (bool)array);
		return self;
	}
	-(TSKernel*)setSamplerArray_: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSamplerArray(index, num, (bool)array);
		return self;
	}
	-(uint32_t)getSamplerArray: (uint32_t)index {
		return [self ref].getSamplerArray(index);
	}
	-(uint32_t)getSamplerArray_: (uint32_t)index {
		return [self ref].getSamplerArray(index);
	}
	-(uint32_t)addTexture {
		return [self ref].addTexture();
	}
	-(TSKernel*)setTextures: (uint32_t)num {
		[self ref].setTextures(num);
		return self;
	}
	-(TSKernel*)setTextures_: (uint32_t)num {
		[self ref].setTextures(num);
		return self;
	}
	-(uint32_t)getNumTextures {
		return [self ref].getNumTextures();
	}
	-(TSKernel*)setTextureOffset: (uint32_t)offset {
		[self ref].setTextureOffset(offset);
		return self;
	}
	-(TSKernel*)setTextureOffset_: (uint32_t)offset {
		[self ref].setTextureOffset(offset);
		return self;
	}
	-(uint32_t)getTextureOffset {
		return [self ref].getTextureOffset();
	}
	-(TSKernel*)setTextureArray: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setTextureArray(index, num, (bool)array);
		return self;
	}
	-(TSKernel*)setTextureArray_: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setTextureArray(index, num, (bool)array);
		return self;
	}
	-(uint32_t)getTextureArray: (uint32_t)index {
		return [self ref].getTextureArray(index);
	}
	-(uint32_t)getTextureArray_: (uint32_t)index {
		return [self ref].getTextureArray(index);
	}
	-(uint32_t)addSurface {
		return [self ref].addSurface();
	}
	-(TSKernel*)setSurfaces: (uint32_t)num {
		[self ref].setSurfaces(num);
		return self;
	}
	-(TSKernel*)setSurfaces_: (uint32_t)num {
		[self ref].setSurfaces(num);
		return self;
	}
	-(uint32_t)getNumSurfaces {
		return [self ref].getNumSurfaces();
	}
	-(TSKernel*)setSurfaceOffset: (uint32_t)offset {
		[self ref].setSurfaceOffset(offset);
		return self;
	}
	-(TSKernel*)setSurfaceOffset_: (uint32_t)offset {
		[self ref].setSurfaceOffset(offset);
		return self;
	}
	-(uint32_t)getSurfaceOffset {
		return [self ref].getSurfaceOffset();
	}
	-(TSKernel*)setSurfaceArray: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSurfaceArray(index, num, (bool)array);
		return self;
	}
	-(TSKernel*)setSurfaceArray_: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSurfaceArray(index, num, (bool)array);
		return self;
	}
	-(uint32_t)getSurfaceArray: (uint32_t)index {
		return [self ref].getSurfaceArray(index);
	}
	-(uint32_t)getSurfaceArray_: (uint32_t)index {
		return [self ref].getSurfaceArray(index);
	}
	-(uint32_t)addUniform {
		return [self ref].addUniform();
	}
	-(uint32_t)addUniform_1: (TS_BindFlags)flags {
		return [self ref].addUniform((Tellusim::BindFlags)flags);
	}
	-(uint32_t)addUniform_1_: (TS_BindFlags)flags {
		return [self ref].addUniform((Tellusim::BindFlags)flags);
	}
	-(TSKernel*)setUniforms: (uint32_t)num {
		[self ref].setUniforms(num);
		return self;
	}
	-(TSKernel*)setUniforms_: (uint32_t)num {
		[self ref].setUniforms(num);
		return self;
	}
	-(TSKernel*)setUniforms_1: (uint32_t)num flags: (TS_BindFlags)flags {
		[self ref].setUniforms(num, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSKernel*)setUniforms_1_: (uint32_t)num flags: (TS_BindFlags)flags {
		[self ref].setUniforms(num, (Tellusim::BindFlags)flags);
		return self;
	}
	-(uint32_t)getNumUniforms {
		return [self ref].getNumUniforms();
	}
	-(TSKernel*)setUniformOffset: (uint32_t)offset {
		[self ref].setUniformOffset(offset);
		return self;
	}
	-(TSKernel*)setUniformOffset_: (uint32_t)offset {
		[self ref].setUniformOffset(offset);
		return self;
	}
	-(uint32_t)getUniformOffset {
		return [self ref].getUniformOffset();
	}
	-(TSKernel*)setUniformFlags: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setUniformFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSKernel*)setUniformFlags_: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setUniformFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_BindFlags)getUniformFlags: (uint32_t)index {
		return (TS_BindFlags)[self ref].getUniformFlags(index);
	}
	-(TS_BindFlags)getUniformFlags_: (uint32_t)index {
		return (TS_BindFlags)[self ref].getUniformFlags(index);
	}
	-(uint32_t)addStorage {
		return [self ref].addStorage();
	}
	-(uint32_t)addStorage_1: (TS_BindFlags)flags {
		return [self ref].addStorage((Tellusim::BindFlags)flags);
	}
	-(uint32_t)addStorage_1_: (TS_BindFlags)flags {
		return [self ref].addStorage((Tellusim::BindFlags)flags);
	}
	-(TSKernel*)setStorages: (uint32_t)num {
		[self ref].setStorages(num);
		return self;
	}
	-(TSKernel*)setStorages_: (uint32_t)num {
		[self ref].setStorages(num);
		return self;
	}
	-(TSKernel*)setStorages_1: (uint32_t)num flags: (TS_BindFlags)flags {
		[self ref].setStorages(num, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSKernel*)setStorages_1_: (uint32_t)num flags: (TS_BindFlags)flags {
		[self ref].setStorages(num, (Tellusim::BindFlags)flags);
		return self;
	}
	-(uint32_t)getNumStorages {
		return [self ref].getNumStorages();
	}
	-(TSKernel*)setStorageOffset: (uint32_t)offset {
		[self ref].setStorageOffset(offset);
		return self;
	}
	-(TSKernel*)setStorageOffset_: (uint32_t)offset {
		[self ref].setStorageOffset(offset);
		return self;
	}
	-(uint32_t)getStorageOffset {
		return [self ref].getStorageOffset();
	}
	-(TSKernel*)setStorageFlags: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setStorageFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSKernel*)setStorageFlags_: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setStorageFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_BindFlags)getStorageFlags: (uint32_t)index {
		return (TS_BindFlags)[self ref].getStorageFlags(index);
	}
	-(TS_BindFlags)getStorageFlags_: (uint32_t)index {
		return (TS_BindFlags)[self ref].getStorageFlags(index);
	}
	-(uint32_t)addTracing {
		return [self ref].addTracing();
	}
	-(TSKernel*)setTracings: (uint32_t)num {
		[self ref].setTracings(num);
		return self;
	}
	-(TSKernel*)setTracings_: (uint32_t)num {
		[self ref].setTracings(num);
		return self;
	}
	-(uint32_t)getNumTracings {
		return [self ref].getNumTracings();
	}
	-(TSKernel*)setTracingOffset: (uint32_t)offset {
		[self ref].setTracingOffset(offset);
		return self;
	}
	-(TSKernel*)setTracingOffset_: (uint32_t)offset {
		[self ref].setTracingOffset(offset);
		return self;
	}
	-(uint32_t)getTracingOffset {
		return [self ref].getTracingOffset();
	}
	-(uint32_t)addTexel {
		return [self ref].addTexel();
	}
	-(TSKernel*)setTexels: (uint32_t)num {
		[self ref].setTexels(num);
		return self;
	}
	-(TSKernel*)setTexels_: (uint32_t)num {
		[self ref].setTexels(num);
		return self;
	}
	-(uint32_t)getNumTexels {
		return [self ref].getNumTexels();
	}
	-(TSKernel*)setTexelOffset: (uint32_t)offset {
		[self ref].setTexelOffset(offset);
		return self;
	}
	-(TSKernel*)setTexelOffset_: (uint32_t)offset {
		[self ref].setTexelOffset(offset);
		return self;
	}
	-(uint32_t)getTexelOffset {
		return [self ref].getTexelOffset();
	}
	-(uint32_t)addTable: (TS_TableType)type size: (uint32_t)size {
		return [self ref].addTable((Tellusim::TableType)type, size);
	}
	-(uint32_t)addTable_: (TS_TableType)type size: (uint32_t)size {
		return [self ref].addTable((Tellusim::TableType)type, size);
	}
	-(uint32_t)getNumTables {
		return [self ref].getNumTables();
	}
	-(TSKernel*)setTableOffset: (uint32_t)offset {
		[self ref].setTableOffset(offset);
		return self;
	}
	-(TSKernel*)setTableOffset_: (uint32_t)offset {
		[self ref].setTableOffset(offset);
		return self;
	}
	-(uint32_t)getTableOffset {
		return [self ref].getTableOffset();
	}
	-(TSKernel*)setTableType: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size {
		[self ref].setTableType(index, (Tellusim::TableType)type, size);
		return self;
	}
	-(TSKernel*)setTableType_: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size {
		[self ref].setTableType(index, (Tellusim::TableType)type, size);
		return self;
	}
	-(TSKernel*)setTableType_1: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size flags: (TS_BindFlags)flags {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSKernel*)setTableType_1_: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size flags: (TS_BindFlags)flags {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_TableType)getTableType: (uint32_t)index {
		return (TS_TableType)[self ref].getTableType(index);
	}
	-(TS_TableType)getTableType_: (uint32_t)index {
		return (TS_TableType)[self ref].getTableType(index);
	}
	-(uint32_t)getTableSize: (uint32_t)index {
		return [self ref].getTableSize(index);
	}
	-(uint32_t)getTableSize_: (uint32_t)index {
		return [self ref].getTableSize(index);
	}
	-(TSKernel*)setTableFlags: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setTableFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSKernel*)setTableFlags_: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setTableFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_BindFlags)getTableFlags: (uint32_t)index {
		return (TS_BindFlags)[self ref].getTableFlags(index);
	}
	-(TS_BindFlags)getTableFlags_: (uint32_t)index {
		return (TS_BindFlags)[self ref].getTableFlags(index);
	}
	-(void)setGroupSize: (uint32_t)width {
		[self ref].setGroupSize(width);
	}
	-(void)setGroupSize_: (uint32_t)width {
		[self ref].setGroupSize(width);
	}
	-(void)setGroupSize_1: (uint32_t)width height: (uint32_t)height {
		[self ref].setGroupSize(width, height);
	}
	-(void)setGroupSize_1_: (uint32_t)width height: (uint32_t)height {
		[self ref].setGroupSize(width, height);
	}
	-(void)setGroupSize_2: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		[self ref].setGroupSize(width, height, depth);
	}
	-(void)setGroupSize_2_: (uint32_t)width height: (uint32_t)height depth: (uint32_t)depth {
		[self ref].setGroupSize(width, height, depth);
	}
	-(uint32_t)getGroupSizeX {
		return [self ref].getGroupSizeX();
	}
	-(uint32_t)getGroupSizeY {
		return [self ref].getGroupSizeY();
	}
	-(uint32_t)getGroupSizeZ {
		return [self ref].getGroupSizeZ();
	}
@end

// Tellusim::D3D12Kernel
@implementation TSD3D12Kernel
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Kernel();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Kernel*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Kernel&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Kernel((Tellusim::D3D12Kernel&)ref);
		return self;
	}
	-(Tellusim::D3D12Kernel*)pointer {
		return (Tellusim::D3D12Kernel*)impl;
	}
	-(Tellusim::D3D12Kernel&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Kernel*)impl;
	}
	-(id)initKernel: (TSKernel*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Kernel([base ref]);
		return self;
	}
	-(TSKernel*)getKernel {
		return [[TSKernel alloc] init_ref:([self ref].getKernel())];
	}
	-(BOOL)equalPtr: (const TSD3D12Kernel*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Kernel*)copyPtr {
		return [[TSD3D12Kernel alloc] init_ref:[self ref]];
	}
	-(TSD3D12Kernel*)clonePtr {
		return [[TSD3D12Kernel alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Kernel*)null {
		return [[TSD3D12Kernel alloc] init_ptr:nullptr];
	}
	-(ID3D12RootSignature*)getRootSignature {
		return [self ref].getRootSignature();
	}
@end

// Tellusim::MTLKernel
@implementation TSMTLKernel
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLKernel();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLKernel*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLKernel&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLKernel((Tellusim::MTLKernel&)ref);
		return self;
	}
	-(Tellusim::MTLKernel*)pointer {
		return (Tellusim::MTLKernel*)impl;
	}
	-(Tellusim::MTLKernel&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLKernel*)impl;
	}
	-(id)initKernel: (TSKernel*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLKernel([base ref]);
		return self;
	}
	-(TSKernel*)getKernel {
		return [[TSKernel alloc] init_ref:([self ref].getKernel())];
	}
	-(BOOL)equalPtr: (const TSMTLKernel*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLKernel*)copyPtr {
		return [[TSMTLKernel alloc] init_ref:[self ref]];
	}
	-(TSMTLKernel*)clonePtr {
		return [[TSMTLKernel alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLKernel*)null {
		return [[TSMTLKernel alloc] init_ptr:nullptr];
	}
	-(void)setIndirect: (BOOL)enabled {
		[self ref].setIndirect((bool)enabled);
	}
	-(void)setIndirect_: (BOOL)enabled {
		[self ref].setIndirect((bool)enabled);
	}
	-(BOOL)isIndirect {
		return [self ref].isIndirect();
	}
	-(void*)getComputeFunction {
		return [self ref].getComputeFunction();
	}
@end

// Tellusim::FUKernel
@implementation TSFUKernel
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUKernel();
		return self;
	}
	-(id)init_2: (TSKernel**)kernels kernels_size: (uint32_t)kernels_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Kernel> kernels_(kernels_size);
		for(uint32_t i = 0; i < kernels_size; i++) if(kernels[i]) kernels_[i] = [kernels[i] ref];
		impl = new Tellusim::FUKernel(kernels_);
		return self;
	}
	-(id)init_2_: (TSKernel**)kernels kernels_size: (uint32_t)kernels_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Kernel> kernels_(kernels_size);
		for(uint32_t i = 0; i < kernels_size; i++) if(kernels[i]) kernels_[i] = [kernels[i] ref];
		impl = new Tellusim::FUKernel(kernels_);
		return self;
	}
	-(id)init_3: (TSKernel**)kernels kernels_size: (uint32_t)kernels_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Kernel> kernels_(kernels_size);
		for(uint32_t i = 0; i < kernels_size; i++) if(kernels[i]) kernels_[i] = [kernels[i] ref];
		impl = new Tellusim::FUKernel(kernels_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSKernel**)kernels kernels_size: (uint32_t)kernels_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Kernel> kernels_(kernels_size);
		for(uint32_t i = 0; i < kernels_size; i++) if(kernels[i]) kernels_[i] = [kernels[i] ref];
		impl = new Tellusim::FUKernel(kernels_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUKernel*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUKernel&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUKernel((Tellusim::FUKernel&)ref);
		return self;
	}
	-(Tellusim::FUKernel*)pointer {
		return (Tellusim::FUKernel*)impl;
	}
	-(Tellusim::FUKernel&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUKernel*)impl;
	}
	-(id)initKernel: (TSKernel*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUKernel([base ref]);
		return self;
	}
	-(TSKernel*)getKernel {
		return [[TSKernel alloc] init_ref:([self ref].getKernel())];
	}
	-(BOOL)equalPtr: (const TSFUKernel*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUKernel*)copyPtr {
		return [[TSFUKernel alloc] init_ref:[self ref]];
	}
	-(TSFUKernel*)clonePtr {
		return [[TSFUKernel alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUKernel*)null {
		return [[TSFUKernel alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumKernels {
		return [self ref].getNumKernels();
	}
	-(const TSKernel*)getKernel: (uint32_t)index {
		return [[TSKernel alloc] init_ref:([self ref].getKernel(index))];
	}
	-(const TSKernel*)getKernel_: (uint32_t)index {
		return [[TSKernel alloc] init_ref:([self ref].getKernel(index))];
	}
@end

// Tellusim::Pipeline
@implementation TSPipeline
	-(id)init {
		self = [super init];
		impl = new Tellusim::Pipeline();
		return self;
	}
	-(id)init_ptr: (Tellusim::Pipeline*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Pipeline&)ref {
		self = [super init];
		impl = new Tellusim::Pipeline((Tellusim::Pipeline&)ref);
		return self;
	}
	-(Tellusim::Pipeline*)pointer {
		return (Tellusim::Pipeline*)impl;
	}
	-(Tellusim::Pipeline&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Pipeline*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Pipeline*)impl;
	}
	-(BOOL)equalPtr: (const TSPipeline*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSPipeline*)copyPtr {
		return [[TSPipeline alloc] init_ref:[self ref]];
	}
	-(TSPipeline*)clonePtr {
		return [[TSPipeline alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSPipeline*)null {
		return [[TSPipeline alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(BOOL)create {
		return [self ref].create();
	}
	-(void)setParameters: (const TSPipeline*)pipeline {
		[self ref].setParameters([pipeline ref]);
	}
	-(void)setParameters_: (const TSPipeline*)pipeline {
		[self ref].setParameters([pipeline ref]);
	}
	-(BOOL)saveState: (TSStream*)stream {
		return [self ref].saveState([stream ref]);
	}
	-(BOOL)saveState_: (TSStream*)stream {
		return [self ref].saveState([stream ref]);
	}
	-(void)addShader: (TSShader*)shader {
		[self ref].addShader([shader ref]);
	}
	-(void)addShader_: (TSShader*)shader {
		[self ref].addShader([shader ref]);
	}
	-(void)addShader_1: (TSShader*)shader owner: (BOOL)owner {
		[self ref].addShader([shader ref], (bool)owner);
	}
	-(void)addShader_1_: (TSShader*)shader owner: (BOOL)owner {
		[self ref].addShader([shader ref], (bool)owner);
	}
	-(TSShader*)getVertexShader {
		return [[TSShader alloc] init_ref:([self ref].getVertexShader())];
	}
	-(TSShader*)getControlShader {
		return [[TSShader alloc] init_ref:([self ref].getControlShader())];
	}
	-(TSShader*)getEvaluateShader {
		return [[TSShader alloc] init_ref:([self ref].getEvaluateShader())];
	}
	-(TSShader*)getGeometryShader {
		return [[TSShader alloc] init_ref:([self ref].getGeometryShader())];
	}
	-(TSShader*)getFragmentShader {
		return [[TSShader alloc] init_ref:([self ref].getFragmentShader())];
	}
	-(TSShader*)getTaskShader {
		return [[TSShader alloc] init_ref:([self ref].getTaskShader())];
	}
	-(TSShader*)getMeshShader {
		return [[TSShader alloc] init_ref:([self ref].getMeshShader())];
	}
	-(BOOL)loadShader: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)loadShader_: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)loadShaderGLSL: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)loadShaderGLSL_: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)loadShader_1: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShader_1_: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShader_2: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShader_2_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShader_3: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShader_3_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShader_4: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShader_4_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShaderGLSL_1: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShaderGLSL_1_: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShaderGLSL_2: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShaderGLSL_2_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShaderGLSL_3: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShaderGLSL_3_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShaderGLSL_4: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShaderGLSL_4_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShaderSPIRV: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShaderSPIRV((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShaderSPIRV_: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShaderSPIRV((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)createShader: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)createShader_: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)createShaderGLSL: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)createShaderGLSL_: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)createShader_1: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createShader((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createShader_1_: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createShader((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createShader_2: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShader_2_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShader_3: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShader_3_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShader_4: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShader_4_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShaderGLSL_1: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createShaderGLSL_1_: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createShaderGLSL_2: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShaderGLSL_2_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShaderGLSL_3: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShaderGLSL_3_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShaderGLSL_4: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShaderGLSL_4_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShaderSPIRV: (TS_ShaderType)type data: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [self ref].createShaderSPIRV((Tellusim::Shader::Type)type, data_);
	}
	-(BOOL)createShaderSPIRV_: (TS_ShaderType)type data: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [self ref].createShaderSPIRV((Tellusim::Shader::Type)type, data_);
	}
	-(uint32_t)addSampler: (TS_ShaderMask)mask {
		return [self ref].addSampler((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addSampler_: (TS_ShaderMask)mask {
		return [self ref].addSampler((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumSamplers {
		return [self ref].getNumSamplers();
	}
	-(TSPipeline*)setSamplerOffset: (uint32_t)offset {
		[self ref].setSamplerOffset(offset);
		return self;
	}
	-(TSPipeline*)setSamplerOffset_: (uint32_t)offset {
		[self ref].setSamplerOffset(offset);
		return self;
	}
	-(uint32_t)getSamplerOffset {
		return [self ref].getSamplerOffset();
	}
	-(TSPipeline*)setSamplerMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setSamplerMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setSamplerMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setSamplerMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getSamplerMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getSamplerMask(index);
	}
	-(TS_ShaderMask)getSamplerMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getSamplerMask(index);
	}
	-(TSPipeline*)setSamplerMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setSamplerMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setSamplerMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setSamplerMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setSamplerMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setSamplerMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TSPipeline*)setSamplerMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setSamplerMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TS_ShaderMask)getSamplerMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getSamplerMasks(index, num);
	}
	-(TS_ShaderMask)getSamplerMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getSamplerMasks(index, num);
	}
	-(TSPipeline*)setSamplerArray: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSamplerArray(index, num, (bool)array);
		return self;
	}
	-(TSPipeline*)setSamplerArray_: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSamplerArray(index, num, (bool)array);
		return self;
	}
	-(uint32_t)getSamplerArray: (uint32_t)index {
		return [self ref].getSamplerArray(index);
	}
	-(uint32_t)getSamplerArray_: (uint32_t)index {
		return [self ref].getSamplerArray(index);
	}
	-(uint32_t)addTexture: (TS_ShaderMask)mask {
		return [self ref].addTexture((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTexture_: (TS_ShaderMask)mask {
		return [self ref].addTexture((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumTextures {
		return [self ref].getNumTextures();
	}
	-(TSPipeline*)setTextureOffset: (uint32_t)offset {
		[self ref].setTextureOffset(offset);
		return self;
	}
	-(TSPipeline*)setTextureOffset_: (uint32_t)offset {
		[self ref].setTextureOffset(offset);
		return self;
	}
	-(uint32_t)getTextureOffset {
		return [self ref].getTextureOffset();
	}
	-(TSPipeline*)setTextureMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTextureMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTextureMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTextureMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTextureMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTextureMask(index);
	}
	-(TS_ShaderMask)getTextureMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTextureMask(index);
	}
	-(TSPipeline*)setTextureMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTextureMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTextureMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTextureMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTextureMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setTextureMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TSPipeline*)setTextureMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setTextureMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TS_ShaderMask)getTextureMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTextureMasks(index, num);
	}
	-(TS_ShaderMask)getTextureMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTextureMasks(index, num);
	}
	-(TSPipeline*)setTextureArray: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setTextureArray(index, num, (bool)array);
		return self;
	}
	-(TSPipeline*)setTextureArray_: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setTextureArray(index, num, (bool)array);
		return self;
	}
	-(uint32_t)getTextureArray: (uint32_t)index {
		return [self ref].getTextureArray(index);
	}
	-(uint32_t)getTextureArray_: (uint32_t)index {
		return [self ref].getTextureArray(index);
	}
	-(uint32_t)addSurface: (TS_ShaderMask)mask {
		return [self ref].addSurface((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addSurface_: (TS_ShaderMask)mask {
		return [self ref].addSurface((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumSurfaces {
		return [self ref].getNumSurfaces();
	}
	-(TSPipeline*)setSurfaceOffset: (uint32_t)offset {
		[self ref].setSurfaceOffset(offset);
		return self;
	}
	-(TSPipeline*)setSurfaceOffset_: (uint32_t)offset {
		[self ref].setSurfaceOffset(offset);
		return self;
	}
	-(uint32_t)getSurfaceOffset {
		return [self ref].getSurfaceOffset();
	}
	-(TSPipeline*)setSurfaceMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setSurfaceMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setSurfaceMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setSurfaceMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getSurfaceMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getSurfaceMask(index);
	}
	-(TS_ShaderMask)getSurfaceMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getSurfaceMask(index);
	}
	-(TSPipeline*)setSurfaceMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setSurfaceMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setSurfaceMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setSurfaceMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setSurfaceMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setSurfaceMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TSPipeline*)setSurfaceMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setSurfaceMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TS_ShaderMask)getSurfaceMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getSurfaceMasks(index, num);
	}
	-(TS_ShaderMask)getSurfaceMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getSurfaceMasks(index, num);
	}
	-(TSPipeline*)setSurfaceArray: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSurfaceArray(index, num, (bool)array);
		return self;
	}
	-(TSPipeline*)setSurfaceArray_: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSurfaceArray(index, num, (bool)array);
		return self;
	}
	-(uint32_t)getSurfaceArray: (uint32_t)index {
		return [self ref].getSurfaceArray(index);
	}
	-(uint32_t)getSurfaceArray_: (uint32_t)index {
		return [self ref].getSurfaceArray(index);
	}
	-(uint32_t)addUniform: (TS_ShaderMask)mask {
		return [self ref].addUniform((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addUniform_: (TS_ShaderMask)mask {
		return [self ref].addUniform((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addUniform_1: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addUniform((Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)addUniform_1_: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addUniform((Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)getNumUniforms {
		return [self ref].getNumUniforms();
	}
	-(TSPipeline*)setUniformOffset: (uint32_t)offset {
		[self ref].setUniformOffset(offset);
		return self;
	}
	-(TSPipeline*)setUniformOffset_: (uint32_t)offset {
		[self ref].setUniformOffset(offset);
		return self;
	}
	-(uint32_t)getUniformOffset {
		return [self ref].getUniformOffset();
	}
	-(TSPipeline*)setUniformMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setUniformMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setUniformMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setUniformMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setUniformMask_1: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setUniformMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSPipeline*)setUniformMask_1_: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setUniformMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getUniformMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getUniformMask(index);
	}
	-(TS_ShaderMask)getUniformMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getUniformMask(index);
	}
	-(TSPipeline*)setUniformMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setUniformMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setUniformMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setUniformMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setUniformMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setUniformMasks(index, num, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSPipeline*)setUniformMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setUniformMasks(index, num, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getUniformMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getUniformMasks(index, num);
	}
	-(TS_ShaderMask)getUniformMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getUniformMasks(index, num);
	}
	-(TSPipeline*)setUniformFlags: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setUniformFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSPipeline*)setUniformFlags_: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setUniformFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_BindFlags)getUniformFlags: (uint32_t)index {
		return (TS_BindFlags)[self ref].getUniformFlags(index);
	}
	-(TS_BindFlags)getUniformFlags_: (uint32_t)index {
		return (TS_BindFlags)[self ref].getUniformFlags(index);
	}
	-(uint32_t)addStorage: (TS_ShaderMask)mask {
		return [self ref].addStorage((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addStorage_: (TS_ShaderMask)mask {
		return [self ref].addStorage((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addStorage_1: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addStorage((Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)addStorage_1_: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addStorage((Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)getNumStorages {
		return [self ref].getNumStorages();
	}
	-(TSPipeline*)setStorageOffset: (uint32_t)offset {
		[self ref].setStorageOffset(offset);
		return self;
	}
	-(TSPipeline*)setStorageOffset_: (uint32_t)offset {
		[self ref].setStorageOffset(offset);
		return self;
	}
	-(uint32_t)getStorageOffset {
		return [self ref].getStorageOffset();
	}
	-(TSPipeline*)setStorageMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setStorageMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setStorageMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setStorageMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setStorageMask_1: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setStorageMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSPipeline*)setStorageMask_1_: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setStorageMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getStorageMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getStorageMask(index);
	}
	-(TS_ShaderMask)getStorageMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getStorageMask(index);
	}
	-(TSPipeline*)setStorageMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setStorageMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setStorageMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setStorageMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setStorageMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setStorageMasks(index, num, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSPipeline*)setStorageMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setStorageMasks(index, num, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getStorageMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getStorageMasks(index, num);
	}
	-(TS_ShaderMask)getStorageMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getStorageMasks(index, num);
	}
	-(TSPipeline*)setStorageFlags: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setStorageFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSPipeline*)setStorageFlags_: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setStorageFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_BindFlags)getStorageFlags: (uint32_t)index {
		return (TS_BindFlags)[self ref].getStorageFlags(index);
	}
	-(TS_BindFlags)getStorageFlags_: (uint32_t)index {
		return (TS_BindFlags)[self ref].getStorageFlags(index);
	}
	-(uint32_t)addTracing: (TS_ShaderMask)mask {
		return [self ref].addTracing((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTracing_: (TS_ShaderMask)mask {
		return [self ref].addTracing((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumTracings {
		return [self ref].getNumTracings();
	}
	-(TSPipeline*)setTracingOffset: (uint32_t)offset {
		[self ref].setTracingOffset(offset);
		return self;
	}
	-(TSPipeline*)setTracingOffset_: (uint32_t)offset {
		[self ref].setTracingOffset(offset);
		return self;
	}
	-(uint32_t)getTracingOffset {
		return [self ref].getTracingOffset();
	}
	-(TSPipeline*)setTracingMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTracingMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTracingMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTracingMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTracingMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTracingMask(index);
	}
	-(TS_ShaderMask)getTracingMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTracingMask(index);
	}
	-(TSPipeline*)setTracingMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTracingMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTracingMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTracingMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTracingMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTracingMasks(index, num);
	}
	-(TS_ShaderMask)getTracingMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTracingMasks(index, num);
	}
	-(uint32_t)addTexel: (TS_ShaderMask)mask {
		return [self ref].addTexel((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTexel_: (TS_ShaderMask)mask {
		return [self ref].addTexel((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumTexels {
		return [self ref].getNumTexels();
	}
	-(TSPipeline*)setTexelOffset: (uint32_t)offset {
		[self ref].setTexelOffset(offset);
		return self;
	}
	-(TSPipeline*)setTexelOffset_: (uint32_t)offset {
		[self ref].setTexelOffset(offset);
		return self;
	}
	-(uint32_t)getTexelOffset {
		return [self ref].getTexelOffset();
	}
	-(TSPipeline*)setTexelMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTexelMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTexelMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTexelMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTexelMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTexelMask(index);
	}
	-(TS_ShaderMask)getTexelMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTexelMask(index);
	}
	-(TSPipeline*)setTexelMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTexelMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTexelMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTexelMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTexelMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTexelMasks(index, num);
	}
	-(TS_ShaderMask)getTexelMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTexelMasks(index, num);
	}
	-(uint32_t)addTable: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask {
		return [self ref].addTable((Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTable_: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask {
		return [self ref].addTable((Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTable_1: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addTable((Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)addTable_1_: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addTable((Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)getNumTables {
		return [self ref].getNumTables();
	}
	-(TSPipeline*)setTableOffset: (uint32_t)offset {
		[self ref].setTableOffset(offset);
		return self;
	}
	-(TSPipeline*)setTableOffset_: (uint32_t)offset {
		[self ref].setTableOffset(offset);
		return self;
	}
	-(uint32_t)getTableOffset {
		return [self ref].getTableOffset();
	}
	-(TSPipeline*)setTableType: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTableType_: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTableType_1: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSPipeline*)setTableType_1_: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_TableType)getTableType: (uint32_t)index {
		return (TS_TableType)[self ref].getTableType(index);
	}
	-(TS_TableType)getTableType_: (uint32_t)index {
		return (TS_TableType)[self ref].getTableType(index);
	}
	-(uint32_t)getTableSize: (uint32_t)index {
		return [self ref].getTableSize(index);
	}
	-(uint32_t)getTableSize_: (uint32_t)index {
		return [self ref].getTableSize(index);
	}
	-(TSPipeline*)setTableMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTableMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTableMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTableMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSPipeline*)setTableMask_1: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setTableMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSPipeline*)setTableMask_1_: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setTableMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getTableMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTableMask(index);
	}
	-(TS_ShaderMask)getTableMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTableMask(index);
	}
	-(TSPipeline*)setTableFlags: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setTableFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSPipeline*)setTableFlags_: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setTableFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_BindFlags)getTableFlags: (uint32_t)index {
		return (TS_BindFlags)[self ref].getTableFlags(index);
	}
	-(TS_BindFlags)getTableFlags_: (uint32_t)index {
		return (TS_BindFlags)[self ref].getTableFlags(index);
	}
	-(uint32_t)getNumVertices {
		return [self ref].getNumVertices();
	}
	-(uint32_t)getVertexStride: (uint32_t)index {
		return [self ref].getVertexStride(index);
	}
	-(uint32_t)getVertexStride_: (uint32_t)index {
		return [self ref].getVertexStride(index);
	}
	-(uint32_t)getVertexRate: (uint32_t)index {
		return [self ref].getVertexRate(index);
	}
	-(uint32_t)getVertexRate_: (uint32_t)index {
		return [self ref].getVertexRate(index);
	}
	-(uint32_t)addAttribute: (TS_PipelineAttribute)attribute format: (TS_Format)format vertex: (uint32_t)vertex offset: (size_t)offset stride: (size_t)stride {
		return [self ref].addAttribute((Tellusim::Pipeline::Attribute)attribute, (Tellusim::Format)format, vertex, offset, stride);
	}
	-(uint32_t)addAttribute_: (TS_PipelineAttribute)attribute format: (TS_Format)format vertex: (uint32_t)vertex offset: (size_t)offset stride: (size_t)stride {
		return [self ref].addAttribute((Tellusim::Pipeline::Attribute)attribute, (Tellusim::Format)format, vertex, offset, stride);
	}
	-(uint32_t)addAttribute_1: (TS_PipelineAttribute)attribute format: (TS_Format)format vertex: (uint32_t)vertex offset: (size_t)offset stride: (size_t)stride rate: (uint32_t)rate {
		return [self ref].addAttribute((Tellusim::Pipeline::Attribute)attribute, (Tellusim::Format)format, vertex, offset, stride, rate);
	}
	-(uint32_t)addAttribute_1_: (TS_PipelineAttribute)attribute format: (TS_Format)format vertex: (uint32_t)vertex offset: (size_t)offset stride: (size_t)stride rate: (uint32_t)rate {
		return [self ref].addAttribute((Tellusim::Pipeline::Attribute)attribute, (Tellusim::Format)format, vertex, offset, stride, rate);
	}
	-(TSPipeline*)setAttribute: (uint32_t)index attribute: (TS_PipelineAttribute)attribute format: (TS_Format)format vertex: (uint32_t)vertex offset: (size_t)offset stride: (size_t)stride {
		[self ref].setAttribute(index, (Tellusim::Pipeline::Attribute)attribute, (Tellusim::Format)format, vertex, offset, stride);
		return self;
	}
	-(TSPipeline*)setAttribute_: (uint32_t)index attribute: (TS_PipelineAttribute)attribute format: (TS_Format)format vertex: (uint32_t)vertex offset: (size_t)offset stride: (size_t)stride {
		[self ref].setAttribute(index, (Tellusim::Pipeline::Attribute)attribute, (Tellusim::Format)format, vertex, offset, stride);
		return self;
	}
	-(TSPipeline*)setAttribute_1: (uint32_t)index attribute: (TS_PipelineAttribute)attribute format: (TS_Format)format vertex: (uint32_t)vertex offset: (size_t)offset stride: (size_t)stride rate: (uint32_t)rate {
		[self ref].setAttribute(index, (Tellusim::Pipeline::Attribute)attribute, (Tellusim::Format)format, vertex, offset, stride, rate);
		return self;
	}
	-(TSPipeline*)setAttribute_1_: (uint32_t)index attribute: (TS_PipelineAttribute)attribute format: (TS_Format)format vertex: (uint32_t)vertex offset: (size_t)offset stride: (size_t)stride rate: (uint32_t)rate {
		[self ref].setAttribute(index, (Tellusim::Pipeline::Attribute)attribute, (Tellusim::Format)format, vertex, offset, stride, rate);
		return self;
	}
	-(TSPipeline*)setAttributeType: (uint32_t)index attribute: (TS_PipelineAttribute)attribute {
		[self ref].setAttributeType(index, (Tellusim::Pipeline::Attribute)attribute);
		return self;
	}
	-(TSPipeline*)setAttributeType_: (uint32_t)index attribute: (TS_PipelineAttribute)attribute {
		[self ref].setAttributeType(index, (Tellusim::Pipeline::Attribute)attribute);
		return self;
	}
	-(TSPipeline*)setAttributeFormat: (uint32_t)index format: (TS_Format)format {
		[self ref].setAttributeFormat(index, (Tellusim::Format)format);
		return self;
	}
	-(TSPipeline*)setAttributeFormat_: (uint32_t)index format: (TS_Format)format {
		[self ref].setAttributeFormat(index, (Tellusim::Format)format);
		return self;
	}
	-(TSPipeline*)setAttributeVertex: (uint32_t)index vertex: (uint32_t)vertex {
		[self ref].setAttributeVertex(index, vertex);
		return self;
	}
	-(TSPipeline*)setAttributeVertex_: (uint32_t)index vertex: (uint32_t)vertex {
		[self ref].setAttributeVertex(index, vertex);
		return self;
	}
	-(TSPipeline*)setAttributeOffset: (uint32_t)index offset: (size_t)offset {
		[self ref].setAttributeOffset(index, offset);
		return self;
	}
	-(TSPipeline*)setAttributeOffset_: (uint32_t)index offset: (size_t)offset {
		[self ref].setAttributeOffset(index, offset);
		return self;
	}
	-(TSPipeline*)setAttributeStride: (uint32_t)index stride: (size_t)stride {
		[self ref].setAttributeStride(index, stride);
		return self;
	}
	-(TSPipeline*)setAttributeStride_: (uint32_t)index stride: (size_t)stride {
		[self ref].setAttributeStride(index, stride);
		return self;
	}
	-(TSPipeline*)setAttributeRate: (uint32_t)index rate: (uint32_t)rate {
		[self ref].setAttributeRate(index, rate);
		return self;
	}
	-(TSPipeline*)setAttributeRate_: (uint32_t)index rate: (uint32_t)rate {
		[self ref].setAttributeRate(index, rate);
		return self;
	}
	-(uint32_t)getNumAttributes {
		return [self ref].getNumAttributes();
	}
	-(TS_PipelineAttribute)getAttributeType: (uint32_t)index {
		return (TS_PipelineAttribute)[self ref].getAttributeType(index);
	}
	-(TS_PipelineAttribute)getAttributeType_: (uint32_t)index {
		return (TS_PipelineAttribute)[self ref].getAttributeType(index);
	}
	-(TS_Format)getAttributeFormat: (uint32_t)index {
		return (TS_Format)[self ref].getAttributeFormat(index);
	}
	-(TS_Format)getAttributeFormat_: (uint32_t)index {
		return (TS_Format)[self ref].getAttributeFormat(index);
	}
	-(uint32_t)getAttributeVertex: (uint32_t)index {
		return [self ref].getAttributeVertex(index);
	}
	-(uint32_t)getAttributeVertex_: (uint32_t)index {
		return [self ref].getAttributeVertex(index);
	}
	-(uint32_t)getAttributeOffset: (uint32_t)index {
		return [self ref].getAttributeOffset(index);
	}
	-(uint32_t)getAttributeOffset_: (uint32_t)index {
		return [self ref].getAttributeOffset(index);
	}
	-(uint32_t)getAttributeStride: (uint32_t)index {
		return [self ref].getAttributeStride(index);
	}
	-(uint32_t)getAttributeStride_: (uint32_t)index {
		return [self ref].getAttributeStride(index);
	}
	-(uint32_t)getAttributeRate: (uint32_t)index {
		return [self ref].getAttributeRate(index);
	}
	-(uint32_t)getAttributeRate_: (uint32_t)index {
		return [self ref].getAttributeRate(index);
	}
	-(void)setPrimitive: (TS_PipelinePrimitive)primitive {
		[self ref].setPrimitive((Tellusim::Pipeline::Primitive)primitive);
	}
	-(void)setPrimitive_: (TS_PipelinePrimitive)primitive {
		[self ref].setPrimitive((Tellusim::Pipeline::Primitive)primitive);
	}
	-(TS_PipelinePrimitive)getPrimitive {
		return (TS_PipelinePrimitive)[self ref].getPrimitive();
	}
	-(void)setFillMode: (TS_PipelineFillMode)mode {
		[self ref].setFillMode((Tellusim::Pipeline::FillMode)mode);
	}
	-(void)setFillMode_: (TS_PipelineFillMode)mode {
		[self ref].setFillMode((Tellusim::Pipeline::FillMode)mode);
	}
	-(TS_PipelineFillMode)getFillMode {
		return (TS_PipelineFillMode)[self ref].getFillMode();
	}
	-(void)setCullMode: (TS_PipelineCullMode)mode {
		[self ref].setCullMode((Tellusim::Pipeline::CullMode)mode);
	}
	-(void)setCullMode_: (TS_PipelineCullMode)mode {
		[self ref].setCullMode((Tellusim::Pipeline::CullMode)mode);
	}
	-(TS_PipelineCullMode)getCullMode {
		return (TS_PipelineCullMode)[self ref].getCullMode();
	}
	-(void)setFrontMode: (TS_PipelineFrontMode)mode {
		[self ref].setFrontMode((Tellusim::Pipeline::FrontMode)mode);
	}
	-(void)setFrontMode_: (TS_PipelineFrontMode)mode {
		[self ref].setFrontMode((Tellusim::Pipeline::FrontMode)mode);
	}
	-(TS_PipelineFrontMode)getFrontMode {
		return (TS_PipelineFrontMode)[self ref].getFrontMode();
	}
	-(void)setDepthBias: (float32_t)bias slope: (float32_t)slope {
		[self ref].setDepthBias(bias, slope);
	}
	-(void)setDepthBias_: (float32_t)bias slope: (float32_t)slope {
		[self ref].setDepthBias(bias, slope);
	}
	-(void)setDepthBias_1: (float32_t)bias slope: (float32_t)slope clamp: (float32_t)clamp {
		[self ref].setDepthBias(bias, slope, clamp);
	}
	-(void)setDepthBias_1_: (float32_t)bias slope: (float32_t)slope clamp: (float32_t)clamp {
		[self ref].setDepthBias(bias, slope, clamp);
	}
	-(float32_t)getDepthBias {
		return [self ref].getDepthBias();
	}
	-(float32_t)getDepthSlope {
		return [self ref].getDepthSlope();
	}
	-(float32_t)getDepthClamp {
		return [self ref].getDepthClamp();
	}
	-(void)setMultisample: (uint32_t)multisample {
		[self ref].setMultisample(multisample);
	}
	-(void)setMultisample_: (uint32_t)multisample {
		[self ref].setMultisample(multisample);
	}
	-(uint32_t)getMultisample {
		return [self ref].getMultisample();
	}
	-(void)setSampleMask: (uint32_t)sample_mask {
		[self ref].setSampleMask(sample_mask);
	}
	-(void)setSampleMask_: (uint32_t)sample_mask {
		[self ref].setSampleMask(sample_mask);
	}
	-(uint32_t)getSampleMask {
		return [self ref].getSampleMask();
	}
	-(void)setDepthClip: (BOOL)enabled {
		[self ref].setDepthClip((bool)enabled);
	}
	-(void)setDepthClip_: (BOOL)enabled {
		[self ref].setDepthClip((bool)enabled);
	}
	-(BOOL)getDepthClip {
		return [self ref].getDepthClip();
	}
	-(void)setDepthReplace: (BOOL)enabled {
		[self ref].setDepthReplace((bool)enabled);
	}
	-(void)setDepthReplace_: (BOOL)enabled {
		[self ref].setDepthReplace((bool)enabled);
	}
	-(BOOL)getDepthReplace {
		return [self ref].getDepthReplace();
	}
	-(void)setScissorTest: (BOOL)enabled {
		[self ref].setScissorTest((bool)enabled);
	}
	-(void)setScissorTest_: (BOOL)enabled {
		[self ref].setScissorTest((bool)enabled);
	}
	-(BOOL)getScissorTest {
		return [self ref].getScissorTest();
	}
	-(void)setRasterDiscard: (BOOL)enabled {
		[self ref].setRasterDiscard((bool)enabled);
	}
	-(void)setRasterDiscard_: (BOOL)enabled {
		[self ref].setRasterDiscard((bool)enabled);
	}
	-(BOOL)getRasterDiscard {
		return [self ref].getRasterDiscard();
	}
	-(void)setSampleShading: (BOOL)enabled {
		[self ref].setSampleShading((bool)enabled);
	}
	-(void)setSampleShading_: (BOOL)enabled {
		[self ref].setSampleShading((bool)enabled);
	}
	-(BOOL)getSampleShading {
		return [self ref].getSampleShading();
	}
	-(void)setAlphaToCoverage: (BOOL)enabled {
		[self ref].setAlphaToCoverage((bool)enabled);
	}
	-(void)setAlphaToCoverage_: (BOOL)enabled {
		[self ref].setAlphaToCoverage((bool)enabled);
	}
	-(BOOL)getAlphaToCoverage {
		return [self ref].getAlphaToCoverage();
	}
	-(void)setMultisampleRaster: (BOOL)enabled {
		[self ref].setMultisampleRaster((bool)enabled);
	}
	-(void)setMultisampleRaster_: (BOOL)enabled {
		[self ref].setMultisampleRaster((bool)enabled);
	}
	-(BOOL)getMultisampleRaster {
		return [self ref].getMultisampleRaster();
	}
	-(void)setConservativeRaster: (BOOL)enabled {
		[self ref].setConservativeRaster((bool)enabled);
	}
	-(void)setConservativeRaster_: (BOOL)enabled {
		[self ref].setConservativeRaster((bool)enabled);
	}
	-(BOOL)getConservativeRaster {
		return [self ref].getConservativeRaster();
	}
	-(void)setNumViewports: (uint32_t)num_viewports {
		[self ref].setNumViewports(num_viewports);
	}
	-(void)setNumViewports_: (uint32_t)num_viewports {
		[self ref].setNumViewports(num_viewports);
	}
	-(uint32_t)getNumTargets {
		return [self ref].getNumTargets();
	}
	-(uint32_t)getNumViewports {
		return [self ref].getNumViewports();
	}
	-(void)setNumClipDistances: (uint32_t)num_distances {
		[self ref].setNumClipDistances(num_distances);
	}
	-(void)setNumClipDistances_: (uint32_t)num_distances {
		[self ref].setNumClipDistances(num_distances);
	}
	-(uint32_t)getNumClipDistances {
		return [self ref].getNumClipDistances();
	}
	-(void)setBlend: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlend_: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlendColor: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlendColor((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlendColor_: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlendColor((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlendAlpha: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlendAlpha((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlendAlpha_: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlendAlpha((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlend_1: (uint32_t)index op: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend(index, (Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlend_1_: (uint32_t)index op: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend(index, (Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlendColor_1: (uint32_t)index op: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlendColor(index, (Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlendColor_1_: (uint32_t)index op: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlendColor(index, (Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlendAlpha_1: (uint32_t)index op: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlendAlpha(index, (Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlendAlpha_1_: (uint32_t)index op: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlendAlpha(index, (Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(TS_PipelineBlendOp)getBlendColorOp: (uint32_t)index {
		return (TS_PipelineBlendOp)[self ref].getBlendColorOp(index);
	}
	-(TS_PipelineBlendOp)getBlendColorOp_: (uint32_t)index {
		return (TS_PipelineBlendOp)[self ref].getBlendColorOp(index);
	}
	-(TS_PipelineBlendOp)getBlendAlphaOp: (uint32_t)index {
		return (TS_PipelineBlendOp)[self ref].getBlendAlphaOp(index);
	}
	-(TS_PipelineBlendOp)getBlendAlphaOp_: (uint32_t)index {
		return (TS_PipelineBlendOp)[self ref].getBlendAlphaOp(index);
	}
	-(TS_PipelineBlendFunc)getBlendSrcColorFunc: (uint32_t)index {
		return (TS_PipelineBlendFunc)[self ref].getBlendSrcColorFunc(index);
	}
	-(TS_PipelineBlendFunc)getBlendSrcColorFunc_: (uint32_t)index {
		return (TS_PipelineBlendFunc)[self ref].getBlendSrcColorFunc(index);
	}
	-(TS_PipelineBlendFunc)getBlendSrcAlphaFunc: (uint32_t)index {
		return (TS_PipelineBlendFunc)[self ref].getBlendSrcAlphaFunc(index);
	}
	-(TS_PipelineBlendFunc)getBlendSrcAlphaFunc_: (uint32_t)index {
		return (TS_PipelineBlendFunc)[self ref].getBlendSrcAlphaFunc(index);
	}
	-(TS_PipelineBlendFunc)getBlendDestColorFunc: (uint32_t)index {
		return (TS_PipelineBlendFunc)[self ref].getBlendDestColorFunc(index);
	}
	-(TS_PipelineBlendFunc)getBlendDestColorFunc_: (uint32_t)index {
		return (TS_PipelineBlendFunc)[self ref].getBlendDestColorFunc(index);
	}
	-(TS_PipelineBlendFunc)getBlendDestAlphaFunc: (uint32_t)index {
		return (TS_PipelineBlendFunc)[self ref].getBlendDestAlphaFunc(index);
	}
	-(TS_PipelineBlendFunc)getBlendDestAlphaFunc_: (uint32_t)index {
		return (TS_PipelineBlendFunc)[self ref].getBlendDestAlphaFunc(index);
	}
	-(void)setColorMask: (TS_PipelineColorMask)mask {
		[self ref].setColorMask((Tellusim::Pipeline::ColorMask)mask);
	}
	-(void)setColorMask_: (TS_PipelineColorMask)mask {
		[self ref].setColorMask((Tellusim::Pipeline::ColorMask)mask);
	}
	-(void)setColorMask_1: (uint32_t)index mask: (TS_PipelineColorMask)mask {
		[self ref].setColorMask(index, (Tellusim::Pipeline::ColorMask)mask);
	}
	-(void)setColorMask_1_: (uint32_t)index mask: (TS_PipelineColorMask)mask {
		[self ref].setColorMask(index, (Tellusim::Pipeline::ColorMask)mask);
	}
	-(void)setColorFormat: (uint32_t)index format: (TS_Format)format {
		[self ref].setColorFormat(index, (Tellusim::Format)format);
	}
	-(void)setColorFormat_: (uint32_t)index format: (TS_Format)format {
		[self ref].setColorFormat(index, (Tellusim::Format)format);
	}
	-(void)setColorFormat_1: (TS_Format)format {
		[self ref].setColorFormat((Tellusim::Format)format);
	}
	-(void)setColorFormat_1_: (TS_Format)format {
		[self ref].setColorFormat((Tellusim::Format)format);
	}
	-(void)setColorFormat_2: (TS_Format)format num: (uint32_t)num {
		[self ref].setColorFormat((Tellusim::Format)format, num);
	}
	-(void)setColorFormat_2_: (TS_Format)format num: (uint32_t)num {
		[self ref].setColorFormat((Tellusim::Format)format, num);
	}
	-(TS_PipelineColorMask)getColorMask: (uint32_t)index {
		return (TS_PipelineColorMask)[self ref].getColorMask(index);
	}
	-(TS_PipelineColorMask)getColorMask_: (uint32_t)index {
		return (TS_PipelineColorMask)[self ref].getColorMask(index);
	}
	-(TS_Format)getColorFormat: (uint32_t)index {
		return (TS_Format)[self ref].getColorFormat(index);
	}
	-(TS_Format)getColorFormat_: (uint32_t)index {
		return (TS_Format)[self ref].getColorFormat(index);
	}
	-(void)setDepthMask: (TS_PipelineDepthMask)mask {
		[self ref].setDepthMask((Tellusim::Pipeline::DepthMask)mask);
	}
	-(void)setDepthMask_: (TS_PipelineDepthMask)mask {
		[self ref].setDepthMask((Tellusim::Pipeline::DepthMask)mask);
	}
	-(void)setDepthFunc: (TS_PipelineDepthFunc)func {
		[self ref].setDepthFunc((Tellusim::Pipeline::DepthFunc)func);
	}
	-(void)setDepthFunc_: (TS_PipelineDepthFunc)func {
		[self ref].setDepthFunc((Tellusim::Pipeline::DepthFunc)func);
	}
	-(void)setDepthFormat: (TS_Format)format {
		[self ref].setDepthFormat((Tellusim::Format)format);
	}
	-(void)setDepthFormat_: (TS_Format)format {
		[self ref].setDepthFormat((Tellusim::Format)format);
	}
	-(TS_PipelineDepthMask)getDepthMask {
		return (TS_PipelineDepthMask)[self ref].getDepthMask();
	}
	-(TS_PipelineDepthFunc)getDepthFunc {
		return (TS_PipelineDepthFunc)[self ref].getDepthFunc();
	}
	-(TS_Format)getDepthFormat {
		return (TS_Format)[self ref].getDepthFormat();
	}
	-(void)setStencilMask: (uint32_t)mask {
		[self ref].setStencilMask(mask);
	}
	-(void)setStencilMask_: (uint32_t)mask {
		[self ref].setStencilMask(mask);
	}
	-(void)setStencilBackMask: (uint32_t)mask {
		[self ref].setStencilBackMask(mask);
	}
	-(void)setStencilBackMask_: (uint32_t)mask {
		[self ref].setStencilBackMask(mask);
	}
	-(void)setStencilFrontMask: (uint32_t)mask {
		[self ref].setStencilFrontMask(mask);
	}
	-(void)setStencilFrontMask_: (uint32_t)mask {
		[self ref].setStencilFrontMask(mask);
	}
	-(void)setStencilFunc: (TS_PipelineStencilFunc)func dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilFunc_: (TS_PipelineStencilFunc)func dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilBackFunc: (TS_PipelineStencilFunc)func dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilBackFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilBackFunc_: (TS_PipelineStencilFunc)func dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilBackFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilFrontFunc: (TS_PipelineStencilFunc)func dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFrontFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilFrontFunc_: (TS_PipelineStencilFunc)func dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFrontFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilFunc_1: (TS_PipelineStencilFunc)func fail_op: (TS_PipelineStencilOp)fail_op dfail_op: (TS_PipelineStencilOp)dfail_op dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)fail_op, (Tellusim::Pipeline::StencilOp)dfail_op, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilFunc_1_: (TS_PipelineStencilFunc)func fail_op: (TS_PipelineStencilOp)fail_op dfail_op: (TS_PipelineStencilOp)dfail_op dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)fail_op, (Tellusim::Pipeline::StencilOp)dfail_op, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilBackFunc_1: (TS_PipelineStencilFunc)func fail_op: (TS_PipelineStencilOp)fail_op dfail_op: (TS_PipelineStencilOp)dfail_op dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilBackFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)fail_op, (Tellusim::Pipeline::StencilOp)dfail_op, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilBackFunc_1_: (TS_PipelineStencilFunc)func fail_op: (TS_PipelineStencilOp)fail_op dfail_op: (TS_PipelineStencilOp)dfail_op dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilBackFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)fail_op, (Tellusim::Pipeline::StencilOp)dfail_op, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilFrontFunc_1: (TS_PipelineStencilFunc)func fail_op: (TS_PipelineStencilOp)fail_op dfail_op: (TS_PipelineStencilOp)dfail_op dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFrontFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)fail_op, (Tellusim::Pipeline::StencilOp)dfail_op, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilFrontFunc_1_: (TS_PipelineStencilFunc)func fail_op: (TS_PipelineStencilOp)fail_op dfail_op: (TS_PipelineStencilOp)dfail_op dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFrontFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)fail_op, (Tellusim::Pipeline::StencilOp)dfail_op, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(uint32_t)getStencilBackMask {
		return [self ref].getStencilBackMask();
	}
	-(TS_PipelineStencilFunc)getStencilBackFunc {
		return (TS_PipelineStencilFunc)[self ref].getStencilBackFunc();
	}
	-(TS_PipelineStencilOp)getStencilBackFailOp {
		return (TS_PipelineStencilOp)[self ref].getStencilBackFailOp();
	}
	-(TS_PipelineStencilOp)getStencilBackDepthFailOp {
		return (TS_PipelineStencilOp)[self ref].getStencilBackDepthFailOp();
	}
	-(TS_PipelineStencilOp)getStencilBackDepthPassOp {
		return (TS_PipelineStencilOp)[self ref].getStencilBackDepthPassOp();
	}
	-(uint32_t)getStencilFrontMask {
		return [self ref].getStencilFrontMask();
	}
	-(TS_PipelineStencilFunc)getStencilFrontFunc {
		return (TS_PipelineStencilFunc)[self ref].getStencilFrontFunc();
	}
	-(TS_PipelineStencilOp)getStencilFrontFailOp {
		return (TS_PipelineStencilOp)[self ref].getStencilFrontFailOp();
	}
	-(TS_PipelineStencilOp)getStencilFrontDepthFailOp {
		return (TS_PipelineStencilOp)[self ref].getStencilFrontDepthFailOp();
	}
	-(TS_PipelineStencilOp)getStencilFrontDepthPassOp {
		return (TS_PipelineStencilOp)[self ref].getStencilFrontDepthPassOp();
	}
@end

// Tellusim::D3D12Pipeline
@implementation TSD3D12Pipeline
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Pipeline();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Pipeline*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Pipeline&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Pipeline((Tellusim::D3D12Pipeline&)ref);
		return self;
	}
	-(Tellusim::D3D12Pipeline*)pointer {
		return (Tellusim::D3D12Pipeline*)impl;
	}
	-(Tellusim::D3D12Pipeline&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Pipeline*)impl;
	}
	-(id)initPipeline: (TSPipeline*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Pipeline([base ref]);
		return self;
	}
	-(TSPipeline*)getPipeline {
		return [[TSPipeline alloc] init_ref:([self ref].getPipeline())];
	}
	-(BOOL)equalPtr: (const TSD3D12Pipeline*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Pipeline*)copyPtr {
		return [[TSD3D12Pipeline alloc] init_ref:[self ref]];
	}
	-(TSD3D12Pipeline*)clonePtr {
		return [[TSD3D12Pipeline alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Pipeline*)null {
		return [[TSD3D12Pipeline alloc] init_ptr:nullptr];
	}
	-(ID3D12RootSignature*)getRootSignature {
		return [self ref].getRootSignature();
	}
@end

// Tellusim::MTLPipeline
@implementation TSMTLPipeline
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLPipeline();
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLPipeline*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLPipeline&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLPipeline((Tellusim::MTLPipeline&)ref);
		return self;
	}
	-(Tellusim::MTLPipeline*)pointer {
		return (Tellusim::MTLPipeline*)impl;
	}
	-(Tellusim::MTLPipeline&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLPipeline*)impl;
	}
	-(id)initPipeline: (TSPipeline*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLPipeline([base ref]);
		return self;
	}
	-(TSPipeline*)getPipeline {
		return [[TSPipeline alloc] init_ref:([self ref].getPipeline())];
	}
	-(BOOL)equalPtr: (const TSMTLPipeline*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLPipeline*)copyPtr {
		return [[TSMTLPipeline alloc] init_ref:[self ref]];
	}
	-(TSMTLPipeline*)clonePtr {
		return [[TSMTLPipeline alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLPipeline*)null {
		return [[TSMTLPipeline alloc] init_ptr:nullptr];
	}
	-(void)setIndirect: (BOOL)enabled {
		[self ref].setIndirect((bool)enabled);
	}
	-(void)setIndirect_: (BOOL)enabled {
		[self ref].setIndirect((bool)enabled);
	}
	-(BOOL)isIndirect {
		return [self ref].isIndirect();
	}
	-(void*)getVertexFunction {
		return [self ref].getVertexFunction();
	}
	-(void*)getFragmentFunction {
		return [self ref].getFragmentFunction();
	}
@end

// Tellusim::FUPipeline
@implementation TSFUPipeline
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUPipeline();
		return self;
	}
	-(id)init_2: (TSPipeline**)pipelines pipelines_size: (uint32_t)pipelines_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Pipeline> pipelines_(pipelines_size);
		for(uint32_t i = 0; i < pipelines_size; i++) if(pipelines[i]) pipelines_[i] = [pipelines[i] ref];
		impl = new Tellusim::FUPipeline(pipelines_);
		return self;
	}
	-(id)init_2_: (TSPipeline**)pipelines pipelines_size: (uint32_t)pipelines_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Pipeline> pipelines_(pipelines_size);
		for(uint32_t i = 0; i < pipelines_size; i++) if(pipelines[i]) pipelines_[i] = [pipelines[i] ref];
		impl = new Tellusim::FUPipeline(pipelines_);
		return self;
	}
	-(id)init_3: (TSPipeline**)pipelines pipelines_size: (uint32_t)pipelines_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Pipeline> pipelines_(pipelines_size);
		for(uint32_t i = 0; i < pipelines_size; i++) if(pipelines[i]) pipelines_[i] = [pipelines[i] ref];
		impl = new Tellusim::FUPipeline(pipelines_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSPipeline**)pipelines pipelines_size: (uint32_t)pipelines_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Pipeline> pipelines_(pipelines_size);
		for(uint32_t i = 0; i < pipelines_size; i++) if(pipelines[i]) pipelines_[i] = [pipelines[i] ref];
		impl = new Tellusim::FUPipeline(pipelines_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUPipeline*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUPipeline&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUPipeline((Tellusim::FUPipeline&)ref);
		return self;
	}
	-(Tellusim::FUPipeline*)pointer {
		return (Tellusim::FUPipeline*)impl;
	}
	-(Tellusim::FUPipeline&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUPipeline*)impl;
	}
	-(id)initPipeline: (TSPipeline*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUPipeline([base ref]);
		return self;
	}
	-(TSPipeline*)getPipeline {
		return [[TSPipeline alloc] init_ref:([self ref].getPipeline())];
	}
	-(BOOL)equalPtr: (const TSFUPipeline*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUPipeline*)copyPtr {
		return [[TSFUPipeline alloc] init_ref:[self ref]];
	}
	-(TSFUPipeline*)clonePtr {
		return [[TSFUPipeline alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUPipeline*)null {
		return [[TSFUPipeline alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumPipelines {
		return [self ref].getNumPipelines();
	}
	-(const TSPipeline*)getPipeline: (uint32_t)index {
		return [[TSPipeline alloc] init_ref:([self ref].getPipeline(index))];
	}
	-(const TSPipeline*)getPipeline_: (uint32_t)index {
		return [[TSPipeline alloc] init_ref:([self ref].getPipeline(index))];
	}
@end

// Tellusim::Traversal
@implementation TSTraversal
	-(id)init {
		self = [super init];
		impl = new Tellusim::Traversal();
		return self;
	}
	-(id)init_ptr: (Tellusim::Traversal*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Traversal&)ref {
		self = [super init];
		impl = new Tellusim::Traversal((Tellusim::Traversal&)ref);
		return self;
	}
	-(Tellusim::Traversal*)pointer {
		return (Tellusim::Traversal*)impl;
	}
	-(Tellusim::Traversal&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Traversal*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Traversal*)impl;
	}
	-(BOOL)equalPtr: (const TSTraversal*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSTraversal*)copyPtr {
		return [[TSTraversal alloc] init_ref:[self ref]];
	}
	-(TSTraversal*)clonePtr {
		return [[TSTraversal alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSTraversal*)null {
		return [[TSTraversal alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(void)setName: (const char*)name {
		[self ref].setName(name);
	}
	-(void)setName_: (const char*)name {
		[self ref].setName(name);
	}
	-(NSString*)getName {
		return [NSString stringWithUTF8String:[self ref].getName().get()];
	}
	-(BOOL)create {
		return [self ref].create();
	}
	-(void)setParameters: (const TSTraversal*)traversal {
		[self ref].setParameters([traversal ref]);
	}
	-(void)setParameters_: (const TSTraversal*)traversal {
		[self ref].setParameters([traversal ref]);
	}
	-(BOOL)saveState: (TSStream*)stream {
		return [self ref].saveState([stream ref]);
	}
	-(BOOL)saveState_: (TSStream*)stream {
		return [self ref].saveState([stream ref]);
	}
	-(void)addShader: (TSShader*)shader {
		[self ref].addShader([shader ref]);
	}
	-(void)addShader_: (TSShader*)shader {
		[self ref].addShader([shader ref]);
	}
	-(void)addShader_1: (TSShader*)shader owner: (BOOL)owner {
		[self ref].addShader([shader ref], (bool)owner);
	}
	-(void)addShader_1_: (TSShader*)shader owner: (BOOL)owner {
		[self ref].addShader([shader ref], (bool)owner);
	}
	-(TSShader*)getRayGenShader {
		return [[TSShader alloc] init_ref:([self ref].getRayGenShader())];
	}
	-(BOOL)loadShader: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)loadShader_: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)loadShaderGLSL: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)loadShaderGLSL_: (TS_ShaderType)type name: (const char*)name format: (const char*)format {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, "%s", format);
	}
	-(BOOL)loadShader_1: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShader_1_: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShader_2: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShader_2_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShader_3: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShader_3_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShader_4: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShader_4_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShader((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShaderGLSL_1: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShaderGLSL_1_: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShaderGLSL_2: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShaderGLSL_2_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)loadShaderGLSL_3: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShaderGLSL_3_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)loadShaderGLSL_4: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShaderGLSL_4_: (TS_ShaderType)type name: (const char*)name macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].loadShaderGLSL((Tellusim::Shader::Type)type, name, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)loadShaderSPIRV: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShaderSPIRV((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)loadShaderSPIRV_: (TS_ShaderType)type name: (const char*)name {
		return [self ref].loadShaderSPIRV((Tellusim::Shader::Type)type, name);
	}
	-(BOOL)createShader: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)createShader_: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)createShaderGLSL: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)createShaderGLSL_: (TS_ShaderType)type src: (const char*)src format: (const char*)format {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, "%s", format);
	}
	-(BOOL)createShader_1: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createShader((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createShader_1_: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createShader((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createShader_2: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShader_2_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShader_3: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShader_3_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShader_4: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShader_4_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShader((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShaderGLSL_1: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createShaderGLSL_1_: (TS_ShaderType)type src: (const char*)src {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src);
	}
	-(BOOL)createShaderGLSL_2: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShaderGLSL_2_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null);
	}
	-(BOOL)createShaderGLSL_3: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShaderGLSL_3_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes);
	}
	-(BOOL)createShaderGLSL_4: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShaderGLSL_4_: (TS_ShaderType)type src: (const char*)src macros: (const TSString*)macros includes: (const char**)includes size: (uint32_t)size {
		return [self ref].createShaderGLSL((Tellusim::Shader::Type)type, src, (macros) ? [macros ref] : Tellusim::String::null, includes, size);
	}
	-(BOOL)createShaderSPIRV: (TS_ShaderType)type data: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [self ref].createShaderSPIRV((Tellusim::Shader::Type)type, data_);
	}
	-(BOOL)createShaderSPIRV_: (TS_ShaderType)type data: (uint32_t*)data data_size: (uint32_t)data_size {
		Tellusim::Array<uint32_t> data_(data_size, data);
		return [self ref].createShaderSPIRV((Tellusim::Shader::Type)type, data_);
	}
	-(uint32_t)addSampler: (TS_ShaderMask)mask {
		return [self ref].addSampler((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addSampler_: (TS_ShaderMask)mask {
		return [self ref].addSampler((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumSamplers {
		return [self ref].getNumSamplers();
	}
	-(TSTraversal*)setSamplerOffset: (uint32_t)offset {
		[self ref].setSamplerOffset(offset);
		return self;
	}
	-(TSTraversal*)setSamplerOffset_: (uint32_t)offset {
		[self ref].setSamplerOffset(offset);
		return self;
	}
	-(uint32_t)getSamplerOffset {
		return [self ref].getSamplerOffset();
	}
	-(TSTraversal*)setSamplerMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setSamplerMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setSamplerMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setSamplerMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getSamplerMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getSamplerMask(index);
	}
	-(TS_ShaderMask)getSamplerMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getSamplerMask(index);
	}
	-(TSTraversal*)setSamplerMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setSamplerMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setSamplerMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setSamplerMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setSamplerMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setSamplerMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TSTraversal*)setSamplerMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setSamplerMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TS_ShaderMask)getSamplerMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getSamplerMasks(index, num);
	}
	-(TS_ShaderMask)getSamplerMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getSamplerMasks(index, num);
	}
	-(TSTraversal*)setSamplerArray: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSamplerArray(index, num, (bool)array);
		return self;
	}
	-(TSTraversal*)setSamplerArray_: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSamplerArray(index, num, (bool)array);
		return self;
	}
	-(uint32_t)getSamplerArray: (uint32_t)index {
		return [self ref].getSamplerArray(index);
	}
	-(uint32_t)getSamplerArray_: (uint32_t)index {
		return [self ref].getSamplerArray(index);
	}
	-(uint32_t)addTexture: (TS_ShaderMask)mask {
		return [self ref].addTexture((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTexture_: (TS_ShaderMask)mask {
		return [self ref].addTexture((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumTextures {
		return [self ref].getNumTextures();
	}
	-(TSTraversal*)setTextureOffset: (uint32_t)offset {
		[self ref].setTextureOffset(offset);
		return self;
	}
	-(TSTraversal*)setTextureOffset_: (uint32_t)offset {
		[self ref].setTextureOffset(offset);
		return self;
	}
	-(uint32_t)getTextureOffset {
		return [self ref].getTextureOffset();
	}
	-(TSTraversal*)setTextureMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTextureMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTextureMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTextureMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTextureMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTextureMask(index);
	}
	-(TS_ShaderMask)getTextureMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTextureMask(index);
	}
	-(TSTraversal*)setTextureMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTextureMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTextureMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTextureMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTextureMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setTextureMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TSTraversal*)setTextureMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setTextureMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TS_ShaderMask)getTextureMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTextureMasks(index, num);
	}
	-(TS_ShaderMask)getTextureMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTextureMasks(index, num);
	}
	-(TSTraversal*)setTextureArray: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setTextureArray(index, num, (bool)array);
		return self;
	}
	-(TSTraversal*)setTextureArray_: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setTextureArray(index, num, (bool)array);
		return self;
	}
	-(uint32_t)getTextureArray: (uint32_t)index {
		return [self ref].getTextureArray(index);
	}
	-(uint32_t)getTextureArray_: (uint32_t)index {
		return [self ref].getTextureArray(index);
	}
	-(uint32_t)addSurface: (TS_ShaderMask)mask {
		return [self ref].addSurface((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addSurface_: (TS_ShaderMask)mask {
		return [self ref].addSurface((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumSurfaces {
		return [self ref].getNumSurfaces();
	}
	-(TSTraversal*)setSurfaceOffset: (uint32_t)offset {
		[self ref].setSurfaceOffset(offset);
		return self;
	}
	-(TSTraversal*)setSurfaceOffset_: (uint32_t)offset {
		[self ref].setSurfaceOffset(offset);
		return self;
	}
	-(uint32_t)getSurfaceOffset {
		return [self ref].getSurfaceOffset();
	}
	-(TSTraversal*)setSurfaceMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setSurfaceMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setSurfaceMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setSurfaceMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getSurfaceMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getSurfaceMask(index);
	}
	-(TS_ShaderMask)getSurfaceMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getSurfaceMask(index);
	}
	-(TSTraversal*)setSurfaceMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setSurfaceMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setSurfaceMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setSurfaceMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setSurfaceMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setSurfaceMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TSTraversal*)setSurfaceMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask array: (BOOL)array {
		[self ref].setSurfaceMasks(index, num, (Tellusim::Shader::Mask)mask, (bool)array);
		return self;
	}
	-(TS_ShaderMask)getSurfaceMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getSurfaceMasks(index, num);
	}
	-(TS_ShaderMask)getSurfaceMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getSurfaceMasks(index, num);
	}
	-(TSTraversal*)setSurfaceArray: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSurfaceArray(index, num, (bool)array);
		return self;
	}
	-(TSTraversal*)setSurfaceArray_: (uint32_t)index num: (uint32_t)num array: (BOOL)array {
		[self ref].setSurfaceArray(index, num, (bool)array);
		return self;
	}
	-(uint32_t)getSurfaceArray: (uint32_t)index {
		return [self ref].getSurfaceArray(index);
	}
	-(uint32_t)getSurfaceArray_: (uint32_t)index {
		return [self ref].getSurfaceArray(index);
	}
	-(uint32_t)addUniform: (TS_ShaderMask)mask {
		return [self ref].addUniform((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addUniform_: (TS_ShaderMask)mask {
		return [self ref].addUniform((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addUniform_1: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addUniform((Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)addUniform_1_: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addUniform((Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)getNumUniforms {
		return [self ref].getNumUniforms();
	}
	-(TSTraversal*)setUniformOffset: (uint32_t)offset {
		[self ref].setUniformOffset(offset);
		return self;
	}
	-(TSTraversal*)setUniformOffset_: (uint32_t)offset {
		[self ref].setUniformOffset(offset);
		return self;
	}
	-(uint32_t)getUniformOffset {
		return [self ref].getUniformOffset();
	}
	-(TSTraversal*)setUniformMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setUniformMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setUniformMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setUniformMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setUniformMask_1: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setUniformMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSTraversal*)setUniformMask_1_: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setUniformMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getUniformMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getUniformMask(index);
	}
	-(TS_ShaderMask)getUniformMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getUniformMask(index);
	}
	-(TSTraversal*)setUniformMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setUniformMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setUniformMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setUniformMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setUniformMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setUniformMasks(index, num, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSTraversal*)setUniformMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setUniformMasks(index, num, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getUniformMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getUniformMasks(index, num);
	}
	-(TS_ShaderMask)getUniformMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getUniformMasks(index, num);
	}
	-(TSTraversal*)setUniformFlags: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setUniformFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSTraversal*)setUniformFlags_: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setUniformFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_BindFlags)getUniformFlags: (uint32_t)index {
		return (TS_BindFlags)[self ref].getUniformFlags(index);
	}
	-(TS_BindFlags)getUniformFlags_: (uint32_t)index {
		return (TS_BindFlags)[self ref].getUniformFlags(index);
	}
	-(uint32_t)addStorage: (TS_ShaderMask)mask {
		return [self ref].addStorage((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addStorage_: (TS_ShaderMask)mask {
		return [self ref].addStorage((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addStorage_1: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addStorage((Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)addStorage_1_: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addStorage((Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)getNumStorages {
		return [self ref].getNumStorages();
	}
	-(TSTraversal*)setStorageOffset: (uint32_t)offset {
		[self ref].setStorageOffset(offset);
		return self;
	}
	-(TSTraversal*)setStorageOffset_: (uint32_t)offset {
		[self ref].setStorageOffset(offset);
		return self;
	}
	-(uint32_t)getStorageOffset {
		return [self ref].getStorageOffset();
	}
	-(TSTraversal*)setStorageMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setStorageMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setStorageMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setStorageMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setStorageMask_1: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setStorageMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSTraversal*)setStorageMask_1_: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setStorageMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getStorageMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getStorageMask(index);
	}
	-(TS_ShaderMask)getStorageMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getStorageMask(index);
	}
	-(TSTraversal*)setStorageMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setStorageMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setStorageMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setStorageMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setStorageMasks_1: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setStorageMasks(index, num, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSTraversal*)setStorageMasks_1_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setStorageMasks(index, num, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getStorageMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getStorageMasks(index, num);
	}
	-(TS_ShaderMask)getStorageMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getStorageMasks(index, num);
	}
	-(TSTraversal*)setStorageFlags: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setStorageFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSTraversal*)setStorageFlags_: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setStorageFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_BindFlags)getStorageFlags: (uint32_t)index {
		return (TS_BindFlags)[self ref].getStorageFlags(index);
	}
	-(TS_BindFlags)getStorageFlags_: (uint32_t)index {
		return (TS_BindFlags)[self ref].getStorageFlags(index);
	}
	-(uint32_t)addTracing: (TS_ShaderMask)mask {
		return [self ref].addTracing((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTracing_: (TS_ShaderMask)mask {
		return [self ref].addTracing((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumTracings {
		return [self ref].getNumTracings();
	}
	-(TSTraversal*)setTracingOffset: (uint32_t)offset {
		[self ref].setTracingOffset(offset);
		return self;
	}
	-(TSTraversal*)setTracingOffset_: (uint32_t)offset {
		[self ref].setTracingOffset(offset);
		return self;
	}
	-(uint32_t)getTracingOffset {
		return [self ref].getTracingOffset();
	}
	-(TSTraversal*)setTracingMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTracingMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTracingMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTracingMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTracingMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTracingMask(index);
	}
	-(TS_ShaderMask)getTracingMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTracingMask(index);
	}
	-(TSTraversal*)setTracingMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTracingMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTracingMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTracingMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTracingMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTracingMasks(index, num);
	}
	-(TS_ShaderMask)getTracingMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTracingMasks(index, num);
	}
	-(uint32_t)addTexel: (TS_ShaderMask)mask {
		return [self ref].addTexel((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTexel_: (TS_ShaderMask)mask {
		return [self ref].addTexel((Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)getNumTexels {
		return [self ref].getNumTexels();
	}
	-(TSTraversal*)setTexelOffset: (uint32_t)offset {
		[self ref].setTexelOffset(offset);
		return self;
	}
	-(TSTraversal*)setTexelOffset_: (uint32_t)offset {
		[self ref].setTexelOffset(offset);
		return self;
	}
	-(uint32_t)getTexelOffset {
		return [self ref].getTexelOffset();
	}
	-(TSTraversal*)setTexelMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTexelMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTexelMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTexelMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTexelMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTexelMask(index);
	}
	-(TS_ShaderMask)getTexelMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTexelMask(index);
	}
	-(TSTraversal*)setTexelMasks: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTexelMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTexelMasks_: (uint32_t)index num: (uint32_t)num mask: (TS_ShaderMask)mask {
		[self ref].setTexelMasks(index, num, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TS_ShaderMask)getTexelMasks: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTexelMasks(index, num);
	}
	-(TS_ShaderMask)getTexelMasks_: (uint32_t)index num: (uint32_t)num {
		return (TS_ShaderMask)[self ref].getTexelMasks(index, num);
	}
	-(uint32_t)addTable: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask {
		return [self ref].addTable((Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTable_: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask {
		return [self ref].addTable((Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask);
	}
	-(uint32_t)addTable_1: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addTable((Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)addTable_1_: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		return [self ref].addTable((Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
	}
	-(uint32_t)getNumTables {
		return [self ref].getNumTables();
	}
	-(TSTraversal*)setTableOffset: (uint32_t)offset {
		[self ref].setTableOffset(offset);
		return self;
	}
	-(TSTraversal*)setTableOffset_: (uint32_t)offset {
		[self ref].setTableOffset(offset);
		return self;
	}
	-(uint32_t)getTableOffset {
		return [self ref].getTableOffset();
	}
	-(TSTraversal*)setTableType: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTableType_: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTableType_1: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSTraversal*)setTableType_1_: (uint32_t)index type: (TS_TableType)type size: (uint32_t)size mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setTableType(index, (Tellusim::TableType)type, size, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_TableType)getTableType: (uint32_t)index {
		return (TS_TableType)[self ref].getTableType(index);
	}
	-(TS_TableType)getTableType_: (uint32_t)index {
		return (TS_TableType)[self ref].getTableType(index);
	}
	-(uint32_t)getTableSize: (uint32_t)index {
		return [self ref].getTableSize(index);
	}
	-(uint32_t)getTableSize_: (uint32_t)index {
		return [self ref].getTableSize(index);
	}
	-(TSTraversal*)setTableMask: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTableMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTableMask_: (uint32_t)index mask: (TS_ShaderMask)mask {
		[self ref].setTableMask(index, (Tellusim::Shader::Mask)mask);
		return self;
	}
	-(TSTraversal*)setTableMask_1: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setTableMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSTraversal*)setTableMask_1_: (uint32_t)index mask: (TS_ShaderMask)mask flags: (TS_BindFlags)flags {
		[self ref].setTableMask(index, (Tellusim::Shader::Mask)mask, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_ShaderMask)getTableMask: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTableMask(index);
	}
	-(TS_ShaderMask)getTableMask_: (uint32_t)index {
		return (TS_ShaderMask)[self ref].getTableMask(index);
	}
	-(TSTraversal*)setTableFlags: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setTableFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TSTraversal*)setTableFlags_: (uint32_t)index flags: (TS_BindFlags)flags {
		[self ref].setTableFlags(index, (Tellusim::BindFlags)flags);
		return self;
	}
	-(TS_BindFlags)getTableFlags: (uint32_t)index {
		return (TS_BindFlags)[self ref].getTableFlags(index);
	}
	-(TS_BindFlags)getTableFlags_: (uint32_t)index {
		return (TS_BindFlags)[self ref].getTableFlags(index);
	}
	-(void)setRecursionDepth: (uint32_t)depth {
		[self ref].setRecursionDepth(depth);
	}
	-(void)setRecursionDepth_: (uint32_t)depth {
		[self ref].setRecursionDepth(depth);
	}
	-(uint32_t)getRecursionDepth {
		return [self ref].getRecursionDepth();
	}
@end

// Tellusim::D3D12Traversal
@implementation TSD3D12Traversal
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Traversal();
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Traversal*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Traversal&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Traversal((Tellusim::D3D12Traversal&)ref);
		return self;
	}
	-(Tellusim::D3D12Traversal*)pointer {
		return (Tellusim::D3D12Traversal*)impl;
	}
	-(Tellusim::D3D12Traversal&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Traversal*)impl;
	}
	-(id)initTraversal: (TSTraversal*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Traversal([base ref]);
		return self;
	}
	-(TSTraversal*)getTraversal {
		return [[TSTraversal alloc] init_ref:([self ref].getTraversal())];
	}
	-(BOOL)equalPtr: (const TSD3D12Traversal*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Traversal*)copyPtr {
		return [[TSD3D12Traversal alloc] init_ref:[self ref]];
	}
	-(TSD3D12Traversal*)clonePtr {
		return [[TSD3D12Traversal alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Traversal*)null {
		return [[TSD3D12Traversal alloc] init_ptr:nullptr];
	}
	-(ID3D12RootSignature*)getRootSignature {
		return [self ref].getRootSignature();
	}
@end

// Tellusim::FUTraversal
@implementation TSFUTraversal
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTraversal();
		return self;
	}
	-(id)init_2: (TSTraversal**)traversals traversals_size: (uint32_t)traversals_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Traversal> traversals_(traversals_size);
		for(uint32_t i = 0; i < traversals_size; i++) if(traversals[i]) traversals_[i] = [traversals[i] ref];
		impl = new Tellusim::FUTraversal(traversals_);
		return self;
	}
	-(id)init_2_: (TSTraversal**)traversals traversals_size: (uint32_t)traversals_size {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Traversal> traversals_(traversals_size);
		for(uint32_t i = 0; i < traversals_size; i++) if(traversals[i]) traversals_[i] = [traversals[i] ref];
		impl = new Tellusim::FUTraversal(traversals_);
		return self;
	}
	-(id)init_3: (TSTraversal**)traversals traversals_size: (uint32_t)traversals_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Traversal> traversals_(traversals_size);
		for(uint32_t i = 0; i < traversals_size; i++) if(traversals[i]) traversals_[i] = [traversals[i] ref];
		impl = new Tellusim::FUTraversal(traversals_, (bool)owner);
		return self;
	}
	-(id)init_3_: (TSTraversal**)traversals traversals_size: (uint32_t)traversals_size owner: (BOOL)owner {
		self = [super init_ptr:nullptr];
		Tellusim::Array<Tellusim::Traversal> traversals_(traversals_size);
		for(uint32_t i = 0; i < traversals_size; i++) if(traversals[i]) traversals_[i] = [traversals[i] ref];
		impl = new Tellusim::FUTraversal(traversals_, (bool)owner);
		return self;
	}
	-(id)init_ptr: (Tellusim::FUTraversal*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FUTraversal&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTraversal((Tellusim::FUTraversal&)ref);
		return self;
	}
	-(Tellusim::FUTraversal*)pointer {
		return (Tellusim::FUTraversal*)impl;
	}
	-(Tellusim::FUTraversal&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FUTraversal*)impl;
	}
	-(id)initTraversal: (TSTraversal*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::FUTraversal([base ref]);
		return self;
	}
	-(TSTraversal*)getTraversal {
		return [[TSTraversal alloc] init_ref:([self ref].getTraversal())];
	}
	-(BOOL)equalPtr: (const TSFUTraversal*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFUTraversal*)copyPtr {
		return [[TSFUTraversal alloc] init_ref:[self ref]];
	}
	-(TSFUTraversal*)clonePtr {
		return [[TSFUTraversal alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFUTraversal*)null {
		return [[TSFUTraversal alloc] init_ptr:nullptr];
	}
	-(void)setMask: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(void)setMask_: (uint32_t)mask {
		[self ref].setMask(mask);
	}
	-(uint32_t)getMask {
		return [self ref].getMask();
	}
	-(uint32_t)getNumTraversals {
		return [self ref].getNumTraversals();
	}
	-(const TSTraversal*)getTraversal: (uint32_t)index {
		return [[TSTraversal alloc] init_ref:([self ref].getTraversal(index))];
	}
	-(const TSTraversal*)getTraversal_: (uint32_t)index {
		return [[TSTraversal alloc] init_ref:([self ref].getTraversal(index))];
	}
@end

// Tellusim::Surface
@implementation TSSurface
	-(id)init {
		self = [super init];
		impl = new Tellusim::Surface();
		return self;
	}
	-(id)init_1: (TSContext*)context {
		self = [super init];
		impl = new Tellusim::Surface([context ref]);
		return self;
	}
	-(id)init_1_: (TSContext*)context {
		self = [super init];
		impl = new Tellusim::Surface([context ref]);
		return self;
	}
	-(id)init_2: (TS_Platform)platform {
		self = [super init];
		impl = new Tellusim::Surface((Tellusim::Platform)platform);
		return self;
	}
	-(id)init_2_: (TS_Platform)platform {
		self = [super init];
		impl = new Tellusim::Surface((Tellusim::Platform)platform);
		return self;
	}
	-(id)init_ptr: (Tellusim::Surface*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Surface&)ref {
		self = [super init];
		impl = new Tellusim::Surface((Tellusim::Surface&)ref);
		return self;
	}
	-(Tellusim::Surface*)pointer {
		return (Tellusim::Surface*)impl;
	}
	-(Tellusim::Surface&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Surface*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Surface*)impl;
	}
	-(BOOL)equalPtr: (const TSSurface*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSSurface*)copyPtr {
		return [[TSSurface alloc] init_ref:[self ref]];
	}
	-(TSSurface*)clonePtr {
		return [[TSSurface alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSSurface*)null {
		return [[TSSurface alloc] init_ptr:nullptr];
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)setSize: (uint32_t)width height: (uint32_t)height {
		[self ref].setSize(width, height);
	}
	-(void)setSize_: (uint32_t)width height: (uint32_t)height {
		[self ref].setSize(width, height);
	}
	-(uint32_t)getWidth {
		return [self ref].getWidth();
	}
	-(uint32_t)getHeight {
		return [self ref].getHeight();
	}
	-(void)setMultisample: (uint32_t)multisample {
		[self ref].setMultisample(multisample);
	}
	-(void)setMultisample_: (uint32_t)multisample {
		[self ref].setMultisample(multisample);
	}
	-(uint32_t)getMultisample {
		return [self ref].getMultisample();
	}
	-(BOOL)hasMultisample {
		return [self ref].hasMultisample();
	}
	-(void)setColorLayer: (uint32_t)layer layers: (uint32_t)layers {
		[self ref].setColorLayer(layer, layers);
	}
	-(void)setColorLayer_: (uint32_t)layer layers: (uint32_t)layers {
		[self ref].setColorLayer(layer, layers);
	}
	-(void)setDepthLayer: (uint32_t)layer layers: (uint32_t)layers {
		[self ref].setDepthLayer(layer, layers);
	}
	-(void)setDepthLayer_: (uint32_t)layer layers: (uint32_t)layers {
		[self ref].setDepthLayer(layer, layers);
	}
	-(uint32_t)getColorLayer {
		return [self ref].getColorLayer();
	}
	-(uint32_t)getDepthLayer {
		return [self ref].getDepthLayer();
	}
	-(uint32_t)getColorLayers {
		return [self ref].getColorLayers();
	}
	-(uint32_t)getDepthLayers {
		return [self ref].getDepthLayers();
	}
	-(BOOL)hasColorLayers {
		return [self ref].hasColorLayers();
	}
	-(BOOL)hasDepthLayers {
		return [self ref].hasDepthLayers();
	}
	-(void)setColorFormat: (TS_Format)format {
		[self ref].setColorFormat((Tellusim::Format)format);
	}
	-(void)setColorFormat_: (TS_Format)format {
		[self ref].setColorFormat((Tellusim::Format)format);
	}
	-(void)setDepthFormat: (TS_Format)format {
		[self ref].setDepthFormat((Tellusim::Format)format);
	}
	-(void)setDepthFormat_: (TS_Format)format {
		[self ref].setDepthFormat((Tellusim::Format)format);
	}
	-(TS_Format)getColorFormat {
		return (TS_Format)[self ref].getColorFormat();
	}
	-(TS_Format)getDepthFormat {
		return (TS_Format)[self ref].getDepthFormat();
	}
@end

// Tellusim::D3D12Surface
@implementation TSD3D12Surface
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Surface();
		return self;
	}
	-(id)init_4: (TSD3D12Context*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Surface([context ref]);
		return self;
	}
	-(id)init_4_: (TSD3D12Context*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Surface([context ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D12Surface*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D12Surface&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Surface((Tellusim::D3D12Surface&)ref);
		return self;
	}
	-(Tellusim::D3D12Surface*)pointer {
		return (Tellusim::D3D12Surface*)impl;
	}
	-(Tellusim::D3D12Surface&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D12Surface*)impl;
	}
	-(id)initSurface: (TSSurface*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D12Surface([base ref]);
		return self;
	}
	-(TSSurface*)getSurface {
		return [[TSSurface alloc] init_ref:([self ref].getSurface())];
	}
	-(BOOL)equalPtr: (const TSD3D12Surface*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D12Surface*)copyPtr {
		return [[TSD3D12Surface alloc] init_ref:[self ref]];
	}
	-(TSD3D12Surface*)clonePtr {
		return [[TSD3D12Surface alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D12Surface*)null {
		return [[TSD3D12Surface alloc] init_ptr:nullptr];
	}
	-(IDXGIFactory4*)getFactory {
		return [self ref].getFactory();
	}
	-(ID3D12Device*)getDevice {
		return [self ref].getDevice();
	}
	-(ID3D12CommandQueue*)getQueue {
		return [self ref].getQueue();
	}
	-(ID3D12GraphicsCommandList*)getCommand {
		return [self ref].getCommand();
	}
	-(void)setSwapChain: (IDXGISwapChain*)swap_chain {
		[self ref].setSwapChain(swap_chain);
	}
	-(void)setSwapChain_: (IDXGISwapChain*)swap_chain {
		[self ref].setSwapChain(swap_chain);
	}
	-(IDXGISwapChain*)getSwapChain {
		return [self ref].getSwapChain();
	}
	-(void)setRenderTarget: (ID3D12Resource*)render_target {
		[self ref].setRenderTarget(render_target);
	}
	-(void)setRenderTarget_: (ID3D12Resource*)render_target {
		[self ref].setRenderTarget(render_target);
	}
	-(void)setDepthStencil: (ID3D12Resource*)depth_stencil {
		[self ref].setDepthStencil(depth_stencil);
	}
	-(void)setDepthStencil_: (ID3D12Resource*)depth_stencil {
		[self ref].setDepthStencil(depth_stencil);
	}
	-(ID3D12Resource*)getRenderTarget {
		return [self ref].getRenderTarget();
	}
	-(ID3D12Resource*)getDepthStencil {
		return [self ref].getDepthStencil();
	}
	-(void)setRenderTargetView: (size_t)render_target_view {
		[self ref].setRenderTargetView(render_target_view);
	}
	-(void)setRenderTargetView_: (size_t)render_target_view {
		[self ref].setRenderTargetView(render_target_view);
	}
	-(void)setDepthStencilView: (size_t)depth_stencil_view {
		[self ref].setDepthStencilView(depth_stencil_view);
	}
	-(void)setDepthStencilView_: (size_t)depth_stencil_view {
		[self ref].setDepthStencilView(depth_stencil_view);
	}
	-(size_t)getRenderTargetView {
		return [self ref].getRenderTargetView();
	}
	-(size_t)getDepthStencilView {
		return [self ref].getDepthStencilView();
	}
	-(uint32_t)getColorDXGIFormat {
		return [self ref].getColorDXGIFormat();
	}
	-(uint32_t)getDepthDXGIFormat {
		return [self ref].getDepthDXGIFormat();
	}
@end

// Tellusim::D3D11Surface
@implementation TSD3D11Surface
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Surface();
		return self;
	}
	-(id)init_4: (TSD3D11Context*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Surface([context ref]);
		return self;
	}
	-(id)init_4_: (TSD3D11Context*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Surface([context ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::D3D11Surface*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::D3D11Surface&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Surface((Tellusim::D3D11Surface&)ref);
		return self;
	}
	-(Tellusim::D3D11Surface*)pointer {
		return (Tellusim::D3D11Surface*)impl;
	}
	-(Tellusim::D3D11Surface&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::D3D11Surface*)impl;
	}
	-(id)initSurface: (TSSurface*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::D3D11Surface([base ref]);
		return self;
	}
	-(TSSurface*)getSurface {
		return [[TSSurface alloc] init_ref:([self ref].getSurface())];
	}
	-(BOOL)equalPtr: (const TSD3D11Surface*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSD3D11Surface*)copyPtr {
		return [[TSD3D11Surface alloc] init_ref:[self ref]];
	}
	-(TSD3D11Surface*)clonePtr {
		return [[TSD3D11Surface alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSD3D11Surface*)null {
		return [[TSD3D11Surface alloc] init_ptr:nullptr];
	}
	-(IDXGIFactory*)getFactory {
		return [self ref].getFactory();
	}
	-(ID3D11Device*)getDevice {
		return [self ref].getDevice();
	}
	-(ID3D11DeviceContext*)getContext {
		return [self ref].getContext();
	}
	-(void)setSwapChain: (IDXGISwapChain*)swap_chain {
		[self ref].setSwapChain(swap_chain);
	}
	-(void)setSwapChain_: (IDXGISwapChain*)swap_chain {
		[self ref].setSwapChain(swap_chain);
	}
	-(IDXGISwapChain*)getSwapChain {
		return [self ref].getSwapChain();
	}
	-(void)setRenderTarget: (ID3D11Texture2D*)render_target {
		[self ref].setRenderTarget(render_target);
	}
	-(void)setRenderTarget_: (ID3D11Texture2D*)render_target {
		[self ref].setRenderTarget(render_target);
	}
	-(void)setDepthStencil: (ID3D11Texture2D*)depth_stencil {
		[self ref].setDepthStencil(depth_stencil);
	}
	-(void)setDepthStencil_: (ID3D11Texture2D*)depth_stencil {
		[self ref].setDepthStencil(depth_stencil);
	}
	-(ID3D11Texture2D*)getRenderTarget {
		return [self ref].getRenderTarget();
	}
	-(ID3D11Texture2D*)getDepthStencil {
		return [self ref].getDepthStencil();
	}
	-(void)setRenderTargetView: (ID3D11RenderTargetView*)render_target_view {
		[self ref].setRenderTargetView(render_target_view);
	}
	-(void)setRenderTargetView_: (ID3D11RenderTargetView*)render_target_view {
		[self ref].setRenderTargetView(render_target_view);
	}
	-(void)setDepthStencilView: (ID3D11DepthStencilView*)depth_stencil_view {
		[self ref].setDepthStencilView(depth_stencil_view);
	}
	-(void)setDepthStencilView_: (ID3D11DepthStencilView*)depth_stencil_view {
		[self ref].setDepthStencilView(depth_stencil_view);
	}
	-(ID3D11RenderTargetView*)getRenderTargetView {
		return [self ref].getRenderTargetView();
	}
	-(ID3D11DepthStencilView*)getDepthStencilView {
		return [self ref].getDepthStencilView();
	}
	-(uint32_t)getColorDXGIFormat {
		return [self ref].getColorDXGIFormat();
	}
	-(uint32_t)getDepthDXGIFormat {
		return [self ref].getDepthDXGIFormat();
	}
@end

// Tellusim::MTLSurface
@implementation TSMTLSurface
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLSurface();
		return self;
	}
	-(id)init_4: (TSMTLContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLSurface([context ref]);
		return self;
	}
	-(id)init_4_: (TSMTLContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLSurface([context ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::MTLSurface*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::MTLSurface&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLSurface((Tellusim::MTLSurface&)ref);
		return self;
	}
	-(Tellusim::MTLSurface*)pointer {
		return (Tellusim::MTLSurface*)impl;
	}
	-(Tellusim::MTLSurface&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MTLSurface*)impl;
	}
	-(id)initSurface: (TSSurface*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::MTLSurface([base ref]);
		return self;
	}
	-(TSSurface*)getSurface {
		return [[TSSurface alloc] init_ref:([self ref].getSurface())];
	}
	-(BOOL)equalPtr: (const TSMTLSurface*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSMTLSurface*)copyPtr {
		return [[TSMTLSurface alloc] init_ref:[self ref]];
	}
	-(TSMTLSurface*)clonePtr {
		return [[TSMTLSurface alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSMTLSurface*)null {
		return [[TSMTLSurface alloc] init_ptr:nullptr];
	}
	-(void*)getDevice {
		return [self ref].getDevice();
	}
	-(void*)getQueue {
		return [self ref].getQueue();
	}
	-(void*)getCommand {
		return [self ref].getCommand();
	}
	-(void)setDescriptor: (void*)descriptor {
		[self ref].setDescriptor(descriptor);
	}
	-(void)setDescriptor_: (void*)descriptor {
		[self ref].setDescriptor(descriptor);
	}
	-(void*)getDescriptor {
		return [self ref].getDescriptor();
	}
	-(uint32_t)getColorPixelFormat {
		return [self ref].getColorPixelFormat();
	}
	-(uint32_t)getDepthPixelFormat {
		return [self ref].getDepthPixelFormat();
	}
@end

// Tellusim::VKSurface
@implementation TSVKSurface
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKSurface();
		return self;
	}
	-(id)init_4: (TSVKContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKSurface([context ref]);
		return self;
	}
	-(id)init_4_: (TSVKContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKSurface([context ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::VKSurface*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::VKSurface&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKSurface((Tellusim::VKSurface&)ref);
		return self;
	}
	-(Tellusim::VKSurface*)pointer {
		return (Tellusim::VKSurface*)impl;
	}
	-(Tellusim::VKSurface&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::VKSurface*)impl;
	}
	-(id)initSurface: (TSSurface*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::VKSurface([base ref]);
		return self;
	}
	-(TSSurface*)getSurface {
		return [[TSSurface alloc] init_ref:([self ref].getSurface())];
	}
	-(BOOL)equalPtr: (const TSVKSurface*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSVKSurface*)copyPtr {
		return [[TSVKSurface alloc] init_ref:[self ref]];
	}
	-(TSVKSurface*)clonePtr {
		return [[TSVKSurface alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSVKSurface*)null {
		return [[TSVKSurface alloc] init_ptr:nullptr];
	}
	-(VkInstance)getInstance {
		return [self ref].getInstance();
	}
	-(VkPhysicalDevice)getAdapter {
		return [self ref].getAdapter();
	}
	-(VkDevice)getDevice {
		return [self ref].getDevice();
	}
	-(VkQueue)getQueue {
		return [self ref].getQueue();
	}
	-(VkCommandBuffer)getCommand {
		return [self ref].getCommand();
	}
	-(uint32_t)getFamily {
		return [self ref].getFamily();
	}
	-(void)setColorImage: (VkImage)image {
		[self ref].setColorImage(image);
	}
	-(void)setColorImage_: (VkImage)image {
		[self ref].setColorImage(image);
	}
	-(void)setDepthImage: (VkImage)image {
		[self ref].setDepthImage(image);
	}
	-(void)setDepthImage_: (VkImage)image {
		[self ref].setDepthImage(image);
	}
	-(VkImage)getColorImage {
		return [self ref].getColorImage();
	}
	-(VkImage)getDepthImage {
		return [self ref].getDepthImage();
	}
	-(void)setColorImageView: (VkImageView)image_view {
		[self ref].setColorImageView(image_view);
	}
	-(void)setColorImageView_: (VkImageView)image_view {
		[self ref].setColorImageView(image_view);
	}
	-(void)setDepthImageView: (VkImageView)image_view {
		[self ref].setDepthImageView(image_view);
	}
	-(void)setDepthImageView_: (VkImageView)image_view {
		[self ref].setDepthImageView(image_view);
	}
	-(VkImageView)getColorImageView {
		return [self ref].getColorImageView();
	}
	-(VkImageView)getDepthImageView {
		return [self ref].getDepthImageView();
	}
	-(void)setRenderPass: (VkRenderPass)render_pass {
		[self ref].setRenderPass(render_pass);
	}
	-(void)setRenderPass_: (VkRenderPass)render_pass {
		[self ref].setRenderPass(render_pass);
	}
	-(void)setFramebuffer: (VkFramebuffer)framebuffer {
		[self ref].setFramebuffer(framebuffer);
	}
	-(void)setFramebuffer_: (VkFramebuffer)framebuffer {
		[self ref].setFramebuffer(framebuffer);
	}
	-(VkRenderPass)getRenderPass {
		return [self ref].getRenderPass();
	}
	-(VkFramebuffer)getFramebuffer {
		return [self ref].getFramebuffer();
	}
	-(uint32_t)getColorPixelFormat {
		return [self ref].getColorPixelFormat();
	}
	-(uint32_t)getDepthPixelFormat {
		return [self ref].getDepthPixelFormat();
	}
@end

// Tellusim::GLSurface
@implementation TSGLSurface
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLSurface();
		return self;
	}
	-(id)init_4: (TSGLContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLSurface([context ref]);
		return self;
	}
	-(id)init_4_: (TSGLContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLSurface([context ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::GLSurface*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLSurface&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLSurface((Tellusim::GLSurface&)ref);
		return self;
	}
	-(Tellusim::GLSurface*)pointer {
		return (Tellusim::GLSurface*)impl;
	}
	-(Tellusim::GLSurface&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLSurface*)impl;
	}
	-(id)initSurface: (TSSurface*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLSurface([base ref]);
		return self;
	}
	-(TSSurface*)getSurface {
		return [[TSSurface alloc] init_ref:([self ref].getSurface())];
	}
	-(BOOL)equalPtr: (const TSGLSurface*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLSurface*)copyPtr {
		return [[TSGLSurface alloc] init_ref:[self ref]];
	}
	-(TSGLSurface*)clonePtr {
		return [[TSGLSurface alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLSurface*)null {
		return [[TSGLSurface alloc] init_ptr:nullptr];
	}
	-(void*)getContext {
		return [self ref].getContext();
	}
	-(void)setColorTextureID: (uint32_t)texture_id {
		[self ref].setColorTextureID(texture_id);
	}
	-(void)setColorTextureID_: (uint32_t)texture_id {
		[self ref].setColorTextureID(texture_id);
	}
	-(void)setDepthTextureID: (uint32_t)texture_id {
		[self ref].setDepthTextureID(texture_id);
	}
	-(void)setDepthTextureID_: (uint32_t)texture_id {
		[self ref].setDepthTextureID(texture_id);
	}
	-(uint32_t)getColorTextureID {
		return [self ref].getColorTextureID();
	}
	-(uint32_t)getDepthTextureID {
		return [self ref].getDepthTextureID();
	}
	-(void)setFramebufferID: (uint32_t)framebuffer_id {
		[self ref].setFramebufferID(framebuffer_id);
	}
	-(void)setFramebufferID_: (uint32_t)framebuffer_id {
		[self ref].setFramebufferID(framebuffer_id);
	}
	-(uint32_t)getFramebufferID {
		return [self ref].getFramebufferID();
	}
	-(uint32_t)getColorInternalFormat {
		return [self ref].getColorInternalFormat();
	}
	-(uint32_t)getDepthInternalFormat {
		return [self ref].getDepthInternalFormat();
	}
@end

// Tellusim::GLESSurface
@implementation TSGLESSurface
	-(id)init_3 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESSurface();
		return self;
	}
	-(id)init_4: (TSGLESContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESSurface([context ref]);
		return self;
	}
	-(id)init_4_: (TSGLESContext*)context {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESSurface([context ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::GLESSurface*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::GLESSurface&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESSurface((Tellusim::GLESSurface&)ref);
		return self;
	}
	-(Tellusim::GLESSurface*)pointer {
		return (Tellusim::GLESSurface*)impl;
	}
	-(Tellusim::GLESSurface&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::GLESSurface*)impl;
	}
	-(id)initSurface: (TSSurface*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::GLESSurface([base ref]);
		return self;
	}
	-(TSSurface*)getSurface {
		return [[TSSurface alloc] init_ref:([self ref].getSurface())];
	}
	-(BOOL)equalPtr: (const TSGLESSurface*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSGLESSurface*)copyPtr {
		return [[TSGLESSurface alloc] init_ref:[self ref]];
	}
	-(TSGLESSurface*)clonePtr {
		return [[TSGLESSurface alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSGLESSurface*)null {
		return [[TSGLESSurface alloc] init_ptr:nullptr];
	}
	-(void*)getContext {
		return [self ref].getContext();
	}
	-(void)setColorTextureID: (uint32_t)texture_id {
		[self ref].setColorTextureID(texture_id);
	}
	-(void)setColorTextureID_: (uint32_t)texture_id {
		[self ref].setColorTextureID(texture_id);
	}
	-(void)setDepthTextureID: (uint32_t)texture_id {
		[self ref].setDepthTextureID(texture_id);
	}
	-(void)setDepthTextureID_: (uint32_t)texture_id {
		[self ref].setDepthTextureID(texture_id);
	}
	-(uint32_t)getColorTextureID {
		return [self ref].getColorTextureID();
	}
	-(uint32_t)getDepthTextureID {
		return [self ref].getDepthTextureID();
	}
	-(void)setFramebufferID: (uint32_t)framebuffer_id {
		[self ref].setFramebufferID(framebuffer_id);
	}
	-(void)setFramebufferID_: (uint32_t)framebuffer_id {
		[self ref].setFramebufferID(framebuffer_id);
	}
	-(uint32_t)getFramebufferID {
		return [self ref].getFramebufferID();
	}
	-(uint32_t)getColorInternalFormat {
		return [self ref].getColorInternalFormat();
	}
	-(uint32_t)getDepthInternalFormat {
		return [self ref].getDepthInternalFormat();
	}
@end

// Tellusim::Window
@implementation TSWindow
	-(id)init {
		self = [super init];
		impl = new Tellusim::Window();
		return self;
	}
	-(id)init_1: (TS_Platform)platform {
		self = [super init];
		impl = new Tellusim::Window((Tellusim::Platform)platform);
		return self;
	}
	-(id)init_1_: (TS_Platform)platform {
		self = [super init];
		impl = new Tellusim::Window((Tellusim::Platform)platform);
		return self;
	}
	-(id)init_2: (TS_Platform)platform index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::Window((Tellusim::Platform)platform, index);
		return self;
	}
	-(id)init_2_: (TS_Platform)platform index: (uint32_t)index {
		self = [super init];
		impl = new Tellusim::Window((Tellusim::Platform)platform, index);
		return self;
	}
	-(id)init_3: (TSSurface*)surface {
		self = [super init];
		impl = new Tellusim::Window([surface ref]);
		return self;
	}
	-(id)init_3_: (TSSurface*)surface {
		self = [super init];
		impl = new Tellusim::Window([surface ref]);
		return self;
	}
	-(id)init_ptr: (Tellusim::Window*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Window&)ref {
		self = [super init];
		impl = new Tellusim::Window((Tellusim::Window&)ref);
		return self;
	}
	-(Tellusim::Window*)pointer {
		return (Tellusim::Window*)impl;
	}
	-(Tellusim::Window&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Window*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Window*)impl;
	}
	-(BOOL)equalPtr: (const TSWindow*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSWindow*)copyPtr {
		return [[TSWindow alloc] init_ref:[self ref]];
	}
	-(TSWindow*)clonePtr {
		return [[TSWindow alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSWindow*)null {
		return [[TSWindow alloc] init_ptr:nullptr];
	}
	+(uint32_t)getNumWindows {
		return Tellusim::Window::getNumWindows();
	}
	+(TSWindow*)getWindow: (uint32_t)index {
		return [[TSWindow alloc] init_ref:(Tellusim::Window::getWindow(index))];
	}
	+(TSWindow*)getWindow_: (uint32_t)index {
		return [[TSWindow alloc] init_ref:(Tellusim::Window::getWindow(index))];
	}
	+(void)update {
		Tellusim::Window::update();
	}
	+(void)update_1: (BOOL)wait {
		Tellusim::Window::update((bool)wait);
	}
	+(void)update_1_: (BOOL)wait {
		Tellusim::Window::update((bool)wait);
	}
	-(TS_Platform)getPlatform {
		return (TS_Platform)[self ref].getPlatform();
	}
	-(NSString*)getPlatformName {
		return [NSString stringWithUTF8String:[self ref].getPlatformName()];
	}
	-(uint32_t)getIndex {
		return [self ref].getIndex();
	}
	-(void)setSurface: (TSSurface*)surface {
		[self ref].setSurface([surface ref]);
	}
	-(void)setSurface_: (TSSurface*)surface {
		[self ref].setSurface([surface ref]);
	}
	-(TSSurface*)getSurface {
		return [[TSSurface alloc] init_ref:([self ref].getSurface())];
	}
	-(void*)getHandle {
		return [self ref].getHandle();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(BOOL)create: (const char*)title {
		return [self ref].create(title);
	}
	-(BOOL)create_: (const char*)title {
		return [self ref].create(title);
	}
	-(BOOL)create_1: (const char*)title flags: (TS_WindowFlags)flags {
		return [self ref].create(title, (Tellusim::Window::Flags)flags);
	}
	-(BOOL)create_1_: (const char*)title flags: (TS_WindowFlags)flags {
		return [self ref].create(title, (Tellusim::Window::Flags)flags);
	}
	-(BOOL)create_2: (const TSString*)title {
		return [self ref].create((title) ? [title ref] : Tellusim::String::null);
	}
	-(BOOL)create_2_: (const TSString*)title {
		return [self ref].create((title) ? [title ref] : Tellusim::String::null);
	}
	-(BOOL)create_3: (const TSString*)title flags: (TS_WindowFlags)flags {
		return [self ref].create((title) ? [title ref] : Tellusim::String::null, (Tellusim::Window::Flags)flags);
	}
	-(BOOL)create_3_: (const TSString*)title flags: (TS_WindowFlags)flags {
		return [self ref].create((title) ? [title ref] : Tellusim::String::null, (Tellusim::Window::Flags)flags);
	}
	-(BOOL)create_4 {
		return [self ref].create();
	}
	-(BOOL)create_5: (TS_WindowFlags)flags {
		return [self ref].create((Tellusim::Window::Flags)flags);
	}
	-(BOOL)create_5_: (TS_WindowFlags)flags {
		return [self ref].create((Tellusim::Window::Flags)flags);
	}
	-(void)release_ {
		[self ref].release();
	}
	-(BOOL)clear: (TSColor)color {
		return [self ref].clear(*(Tellusim::Color*)&color);
	}
	-(BOOL)clear_: (TSColor)color {
		return [self ref].clear(*(Tellusim::Color*)&color);
	}
	-(BOOL)grab: (TSImage*)image {
		return [self ref].grab([image ref]);
	}
	-(BOOL)grab_: (TSImage*)image {
		return [self ref].grab([image ref]);
	}
	-(BOOL)render {
		return [self ref].render();
	}
	-(BOOL)present {
		return [self ref].present();
	}
	-(BOOL)finish {
		return [self ref].finish();
	}
	-(TS_Format)getColorFormat {
		return (TS_Format)[self ref].getColorFormat();
	}
	-(TS_Format)getDepthFormat {
		return (TS_Format)[self ref].getDepthFormat();
	}
	-(uint32_t)getMultisample {
		return [self ref].getMultisample();
	}
	-(BOOL)hasMultisample {
		return [self ref].hasMultisample();
	}
	-(void)setFlags: (TS_WindowFlags)flags {
		[self ref].setFlags((Tellusim::Window::Flags)flags);
	}
	-(void)setFlags_: (TS_WindowFlags)flags {
		[self ref].setFlags((Tellusim::Window::Flags)flags);
	}
	-(TS_WindowFlags)getFlags {
		return (TS_WindowFlags)[self ref].getFlags();
	}
	-(BOOL)hasFlag: (TS_WindowFlags)flags {
		return [self ref].hasFlag((Tellusim::Window::Flags)flags);
	}
	-(BOOL)hasFlag_: (TS_WindowFlags)flags {
		return [self ref].hasFlag((Tellusim::Window::Flags)flags);
	}
	-(BOOL)hasFlags: (TS_WindowFlags)flags {
		return [self ref].hasFlags((Tellusim::Window::Flags)flags);
	}
	-(BOOL)hasFlags_: (TS_WindowFlags)flags {
		return [self ref].hasFlags((Tellusim::Window::Flags)flags);
	}
	-(void)setRefreshRate: (uint32_t)rate {
		[self ref].setRefreshRate(rate);
	}
	-(void)setRefreshRate_: (uint32_t)rate {
		[self ref].setRefreshRate(rate);
	}
	-(uint32_t)getRefreshRate {
		return [self ref].getRefreshRate();
	}
	-(BOOL)setHidden: (BOOL)hidden {
		return [self ref].setHidden((bool)hidden);
	}
	-(BOOL)setHidden_: (BOOL)hidden {
		return [self ref].setHidden((bool)hidden);
	}
	-(BOOL)isHidden {
		return [self ref].isHidden();
	}
	-(BOOL)setFocused: (BOOL)focused {
		return [self ref].setFocused((bool)focused);
	}
	-(BOOL)setFocused_: (BOOL)focused {
		return [self ref].setFocused((bool)focused);
	}
	-(BOOL)isFocused {
		return [self ref].isFocused();
	}
	-(BOOL)setMinimized: (BOOL)minimized {
		return [self ref].setMinimized((bool)minimized);
	}
	-(BOOL)setMinimized_: (BOOL)minimized {
		return [self ref].setMinimized((bool)minimized);
	}
	-(BOOL)isMinimized {
		return [self ref].isMinimized();
	}
	-(BOOL)setFullscreen: (BOOL)fullscreen {
		return [self ref].setFullscreen((bool)fullscreen);
	}
	-(BOOL)setFullscreen_: (BOOL)fullscreen {
		return [self ref].setFullscreen((bool)fullscreen);
	}
	-(BOOL)isFullscreen {
		return [self ref].isFullscreen();
	}
	-(BOOL)isOccluded {
		return [self ref].isOccluded();
	}
	-(BOOL)setTitle: (const char*)title {
		return [self ref].setTitle(title);
	}
	-(BOOL)setTitle_: (const char*)title {
		return [self ref].setTitle(title);
	}
	-(BOOL)setTitle_1: (const TSString*)title {
		return [self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(BOOL)setTitle_1_: (const TSString*)title {
		return [self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(NSString*)getTitle {
		return [NSString stringWithUTF8String:[self ref].getTitle().get()];
	}
	-(BOOL)setIcon: (const TSImage*)image {
		return [self ref].setIcon([image ref]);
	}
	-(BOOL)setIcon_: (const TSImage*)image {
		return [self ref].setIcon([image ref]);
	}
	-(TSImage*)getIcon {
		return [[TSImage alloc] init_ref:([self ref].getIcon())];
	}
	-(BOOL)setGeometry: (int32_t)x y: (int32_t)y width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setGeometry(x, y, width, height);
	}
	-(BOOL)setGeometry_: (int32_t)x y: (int32_t)y width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setGeometry(x, y, width, height);
	}
	-(BOOL)setGeometry_1: (int32_t)x y: (int32_t)y width: (uint32_t)width height: (uint32_t)height force: (BOOL)force {
		return [self ref].setGeometry(x, y, width, height, (bool)force);
	}
	-(BOOL)setGeometry_1_: (int32_t)x y: (int32_t)y width: (uint32_t)width height: (uint32_t)height force: (BOOL)force {
		return [self ref].setGeometry(x, y, width, height, (bool)force);
	}
	-(BOOL)setPosition: (int32_t)x y: (int32_t)y {
		return [self ref].setPosition(x, y);
	}
	-(BOOL)setPosition_: (int32_t)x y: (int32_t)y {
		return [self ref].setPosition(x, y);
	}
	-(BOOL)setPosition_1: (int32_t)x y: (int32_t)y force: (BOOL)force {
		return [self ref].setPosition(x, y, (bool)force);
	}
	-(BOOL)setPosition_1_: (int32_t)x y: (int32_t)y force: (BOOL)force {
		return [self ref].setPosition(x, y, (bool)force);
	}
	-(int32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(int32_t)getPositionX_1: (BOOL)title {
		return [self ref].getPositionX((bool)title);
	}
	-(int32_t)getPositionX_1_: (BOOL)title {
		return [self ref].getPositionX((bool)title);
	}
	-(int32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(int32_t)getPositionY_1: (BOOL)title {
		return [self ref].getPositionY((bool)title);
	}
	-(int32_t)getPositionY_1_: (BOOL)title {
		return [self ref].getPositionY((bool)title);
	}
	-(BOOL)setSize: (uint32_t)width height: (uint32_t)height {
		return [self ref].setSize(width, height);
	}
	-(BOOL)setSize_: (uint32_t)width height: (uint32_t)height {
		return [self ref].setSize(width, height);
	}
	-(BOOL)setSize_1: (uint32_t)width height: (uint32_t)height force: (BOOL)force {
		return [self ref].setSize(width, height, (bool)force);
	}
	-(BOOL)setSize_1_: (uint32_t)width height: (uint32_t)height force: (BOOL)force {
		return [self ref].setSize(width, height, (bool)force);
	}
	-(uint32_t)getWidth {
		return [self ref].getWidth();
	}
	-(uint32_t)getHeight {
		return [self ref].getHeight();
	}
	-(float32_t)getScale {
		return [self ref].getScale();
	}
	-(uint32_t)getDpiX {
		return [self ref].getDpiX();
	}
	-(uint32_t)getDpiY {
		return [self ref].getDpiY();
	}
	-(BOOL)setMouse: (int32_t)x y: (int32_t)y {
		return [self ref].setMouse(x, y);
	}
	-(BOOL)setMouse_: (int32_t)x y: (int32_t)y {
		return [self ref].setMouse(x, y);
	}
	-(BOOL)setMouse_1: (int32_t)x y: (int32_t)y force: (BOOL)force {
		return [self ref].setMouse(x, y, (bool)force);
	}
	-(BOOL)setMouse_1_: (int32_t)x y: (int32_t)y force: (BOOL)force {
		return [self ref].setMouse(x, y, (bool)force);
	}
	-(int32_t)getMouseX {
		return [self ref].getMouseX();
	}
	-(int32_t)getMouseY {
		return [self ref].getMouseY();
	}
	-(BOOL)setMouseDelta: (int32_t)dx dy: (int32_t)dy {
		return [self ref].setMouseDelta(dx, dy);
	}
	-(BOOL)setMouseDelta_: (int32_t)dx dy: (int32_t)dy {
		return [self ref].setMouseDelta(dx, dy);
	}
	-(int32_t)getMouseDX {
		return [self ref].getMouseDX();
	}
	-(int32_t)getMouseDY {
		return [self ref].getMouseDY();
	}
	-(BOOL)setMouseHidden: (BOOL)hidden {
		return [self ref].setMouseHidden((bool)hidden);
	}
	-(BOOL)setMouseHidden_: (BOOL)hidden {
		return [self ref].setMouseHidden((bool)hidden);
	}
	-(BOOL)setMouseHidden_1: (BOOL)hidden force: (BOOL)force {
		return [self ref].setMouseHidden((bool)hidden, (bool)force);
	}
	-(BOOL)setMouseHidden_1_: (BOOL)hidden force: (BOOL)force {
		return [self ref].setMouseHidden((bool)hidden, (bool)force);
	}
	-(BOOL)isMouseHidden {
		return [self ref].isMouseHidden();
	}
	-(BOOL)setMouseClipped: (BOOL)clipped {
		return [self ref].setMouseClipped((bool)clipped);
	}
	-(BOOL)setMouseClipped_: (BOOL)clipped {
		return [self ref].setMouseClipped((bool)clipped);
	}
	-(BOOL)setMouseClipped_1: (BOOL)clipped force: (BOOL)force {
		return [self ref].setMouseClipped((bool)clipped, (bool)force);
	}
	-(BOOL)setMouseClipped_1_: (BOOL)clipped force: (BOOL)force {
		return [self ref].setMouseClipped((bool)clipped, (bool)force);
	}
	-(BOOL)isMouseClipped {
		return [self ref].isMouseClipped();
	}
	-(BOOL)isMouseInside {
		return [self ref].isMouseInside();
	}
	-(BOOL)setMouseCursor: (TS_WindowCursor)cursor {
		return [self ref].setMouseCursor((Tellusim::Window::Cursor)cursor);
	}
	-(BOOL)setMouseCursor_: (TS_WindowCursor)cursor {
		return [self ref].setMouseCursor((Tellusim::Window::Cursor)cursor);
	}
	-(BOOL)setMouseCursor_1: (TS_WindowCursor)cursor force: (BOOL)force {
		return [self ref].setMouseCursor((Tellusim::Window::Cursor)cursor, (bool)force);
	}
	-(BOOL)setMouseCursor_1_: (TS_WindowCursor)cursor force: (BOOL)force {
		return [self ref].setMouseCursor((Tellusim::Window::Cursor)cursor, (bool)force);
	}
	-(TS_WindowCursor)getMouseCursor {
		return (TS_WindowCursor)[self ref].getMouseCursor();
	}
	-(BOOL)setMouseButtons: (TS_WindowButton)buttons {
		return [self ref].setMouseButtons((Tellusim::Window::Button)buttons);
	}
	-(BOOL)setMouseButtons_: (TS_WindowButton)buttons {
		return [self ref].setMouseButtons((Tellusim::Window::Button)buttons);
	}
	-(TS_WindowButton)getMouseButtons {
		return (TS_WindowButton)[self ref].getMouseButtons();
	}
	-(BOOL)setMouseButton: (TS_WindowButton)button value: (BOOL)value {
		return [self ref].setMouseButton((Tellusim::Window::Button)button, (bool)value);
	}
	-(BOOL)setMouseButton_: (TS_WindowButton)button value: (BOOL)value {
		return [self ref].setMouseButton((Tellusim::Window::Button)button, (bool)value);
	}
	-(BOOL)getMouseButton: (TS_WindowButton)button {
		return [self ref].getMouseButton((Tellusim::Window::Button)button);
	}
	-(BOOL)getMouseButton_: (TS_WindowButton)button {
		return [self ref].getMouseButton((Tellusim::Window::Button)button);
	}
	-(BOOL)getMouseButton_1: (TS_WindowButton)button clear: (BOOL)clear {
		return [self ref].getMouseButton((Tellusim::Window::Button)button, (bool)clear);
	}
	-(BOOL)getMouseButton_1_: (TS_WindowButton)button clear: (BOOL)clear {
		return [self ref].getMouseButton((Tellusim::Window::Button)button, (bool)clear);
	}
	-(void)releaseMouseButtons: (TS_WindowButton)buttons {
		[self ref].releaseMouseButtons((Tellusim::Window::Button)buttons);
	}
	-(void)releaseMouseButtons_: (TS_WindowButton)buttons {
		[self ref].releaseMouseButtons((Tellusim::Window::Button)buttons);
	}
	-(TS_WindowButton)clearMouseButtons {
		return (TS_WindowButton)[self ref].clearMouseButtons();
	}
	-(BOOL)setMouseAxis: (TS_WindowAxis)axis value: (float32_t)value {
		return [self ref].setMouseAxis((Tellusim::Window::Axis)axis, value);
	}
	-(BOOL)setMouseAxis_: (TS_WindowAxis)axis value: (float32_t)value {
		return [self ref].setMouseAxis((Tellusim::Window::Axis)axis, value);
	}
	-(float32_t)getMouseAxis: (TS_WindowAxis)axis {
		return [self ref].getMouseAxis((Tellusim::Window::Axis)axis);
	}
	-(float32_t)getMouseAxis_: (TS_WindowAxis)axis {
		return [self ref].getMouseAxis((Tellusim::Window::Axis)axis);
	}
	-(float32_t)clearMouseAxis: (TS_WindowAxis)axis {
		return [self ref].clearMouseAxis((Tellusim::Window::Axis)axis);
	}
	-(float32_t)clearMouseAxis_: (TS_WindowAxis)axis {
		return [self ref].clearMouseAxis((Tellusim::Window::Axis)axis);
	}
	-(void)setMousePressedCallback: (id<TSWindowMousePressedCallback>)func {
		[self ref].setMousePressedCallback(Tellusim::makeTSWindowMousePressedCallback(func));
	}
	-(void)setMousePressedCallback_: (id<TSWindowMousePressedCallback>)func {
		[self ref].setMousePressedCallback(Tellusim::makeTSWindowMousePressedCallback(func));
	}
	-(void)setMouseReleasedCallback: (id<TSWindowMouseReleasedCallback>)func {
		[self ref].setMouseReleasedCallback(Tellusim::makeTSWindowMouseReleasedCallback(func));
	}
	-(void)setMouseReleasedCallback_: (id<TSWindowMouseReleasedCallback>)func {
		[self ref].setMouseReleasedCallback(Tellusim::makeTSWindowMouseReleasedCallback(func));
	}
	-(void)setMouseChangedCallback: (id<TSWindowMouseChangedCallback>)func {
		[self ref].setMouseChangedCallback(Tellusim::makeTSWindowMouseChangedCallback(func));
	}
	-(void)setMouseChangedCallback_: (id<TSWindowMouseChangedCallback>)func {
		[self ref].setMouseChangedCallback(Tellusim::makeTSWindowMouseChangedCallback(func));
	}
	-(void)setMouseRotatedCallback: (id<TSWindowMouseRotatedCallback>)func {
		[self ref].setMouseRotatedCallback(Tellusim::makeTSWindowMouseRotatedCallback(func));
	}
	-(void)setMouseRotatedCallback_: (id<TSWindowMouseRotatedCallback>)func {
		[self ref].setMouseRotatedCallback(Tellusim::makeTSWindowMouseRotatedCallback(func));
	}
	-(uint32_t)getNumTouches {
		return [self ref].getNumTouches();
	}
	-(uint32_t)addTouch: (int32_t)x y: (int32_t)y {
		return [self ref].addTouch(x, y);
	}
	-(uint32_t)addTouch_: (int32_t)x y: (int32_t)y {
		return [self ref].addTouch(x, y);
	}
	-(int32_t)getTouchX: (uint32_t)touch {
		return [self ref].getTouchX(touch);
	}
	-(int32_t)getTouchX_: (uint32_t)touch {
		return [self ref].getTouchX(touch);
	}
	-(int32_t)getTouchY: (uint32_t)touch {
		return [self ref].getTouchY(touch);
	}
	-(int32_t)getTouchY_: (uint32_t)touch {
		return [self ref].getTouchY(touch);
	}
	-(uint32_t)findTouch: (int32_t)x y: (int32_t)y {
		return [self ref].findTouch(x, y);
	}
	-(uint32_t)findTouch_: (int32_t)x y: (int32_t)y {
		return [self ref].findTouch(x, y);
	}
	-(void)clearTouches {
		[self ref].clearTouches();
	}
	-(void)setTouchChangedCallback: (id<TSWindowTouchChangedCallback>)func {
		[self ref].setTouchChangedCallback(Tellusim::makeTSWindowTouchChangedCallback(func));
	}
	-(void)setTouchChangedCallback_: (id<TSWindowTouchChangedCallback>)func {
		[self ref].setTouchChangedCallback(Tellusim::makeTSWindowTouchChangedCallback(func));
	}
	-(void)setKeyboardKey: (uint32_t)key value: (BOOL)value {
		[self ref].setKeyboardKey(key, (bool)value);
	}
	-(void)setKeyboardKey_: (uint32_t)key value: (BOOL)value {
		[self ref].setKeyboardKey(key, (bool)value);
	}
	-(BOOL)getKeyboardKey: (uint32_t)key {
		return [self ref].getKeyboardKey(key);
	}
	-(BOOL)getKeyboardKey_: (uint32_t)key {
		return [self ref].getKeyboardKey(key);
	}
	-(BOOL)getKeyboardKey_1: (uint32_t)key clear: (BOOL)clear {
		return [self ref].getKeyboardKey(key, (bool)clear);
	}
	-(BOOL)getKeyboardKey_1_: (uint32_t)key clear: (BOOL)clear {
		return [self ref].getKeyboardKey(key, (bool)clear);
	}
	-(void)setKeyboardPressedCallback: (id<TSWindowKeyboardPressedCallback>)func {
		[self ref].setKeyboardPressedCallback(Tellusim::makeTSWindowKeyboardPressedCallback(func));
	}
	-(void)setKeyboardPressedCallback_: (id<TSWindowKeyboardPressedCallback>)func {
		[self ref].setKeyboardPressedCallback(Tellusim::makeTSWindowKeyboardPressedCallback(func));
	}
	-(void)setKeyboardReleasedCallback: (id<TSWindowKeyboardReleasedCallback>)func {
		[self ref].setKeyboardReleasedCallback(Tellusim::makeTSWindowKeyboardReleasedCallback(func));
	}
	-(void)setKeyboardReleasedCallback_: (id<TSWindowKeyboardReleasedCallback>)func {
		[self ref].setKeyboardReleasedCallback(Tellusim::makeTSWindowKeyboardReleasedCallback(func));
	}
	-(void)setSizeChangedCallback: (id<TSWindowSizeChangedCallback>)func {
		[self ref].setSizeChangedCallback(Tellusim::makeTSWindowSizeChangedCallback(func));
	}
	-(void)setSizeChangedCallback_: (id<TSWindowSizeChangedCallback>)func {
		[self ref].setSizeChangedCallback(Tellusim::makeTSWindowSizeChangedCallback(func));
	}
	-(void)setFocusChangedCallback: (id<TSWindowFocusChangedCallback>)func {
		[self ref].setFocusChangedCallback(Tellusim::makeTSWindowFocusChangedCallback(func));
	}
	-(void)setFocusChangedCallback_: (id<TSWindowFocusChangedCallback>)func {
		[self ref].setFocusChangedCallback(Tellusim::makeTSWindowFocusChangedCallback(func));
	}
	-(void)setCloseClickedCallback: (id<TSWindowCloseClickedCallback>)func {
		[self ref].setCloseClickedCallback(Tellusim::makeTSWindowCloseClickedCallback(func));
	}
	-(void)setCloseClickedCallback_: (id<TSWindowCloseClickedCallback>)func {
		[self ref].setCloseClickedCallback(Tellusim::makeTSWindowCloseClickedCallback(func));
	}
	-(void)setPauseChangedCallback: (id<TSWindowPauseChangedCallback>)func {
		[self ref].setPauseChangedCallback(Tellusim::makeTSWindowPauseChangedCallback(func));
	}
	-(void)setPauseChangedCallback_: (id<TSWindowPauseChangedCallback>)func {
		[self ref].setPauseChangedCallback(Tellusim::makeTSWindowPauseChangedCallback(func));
	}
	-(void)setFileDroppedCallback: (id<TSWindowFileDroppedCallback>)func {
		[self ref].setFileDroppedCallback(Tellusim::makeTSWindowFileDroppedCallback(func));
	}
	-(void)setFileDroppedCallback_: (id<TSWindowFileDroppedCallback>)func {
		[self ref].setFileDroppedCallback(Tellusim::makeTSWindowFileDroppedCallback(func));
	}
	-(void)setUpdateCallback: (id<TSWindowUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSWindowUpdateCallback(func));
	}
	-(void)setUpdateCallback_: (id<TSWindowUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSWindowUpdateCallback(func));
	}
	-(void)setPresentCallback: (id<TSWindowPresentCallback>)func {
		[self ref].setPresentCallback(Tellusim::makeTSWindowPresentCallback(func));
	}
	-(void)setPresentCallback_: (id<TSWindowPresentCallback>)func {
		[self ref].setPresentCallback(Tellusim::makeTSWindowPresentCallback(func));
	}
	-(BOOL)run: (id<TSWindowMainLoopCallback>)func {
		return [self ref].run(Tellusim::makeTSWindowMainLoopCallback(func));
	}
	-(BOOL)run_: (id<TSWindowMainLoopCallback>)func {
		return [self ref].run(Tellusim::makeTSWindowMainLoopCallback(func));
	}
	-(BOOL)isRunning {
		return [self ref].isRunning();
	}
	-(void)stop {
		[self ref].stop();
	}
	-(BOOL)setCopyText: (const char*)text {
		return [self ref].setCopyText(text);
	}
	-(BOOL)setCopyText_: (const char*)text {
		return [self ref].setCopyText(text);
	}
	-(BOOL)setCopyText_1: (const TSString*)text {
		return [self ref].setCopyText((text) ? [text ref] : Tellusim::String::null);
	}
	-(BOOL)setCopyText_1_: (const TSString*)text {
		return [self ref].setCopyText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getPasteText {
		return [NSString stringWithUTF8String:[self ref].getPasteText().get()];
	}
@end

// Tellusim::Font
@implementation TSFont
	-(id)init {
		self = [super init];
		impl = new Tellusim::Font();
		return self;
	}
	-(id)init_ptr: (Tellusim::Font*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Font&)ref {
		self = [super init];
		impl = new Tellusim::Font((Tellusim::Font&)ref);
		return self;
	}
	-(Tellusim::Font*)pointer {
		return (Tellusim::Font*)impl;
	}
	-(Tellusim::Font&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Font*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Font*)impl;
	}
	-(BOOL)equalPtr: (const TSFont*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFont*)copyPtr {
		return [[TSFont alloc] init_ref:[self ref]];
	}
	-(TSFont*)clonePtr {
		return [[TSFont alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFont*)null {
		return [[TSFont alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isLoaded {
		return [self ref].isLoaded();
	}
	-(BOOL)load: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_: (const char*)name {
		return [self ref].load(name);
	}
	-(BOOL)load_1: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(BOOL)load_1_: (TSStream*)stream {
		return [self ref].load([stream ref]);
	}
	-(float32_t)getAdvance: (TSFontStyle)style code: (uint32_t)code {
		return [self ref].getAdvance(*(Tellusim::FontStyle*)&style, code);
	}
	-(float32_t)getAdvance_: (TSFontStyle)style code: (uint32_t)code {
		return [self ref].getAdvance(*(Tellusim::FontStyle*)&style, code);
	}
	-(TSRect)getRect: (TSVector3f)position style: (TSFontStyle)style str: (const char*)str {
		Tellusim::Rect ret = [self ref].getRect(*(Tellusim::Vector3f*)&position, *(Tellusim::FontStyle*)&style, str);
		return *(TSRect*)&ret;
	}
	-(TSRect)getRect_: (TSVector3f)position style: (TSFontStyle)style str: (const char*)str {
		Tellusim::Rect ret = [self ref].getRect(*(Tellusim::Vector3f*)&position, *(Tellusim::FontStyle*)&style, str);
		return *(TSRect*)&ret;
	}
	-(TSRect)getRect_1: (TSVector3f)position style: (TSFontStyle)style str: (const uint32_t*)str {
		Tellusim::Rect ret = [self ref].getRect(*(Tellusim::Vector3f*)&position, *(Tellusim::FontStyle*)&style, str);
		return *(TSRect*)&ret;
	}
	-(TSRect)getRect_1_: (TSVector3f)position style: (TSFontStyle)style str: (const uint32_t*)str {
		Tellusim::Rect ret = [self ref].getRect(*(Tellusim::Vector3f*)&position, *(Tellusim::FontStyle*)&style, str);
		return *(TSRect*)&ret;
	}
	-(TSRect)getRect_2: (const TSFontBatch*)batches num_batches: (uint32_t)num_batches {
		Tellusim::Rect ret = [self ref].getRect(*(const Tellusim::FontBatch**)&batches, num_batches);
		return *(TSRect*)&ret;
	}
	-(TSRect)getRect_2_: (const TSFontBatch*)batches num_batches: (uint32_t)num_batches {
		Tellusim::Rect ret = [self ref].getRect(*(const Tellusim::FontBatch**)&batches, num_batches);
		return *(TSRect*)&ret;
	}
	-(TSRect)getRect_3: (const TSFontBatch32*)batches num_batches: (uint32_t)num_batches {
		Tellusim::Rect ret = [self ref].getRect(*(const Tellusim::FontBatch32**)&batches, num_batches);
		return *(TSRect*)&ret;
	}
	-(TSRect)getRect_3_: (const TSFontBatch32*)batches num_batches: (uint32_t)num_batches {
		Tellusim::Rect ret = [self ref].getRect(*(const Tellusim::FontBatch32**)&batches, num_batches);
		return *(TSRect*)&ret;
	}
	-(void)create: (const TSDevice*)device style: (TSFontStyle)style str: (const char*)str {
		[self ref].create([device ref], *(Tellusim::FontStyle*)&style, str);
	}
	-(void)create_: (const TSDevice*)device style: (TSFontStyle)style str: (const char*)str {
		[self ref].create([device ref], *(Tellusim::FontStyle*)&style, str);
	}
	-(void)create_1: (const TSDevice*)device style: (TSFontStyle)style str: (const uint32_t*)str {
		[self ref].create([device ref], *(Tellusim::FontStyle*)&style, str);
	}
	-(void)create_1_: (const TSDevice*)device style: (TSFontStyle)style str: (const uint32_t*)str {
		[self ref].create([device ref], *(Tellusim::FontStyle*)&style, str);
	}
	-(void)create_2: (const TSDevice*)device batches: (const TSFontBatch*)batches num_batches: (uint32_t)num_batches {
		[self ref].create([device ref], *(const Tellusim::FontBatch**)&batches, num_batches);
	}
	-(void)create_2_: (const TSDevice*)device batches: (const TSFontBatch*)batches num_batches: (uint32_t)num_batches {
		[self ref].create([device ref], *(const Tellusim::FontBatch**)&batches, num_batches);
	}
	-(void)create_3: (const TSDevice*)device batches: (const TSFontBatch32*)batches num_batches: (uint32_t)num_batches {
		[self ref].create([device ref], *(const Tellusim::FontBatch32**)&batches, num_batches);
	}
	-(void)create_3_: (const TSDevice*)device batches: (const TSFontBatch32*)batches num_batches: (uint32_t)num_batches {
		[self ref].create([device ref], *(const Tellusim::FontBatch32**)&batches, num_batches);
	}
	-(void)draw: (TSCommand*)command position: (TSVector3f)position style: (TSFontStyle)style str: (const char*)str {
		[self ref].draw([command ref], *(Tellusim::Vector3f*)&position, *(Tellusim::FontStyle*)&style, str);
	}
	-(void)draw_: (TSCommand*)command position: (TSVector3f)position style: (TSFontStyle)style str: (const char*)str {
		[self ref].draw([command ref], *(Tellusim::Vector3f*)&position, *(Tellusim::FontStyle*)&style, str);
	}
	-(void)draw_1: (TSCommand*)command position: (TSVector3f)position style: (TSFontStyle)style str: (const uint32_t*)str {
		[self ref].draw([command ref], *(Tellusim::Vector3f*)&position, *(Tellusim::FontStyle*)&style, str);
	}
	-(void)draw_1_: (TSCommand*)command position: (TSVector3f)position style: (TSFontStyle)style str: (const uint32_t*)str {
		[self ref].draw([command ref], *(Tellusim::Vector3f*)&position, *(Tellusim::FontStyle*)&style, str);
	}
	-(void)draw_2: (TSCommand*)command batches: (const TSFontBatch*)batches num_batches: (uint32_t)num_batches {
		[self ref].draw([command ref], *(const Tellusim::FontBatch**)&batches, num_batches);
	}
	-(void)draw_2_: (TSCommand*)command batches: (const TSFontBatch*)batches num_batches: (uint32_t)num_batches {
		[self ref].draw([command ref], *(const Tellusim::FontBatch**)&batches, num_batches);
	}
	-(void)draw_3: (TSCommand*)command batches: (const TSFontBatch32*)batches num_batches: (uint32_t)num_batches {
		[self ref].draw([command ref], *(const Tellusim::FontBatch32**)&batches, num_batches);
	}
	-(void)draw_3_: (TSCommand*)command batches: (const TSFontBatch32*)batches num_batches: (uint32_t)num_batches {
		[self ref].draw([command ref], *(const Tellusim::FontBatch32**)&batches, num_batches);
	}
	-(BOOL)flush: (const TSDevice*)device {
		return [self ref].flush([device ref]);
	}
	-(BOOL)flush_: (const TSDevice*)device {
		return [self ref].flush([device ref]);
	}
@end

// Tellusim::CanvasElement
@implementation TSCanvasElement
	-(id)init {
		self = [super init];
		impl = new Tellusim::CanvasElement();
		return self;
	}
	-(id)init_ptr: (Tellusim::CanvasElement*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CanvasElement&)ref {
		self = [super init];
		impl = new Tellusim::CanvasElement((Tellusim::CanvasElement&)ref);
		return self;
	}
	-(Tellusim::CanvasElement*)pointer {
		return (Tellusim::CanvasElement*)impl;
	}
	-(Tellusim::CanvasElement&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CanvasElement*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::CanvasElement*)impl;
	}
	-(BOOL)equalPtr: (const TSCanvasElement*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCanvasElement*)copyPtr {
		return [[TSCanvasElement alloc] init_ref:[self ref]];
	}
	-(TSCanvasElement*)clonePtr {
		return [[TSCanvasElement alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCanvasElement*)null {
		return [[TSCanvasElement alloc] init_ptr:nullptr];
	}
	-(TS_CanvasElementType)getType {
		return (TS_CanvasElementType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_CanvasElementType)type {
		return [NSString stringWithUTF8String:Tellusim::CanvasElement::getTypeName((Tellusim::CanvasElement::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_CanvasElementType)type {
		return [NSString stringWithUTF8String:Tellusim::CanvasElement::getTypeName((Tellusim::CanvasElement::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)isText {
		return [self ref].isText();
	}
	-(BOOL)isMesh {
		return [self ref].isMesh();
	}
	-(BOOL)isRect {
		return [self ref].isRect();
	}
	-(BOOL)isTriangle {
		return [self ref].isTriangle();
	}
	-(BOOL)isEllipse {
		return [self ref].isEllipse();
	}
	-(BOOL)isShape {
		return [self ref].isShape();
	}
	-(BOOL)isStrip {
		return [self ref].isStrip();
	}
	-(void)setCanvas: (TSCanvas*)canvas {
		[self ref].setCanvas([canvas ref]);
	}
	-(void)setCanvas_: (TSCanvas*)canvas {
		[self ref].setCanvas([canvas ref]);
	}
	-(const TSCanvas*)getCanvas {
		return [[TSCanvas alloc] init_ref:([self ref].getCanvas())];
	}
	-(void)setMode: (TS_CanvasElementMode)mode {
		[self ref].setMode((Tellusim::CanvasElement::Mode)mode);
	}
	-(void)setMode_: (TS_CanvasElementMode)mode {
		[self ref].setMode((Tellusim::CanvasElement::Mode)mode);
	}
	-(TS_CanvasElementMode)getMode {
		return (TS_CanvasElementMode)[self ref].getMode();
	}
	-(void)setAlign: (TS_CanvasElementAlign)align {
		[self ref].setAlign((Tellusim::CanvasElement::Align)align);
	}
	-(void)setAlign_: (TS_CanvasElementAlign)align {
		[self ref].setAlign((Tellusim::CanvasElement::Align)align);
	}
	-(TS_CanvasElementAlign)getAlign {
		return (TS_CanvasElementAlign)[self ref].getAlign();
	}
	-(BOOL)hasAlign: (TS_CanvasElementAlign)align {
		return [self ref].hasAlign((Tellusim::CanvasElement::Align)align);
	}
	-(BOOL)hasAlign_: (TS_CanvasElementAlign)align {
		return [self ref].hasAlign((Tellusim::CanvasElement::Align)align);
	}
	-(BOOL)hasAligns: (TS_CanvasElementAlign)aligns {
		return [self ref].hasAligns((Tellusim::CanvasElement::Align)aligns);
	}
	-(BOOL)hasAligns_: (TS_CanvasElementAlign)aligns {
		return [self ref].hasAligns((Tellusim::CanvasElement::Align)aligns);
	}
	-(void)setOrder: (int32_t)order {
		[self ref].setOrder(order);
	}
	-(void)setOrder_: (int32_t)order {
		[self ref].setOrder(order);
	}
	-(int32_t)getOrder {
		return [self ref].getOrder();
	}
	-(void)setEnabled: (BOOL)enabled {
		[self ref].setEnabled((bool)enabled);
	}
	-(void)setEnabled_: (BOOL)enabled {
		[self ref].setEnabled((bool)enabled);
	}
	-(BOOL)isEnabled {
		return [self ref].isEnabled();
	}
	-(void)clearColor {
		[self ref].clearColor();
	}
	-(void)setColor: (TS_CanvasElementStack)op {
		[self ref].setColor((Tellusim::CanvasElement::Stack)op);
	}
	-(void)setColor_: (TS_CanvasElementStack)op {
		[self ref].setColor((Tellusim::CanvasElement::Stack)op);
	}
	-(void)setColor_1: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_1_: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_2: (TSColor)color op: (TS_CanvasElementStack)op {
		[self ref].setColor(*(Tellusim::Color*)&color, (Tellusim::CanvasElement::Stack)op);
	}
	-(void)setColor_2_: (TSColor)color op: (TS_CanvasElementStack)op {
		[self ref].setColor(*(Tellusim::Color*)&color, (Tellusim::CanvasElement::Stack)op);
	}
	-(void)setColor_3: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setColor(r, g, b, a);
	}
	-(void)setColor_3_: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setColor(r, g, b, a);
	}
	-(void)setColor_4: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a op: (TS_CanvasElementStack)op {
		[self ref].setColor(r, g, b, a, (Tellusim::CanvasElement::Stack)op);
	}
	-(void)setColor_4_: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a op: (TS_CanvasElementStack)op {
		[self ref].setColor(r, g, b, a, (Tellusim::CanvasElement::Stack)op);
	}
	-(TSColor)getColor {
		Tellusim::Color ret = [self ref].getColor();
		return *(TSColor*)&ret;
	}
	-(TS_CanvasElementStack)getColorOp {
		return (TS_CanvasElementStack)[self ref].getColorOp();
	}
	-(void)clearTransform {
		[self ref].clearTransform();
	}
	-(void)setTransform: (TS_CanvasElementStack)op {
		[self ref].setTransform((Tellusim::CanvasElement::Stack)op);
	}
	-(void)setTransform_: (TS_CanvasElementStack)op {
		[self ref].setTransform((Tellusim::CanvasElement::Stack)op);
	}
	-(void)setTransform_1: (TSMatrix4x4f)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x4f*)&transform);
	}
	-(void)setTransform_1_: (TSMatrix4x4f)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x4f*)&transform);
	}
	-(void)setTransform_2: (TSMatrix4x4f)transform op: (TS_CanvasElementStack)op {
		[self ref].setTransform(*(Tellusim::Matrix4x4f*)&transform, (Tellusim::CanvasElement::Stack)op);
	}
	-(void)setTransform_2_: (TSMatrix4x4f)transform op: (TS_CanvasElementStack)op {
		[self ref].setTransform(*(Tellusim::Matrix4x4f*)&transform, (Tellusim::CanvasElement::Stack)op);
	}
	-(TSMatrix4x4f)getTransform {
		Tellusim::Matrix4x4f ret = [self ref].getTransform();
		return *(TSMatrix4x4f*)&ret;
	}
	-(TS_CanvasElementStack)getTransformOp {
		return (TS_CanvasElementStack)[self ref].getTransformOp();
	}
	-(void)clearScissor {
		[self ref].clearScissor();
	}
	-(void)setScissor: (TS_CanvasElementStack)op {
		[self ref].setScissor((Tellusim::CanvasElement::Stack)op);
	}
	-(void)setScissor_: (TS_CanvasElementStack)op {
		[self ref].setScissor((Tellusim::CanvasElement::Stack)op);
	}
	-(void)setScissor_1: (TSRect)scissor {
		[self ref].setScissor(*(Tellusim::Rect*)&scissor);
	}
	-(void)setScissor_1_: (TSRect)scissor {
		[self ref].setScissor(*(Tellusim::Rect*)&scissor);
	}
	-(void)setScissor_2: (TSRect)scissor op: (TS_CanvasElementStack)op {
		[self ref].setScissor(*(Tellusim::Rect*)&scissor, (Tellusim::CanvasElement::Stack)op);
	}
	-(void)setScissor_2_: (TSRect)scissor op: (TS_CanvasElementStack)op {
		[self ref].setScissor(*(Tellusim::Rect*)&scissor, (Tellusim::CanvasElement::Stack)op);
	}
	-(TSRect)getScissor {
		Tellusim::Rect ret = [self ref].getScissor();
		return *(TSRect*)&ret;
	}
	-(TS_CanvasElementStack)getScissorOp {
		return (TS_CanvasElementStack)[self ref].getScissorOp();
	}
	-(void)setMipmap: (float32_t)mipmap {
		[self ref].setMipmap(mipmap);
	}
	-(void)setMipmap_: (float32_t)mipmap {
		[self ref].setMipmap(mipmap);
	}
	-(float32_t)getMipmap {
		return [self ref].getMipmap();
	}
	-(void)setSampler: (TSSampler*)sampler {
		[self ref].setSampler([sampler ref]);
	}
	-(void)setSampler_: (TSSampler*)sampler {
		[self ref].setSampler([sampler ref]);
	}
	-(TSSampler*)getSampler {
		return [[TSSampler alloc] init_ref:([self ref].getSampler())];
	}
	-(void)setFilter: (TS_SamplerFilter)filter {
		[self ref].setFilter((Tellusim::Sampler::Filter)filter);
	}
	-(void)setFilter_: (TS_SamplerFilter)filter {
		[self ref].setFilter((Tellusim::Sampler::Filter)filter);
	}
	-(TS_SamplerFilter)getFilter {
		return (TS_SamplerFilter)[self ref].getFilter();
	}
	-(void)setAnisotropy: (uint32_t)anisotropy {
		[self ref].setAnisotropy(anisotropy);
	}
	-(void)setAnisotropy_: (uint32_t)anisotropy {
		[self ref].setAnisotropy(anisotropy);
	}
	-(uint32_t)getAnisotropy {
		return [self ref].getAnisotropy();
	}
	-(void)setWrapMode: (TS_SamplerWrapMode)mode {
		[self ref].setWrapMode((Tellusim::Sampler::WrapMode)mode);
	}
	-(void)setWrapMode_: (TS_SamplerWrapMode)mode {
		[self ref].setWrapMode((Tellusim::Sampler::WrapMode)mode);
	}
	-(TS_SamplerWrapMode)getWrapMode {
		return (TS_SamplerWrapMode)[self ref].getWrapMode();
	}
	-(void)setTexture: (TSTexture*)texture {
		[self ref].setTexture([texture ref]);
	}
	-(void)setTexture_: (TSTexture*)texture {
		[self ref].setTexture([texture ref]);
	}
	-(void)setTexture_1: (TSTexture*)texture linear: (BOOL)linear {
		[self ref].setTexture([texture ref], (bool)linear);
	}
	-(void)setTexture_1_: (TSTexture*)texture linear: (BOOL)linear {
		[self ref].setTexture([texture ref], (bool)linear);
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)getTextureLinear {
		return [self ref].getTextureLinear();
	}
	-(void)setPipeline: (TSPipeline*)pipeline {
		[self ref].setPipeline([pipeline ref]);
	}
	-(void)setPipeline_: (TSPipeline*)pipeline {
		[self ref].setPipeline([pipeline ref]);
	}
	-(TSPipeline*)getPipeline {
		return [[TSPipeline alloc] init_ref:([self ref].getPipeline())];
	}
	-(void)setPrimitive: (TS_PipelinePrimitive)primitive {
		[self ref].setPrimitive((Tellusim::Pipeline::Primitive)primitive);
	}
	-(void)setPrimitive_: (TS_PipelinePrimitive)primitive {
		[self ref].setPrimitive((Tellusim::Pipeline::Primitive)primitive);
	}
	-(TS_PipelinePrimitive)getPrimitive {
		return (TS_PipelinePrimitive)[self ref].getPrimitive();
	}
	-(void)setCullMode: (TS_PipelineCullMode)mode {
		[self ref].setCullMode((Tellusim::Pipeline::CullMode)mode);
	}
	-(void)setCullMode_: (TS_PipelineCullMode)mode {
		[self ref].setCullMode((Tellusim::Pipeline::CullMode)mode);
	}
	-(TS_PipelineCullMode)getCullMode {
		return (TS_PipelineCullMode)[self ref].getCullMode();
	}
	-(void)setFrontMode: (TS_PipelineFrontMode)mode {
		[self ref].setFrontMode((Tellusim::Pipeline::FrontMode)mode);
	}
	-(void)setFrontMode_: (TS_PipelineFrontMode)mode {
		[self ref].setFrontMode((Tellusim::Pipeline::FrontMode)mode);
	}
	-(TS_PipelineFrontMode)getFrontMode {
		return (TS_PipelineFrontMode)[self ref].getFrontMode();
	}
	-(void)setBlend: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlend_: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(TS_PipelineBlendOp)getBlendOp {
		return (TS_PipelineBlendOp)[self ref].getBlendOp();
	}
	-(TS_PipelineBlendFunc)getBlendSrcFunc {
		return (TS_PipelineBlendFunc)[self ref].getBlendSrcFunc();
	}
	-(TS_PipelineBlendFunc)getBlendDestFunc {
		return (TS_PipelineBlendFunc)[self ref].getBlendDestFunc();
	}
	-(void)setColorMask: (TS_PipelineColorMask)mask {
		[self ref].setColorMask((Tellusim::Pipeline::ColorMask)mask);
	}
	-(void)setColorMask_: (TS_PipelineColorMask)mask {
		[self ref].setColorMask((Tellusim::Pipeline::ColorMask)mask);
	}
	-(TS_PipelineColorMask)getColorMask {
		return (TS_PipelineColorMask)[self ref].getColorMask();
	}
	-(void)setDepthMask: (TS_PipelineDepthMask)mask {
		[self ref].setDepthMask((Tellusim::Pipeline::DepthMask)mask);
	}
	-(void)setDepthMask_: (TS_PipelineDepthMask)mask {
		[self ref].setDepthMask((Tellusim::Pipeline::DepthMask)mask);
	}
	-(TS_PipelineDepthMask)getDepthMask {
		return (TS_PipelineDepthMask)[self ref].getDepthMask();
	}
	-(void)setDepthFunc: (TS_PipelineDepthFunc)func {
		[self ref].setDepthFunc((Tellusim::Pipeline::DepthFunc)func);
	}
	-(void)setDepthFunc_: (TS_PipelineDepthFunc)func {
		[self ref].setDepthFunc((Tellusim::Pipeline::DepthFunc)func);
	}
	-(TS_PipelineDepthFunc)getDepthFunc {
		return (TS_PipelineDepthFunc)[self ref].getDepthFunc();
	}
	-(void)setStencilRef: (uint32_t)ref {
		[self ref].setStencilRef(ref);
	}
	-(void)setStencilRef_: (uint32_t)ref {
		[self ref].setStencilRef(ref);
	}
	-(void)setStencilFunc: (TS_PipelineStencilFunc)func fail_op: (TS_PipelineStencilOp)fail_op dfail_op: (TS_PipelineStencilOp)dfail_op dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)fail_op, (Tellusim::Pipeline::StencilOp)dfail_op, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(void)setStencilFunc_: (TS_PipelineStencilFunc)func fail_op: (TS_PipelineStencilOp)fail_op dfail_op: (TS_PipelineStencilOp)dfail_op dpass_op: (TS_PipelineStencilOp)dpass_op {
		[self ref].setStencilFunc((Tellusim::Pipeline::StencilFunc)func, (Tellusim::Pipeline::StencilOp)fail_op, (Tellusim::Pipeline::StencilOp)dfail_op, (Tellusim::Pipeline::StencilOp)dpass_op);
	}
	-(uint32_t)getStencilRef {
		return [self ref].getStencilRef();
	}
	-(TS_PipelineStencilFunc)getStencilFunc {
		return (TS_PipelineStencilFunc)[self ref].getStencilFunc();
	}
	-(TS_PipelineStencilOp)getStencilFailOp {
		return (TS_PipelineStencilOp)[self ref].getStencilFailOp();
	}
	-(TS_PipelineStencilOp)getStencilDepthFailOp {
		return (TS_PipelineStencilOp)[self ref].getStencilDepthFailOp();
	}
	-(TS_PipelineStencilOp)getStencilDepthPassOp {
		return (TS_PipelineStencilOp)[self ref].getStencilDepthPassOp();
	}
	-(void)setDrawCallback: (id<TSCanvasElementDrawCallback>)func {
		[self ref].setDrawCallback(Tellusim::makeTSCanvasElementDrawCallback(func));
	}
	-(void)setDrawCallback_: (id<TSCanvasElementDrawCallback>)func {
		[self ref].setDrawCallback(Tellusim::makeTSCanvasElementDrawCallback(func));
	}
	-(TSRect)getRect {
		Tellusim::Rect ret = [self ref].getRect();
		return *(TSRect*)&ret;
	}
@end

// Tellusim::CanvasText
@implementation TSCanvasText
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasText();
		return self;
	}
	-(id)init_2: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasText([canvas ref]);
		return self;
	}
	-(id)init_2_: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasText([canvas ref]);
		return self;
	}
	-(id)init_3: (TSCanvas*)canvas text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasText([canvas ref], text);
		return self;
	}
	-(id)init_3_: (TSCanvas*)canvas text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasText([canvas ref], text);
		return self;
	}
	-(id)init_4: (TSCanvas*)canvas text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasText([canvas ref], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4_: (TSCanvas*)canvas text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasText([canvas ref], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_ptr: (Tellusim::CanvasText*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CanvasText&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasText((Tellusim::CanvasText&)ref);
		return self;
	}
	-(Tellusim::CanvasText*)pointer {
		return (Tellusim::CanvasText*)impl;
	}
	-(Tellusim::CanvasText&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CanvasText*)impl;
	}
	-(id)initCanvasElement: (TSCanvasElement*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasText([base ref]);
		return self;
	}
	-(TSCanvasElement*)getCanvasElement {
		return [[TSCanvasElement alloc] init_ref:([self ref].getCanvasElement())];
	}
	-(BOOL)equalPtr: (const TSCanvasText*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCanvasText*)copyPtr {
		return [[TSCanvasText alloc] init_ref:[self ref]];
	}
	-(TSCanvasText*)clonePtr {
		return [[TSCanvasText alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCanvasText*)null {
		return [[TSCanvasText alloc] init_ptr:nullptr];
	}
	-(void)setFontName: (const char*)name {
		[self ref].setFontName(name);
	}
	-(void)setFontName_: (const char*)name {
		[self ref].setFontName(name);
	}
	-(void)setFontName_1: (const TSString*)name {
		[self ref].setFontName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setFontName_1_: (const TSString*)name {
		[self ref].setFontName((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getFontName {
		return [NSString stringWithUTF8String:[self ref].getFontName().get()];
	}
	-(void)setFontColor: (TSColor)color {
		[self ref].setFontColor(*(Tellusim::Color*)&color);
	}
	-(void)setFontColor_: (TSColor)color {
		[self ref].setFontColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getFontColor {
		Tellusim::Color ret = [self ref].getFontColor();
		return *(TSColor*)&ret;
	}
	-(BOOL)setFontSize: (uint32_t)scale {
		return [self ref].setFontSize(scale);
	}
	-(BOOL)setFontSize_: (uint32_t)scale {
		return [self ref].setFontSize(scale);
	}
	-(uint32_t)getFontSize {
		return [self ref].getFontSize();
	}
	-(BOOL)setFontScale: (uint32_t)scale {
		return [self ref].setFontScale(scale);
	}
	-(BOOL)setFontScale_: (uint32_t)scale {
		return [self ref].setFontScale(scale);
	}
	-(uint32_t)getFontScale {
		return [self ref].getFontScale();
	}
	-(BOOL)setFontStyle: (TSFontStyle)style {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style);
	}
	-(BOOL)setFontStyle_: (TSFontStyle)style {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style);
	}
	-(TSFontStyle)getFontStyleConst {
		Tellusim::FontStyle ret = [self ref].getFontStyleConst();
		return *(TSFontStyle*)&ret;
	}
	-(TSFontStyle)getFontStyle {
		Tellusim::FontStyle ret = [self ref].getFontStyle();
		return *(TSFontStyle*)&ret;
	}
	-(void)setPosition: (TSVector3f)position {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_: (TSVector3f)position {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_1: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_1_: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(x, y, z);
	}
	-(void)setPosition_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(x, y, z);
	}
	-(TSVector3f)getPosition {
		Tellusim::Vector3f ret = [self ref].getPosition();
		return *(TSVector3f*)&ret;
	}
	-(void)setText: (const char*)text {
		[self ref].setText(text);
	}
	-(void)setText_: (const char*)text {
		[self ref].setText(text);
	}
	-(void)setText_1: (const TSString*)text {
		[self ref].setText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setText_1_: (const TSString*)text {
		[self ref].setText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getText {
		return [NSString stringWithUTF8String:[self ref].getText().get()];
	}
	-(void)clearBatches {
		[self ref].clearBatches();
	}
	-(void)setBatches: (TSFontBatch*)batches batches_size: (uint32_t)batches_size {
		Tellusim::Array<Tellusim::FontBatch> batches_(batches_size, (const Tellusim::FontBatch*)batches);
		[self ref].setBatches(batches_);
	}
	-(void)setBatches_: (TSFontBatch*)batches batches_size: (uint32_t)batches_size {
		Tellusim::Array<Tellusim::FontBatch> batches_(batches_size, (const Tellusim::FontBatch*)batches);
		[self ref].setBatches(batches_);
	}
	-(void)setBatches_1: (const TSFontBatch*)batches num_batches: (uint32_t)num_batches {
		[self ref].setBatches(*(const Tellusim::FontBatch**)&batches, num_batches);
	}
	-(void)setBatches_1_: (const TSFontBatch*)batches num_batches: (uint32_t)num_batches {
		[self ref].setBatches(*(const Tellusim::FontBatch**)&batches, num_batches);
	}
@end

// Tellusim::CanvasMesh
@implementation TSCanvasMesh
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasMesh();
		return self;
	}
	-(id)init_2: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasMesh([canvas ref]);
		return self;
	}
	-(id)init_2_: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasMesh([canvas ref]);
		return self;
	}
	-(id)init_3: (TSCanvas*)canvas mode: (TS_CanvasElementMode)mode {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasMesh([canvas ref], (Tellusim::CanvasElement::Mode)mode);
		return self;
	}
	-(id)init_3_: (TSCanvas*)canvas mode: (TS_CanvasElementMode)mode {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasMesh([canvas ref], (Tellusim::CanvasElement::Mode)mode);
		return self;
	}
	-(id)init_ptr: (Tellusim::CanvasMesh*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CanvasMesh&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasMesh((Tellusim::CanvasMesh&)ref);
		return self;
	}
	-(Tellusim::CanvasMesh*)pointer {
		return (Tellusim::CanvasMesh*)impl;
	}
	-(Tellusim::CanvasMesh&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CanvasMesh*)impl;
	}
	-(id)initCanvasElement: (TSCanvasElement*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasMesh([base ref]);
		return self;
	}
	-(TSCanvasElement*)getCanvasElement {
		return [[TSCanvasElement alloc] init_ref:([self ref].getCanvasElement())];
	}
	-(BOOL)equalPtr: (const TSCanvasMesh*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCanvasMesh*)copyPtr {
		return [[TSCanvasMesh alloc] init_ref:[self ref]];
	}
	-(TSCanvasMesh*)clonePtr {
		return [[TSCanvasMesh alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCanvasMesh*)null {
		return [[TSCanvasMesh alloc] init_ptr:nullptr];
	}
	-(void)setTextureName: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_1: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setTextureName_1_: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getTextureName {
		return [NSString stringWithUTF8String:[self ref].getTextureName().get()];
	}
	-(void)setGradientStyle: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(void)setGradientStyle_: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(TSGradientStyle)getGradientStyleConst {
		Tellusim::GradientStyle ret = [self ref].getGradientStyleConst();
		return *(TSGradientStyle*)&ret;
	}
	-(TSGradientStyle)getGradientStyle {
		Tellusim::GradientStyle ret = [self ref].getGradientStyle();
		return *(TSGradientStyle*)&ret;
	}
	-(void)clearVertices {
		[self ref].clearVertices();
	}
	-(void)setNumVertices: (uint32_t)num_vertices {
		[self ref].setNumVertices(num_vertices);
	}
	-(void)setNumVertices_: (uint32_t)num_vertices {
		[self ref].setNumVertices(num_vertices);
	}
	-(void)reserveVertices: (uint32_t)num_vertices {
		[self ref].reserveVertices(num_vertices);
	}
	-(void)reserveVertices_: (uint32_t)num_vertices {
		[self ref].reserveVertices(num_vertices);
	}
	-(uint32_t)getNumVertices {
		return [self ref].getNumVertices();
	}
	-(void)setVertices: (const TSCanvasVertex*)vertices num_vertices: (uint32_t)num_vertices {
		[self ref].setVertices(*(const Tellusim::CanvasVertex**)&vertices, num_vertices);
	}
	-(void)setVertices_: (const TSCanvasVertex*)vertices num_vertices: (uint32_t)num_vertices {
		[self ref].setVertices(*(const Tellusim::CanvasVertex**)&vertices, num_vertices);
	}
	-(void)addVertices: (const TSCanvasVertex*)vertices num_vertices: (uint32_t)num_vertices {
		[self ref].addVertices(*(const Tellusim::CanvasVertex**)&vertices, num_vertices);
	}
	-(void)addVertices_: (const TSCanvasVertex*)vertices num_vertices: (uint32_t)num_vertices {
		[self ref].addVertices(*(const Tellusim::CanvasVertex**)&vertices, num_vertices);
	}
	-(const TSCanvasVertex*)getVertices {
		return (const TSCanvasVertex*)[self ref].getVertices();
	}
	-(void)setVertex: (uint32_t)index vertex: (TSCanvasVertex)vertex {
		[self ref].setVertex(index, *(Tellusim::CanvasVertex*)&vertex);
	}
	-(void)setVertex_: (uint32_t)index vertex: (TSCanvasVertex)vertex {
		[self ref].setVertex(index, *(Tellusim::CanvasVertex*)&vertex);
	}
	-(TSCanvasVertex)getVertex: (uint32_t)index {
		Tellusim::CanvasVertex ret = [self ref].getVertex(index);
		return *(TSCanvasVertex*)&ret;
	}
	-(TSCanvasVertex)getVertex_: (uint32_t)index {
		Tellusim::CanvasVertex ret = [self ref].getVertex(index);
		return *(TSCanvasVertex*)&ret;
	}
	-(void)setVertexPosition: (uint32_t)index position: (TSVector3f)position {
		[self ref].setVertexPosition(index, *(Tellusim::Vector3f*)&position);
	}
	-(void)setVertexPosition_: (uint32_t)index position: (TSVector3f)position {
		[self ref].setVertexPosition(index, *(Tellusim::Vector3f*)&position);
	}
	-(void)setVertexPosition_1: (uint32_t)index x: (float32_t)x y: (float32_t)y {
		[self ref].setVertexPosition(index, x, y);
	}
	-(void)setVertexPosition_1_: (uint32_t)index x: (float32_t)x y: (float32_t)y {
		[self ref].setVertexPosition(index, x, y);
	}
	-(void)setVertexPosition_2: (uint32_t)index x: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setVertexPosition(index, x, y, z);
	}
	-(void)setVertexPosition_2_: (uint32_t)index x: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setVertexPosition(index, x, y, z);
	}
	-(TSVector3f)getVertexPosition: (uint32_t)index {
		Tellusim::Vector3f ret = [self ref].getVertexPosition(index);
		return *(TSVector3f*)&ret;
	}
	-(TSVector3f)getVertexPosition_: (uint32_t)index {
		Tellusim::Vector3f ret = [self ref].getVertexPosition(index);
		return *(TSVector3f*)&ret;
	}
	-(void)setVertexTexCoord: (uint32_t)index texcoord: (TSVector2f)texcoord {
		[self ref].setVertexTexCoord(index, *(Tellusim::Vector2f*)&texcoord);
	}
	-(void)setVertexTexCoord_: (uint32_t)index texcoord: (TSVector2f)texcoord {
		[self ref].setVertexTexCoord(index, *(Tellusim::Vector2f*)&texcoord);
	}
	-(void)setVertexTexCoord_1: (uint32_t)index s: (float32_t)s t: (float32_t)t {
		[self ref].setVertexTexCoord(index, s, t);
	}
	-(void)setVertexTexCoord_1_: (uint32_t)index s: (float32_t)s t: (float32_t)t {
		[self ref].setVertexTexCoord(index, s, t);
	}
	-(TSVector2f)getVertexTexCoord: (uint32_t)index {
		Tellusim::Vector2f ret = [self ref].getVertexTexCoord(index);
		return *(TSVector2f*)&ret;
	}
	-(TSVector2f)getVertexTexCoord_: (uint32_t)index {
		Tellusim::Vector2f ret = [self ref].getVertexTexCoord(index);
		return *(TSVector2f*)&ret;
	}
	-(void)setVertexColor: (uint32_t)index color: (TSColor)color {
		[self ref].setVertexColor(index, *(Tellusim::Color*)&color);
	}
	-(void)setVertexColor_: (uint32_t)index color: (TSColor)color {
		[self ref].setVertexColor(index, *(Tellusim::Color*)&color);
	}
	-(void)setVertexColor_1: (uint32_t)index color: (uint32_t)color {
		[self ref].setVertexColor(index, color);
	}
	-(void)setVertexColor_1_: (uint32_t)index color: (uint32_t)color {
		[self ref].setVertexColor(index, color);
	}
	-(uint32_t)getVertexColor: (uint32_t)index {
		return [self ref].getVertexColor(index);
	}
	-(uint32_t)getVertexColor_: (uint32_t)index {
		return [self ref].getVertexColor(index);
	}
	-(uint32_t)addVertex: (TSVector3f)position {
		return [self ref].addVertex(*(Tellusim::Vector3f*)&position);
	}
	-(uint32_t)addVertex_: (TSVector3f)position {
		return [self ref].addVertex(*(Tellusim::Vector3f*)&position);
	}
	-(uint32_t)addVertex_1: (TSVector3f)position color: (uint32_t)color {
		return [self ref].addVertex(*(Tellusim::Vector3f*)&position, color);
	}
	-(uint32_t)addVertex_1_: (TSVector3f)position color: (uint32_t)color {
		return [self ref].addVertex(*(Tellusim::Vector3f*)&position, color);
	}
	-(uint32_t)addVertex_2: (TSVector3f)position texcoord: (TSVector2f)texcoord {
		return [self ref].addVertex(*(Tellusim::Vector3f*)&position, *(Tellusim::Vector2f*)&texcoord);
	}
	-(uint32_t)addVertex_2_: (TSVector3f)position texcoord: (TSVector2f)texcoord {
		return [self ref].addVertex(*(Tellusim::Vector3f*)&position, *(Tellusim::Vector2f*)&texcoord);
	}
	-(uint32_t)addVertex_3: (TSVector3f)position texcoord: (TSVector2f)texcoord color: (uint32_t)color {
		return [self ref].addVertex(*(Tellusim::Vector3f*)&position, *(Tellusim::Vector2f*)&texcoord, color);
	}
	-(uint32_t)addVertex_3_: (TSVector3f)position texcoord: (TSVector2f)texcoord color: (uint32_t)color {
		return [self ref].addVertex(*(Tellusim::Vector3f*)&position, *(Tellusim::Vector2f*)&texcoord, color);
	}
	-(uint32_t)addVertex_4: (float32_t)x y: (float32_t)y z: (float32_t)z s: (float32_t)s t: (float32_t)t {
		return [self ref].addVertex(x, y, z, s, t);
	}
	-(uint32_t)addVertex_4_: (float32_t)x y: (float32_t)y z: (float32_t)z s: (float32_t)s t: (float32_t)t {
		return [self ref].addVertex(x, y, z, s, t);
	}
	-(uint32_t)addVertex_5: (float32_t)x y: (float32_t)y z: (float32_t)z s: (float32_t)s t: (float32_t)t color: (uint32_t)color {
		return [self ref].addVertex(x, y, z, s, t, color);
	}
	-(uint32_t)addVertex_5_: (float32_t)x y: (float32_t)y z: (float32_t)z s: (float32_t)s t: (float32_t)t color: (uint32_t)color {
		return [self ref].addVertex(x, y, z, s, t, color);
	}
	-(uint32_t)addVertex_6: (float32_t)x y: (float32_t)y z: (float32_t)z {
		return [self ref].addVertex(x, y, z);
	}
	-(uint32_t)addVertex_6_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		return [self ref].addVertex(x, y, z);
	}
	-(uint32_t)addVertex_7: (float32_t)x y: (float32_t)y z: (float32_t)z color: (uint32_t)color {
		return [self ref].addVertex(x, y, z, color);
	}
	-(uint32_t)addVertex_7_: (float32_t)x y: (float32_t)y z: (float32_t)z color: (uint32_t)color {
		return [self ref].addVertex(x, y, z, color);
	}
	-(uint32_t)addVertex_8: (float32_t)x y: (float32_t)y {
		return [self ref].addVertex(x, y);
	}
	-(uint32_t)addVertex_8_: (float32_t)x y: (float32_t)y {
		return [self ref].addVertex(x, y);
	}
	-(uint32_t)addVertex_9: (float32_t)x y: (float32_t)y color: (uint32_t)color {
		return [self ref].addVertex(x, y, color);
	}
	-(uint32_t)addVertex_9_: (float32_t)x y: (float32_t)y color: (uint32_t)color {
		return [self ref].addVertex(x, y, color);
	}
	-(void)clearIndices {
		[self ref].clearIndices();
	}
	-(void)setNumIndices: (uint32_t)num_indices {
		[self ref].setNumIndices(num_indices);
	}
	-(void)setNumIndices_: (uint32_t)num_indices {
		[self ref].setNumIndices(num_indices);
	}
	-(void)reserveIndices: (uint32_t)num_indices {
		[self ref].reserveIndices(num_indices);
	}
	-(void)reserveIndices_: (uint32_t)num_indices {
		[self ref].reserveIndices(num_indices);
	}
	-(uint32_t)getNumIndices {
		return [self ref].getNumIndices();
	}
	-(void)setIndices: (const uint32_t*)indices num_indices: (uint32_t)num_indices {
		[self ref].setIndices(indices, num_indices);
	}
	-(void)setIndices_: (const uint32_t*)indices num_indices: (uint32_t)num_indices {
		[self ref].setIndices(indices, num_indices);
	}
	-(void)addIndices: (const uint32_t*)indices num_indices: (uint32_t)num_indices {
		[self ref].addIndices(indices, num_indices);
	}
	-(void)addIndices_: (const uint32_t*)indices num_indices: (uint32_t)num_indices {
		[self ref].addIndices(indices, num_indices);
	}
	-(const uint32_t*)getIndices {
		return [self ref].getIndices();
	}
	-(uint32_t*)getIndices_1 {
		return [self ref].getIndices();
	}
	-(void)setIndex: (uint32_t)index value: (uint32_t)value {
		[self ref].setIndex(index, value);
	}
	-(void)setIndex_: (uint32_t)index value: (uint32_t)value {
		[self ref].setIndex(index, value);
	}
	-(uint32_t)getIndex: (uint32_t)index {
		return [self ref].getIndex(index);
	}
	-(uint32_t)getIndex_: (uint32_t)index {
		return [self ref].getIndex(index);
	}
	-(void)addIndex: (uint32_t)i0 {
		[self ref].addIndex(i0);
	}
	-(void)addIndex_: (uint32_t)i0 {
		[self ref].addIndex(i0);
	}
	-(void)addIndices_1: (uint32_t)i0 i1: (uint32_t)i1 {
		[self ref].addIndices(i0, i1);
	}
	-(void)addIndices_1_: (uint32_t)i0 i1: (uint32_t)i1 {
		[self ref].addIndices(i0, i1);
	}
	-(void)addIndices_2: (uint32_t)i0 i1: (uint32_t)i1 i2: (uint32_t)i2 {
		[self ref].addIndices(i0, i1, i2);
	}
	-(void)addIndices_2_: (uint32_t)i0 i1: (uint32_t)i1 i2: (uint32_t)i2 {
		[self ref].addIndices(i0, i1, i2);
	}
	-(void)addIndices_3: (uint32_t)i0 i1: (uint32_t)i1 i2: (uint32_t)i2 i3: (uint32_t)i3 {
		[self ref].addIndices(i0, i1, i2, i3);
	}
	-(void)addIndices_3_: (uint32_t)i0 i1: (uint32_t)i1 i2: (uint32_t)i2 i3: (uint32_t)i3 {
		[self ref].addIndices(i0, i1, i2, i3);
	}
	-(void)setRect: (TSRect)rect {
		[self ref].setRect(*(Tellusim::Rect*)&rect);
	}
	-(void)setRect_: (TSRect)rect {
		[self ref].setRect(*(Tellusim::Rect*)&rect);
	}
@end

// Tellusim::CanvasRect
@implementation TSCanvasRect
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasRect();
		return self;
	}
	-(id)init_2: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasRect([canvas ref]);
		return self;
	}
	-(id)init_2_: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasRect([canvas ref]);
		return self;
	}
	-(id)init_3: (TSCanvas*)canvas radius: (float32_t)radius {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasRect([canvas ref], radius);
		return self;
	}
	-(id)init_3_: (TSCanvas*)canvas radius: (float32_t)radius {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasRect([canvas ref], radius);
		return self;
	}
	-(id)init_4: (TSCanvas*)canvas radius: (float32_t)radius size: (TSVector2f)size {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasRect([canvas ref], radius, *(Tellusim::Vector2f*)&size);
		return self;
	}
	-(id)init_4_: (TSCanvas*)canvas radius: (float32_t)radius size: (TSVector2f)size {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasRect([canvas ref], radius, *(Tellusim::Vector2f*)&size);
		return self;
	}
	-(id)init_ptr: (Tellusim::CanvasRect*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CanvasRect&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasRect((Tellusim::CanvasRect&)ref);
		return self;
	}
	-(Tellusim::CanvasRect*)pointer {
		return (Tellusim::CanvasRect*)impl;
	}
	-(Tellusim::CanvasRect&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CanvasRect*)impl;
	}
	-(id)initCanvasElement: (TSCanvasElement*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasRect([base ref]);
		return self;
	}
	-(TSCanvasElement*)getCanvasElement {
		return [[TSCanvasElement alloc] init_ref:([self ref].getCanvasElement())];
	}
	-(BOOL)equalPtr: (const TSCanvasRect*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCanvasRect*)copyPtr {
		return [[TSCanvasRect alloc] init_ref:[self ref]];
	}
	-(TSCanvasRect*)clonePtr {
		return [[TSCanvasRect alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCanvasRect*)null {
		return [[TSCanvasRect alloc] init_ptr:nullptr];
	}
	-(void)setRadius: (float32_t)radius {
		[self ref].setRadius(radius);
	}
	-(void)setRadius_: (float32_t)radius {
		[self ref].setRadius(radius);
	}
	-(float32_t)getRadius {
		return [self ref].getRadius();
	}
	-(void)setTextureName: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_1: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setTextureName_1_: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getTextureName {
		return [NSString stringWithUTF8String:[self ref].getTextureName().get()];
	}
	-(void)setStrokeColor: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(void)setStrokeColor_: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getStrokeColor {
		Tellusim::Color ret = [self ref].getStrokeColor();
		return *(TSColor*)&ret;
	}
	-(void)setStrokeStyle: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(void)setStrokeStyle_: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(TSStrokeStyle)getStrokeStyleConst {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyleConst();
		return *(TSStrokeStyle*)&ret;
	}
	-(TSStrokeStyle)getStrokeStyle {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyle();
		return *(TSStrokeStyle*)&ret;
	}
	-(void)setGradientStyle: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(void)setGradientStyle_: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(TSGradientStyle)getGradientStyleConst {
		Tellusim::GradientStyle ret = [self ref].getGradientStyleConst();
		return *(TSGradientStyle*)&ret;
	}
	-(TSGradientStyle)getGradientStyle {
		Tellusim::GradientStyle ret = [self ref].getGradientStyle();
		return *(TSGradientStyle*)&ret;
	}
	-(void)setSize: (TSVector2f)size {
		[self ref].setSize(*(Tellusim::Vector2f*)&size);
	}
	-(void)setSize_: (TSVector2f)size {
		[self ref].setSize(*(Tellusim::Vector2f*)&size);
	}
	-(void)setSize_1: (float32_t)width height: (float32_t)height {
		[self ref].setSize(width, height);
	}
	-(void)setSize_1_: (float32_t)width height: (float32_t)height {
		[self ref].setSize(width, height);
	}
	-(TSVector2f)getSize {
		Tellusim::Vector2f ret = [self ref].getSize();
		return *(TSVector2f*)&ret;
	}
	-(float32_t)getWidth {
		return [self ref].getWidth();
	}
	-(float32_t)getHeight {
		return [self ref].getHeight();
	}
	-(void)setPosition: (TSVector3f)position {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_: (TSVector3f)position {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_1: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_1_: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(x, y, z);
	}
	-(void)setPosition_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(x, y, z);
	}
	-(TSVector3f)getPosition {
		Tellusim::Vector3f ret = [self ref].getPosition();
		return *(TSVector3f*)&ret;
	}
	-(void)setTexCoord: (TSRect)texcoord {
		[self ref].setTexCoord(*(Tellusim::Rect*)&texcoord);
	}
	-(void)setTexCoord_: (TSRect)texcoord {
		[self ref].setTexCoord(*(Tellusim::Rect*)&texcoord);
	}
	-(void)setTexCoord_1: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setTexCoord(left, right, bottom, top);
	}
	-(void)setTexCoord_1_: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setTexCoord(left, right, bottom, top);
	}
	-(TSRect)getTexCoord {
		Tellusim::Rect ret = [self ref].getTexCoord();
		return *(TSRect*)&ret;
	}
@end

// Tellusim::CanvasTriangle
@implementation TSCanvasTriangle
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasTriangle();
		return self;
	}
	-(id)init_2: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasTriangle([canvas ref]);
		return self;
	}
	-(id)init_2_: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasTriangle([canvas ref]);
		return self;
	}
	-(id)init_3: (TSCanvas*)canvas radius: (float32_t)radius {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasTriangle([canvas ref], radius);
		return self;
	}
	-(id)init_3_: (TSCanvas*)canvas radius: (float32_t)radius {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasTriangle([canvas ref], radius);
		return self;
	}
	-(id)init_ptr: (Tellusim::CanvasTriangle*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CanvasTriangle&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasTriangle((Tellusim::CanvasTriangle&)ref);
		return self;
	}
	-(Tellusim::CanvasTriangle*)pointer {
		return (Tellusim::CanvasTriangle*)impl;
	}
	-(Tellusim::CanvasTriangle&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CanvasTriangle*)impl;
	}
	-(id)initCanvasElement: (TSCanvasElement*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasTriangle([base ref]);
		return self;
	}
	-(TSCanvasElement*)getCanvasElement {
		return [[TSCanvasElement alloc] init_ref:([self ref].getCanvasElement())];
	}
	-(BOOL)equalPtr: (const TSCanvasTriangle*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCanvasTriangle*)copyPtr {
		return [[TSCanvasTriangle alloc] init_ref:[self ref]];
	}
	-(TSCanvasTriangle*)clonePtr {
		return [[TSCanvasTriangle alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCanvasTriangle*)null {
		return [[TSCanvasTriangle alloc] init_ptr:nullptr];
	}
	-(void)setRadius: (float32_t)radius {
		[self ref].setRadius(radius);
	}
	-(void)setRadius_: (float32_t)radius {
		[self ref].setRadius(radius);
	}
	-(float32_t)getRadius {
		return [self ref].getRadius();
	}
	-(void)setStrokeColor: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(void)setStrokeColor_: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getStrokeColor {
		Tellusim::Color ret = [self ref].getStrokeColor();
		return *(TSColor*)&ret;
	}
	-(void)setStrokeStyle: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(void)setStrokeStyle_: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(TSStrokeStyle)getStrokeStyleConst {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyleConst();
		return *(TSStrokeStyle*)&ret;
	}
	-(TSStrokeStyle)getStrokeStyle {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyle();
		return *(TSStrokeStyle*)&ret;
	}
	-(void)setGradientStyle: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(void)setGradientStyle_: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(TSGradientStyle)getGradientStyleConst {
		Tellusim::GradientStyle ret = [self ref].getGradientStyleConst();
		return *(TSGradientStyle*)&ret;
	}
	-(TSGradientStyle)getGradientStyle {
		Tellusim::GradientStyle ret = [self ref].getGradientStyle();
		return *(TSGradientStyle*)&ret;
	}
	-(void)setPosition0: (TSVector3f)position {
		[self ref].setPosition0(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition0_: (TSVector3f)position {
		[self ref].setPosition0(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition1: (TSVector3f)position {
		[self ref].setPosition1(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition1_: (TSVector3f)position {
		[self ref].setPosition1(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition2: (TSVector3f)position {
		[self ref].setPosition2(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition2_: (TSVector3f)position {
		[self ref].setPosition2(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition0_1: (float32_t)x y: (float32_t)y {
		[self ref].setPosition0(x, y);
	}
	-(void)setPosition0_1_: (float32_t)x y: (float32_t)y {
		[self ref].setPosition0(x, y);
	}
	-(void)setPosition0_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition0(x, y, z);
	}
	-(void)setPosition0_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition0(x, y, z);
	}
	-(void)setPosition1_1: (float32_t)x y: (float32_t)y {
		[self ref].setPosition1(x, y);
	}
	-(void)setPosition1_1_: (float32_t)x y: (float32_t)y {
		[self ref].setPosition1(x, y);
	}
	-(void)setPosition1_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition1(x, y, z);
	}
	-(void)setPosition1_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition1(x, y, z);
	}
	-(void)setPosition2_1: (float32_t)x y: (float32_t)y {
		[self ref].setPosition2(x, y);
	}
	-(void)setPosition2_1_: (float32_t)x y: (float32_t)y {
		[self ref].setPosition2(x, y);
	}
	-(void)setPosition2_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition2(x, y, z);
	}
	-(void)setPosition2_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition2(x, y, z);
	}
	-(void)setPosition: (TSVector3f)position_0 position_1: (TSVector3f)position_1 position_2: (TSVector3f)position_2 {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position_0, *(Tellusim::Vector3f*)&position_1, *(Tellusim::Vector3f*)&position_2);
	}
	-(void)setPosition_: (TSVector3f)position_0 position_1: (TSVector3f)position_1 position_2: (TSVector3f)position_2 {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position_0, *(Tellusim::Vector3f*)&position_1, *(Tellusim::Vector3f*)&position_2);
	}
	-(TSVector3f)getPosition0 {
		Tellusim::Vector3f ret = [self ref].getPosition0();
		return *(TSVector3f*)&ret;
	}
	-(TSVector3f)getPosition1 {
		Tellusim::Vector3f ret = [self ref].getPosition1();
		return *(TSVector3f*)&ret;
	}
	-(TSVector3f)getPosition2 {
		Tellusim::Vector3f ret = [self ref].getPosition2();
		return *(TSVector3f*)&ret;
	}
@end

// Tellusim::CanvasEllipse
@implementation TSCanvasEllipse
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasEllipse();
		return self;
	}
	-(id)init_2: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasEllipse([canvas ref]);
		return self;
	}
	-(id)init_2_: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasEllipse([canvas ref]);
		return self;
	}
	-(id)init_3: (TSCanvas*)canvas radius: (float32_t)radius {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasEllipse([canvas ref], radius);
		return self;
	}
	-(id)init_3_: (TSCanvas*)canvas radius: (float32_t)radius {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasEllipse([canvas ref], radius);
		return self;
	}
	-(id)init_ptr: (Tellusim::CanvasEllipse*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CanvasEllipse&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasEllipse((Tellusim::CanvasEllipse&)ref);
		return self;
	}
	-(Tellusim::CanvasEllipse*)pointer {
		return (Tellusim::CanvasEllipse*)impl;
	}
	-(Tellusim::CanvasEllipse&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CanvasEllipse*)impl;
	}
	-(id)initCanvasElement: (TSCanvasElement*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasEllipse([base ref]);
		return self;
	}
	-(TSCanvasElement*)getCanvasElement {
		return [[TSCanvasElement alloc] init_ref:([self ref].getCanvasElement())];
	}
	-(BOOL)equalPtr: (const TSCanvasEllipse*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCanvasEllipse*)copyPtr {
		return [[TSCanvasEllipse alloc] init_ref:[self ref]];
	}
	-(TSCanvasEllipse*)clonePtr {
		return [[TSCanvasEllipse alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCanvasEllipse*)null {
		return [[TSCanvasEllipse alloc] init_ptr:nullptr];
	}
	-(void)setRadius: (float32_t)radius {
		[self ref].setRadius(radius);
	}
	-(void)setRadius_: (float32_t)radius {
		[self ref].setRadius(radius);
	}
	-(float32_t)getRadius {
		return [self ref].getRadius();
	}
	-(void)setTextureName: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_1: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setTextureName_1_: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getTextureName {
		return [NSString stringWithUTF8String:[self ref].getTextureName().get()];
	}
	-(void)setStrokeColor: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(void)setStrokeColor_: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getStrokeColor {
		Tellusim::Color ret = [self ref].getStrokeColor();
		return *(TSColor*)&ret;
	}
	-(void)setStrokeStyle: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(void)setStrokeStyle_: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(TSStrokeStyle)getStrokeStyleConst {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyleConst();
		return *(TSStrokeStyle*)&ret;
	}
	-(TSStrokeStyle)getStrokeStyle {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyle();
		return *(TSStrokeStyle*)&ret;
	}
	-(void)setGradientStyle: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(void)setGradientStyle_: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(TSGradientStyle)getGradientStyleConst {
		Tellusim::GradientStyle ret = [self ref].getGradientStyleConst();
		return *(TSGradientStyle*)&ret;
	}
	-(TSGradientStyle)getGradientStyle {
		Tellusim::GradientStyle ret = [self ref].getGradientStyle();
		return *(TSGradientStyle*)&ret;
	}
	-(void)setPosition: (TSVector3f)position {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_: (TSVector3f)position {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition0: (TSVector3f)position {
		[self ref].setPosition0(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition0_: (TSVector3f)position {
		[self ref].setPosition0(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition1: (TSVector3f)position {
		[self ref].setPosition1(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition1_: (TSVector3f)position {
		[self ref].setPosition1(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_1: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_1_: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(x, y, z);
	}
	-(void)setPosition_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(x, y, z);
	}
	-(void)setPosition0_1: (float32_t)x y: (float32_t)y {
		[self ref].setPosition0(x, y);
	}
	-(void)setPosition0_1_: (float32_t)x y: (float32_t)y {
		[self ref].setPosition0(x, y);
	}
	-(void)setPosition0_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition0(x, y, z);
	}
	-(void)setPosition0_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition0(x, y, z);
	}
	-(void)setPosition1_1: (float32_t)x y: (float32_t)y {
		[self ref].setPosition1(x, y);
	}
	-(void)setPosition1_1_: (float32_t)x y: (float32_t)y {
		[self ref].setPosition1(x, y);
	}
	-(void)setPosition1_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition1(x, y, z);
	}
	-(void)setPosition1_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition1(x, y, z);
	}
	-(void)setPosition_3: (TSVector3f)position_0 position_1: (TSVector3f)position_1 {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position_0, *(Tellusim::Vector3f*)&position_1);
	}
	-(void)setPosition_3_: (TSVector3f)position_0 position_1: (TSVector3f)position_1 {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position_0, *(Tellusim::Vector3f*)&position_1);
	}
	-(TSVector3f)getPosition0 {
		Tellusim::Vector3f ret = [self ref].getPosition0();
		return *(TSVector3f*)&ret;
	}
	-(TSVector3f)getPosition1 {
		Tellusim::Vector3f ret = [self ref].getPosition1();
		return *(TSVector3f*)&ret;
	}
	-(void)setTexCoord: (TSRect)texcoord {
		[self ref].setTexCoord(*(Tellusim::Rect*)&texcoord);
	}
	-(void)setTexCoord_: (TSRect)texcoord {
		[self ref].setTexCoord(*(Tellusim::Rect*)&texcoord);
	}
	-(void)setTexCoord_1: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setTexCoord(left, right, bottom, top);
	}
	-(void)setTexCoord_1_: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setTexCoord(left, right, bottom, top);
	}
	-(TSRect)getTexCoord {
		Tellusim::Rect ret = [self ref].getTexCoord();
		return *(TSRect*)&ret;
	}
@end

// Tellusim::CanvasShape
@implementation TSCanvasShape
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasShape();
		return self;
	}
	-(id)init_2: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasShape([canvas ref]);
		return self;
	}
	-(id)init_2_: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasShape([canvas ref]);
		return self;
	}
	-(id)init_3: (TSCanvas*)canvas cubic: (BOOL)cubic {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasShape([canvas ref], (bool)cubic);
		return self;
	}
	-(id)init_3_: (TSCanvas*)canvas cubic: (BOOL)cubic {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasShape([canvas ref], (bool)cubic);
		return self;
	}
	-(id)init_ptr: (Tellusim::CanvasShape*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CanvasShape&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasShape((Tellusim::CanvasShape&)ref);
		return self;
	}
	-(Tellusim::CanvasShape*)pointer {
		return (Tellusim::CanvasShape*)impl;
	}
	-(Tellusim::CanvasShape&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CanvasShape*)impl;
	}
	-(id)initCanvasElement: (TSCanvasElement*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasShape([base ref]);
		return self;
	}
	-(TSCanvasElement*)getCanvasElement {
		return [[TSCanvasElement alloc] init_ref:([self ref].getCanvasElement())];
	}
	-(BOOL)equalPtr: (const TSCanvasShape*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCanvasShape*)copyPtr {
		return [[TSCanvasShape alloc] init_ref:[self ref]];
	}
	-(TSCanvasShape*)clonePtr {
		return [[TSCanvasShape alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCanvasShape*)null {
		return [[TSCanvasShape alloc] init_ptr:nullptr];
	}
	-(void)setCubic: (BOOL)cubic {
		[self ref].setCubic((bool)cubic);
	}
	-(void)setCubic_: (BOOL)cubic {
		[self ref].setCubic((bool)cubic);
	}
	-(BOOL)isCubic {
		return [self ref].isCubic();
	}
	-(void)setThreshold: (float32_t)threshold {
		[self ref].setThreshold(threshold);
	}
	-(void)setThreshold_: (float32_t)threshold {
		[self ref].setThreshold(threshold);
	}
	-(float32_t)getThreshold {
		return [self ref].getThreshold();
	}
	-(void)setStrokeColor: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(void)setStrokeColor_: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getStrokeColor {
		Tellusim::Color ret = [self ref].getStrokeColor();
		return *(TSColor*)&ret;
	}
	-(void)setStrokeStyle: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(void)setStrokeStyle_: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(TSStrokeStyle)getStrokeStyleConst {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyleConst();
		return *(TSStrokeStyle*)&ret;
	}
	-(TSStrokeStyle)getStrokeStyle {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyle();
		return *(TSStrokeStyle*)&ret;
	}
	-(void)setGradientStyle: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(void)setGradientStyle_: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(TSGradientStyle)getGradientStyleConst {
		Tellusim::GradientStyle ret = [self ref].getGradientStyleConst();
		return *(TSGradientStyle*)&ret;
	}
	-(TSGradientStyle)getGradientStyle {
		Tellusim::GradientStyle ret = [self ref].getGradientStyle();
		return *(TSGradientStyle*)&ret;
	}
	-(BOOL)createSVG: (const char*)src {
		return [self ref].createSVG(src);
	}
	-(BOOL)createSVG_: (const char*)src {
		return [self ref].createSVG(src);
	}
	-(BOOL)createSVG_1: (const char*)src scale: (float32_t)scale {
		return [self ref].createSVG(src, scale);
	}
	-(BOOL)createSVG_1_: (const char*)src scale: (float32_t)scale {
		return [self ref].createSVG(src, scale);
	}
	-(void)clearPositions {
		[self ref].clearPositions();
	}
	-(void)setNumPositions: (uint32_t)num_positions {
		[self ref].setNumPositions(num_positions);
	}
	-(void)setNumPositions_: (uint32_t)num_positions {
		[self ref].setNumPositions(num_positions);
	}
	-(void)reservePositions: (uint32_t)num_positions {
		[self ref].reservePositions(num_positions);
	}
	-(void)reservePositions_: (uint32_t)num_positions {
		[self ref].reservePositions(num_positions);
	}
	-(uint32_t)getNumPositions {
		return [self ref].getNumPositions();
	}
	-(void)setPositions: (const TSVector3f*)positions num_positions: (uint32_t)num_positions {
		[self ref].setPositions(*(const Tellusim::Vector3f**)&positions, num_positions);
	}
	-(void)setPositions_: (const TSVector3f*)positions num_positions: (uint32_t)num_positions {
		[self ref].setPositions(*(const Tellusim::Vector3f**)&positions, num_positions);
	}
	-(void)addPositions: (const TSVector3f*)positions num_positions: (uint32_t)num_positions {
		[self ref].addPositions(*(const Tellusim::Vector3f**)&positions, num_positions);
	}
	-(void)addPositions_: (const TSVector3f*)positions num_positions: (uint32_t)num_positions {
		[self ref].addPositions(*(const Tellusim::Vector3f**)&positions, num_positions);
	}
	-(const TSVector3f*)getPositions {
		return (const TSVector3f*)[self ref].getPositions();
	}
	-(void)setPosition: (uint32_t)index position: (TSVector3f)position {
		[self ref].setPosition(index, *(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_: (uint32_t)index position: (TSVector3f)position {
		[self ref].setPosition(index, *(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_1: (uint32_t)index x: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(index, x, y);
	}
	-(void)setPosition_1_: (uint32_t)index x: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(index, x, y);
	}
	-(void)setPosition_2: (uint32_t)index x: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(index, x, y, z);
	}
	-(void)setPosition_2_: (uint32_t)index x: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(index, x, y, z);
	}
	-(TSVector3f)getPosition: (uint32_t)index {
		Tellusim::Vector3f ret = [self ref].getPosition(index);
		return *(TSVector3f*)&ret;
	}
	-(TSVector3f)getPosition_: (uint32_t)index {
		Tellusim::Vector3f ret = [self ref].getPosition(index);
		return *(TSVector3f*)&ret;
	}
	-(uint32_t)addPosition: (TSVector2f)position {
		return [self ref].addPosition(*(Tellusim::Vector2f*)&position);
	}
	-(uint32_t)addPosition_: (TSVector2f)position {
		return [self ref].addPosition(*(Tellusim::Vector2f*)&position);
	}
	-(uint32_t)addPosition_1: (TSVector3f)position {
		return [self ref].addPosition(*(Tellusim::Vector3f*)&position);
	}
	-(uint32_t)addPosition_1_: (TSVector3f)position {
		return [self ref].addPosition(*(Tellusim::Vector3f*)&position);
	}
	-(uint32_t)addPosition_2: (float32_t)x y: (float32_t)y {
		return [self ref].addPosition(x, y);
	}
	-(uint32_t)addPosition_2_: (float32_t)x y: (float32_t)y {
		return [self ref].addPosition(x, y);
	}
	-(uint32_t)addPosition_3: (float32_t)x y: (float32_t)y z: (float32_t)z {
		return [self ref].addPosition(x, y, z);
	}
	-(uint32_t)addPosition_3_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		return [self ref].addPosition(x, y, z);
	}
	-(void)setTexCoord: (TSRect)texcoord {
		[self ref].setTexCoord(*(Tellusim::Rect*)&texcoord);
	}
	-(void)setTexCoord_: (TSRect)texcoord {
		[self ref].setTexCoord(*(Tellusim::Rect*)&texcoord);
	}
	-(void)setTexCoord_1: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setTexCoord(left, right, bottom, top);
	}
	-(void)setTexCoord_1_: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setTexCoord(left, right, bottom, top);
	}
	-(TSRect)getTexCoord {
		Tellusim::Rect ret = [self ref].getTexCoord();
		return *(TSRect*)&ret;
	}
@end

// Tellusim::CanvasStrip
@implementation TSCanvasStrip
	-(id)init_1 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasStrip();
		return self;
	}
	-(id)init_2: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasStrip([canvas ref]);
		return self;
	}
	-(id)init_2_: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasStrip([canvas ref]);
		return self;
	}
	-(id)init_3: (TSCanvas*)canvas width: (float32_t)width {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasStrip([canvas ref], width);
		return self;
	}
	-(id)init_3_: (TSCanvas*)canvas width: (float32_t)width {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasStrip([canvas ref], width);
		return self;
	}
	-(id)init_ptr: (Tellusim::CanvasStrip*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CanvasStrip&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasStrip((Tellusim::CanvasStrip&)ref);
		return self;
	}
	-(Tellusim::CanvasStrip*)pointer {
		return (Tellusim::CanvasStrip*)impl;
	}
	-(Tellusim::CanvasStrip&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CanvasStrip*)impl;
	}
	-(id)initCanvasElement: (TSCanvasElement*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::CanvasStrip([base ref]);
		return self;
	}
	-(TSCanvasElement*)getCanvasElement {
		return [[TSCanvasElement alloc] init_ref:([self ref].getCanvasElement())];
	}
	-(BOOL)equalPtr: (const TSCanvasStrip*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCanvasStrip*)copyPtr {
		return [[TSCanvasStrip alloc] init_ref:[self ref]];
	}
	-(TSCanvasStrip*)clonePtr {
		return [[TSCanvasStrip alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCanvasStrip*)null {
		return [[TSCanvasStrip alloc] init_ptr:nullptr];
	}
	-(void)setWidth: (float32_t)width {
		[self ref].setWidth(width);
	}
	-(void)setWidth_: (float32_t)width {
		[self ref].setWidth(width);
	}
	-(float32_t)getWidth {
		return [self ref].getWidth();
	}
	-(void)setOffset: (float32_t)offset {
		[self ref].setOffset(offset);
	}
	-(void)setOffset_: (float32_t)offset {
		[self ref].setOffset(offset);
	}
	-(float32_t)getOffset {
		return [self ref].getOffset();
	}
	-(void)setStrokeColor: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(void)setStrokeColor_: (TSColor)color {
		[self ref].setStrokeColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getStrokeColor {
		Tellusim::Color ret = [self ref].getStrokeColor();
		return *(TSColor*)&ret;
	}
	-(void)setStrokeStyle: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(void)setStrokeStyle_: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(TSStrokeStyle)getStrokeStyleConst {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyleConst();
		return *(TSStrokeStyle*)&ret;
	}
	-(TSStrokeStyle)getStrokeStyle {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyle();
		return *(TSStrokeStyle*)&ret;
	}
	-(void)createQuadratic: (TSVector2f)p0 p1: (TSVector2f)p1 p2: (TSVector2f)p2 {
		[self ref].createQuadratic(*(Tellusim::Vector2f*)&p0, *(Tellusim::Vector2f*)&p1, *(Tellusim::Vector2f*)&p2);
	}
	-(void)createQuadratic_: (TSVector2f)p0 p1: (TSVector2f)p1 p2: (TSVector2f)p2 {
		[self ref].createQuadratic(*(Tellusim::Vector2f*)&p0, *(Tellusim::Vector2f*)&p1, *(Tellusim::Vector2f*)&p2);
	}
	-(void)createQuadratic_1: (TSVector2f)p0 p1: (TSVector2f)p1 p2: (TSVector2f)p2 threshold: (float32_t)threshold {
		[self ref].createQuadratic(*(Tellusim::Vector2f*)&p0, *(Tellusim::Vector2f*)&p1, *(Tellusim::Vector2f*)&p2, threshold);
	}
	-(void)createQuadratic_1_: (TSVector2f)p0 p1: (TSVector2f)p1 p2: (TSVector2f)p2 threshold: (float32_t)threshold {
		[self ref].createQuadratic(*(Tellusim::Vector2f*)&p0, *(Tellusim::Vector2f*)&p1, *(Tellusim::Vector2f*)&p2, threshold);
	}
	-(void)createQuadratic_2: (TSVector3f)p0 p1: (TSVector3f)p1 p2: (TSVector3f)p2 {
		[self ref].createQuadratic(*(Tellusim::Vector3f*)&p0, *(Tellusim::Vector3f*)&p1, *(Tellusim::Vector3f*)&p2);
	}
	-(void)createQuadratic_2_: (TSVector3f)p0 p1: (TSVector3f)p1 p2: (TSVector3f)p2 {
		[self ref].createQuadratic(*(Tellusim::Vector3f*)&p0, *(Tellusim::Vector3f*)&p1, *(Tellusim::Vector3f*)&p2);
	}
	-(void)createQuadratic_3: (TSVector3f)p0 p1: (TSVector3f)p1 p2: (TSVector3f)p2 threshold: (float32_t)threshold {
		[self ref].createQuadratic(*(Tellusim::Vector3f*)&p0, *(Tellusim::Vector3f*)&p1, *(Tellusim::Vector3f*)&p2, threshold);
	}
	-(void)createQuadratic_3_: (TSVector3f)p0 p1: (TSVector3f)p1 p2: (TSVector3f)p2 threshold: (float32_t)threshold {
		[self ref].createQuadratic(*(Tellusim::Vector3f*)&p0, *(Tellusim::Vector3f*)&p1, *(Tellusim::Vector3f*)&p2, threshold);
	}
	-(void)createCubic: (TSVector2f)p0 p1: (TSVector2f)p1 p2: (TSVector2f)p2 p3: (TSVector2f)p3 {
		[self ref].createCubic(*(Tellusim::Vector2f*)&p0, *(Tellusim::Vector2f*)&p1, *(Tellusim::Vector2f*)&p2, *(Tellusim::Vector2f*)&p3);
	}
	-(void)createCubic_: (TSVector2f)p0 p1: (TSVector2f)p1 p2: (TSVector2f)p2 p3: (TSVector2f)p3 {
		[self ref].createCubic(*(Tellusim::Vector2f*)&p0, *(Tellusim::Vector2f*)&p1, *(Tellusim::Vector2f*)&p2, *(Tellusim::Vector2f*)&p3);
	}
	-(void)createCubic_1: (TSVector2f)p0 p1: (TSVector2f)p1 p2: (TSVector2f)p2 p3: (TSVector2f)p3 threshold: (float32_t)threshold {
		[self ref].createCubic(*(Tellusim::Vector2f*)&p0, *(Tellusim::Vector2f*)&p1, *(Tellusim::Vector2f*)&p2, *(Tellusim::Vector2f*)&p3, threshold);
	}
	-(void)createCubic_1_: (TSVector2f)p0 p1: (TSVector2f)p1 p2: (TSVector2f)p2 p3: (TSVector2f)p3 threshold: (float32_t)threshold {
		[self ref].createCubic(*(Tellusim::Vector2f*)&p0, *(Tellusim::Vector2f*)&p1, *(Tellusim::Vector2f*)&p2, *(Tellusim::Vector2f*)&p3, threshold);
	}
	-(void)createCubic_2: (TSVector3f)p0 p1: (TSVector3f)p1 p2: (TSVector3f)p2 p3: (TSVector3f)p3 {
		[self ref].createCubic(*(Tellusim::Vector3f*)&p0, *(Tellusim::Vector3f*)&p1, *(Tellusim::Vector3f*)&p2, *(Tellusim::Vector3f*)&p3);
	}
	-(void)createCubic_2_: (TSVector3f)p0 p1: (TSVector3f)p1 p2: (TSVector3f)p2 p3: (TSVector3f)p3 {
		[self ref].createCubic(*(Tellusim::Vector3f*)&p0, *(Tellusim::Vector3f*)&p1, *(Tellusim::Vector3f*)&p2, *(Tellusim::Vector3f*)&p3);
	}
	-(void)createCubic_3: (TSVector3f)p0 p1: (TSVector3f)p1 p2: (TSVector3f)p2 p3: (TSVector3f)p3 threshold: (float32_t)threshold {
		[self ref].createCubic(*(Tellusim::Vector3f*)&p0, *(Tellusim::Vector3f*)&p1, *(Tellusim::Vector3f*)&p2, *(Tellusim::Vector3f*)&p3, threshold);
	}
	-(void)createCubic_3_: (TSVector3f)p0 p1: (TSVector3f)p1 p2: (TSVector3f)p2 p3: (TSVector3f)p3 threshold: (float32_t)threshold {
		[self ref].createCubic(*(Tellusim::Vector3f*)&p0, *(Tellusim::Vector3f*)&p1, *(Tellusim::Vector3f*)&p2, *(Tellusim::Vector3f*)&p3, threshold);
	}
	-(void)clearPositions {
		[self ref].clearPositions();
	}
	-(void)setNumPositions: (uint32_t)num_positions {
		[self ref].setNumPositions(num_positions);
	}
	-(void)setNumPositions_: (uint32_t)num_positions {
		[self ref].setNumPositions(num_positions);
	}
	-(void)reservePositions: (uint32_t)num_positions {
		[self ref].reservePositions(num_positions);
	}
	-(void)reservePositions_: (uint32_t)num_positions {
		[self ref].reservePositions(num_positions);
	}
	-(uint32_t)getNumPositions {
		return [self ref].getNumPositions();
	}
	-(void)setPositions: (const TSVector3f*)positions num_positions: (uint32_t)num_positions {
		[self ref].setPositions(*(const Tellusim::Vector3f**)&positions, num_positions);
	}
	-(void)setPositions_: (const TSVector3f*)positions num_positions: (uint32_t)num_positions {
		[self ref].setPositions(*(const Tellusim::Vector3f**)&positions, num_positions);
	}
	-(void)addPositions: (const TSVector3f*)positions num_positions: (uint32_t)num_positions {
		[self ref].addPositions(*(const Tellusim::Vector3f**)&positions, num_positions);
	}
	-(void)addPositions_: (const TSVector3f*)positions num_positions: (uint32_t)num_positions {
		[self ref].addPositions(*(const Tellusim::Vector3f**)&positions, num_positions);
	}
	-(const TSVector3f*)getPositions {
		return (const TSVector3f*)[self ref].getPositions();
	}
	-(void)setPosition: (uint32_t)index position: (TSVector3f)position {
		[self ref].setPosition(index, *(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_: (uint32_t)index position: (TSVector3f)position {
		[self ref].setPosition(index, *(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_1: (uint32_t)index x: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(index, x, y);
	}
	-(void)setPosition_1_: (uint32_t)index x: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(index, x, y);
	}
	-(void)setPosition_2: (uint32_t)index x: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(index, x, y, z);
	}
	-(void)setPosition_2_: (uint32_t)index x: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(index, x, y, z);
	}
	-(TSVector3f)getPosition: (uint32_t)index {
		Tellusim::Vector3f ret = [self ref].getPosition(index);
		return *(TSVector3f*)&ret;
	}
	-(TSVector3f)getPosition_: (uint32_t)index {
		Tellusim::Vector3f ret = [self ref].getPosition(index);
		return *(TSVector3f*)&ret;
	}
	-(uint32_t)addPosition: (TSVector2f)position {
		return [self ref].addPosition(*(Tellusim::Vector2f*)&position);
	}
	-(uint32_t)addPosition_: (TSVector2f)position {
		return [self ref].addPosition(*(Tellusim::Vector2f*)&position);
	}
	-(uint32_t)addPosition_1: (TSVector3f)position {
		return [self ref].addPosition(*(Tellusim::Vector3f*)&position);
	}
	-(uint32_t)addPosition_1_: (TSVector3f)position {
		return [self ref].addPosition(*(Tellusim::Vector3f*)&position);
	}
	-(uint32_t)addPosition_2: (float32_t)x y: (float32_t)y {
		return [self ref].addPosition(x, y);
	}
	-(uint32_t)addPosition_2_: (float32_t)x y: (float32_t)y {
		return [self ref].addPosition(x, y);
	}
	-(uint32_t)addPosition_3: (float32_t)x y: (float32_t)y z: (float32_t)z {
		return [self ref].addPosition(x, y, z);
	}
	-(uint32_t)addPosition_3_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		return [self ref].addPosition(x, y, z);
	}
@end

// Tellusim::Canvas
@implementation TSCanvas
	-(id)init {
		self = [super init];
		impl = new Tellusim::Canvas();
		return self;
	}
	-(id)init_1: (TSCanvas*)parent {
		self = [super init];
		impl = new Tellusim::Canvas([parent pointer]);
		return self;
	}
	-(id)init_1_: (TSCanvas*)parent {
		self = [super init];
		impl = new Tellusim::Canvas([parent pointer]);
		return self;
	}
	-(id)init_ptr: (Tellusim::Canvas*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Canvas&)ref {
		self = [super init];
		impl = new Tellusim::Canvas((Tellusim::Canvas&)ref);
		return self;
	}
	-(Tellusim::Canvas*)pointer {
		return (Tellusim::Canvas*)impl;
	}
	-(Tellusim::Canvas&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Canvas*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Canvas*)impl;
	}
	-(BOOL)equalPtr: (const TSCanvas*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCanvas*)copyPtr {
		return [[TSCanvas alloc] init_ref:[self ref]];
	}
	-(TSCanvas*)clonePtr {
		return [[TSCanvas alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCanvas*)null {
		return [[TSCanvas alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(uint32_t)getScale: (const TSTarget*)target {
		return [self ref].getScale([target ref]);
	}
	-(uint32_t)getScale_: (const TSTarget*)target {
		return [self ref].getScale([target ref]);
	}
	-(uint32_t)getScale_1: (const TSTarget*)target scale: (uint32_t)scale {
		return [self ref].getScale([target ref], scale);
	}
	-(uint32_t)getScale_1_: (const TSTarget*)target scale: (uint32_t)scale {
		return [self ref].getScale([target ref], scale);
	}
	-(BOOL)create: (const TSDevice*)device color: (TS_Format)color depth: (TS_Format)depth {
		return [self ref].create([device ref], (Tellusim::Format)color, (Tellusim::Format)depth);
	}
	-(BOOL)create_: (const TSDevice*)device color: (TS_Format)color depth: (TS_Format)depth {
		return [self ref].create([device ref], (Tellusim::Format)color, (Tellusim::Format)depth);
	}
	-(BOOL)create_1: (const TSDevice*)device color: (TS_Format)color depth: (TS_Format)depth multisample: (uint32_t)multisample {
		return [self ref].create([device ref], (Tellusim::Format)color, (Tellusim::Format)depth, multisample);
	}
	-(BOOL)create_1_: (const TSDevice*)device color: (TS_Format)color depth: (TS_Format)depth multisample: (uint32_t)multisample {
		return [self ref].create([device ref], (Tellusim::Format)color, (Tellusim::Format)depth, multisample);
	}
	-(BOOL)create_2: (const TSDevice*)device color: (TS_Format)color depth: (TS_Format)depth multisample: (uint32_t)multisample scale: (uint32_t)scale {
		return [self ref].create([device ref], (Tellusim::Format)color, (Tellusim::Format)depth, multisample, scale);
	}
	-(BOOL)create_2_: (const TSDevice*)device color: (TS_Format)color depth: (TS_Format)depth multisample: (uint32_t)multisample scale: (uint32_t)scale {
		return [self ref].create([device ref], (Tellusim::Format)color, (Tellusim::Format)depth, multisample, scale);
	}
	-(BOOL)create_3: (const TSDevice*)device target: (const TSTarget*)target {
		return [self ref].create([device ref], [target ref]);
	}
	-(BOOL)create_3_: (const TSDevice*)device target: (const TSTarget*)target {
		return [self ref].create([device ref], [target ref]);
	}
	-(BOOL)create_4: (const TSDevice*)device target: (const TSTarget*)target scale: (uint32_t)scale {
		return [self ref].create([device ref], [target ref], scale);
	}
	-(BOOL)create_4_: (const TSDevice*)device target: (const TSTarget*)target scale: (uint32_t)scale {
		return [self ref].create([device ref], [target ref], scale);
	}
	-(void)setPipelineHash: (uint32_t)hash {
		[self ref].setPipelineHash(hash);
	}
	-(void)setPipelineHash_: (uint32_t)hash {
		[self ref].setPipelineHash(hash);
	}
	-(uint32_t)getPipelineHash {
		return [self ref].getPipelineHash();
	}
	-(TS_Format)getColorFormat {
		return (TS_Format)[self ref].getColorFormat();
	}
	-(TS_Format)getDepthFormat {
		return (TS_Format)[self ref].getDepthFormat();
	}
	-(uint32_t)getMultisample {
		return [self ref].getMultisample();
	}
	-(void)setOrder: (int32_t)order {
		[self ref].setOrder(order);
	}
	-(void)setOrder_: (int32_t)order {
		[self ref].setOrder(order);
	}
	-(int32_t)getOrder {
		return [self ref].getOrder();
	}
	-(void)setEnabled: (BOOL)enabled {
		[self ref].setEnabled((bool)enabled);
	}
	-(void)setEnabled_: (BOOL)enabled {
		[self ref].setEnabled((bool)enabled);
	}
	-(BOOL)isEnabled {
		return [self ref].isEnabled();
	}
	-(void)setViewport: (TSViewport)viewport {
		[self ref].setViewport(*(Tellusim::Viewport*)&viewport);
	}
	-(void)setViewport_: (TSViewport)viewport {
		[self ref].setViewport(*(Tellusim::Viewport*)&viewport);
	}
	-(void)setViewport_1: (uint32_t)width height: (uint32_t)height {
		[self ref].setViewport(width, height);
	}
	-(void)setViewport_1_: (uint32_t)width height: (uint32_t)height {
		[self ref].setViewport(width, height);
	}
	-(void)setViewport_2: (float32_t)width height: (float32_t)height {
		[self ref].setViewport(width, height);
	}
	-(void)setViewport_2_: (float32_t)width height: (float32_t)height {
		[self ref].setViewport(width, height);
	}
	-(TSViewport)getViewport {
		Tellusim::Viewport ret = [self ref].getViewport();
		return *(TSViewport*)&ret;
	}
	-(float32_t)getWidth {
		return [self ref].getWidth();
	}
	-(float32_t)getHeight {
		return [self ref].getHeight();
	}
	-(void)clearColor {
		[self ref].clearColor();
	}
	-(void)setColor: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_1: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setColor(r, g, b, a);
	}
	-(void)setColor_1_: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setColor(r, g, b, a);
	}
	-(TSColor)getColor {
		Tellusim::Color ret = [self ref].getColor();
		return *(TSColor*)&ret;
	}
	-(void)clearScissor {
		[self ref].clearScissor();
	}
	-(void)setScissor: (TSRect)scissor {
		[self ref].setScissor(*(Tellusim::Rect*)&scissor);
	}
	-(void)setScissor_: (TSRect)scissor {
		[self ref].setScissor(*(Tellusim::Rect*)&scissor);
	}
	-(TSRect)getScissor {
		Tellusim::Rect ret = [self ref].getScissor();
		return *(TSRect*)&ret;
	}
	-(void)clearTransform {
		[self ref].clearTransform();
	}
	-(void)setTransform: (TSMatrix4x4f)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x4f*)&transform);
	}
	-(void)setTransform_: (TSMatrix4x4f)transform {
		[self ref].setTransform(*(Tellusim::Matrix4x4f*)&transform);
	}
	-(TSMatrix4x4f)getTransform {
		Tellusim::Matrix4x4f ret = [self ref].getTransform();
		return *(TSMatrix4x4f*)&ret;
	}
	-(uint32_t)setParent: (TSCanvas*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(uint32_t)setParent_: (TSCanvas*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(const TSCanvas*)getParent {
		return [[TSCanvas alloc] init_ref:([self ref].getParent())];
	}
	-(uint32_t)addChild: (TSCanvas*)child {
		return [self ref].addChild([child ref]);
	}
	-(uint32_t)addChild_: (TSCanvas*)child {
		return [self ref].addChild([child ref]);
	}
	-(BOOL)removeChild: (TSCanvas*)child {
		return [self ref].removeChild([child ref]);
	}
	-(BOOL)removeChild_: (TSCanvas*)child {
		return [self ref].removeChild([child ref]);
	}
	-(BOOL)raiseChild: (TSCanvas*)child {
		return [self ref].raiseChild([child ref]);
	}
	-(BOOL)raiseChild_: (TSCanvas*)child {
		return [self ref].raiseChild([child ref]);
	}
	-(BOOL)lowerChild: (TSCanvas*)child {
		return [self ref].lowerChild([child ref]);
	}
	-(BOOL)lowerChild_: (TSCanvas*)child {
		return [self ref].lowerChild([child ref]);
	}
	-(void)releaseChildren {
		[self ref].releaseChildren();
	}
	-(uint32_t)findChild: (const TSCanvas*)child {
		return [self ref].findChild([child ref]);
	}
	-(uint32_t)findChild_: (const TSCanvas*)child {
		return [self ref].findChild([child ref]);
	}
	-(BOOL)isChild: (const TSCanvas*)child {
		return [self ref].isChild([child ref]);
	}
	-(BOOL)isChild_: (const TSCanvas*)child {
		return [self ref].isChild([child ref]);
	}
	-(uint32_t)getNumChildren {
		return [self ref].getNumChildren();
	}
	-(NSArray<TSCanvas*>*)getChildren {
		const auto &ret = [self ref].getChildren();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSCanvas alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSCanvas*)getChild: (uint32_t)index {
		return [[TSCanvas alloc] init_ref:([self ref].getChild(index))];
	}
	-(const TSCanvas*)getChild_: (uint32_t)index {
		return [[TSCanvas alloc] init_ref:([self ref].getChild(index))];
	}
	-(uint32_t)addElement: (TSCanvasElement*)element {
		return [self ref].addElement([element ref]);
	}
	-(uint32_t)addElement_: (TSCanvasElement*)element {
		return [self ref].addElement([element ref]);
	}
	-(BOOL)removeElement: (TSCanvasElement*)element {
		return [self ref].removeElement([element ref]);
	}
	-(BOOL)removeElement_: (TSCanvasElement*)element {
		return [self ref].removeElement([element ref]);
	}
	-(BOOL)raiseElement: (TSCanvasElement*)element {
		return [self ref].raiseElement([element ref]);
	}
	-(BOOL)raiseElement_: (TSCanvasElement*)element {
		return [self ref].raiseElement([element ref]);
	}
	-(BOOL)lowerElement: (TSCanvasElement*)element {
		return [self ref].lowerElement([element ref]);
	}
	-(BOOL)lowerElement_: (TSCanvasElement*)element {
		return [self ref].lowerElement([element ref]);
	}
	-(uint32_t)findElement: (const TSCanvasElement*)element {
		return [self ref].findElement([element ref]);
	}
	-(uint32_t)findElement_: (const TSCanvasElement*)element {
		return [self ref].findElement([element ref]);
	}
	-(BOOL)isElement: (const TSCanvasElement*)element {
		return [self ref].isElement([element ref]);
	}
	-(BOOL)isElement_: (const TSCanvasElement*)element {
		return [self ref].isElement([element ref]);
	}
	-(uint32_t)getNumElements {
		return [self ref].getNumElements();
	}
	-(NSArray<TSCanvasElement*>*)getElements {
		const auto &ret = [self ref].getElements();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSCanvasElement alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSCanvasElement*)getElement: (uint32_t)index {
		return [[TSCanvasElement alloc] init_ref:([self ref].getElement(index))];
	}
	-(const TSCanvasElement*)getElement_: (uint32_t)index {
		return [[TSCanvasElement alloc] init_ref:([self ref].getElement(index))];
	}
	-(BOOL)isFont: (const char*)name {
		return [self ref].isFont(name);
	}
	-(BOOL)isFont_: (const char*)name {
		return [self ref].isFont(name);
	}
	-(BOOL)addFont: (const char*)name stream: (TSStream*)stream {
		return [self ref].addFont(name, [stream ref]);
	}
	-(BOOL)addFont_: (const char*)name stream: (TSStream*)stream {
		return [self ref].addFont(name, [stream ref]);
	}
	-(BOOL)addFont_1: (const char*)name blob: (const uint8_t(*)[256])blob {
		return [self ref].addFont(name, blob);
	}
	-(BOOL)addFont_1_: (const char*)name blob: (const uint8_t(*)[256])blob {
		return [self ref].addFont(name, blob);
	}
	-(void)removeFont: (const char*)name {
		[self ref].removeFont(name);
	}
	-(void)removeFont_: (const char*)name {
		[self ref].removeFont(name);
	}
	-(TSFont*)getFont: (const char*)name {
		return [[TSFont alloc] init_ref:([self ref].getFont(name))];
	}
	-(TSFont*)getFont_: (const char*)name {
		return [[TSFont alloc] init_ref:([self ref].getFont(name))];
	}
	-(BOOL)isTexture: (const char*)name {
		return [self ref].isTexture(name);
	}
	-(BOOL)isTexture_: (const char*)name {
		return [self ref].isTexture(name);
	}
	-(BOOL)addTexture: (const char*)name stream: (TSStream*)stream {
		return [self ref].addTexture(name, [stream ref]);
	}
	-(BOOL)addTexture_: (const char*)name stream: (TSStream*)stream {
		return [self ref].addTexture(name, [stream ref]);
	}
	-(BOOL)addTexture_1: (const char*)name texture: (TSTexture*)texture {
		return [self ref].addTexture(name, [texture ref]);
	}
	-(BOOL)addTexture_1_: (const char*)name texture: (TSTexture*)texture {
		return [self ref].addTexture(name, [texture ref]);
	}
	-(BOOL)addTexture_2: (const char*)name blob: (const uint8_t(*)[256])blob {
		return [self ref].addTexture(name, blob);
	}
	-(BOOL)addTexture_2_: (const char*)name blob: (const uint8_t(*)[256])blob {
		return [self ref].addTexture(name, blob);
	}
	-(void)removeTexture: (const char*)name {
		[self ref].removeTexture(name);
	}
	-(void)removeTexture_: (const char*)name {
		[self ref].removeTexture(name);
	}
	-(TSTexture*)getTexture: (const char*)name {
		return [[TSTexture alloc] init_ref:([self ref].getTexture(name))];
	}
	-(TSTexture*)getTexture_: (const char*)name {
		return [[TSTexture alloc] init_ref:([self ref].getTexture(name))];
	}
	-(void)setDepthMask: (TS_PipelineDepthMask)mask {
		[self ref].setDepthMask((Tellusim::Pipeline::DepthMask)mask);
	}
	-(void)setDepthMask_: (TS_PipelineDepthMask)mask {
		[self ref].setDepthMask((Tellusim::Pipeline::DepthMask)mask);
	}
	-(TS_PipelineDepthMask)getDepthMask {
		return (TS_PipelineDepthMask)[self ref].getDepthMask();
	}
	-(void)setDepthFunc: (TS_PipelineDepthFunc)func {
		[self ref].setDepthFunc((Tellusim::Pipeline::DepthFunc)func);
	}
	-(void)setDepthFunc_: (TS_PipelineDepthFunc)func {
		[self ref].setDepthFunc((Tellusim::Pipeline::DepthFunc)func);
	}
	-(TS_PipelineDepthFunc)getDepthFunc {
		return (TS_PipelineDepthFunc)[self ref].getDepthFunc();
	}
	-(void)draw: (TSCommand*)command target: (const TSTarget*)target {
		[self ref].draw([command ref], [target ref]);
	}
	-(void)draw_: (TSCommand*)command target: (const TSTarget*)target {
		[self ref].draw([command ref], [target ref]);
	}
	-(void)draw_1: (TSCommand*)command {
		[self ref].draw([command ref]);
	}
	-(void)draw_1_: (TSCommand*)command {
		[self ref].draw([command ref]);
	}
	-(void)setCreateCallback: (id<TSCanvasCreateCallback>)func {
		[self ref].setCreateCallback(Tellusim::makeTSCanvasCreateCallback(func));
	}
	-(void)setCreateCallback_: (id<TSCanvasCreateCallback>)func {
		[self ref].setCreateCallback(Tellusim::makeTSCanvasCreateCallback(func));
	}
	-(void)setPipelineCallback: (id<TSCanvasPipelineCallback>)func {
		[self ref].setPipelineCallback(Tellusim::makeTSCanvasPipelineCallback(func));
	}
	-(void)setPipelineCallback_: (id<TSCanvasPipelineCallback>)func {
		[self ref].setPipelineCallback(Tellusim::makeTSCanvasPipelineCallback(func));
	}
	-(void)setBeginCallback: (id<TSCanvasBeginCallback>)func {
		[self ref].setBeginCallback(Tellusim::makeTSCanvasBeginCallback(func));
	}
	-(void)setBeginCallback_: (id<TSCanvasBeginCallback>)func {
		[self ref].setBeginCallback(Tellusim::makeTSCanvasBeginCallback(func));
	}
	-(void)setDrawCallback: (id<TSCanvasDrawCallback>)func {
		[self ref].setDrawCallback(Tellusim::makeTSCanvasDrawCallback(func));
	}
	-(void)setDrawCallback_: (id<TSCanvasDrawCallback>)func {
		[self ref].setDrawCallback(Tellusim::makeTSCanvasDrawCallback(func));
	}
	-(uint32_t)getNumDrawPipelines {
		return [self ref].getNumDrawPipelines();
	}
	-(uint32_t)getNumDrawElements {
		return [self ref].getNumDrawElements();
	}
	-(uint32_t)getNumDrawCommands {
		return [self ref].getNumDrawCommands();
	}
	-(TSRect)getRect {
		Tellusim::Rect ret = [self ref].getRect();
		return *(TSRect*)&ret;
	}
@end

// Tellusim::Control
@implementation TSControl
	-(id)init {
		self = [super init];
		impl = new Tellusim::Control();
		return self;
	}
	-(id)init_1: (TSControl*)parent {
		self = [super init];
		impl = new Tellusim::Control([parent pointer]);
		return self;
	}
	-(id)init_1_: (TSControl*)parent {
		self = [super init];
		impl = new Tellusim::Control([parent pointer]);
		return self;
	}
	-(id)init_2: (TSControl*)parent width: (float32_t)width {
		self = [super init];
		impl = new Tellusim::Control([parent pointer], width);
		return self;
	}
	-(id)init_2_: (TSControl*)parent width: (float32_t)width {
		self = [super init];
		impl = new Tellusim::Control([parent pointer], width);
		return self;
	}
	-(id)init_3: (TSControl*)parent width: (float32_t)width height: (float32_t)height {
		self = [super init];
		impl = new Tellusim::Control([parent pointer], width, height);
		return self;
	}
	-(id)init_3_: (TSControl*)parent width: (float32_t)width height: (float32_t)height {
		self = [super init];
		impl = new Tellusim::Control([parent pointer], width, height);
		return self;
	}
	-(id)init_ptr: (Tellusim::Control*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Control&)ref {
		self = [super init];
		impl = new Tellusim::Control((Tellusim::Control&)ref);
		return self;
	}
	-(Tellusim::Control*)pointer {
		return (Tellusim::Control*)impl;
	}
	-(Tellusim::Control&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Control*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Control*)impl;
	}
	-(BOOL)equalPtr: (const TSControl*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControl*)copyPtr {
		return [[TSControl alloc] init_ref:[self ref]];
	}
	-(TSControl*)clonePtr {
		return [[TSControl alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControl*)null {
		return [[TSControl alloc] init_ptr:nullptr];
	}
	-(TS_ControlType)getType {
		return (TS_ControlType)[self ref].getType();
	}
	+(NSString*)getTypeName: (TS_ControlType)type {
		return [NSString stringWithUTF8String:Tellusim::Control::getTypeName((Tellusim::Control::Type)type)];
	}
	+(NSString*)getTypeName_: (TS_ControlType)type {
		return [NSString stringWithUTF8String:Tellusim::Control::getTypeName((Tellusim::Control::Type)type)];
	}
	-(NSString*)getTypeName_1 {
		return [NSString stringWithUTF8String:[self ref].getTypeName()];
	}
	-(BOOL)isUnknown {
		return [self ref].isUnknown();
	}
	-(BOOL)isRoot {
		return [self ref].isRoot();
	}
	-(BOOL)isText {
		return [self ref].isText();
	}
	-(BOOL)isRect {
		return [self ref].isRect();
	}
	-(BOOL)isGrid {
		return [self ref].isGrid();
	}
	-(BOOL)isGroup {
		return [self ref].isGroup();
	}
	-(BOOL)isPanel {
		return [self ref].isPanel();
	}
	-(BOOL)isDialog {
		return [self ref].isDialog();
	}
	-(BOOL)isWindow {
		return [self ref].isWindow();
	}
	-(BOOL)isCheck {
		return [self ref].isCheck();
	}
	-(BOOL)isCombo {
		return [self ref].isCombo();
	}
	-(BOOL)isButton {
		return [self ref].isButton();
	}
	-(BOOL)isSlider {
		return [self ref].isSlider();
	}
	-(BOOL)isScroll {
		return [self ref].isScroll();
	}
	-(BOOL)isSplit {
		return [self ref].isSplit();
	}
	-(BOOL)isArea {
		return [self ref].isArea();
	}
	-(BOOL)isTree {
		return [self ref].isTree();
	}
	-(BOOL)isEdit {
		return [self ref].isEdit();
	}
	-(void)setAlign: (TS_ControlAlign)align {
		[self ref].setAlign((Tellusim::Control::Align)align);
	}
	-(void)setAlign_: (TS_ControlAlign)align {
		[self ref].setAlign((Tellusim::Control::Align)align);
	}
	-(TS_ControlAlign)getAlign {
		return (TS_ControlAlign)[self ref].getAlign();
	}
	-(BOOL)hasAlign: (TS_ControlAlign)align {
		return [self ref].hasAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasAlign_: (TS_ControlAlign)align {
		return [self ref].hasAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasAligns: (TS_ControlAlign)aligns {
		return [self ref].hasAligns((Tellusim::Control::Align)aligns);
	}
	-(BOOL)hasAligns_: (TS_ControlAlign)aligns {
		return [self ref].hasAligns((Tellusim::Control::Align)aligns);
	}
	-(BOOL)isSpacer {
		return [self ref].isSpacer();
	}
	-(void)setEnabled: (BOOL)enabled {
		[self ref].setEnabled((bool)enabled);
	}
	-(void)setEnabled_: (BOOL)enabled {
		[self ref].setEnabled((bool)enabled);
	}
	-(BOOL)isEnabled {
		return [self ref].isEnabled();
	}
	-(BOOL)wasEnabled {
		return [self ref].wasEnabled();
	}
	-(BOOL)wasUpdated {
		return [self ref].wasUpdated();
	}
	-(void)setDisabled: (BOOL)disabled {
		[self ref].setDisabled((bool)disabled);
	}
	-(void)setDisabled_: (BOOL)disabled {
		[self ref].setDisabled((bool)disabled);
	}
	-(BOOL)isDisabled {
		return [self ref].isDisabled();
	}
	-(TSCanvas*)getCanvas {
		return [[TSCanvas alloc] init_ref:([self ref].getCanvas())];
	}
	-(const TSControlRoot*)getRoot {
		return [[TSControlRoot alloc] init_ref:([self ref].getRoot())];
	}
	-(const TSControlPanel*)getPanel {
		return [[TSControlPanel alloc] init_ref:([self ref].getPanel())];
	}
	-(uint32_t)setParent: (TSControl*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(uint32_t)setParent_: (TSControl*)parent {
		return [self ref].setParent([parent ref]);
	}
	-(const TSControl*)getParent {
		return [[TSControl alloc] init_ref:([self ref].getParent())];
	}
	-(BOOL)isParentEnabled {
		return [self ref].isParentEnabled();
	}
	-(BOOL)isParentDisabled {
		return [self ref].isParentDisabled();
	}
	-(uint32_t)addChild: (TSControl*)child {
		return [self ref].addChild([child ref]);
	}
	-(uint32_t)addChild_: (TSControl*)child {
		return [self ref].addChild([child ref]);
	}
	-(BOOL)removeChild: (TSControl*)child {
		return [self ref].removeChild([child ref]);
	}
	-(BOOL)removeChild_: (TSControl*)child {
		return [self ref].removeChild([child ref]);
	}
	-(BOOL)raiseChild: (TSControl*)child {
		return [self ref].raiseChild([child ref]);
	}
	-(BOOL)raiseChild_: (TSControl*)child {
		return [self ref].raiseChild([child ref]);
	}
	-(BOOL)lowerChild: (TSControl*)child {
		return [self ref].lowerChild([child ref]);
	}
	-(BOOL)lowerChild_: (TSControl*)child {
		return [self ref].lowerChild([child ref]);
	}
	-(void)releaseChildren {
		[self ref].releaseChildren();
	}
	-(uint32_t)findChild: (const TSControl*)child {
		return [self ref].findChild([child ref]);
	}
	-(uint32_t)findChild_: (const TSControl*)child {
		return [self ref].findChild([child ref]);
	}
	-(BOOL)isChild: (const TSControl*)child {
		return [self ref].isChild([child ref]);
	}
	-(BOOL)isChild_: (const TSControl*)child {
		return [self ref].isChild([child ref]);
	}
	-(uint32_t)getNumChildren {
		return [self ref].getNumChildren();
	}
	-(NSArray<TSControl*>*)getChildren {
		const auto &ret = [self ref].getChildren();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[[TSControl alloc] init_ref:ret[i]]];
		return [array copy];
	}
	-(const TSControl*)getChild: (uint32_t)index {
		return [[TSControl alloc] init_ref:([self ref].getChild(index))];
	}
	-(const TSControl*)getChild_: (uint32_t)index {
		return [[TSControl alloc] init_ref:([self ref].getChild(index))];
	}
	-(void)setSize: (TSVector2f)size {
		[self ref].setSize(*(Tellusim::Vector2f*)&size);
	}
	-(void)setSize_: (TSVector2f)size {
		[self ref].setSize(*(Tellusim::Vector2f*)&size);
	}
	-(void)setSize_1: (float32_t)width height: (float32_t)height {
		[self ref].setSize(width, height);
	}
	-(void)setSize_1_: (float32_t)width height: (float32_t)height {
		[self ref].setSize(width, height);
	}
	-(TSVector2f)getSize {
		Tellusim::Vector2f ret = [self ref].getSize();
		return *(TSVector2f*)&ret;
	}
	-(float32_t)getWidth {
		return [self ref].getWidth();
	}
	-(float32_t)getHeight {
		return [self ref].getHeight();
	}
	-(void)setPosition: (TSVector3f)position {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_: (TSVector3f)position {
		[self ref].setPosition(*(Tellusim::Vector3f*)&position);
	}
	-(void)setPosition_1: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_1_: (float32_t)x y: (float32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(x, y, z);
	}
	-(void)setPosition_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setPosition(x, y, z);
	}
	-(TSVector3f)getPosition {
		Tellusim::Vector3f ret = [self ref].getPosition();
		return *(TSVector3f*)&ret;
	}
	-(float32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(float32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(void)setOffset: (TSVector3f)offset {
		[self ref].setOffset(*(Tellusim::Vector3f*)&offset);
	}
	-(void)setOffset_: (TSVector3f)offset {
		[self ref].setOffset(*(Tellusim::Vector3f*)&offset);
	}
	-(void)setOffset_1: (float32_t)x y: (float32_t)y {
		[self ref].setOffset(x, y);
	}
	-(void)setOffset_1_: (float32_t)x y: (float32_t)y {
		[self ref].setOffset(x, y);
	}
	-(void)setOffset_2: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setOffset(x, y, z);
	}
	-(void)setOffset_2_: (float32_t)x y: (float32_t)y z: (float32_t)z {
		[self ref].setOffset(x, y, z);
	}
	-(TSVector3f)getOffset {
		Tellusim::Vector3f ret = [self ref].getOffset();
		return *(TSVector3f*)&ret;
	}
	-(float32_t)getOffsetX {
		return [self ref].getOffsetX();
	}
	-(float32_t)getOffsetY {
		return [self ref].getOffsetY();
	}
	-(void)setMargin: (float32_t)value {
		[self ref].setMargin(value);
	}
	-(void)setMargin_: (float32_t)value {
		[self ref].setMargin(value);
	}
	-(void)setMargin_1: (float32_t)horizontal vertical: (float32_t)vertical {
		[self ref].setMargin(horizontal, vertical);
	}
	-(void)setMargin_1_: (float32_t)horizontal vertical: (float32_t)vertical {
		[self ref].setMargin(horizontal, vertical);
	}
	-(void)setMargin_2: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setMargin(left, right, bottom, top);
	}
	-(void)setMargin_2_: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setMargin(left, right, bottom, top);
	}
	-(void)setMargin_3: (TSRect)margin {
		[self ref].setMargin(*(Tellusim::Rect*)&margin);
	}
	-(void)setMargin_3_: (TSRect)margin {
		[self ref].setMargin(*(Tellusim::Rect*)&margin);
	}
	-(TSRect)getMargin {
		Tellusim::Rect ret = [self ref].getMargin();
		return *(TSRect*)&ret;
	}
	-(TSRect)getRect {
		Tellusim::Rect ret = [self ref].getRect();
		return *(TSRect*)&ret;
	}
	-(TS_ControlState)getState {
		return (TS_ControlState)[self ref].getState();
	}
@end

// Tellusim::ControlRoot
@implementation TSControlRoot
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRoot();
		return self;
	}
	-(id)init_5: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRoot([canvas ref]);
		return self;
	}
	-(id)init_5_: (TSCanvas*)canvas {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRoot([canvas ref]);
		return self;
	}
	-(id)init_6: (TSCanvas*)canvas blob: (BOOL)blob {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRoot([canvas ref], (bool)blob);
		return self;
	}
	-(id)init_6_: (TSCanvas*)canvas blob: (BOOL)blob {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRoot([canvas ref], (bool)blob);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlRoot*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlRoot&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRoot((Tellusim::ControlRoot&)ref);
		return self;
	}
	-(Tellusim::ControlRoot*)pointer {
		return (Tellusim::ControlRoot*)impl;
	}
	-(Tellusim::ControlRoot&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlRoot*)impl;
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRoot([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlRoot*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlRoot*)copyPtr {
		return [[TSControlRoot alloc] init_ref:[self ref]];
	}
	-(TSControlRoot*)clonePtr {
		return [[TSControlRoot alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlRoot*)null {
		return [[TSControlRoot alloc] init_ptr:nullptr];
	}
	-(void)setViewport: (TSViewport)viewport {
		[self ref].setViewport(*(Tellusim::Viewport*)&viewport);
	}
	-(void)setViewport_: (TSViewport)viewport {
		[self ref].setViewport(*(Tellusim::Viewport*)&viewport);
	}
	-(void)setViewport_1: (uint32_t)width height: (uint32_t)height {
		[self ref].setViewport(width, height);
	}
	-(void)setViewport_1_: (uint32_t)width height: (uint32_t)height {
		[self ref].setViewport(width, height);
	}
	-(void)setViewport_2: (float32_t)width height: (float32_t)height {
		[self ref].setViewport(width, height);
	}
	-(void)setViewport_2_: (float32_t)width height: (float32_t)height {
		[self ref].setViewport(width, height);
	}
	-(TSViewport)getViewport {
		Tellusim::Viewport ret = [self ref].getViewport();
		return *(TSViewport*)&ret;
	}
	-(NSString*)getFontName {
		return [NSString stringWithUTF8String:[self ref].getFontName().get()];
	}
	-(void)setFontName: (const char*)name {
		[self ref].setFontName(name);
	}
	-(void)setFontName_: (const char*)name {
		[self ref].setFontName(name);
	}
	-(void)setFontName_1: (const TSString*)name {
		[self ref].setFontName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setFontName_1_: (const TSString*)name {
		[self ref].setFontName((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)setFontBlob: (const uint8_t(*)[256])blob {
		return [self ref].setFontBlob(blob);
	}
	-(BOOL)setFontBlob_: (const uint8_t(*)[256])blob {
		return [self ref].setFontBlob(blob);
	}
	-(BOOL)setFontBlob_1: (const uint8_t(*)[256])blob name: (const char*)name {
		return [self ref].setFontBlob(blob, name);
	}
	-(BOOL)setFontBlob_1_: (const uint8_t(*)[256])blob name: (const char*)name {
		return [self ref].setFontBlob(blob, name);
	}
	-(BOOL)setFontSize: (uint32_t)size {
		return [self ref].setFontSize(size);
	}
	-(BOOL)setFontSize_: (uint32_t)size {
		return [self ref].setFontSize(size);
	}
	-(BOOL)setFontSize_1: (uint32_t)size update: (BOOL)update {
		return [self ref].setFontSize(size, (bool)update);
	}
	-(BOOL)setFontSize_1_: (uint32_t)size update: (BOOL)update {
		return [self ref].setFontSize(size, (bool)update);
	}
	-(uint32_t)getFontSize {
		return [self ref].getFontSize();
	}
	-(BOOL)setFontScale: (uint32_t)scale {
		return [self ref].setFontScale(scale);
	}
	-(BOOL)setFontScale_: (uint32_t)scale {
		return [self ref].setFontScale(scale);
	}
	-(BOOL)setFontScale_1: (uint32_t)scale update: (BOOL)update {
		return [self ref].setFontScale(scale, (bool)update);
	}
	-(BOOL)setFontScale_1_: (uint32_t)scale update: (BOOL)update {
		return [self ref].setFontScale(scale, (bool)update);
	}
	-(uint32_t)getFontScale {
		return [self ref].getFontScale();
	}
	-(BOOL)setFontStyle: (TSFontStyle)style {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style);
	}
	-(BOOL)setFontStyle_: (TSFontStyle)style {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style);
	}
	-(BOOL)setFontStyle_1: (TSFontStyle)style update: (BOOL)update {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style, (bool)update);
	}
	-(BOOL)setFontStyle_1_: (TSFontStyle)style update: (BOOL)update {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style, (bool)update);
	}
	-(TSFontStyle)getFontStyle {
		Tellusim::FontStyle ret = [self ref].getFontStyle();
		return *(TSFontStyle*)&ret;
	}
	-(NSString*)getTextureName {
		return [NSString stringWithUTF8String:[self ref].getTextureName().get()];
	}
	-(BOOL)setTextureName: (const char*)name {
		return [self ref].setTextureName(name);
	}
	-(BOOL)setTextureName_: (const char*)name {
		return [self ref].setTextureName(name);
	}
	-(BOOL)setTextureName_1: (const char*)name width: (uint32_t)width {
		return [self ref].setTextureName(name, width);
	}
	-(BOOL)setTextureName_1_: (const char*)name width: (uint32_t)width {
		return [self ref].setTextureName(name, width);
	}
	-(BOOL)setTextureName_2: (const char*)name width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setTextureName(name, width, height);
	}
	-(BOOL)setTextureName_2_: (const char*)name width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setTextureName(name, width, height);
	}
	-(BOOL)setTextureName_3: (const char*)name width: (uint32_t)width height: (uint32_t)height border: (float32_t)border {
		return [self ref].setTextureName(name, width, height, border);
	}
	-(BOOL)setTextureName_3_: (const char*)name width: (uint32_t)width height: (uint32_t)height border: (float32_t)border {
		return [self ref].setTextureName(name, width, height, border);
	}
	-(BOOL)setTextureName_4: (const TSString*)name {
		return [self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)setTextureName_4_: (const TSString*)name {
		return [self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(BOOL)setTextureName_5: (const TSString*)name width: (uint32_t)width {
		return [self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, width);
	}
	-(BOOL)setTextureName_5_: (const TSString*)name width: (uint32_t)width {
		return [self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, width);
	}
	-(BOOL)setTextureName_6: (const TSString*)name width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, width, height);
	}
	-(BOOL)setTextureName_6_: (const TSString*)name width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, width, height);
	}
	-(BOOL)setTextureName_7: (const TSString*)name width: (uint32_t)width height: (uint32_t)height border: (float32_t)border {
		return [self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, width, height, border);
	}
	-(BOOL)setTextureName_7_: (const TSString*)name width: (uint32_t)width height: (uint32_t)height border: (float32_t)border {
		return [self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, width, height, border);
	}
	-(BOOL)setTextureBlob: (const uint8_t(*)[256])blob {
		return [self ref].setTextureBlob(blob);
	}
	-(BOOL)setTextureBlob_: (const uint8_t(*)[256])blob {
		return [self ref].setTextureBlob(blob);
	}
	-(BOOL)setTextureBlob_1: (const uint8_t(*)[256])blob name: (const char*)name {
		return [self ref].setTextureBlob(blob, name);
	}
	-(BOOL)setTextureBlob_1_: (const uint8_t(*)[256])blob name: (const char*)name {
		return [self ref].setTextureBlob(blob, name);
	}
	-(BOOL)setTextureBlob_2: (const uint8_t(*)[256])blob name: (const char*)name width: (uint32_t)width {
		return [self ref].setTextureBlob(blob, name, width);
	}
	-(BOOL)setTextureBlob_2_: (const uint8_t(*)[256])blob name: (const char*)name width: (uint32_t)width {
		return [self ref].setTextureBlob(blob, name, width);
	}
	-(BOOL)setTextureBlob_3: (const uint8_t(*)[256])blob name: (const char*)name width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setTextureBlob(blob, name, width, height);
	}
	-(BOOL)setTextureBlob_3_: (const uint8_t(*)[256])blob name: (const char*)name width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setTextureBlob(blob, name, width, height);
	}
	-(BOOL)setTextureBlob_4: (const uint8_t(*)[256])blob name: (const char*)name width: (uint32_t)width height: (uint32_t)height border: (float32_t)border {
		return [self ref].setTextureBlob(blob, name, width, height, border);
	}
	-(BOOL)setTextureBlob_4_: (const uint8_t(*)[256])blob name: (const char*)name width: (uint32_t)width height: (uint32_t)height border: (float32_t)border {
		return [self ref].setTextureBlob(blob, name, width, height, border);
	}
	-(float32_t)getTextureWidth {
		return [self ref].getTextureWidth();
	}
	-(float32_t)getTextureHeight {
		return [self ref].getTextureHeight();
	}
	-(void)setTextColor: (TS_ControlType)type state: (TS_ControlState)state color: (TSColor)color {
		[self ref].setTextColor((Tellusim::Control::Type)type, (Tellusim::Control::State)state, *(Tellusim::Color*)&color);
	}
	-(void)setTextColor_: (TS_ControlType)type state: (TS_ControlState)state color: (TSColor)color {
		[self ref].setTextColor((Tellusim::Control::Type)type, (Tellusim::Control::State)state, *(Tellusim::Color*)&color);
	}
	-(void)setTextOffset: (TS_ControlType)type state: (TS_ControlState)state offset: (TSVector3f)offset {
		[self ref].setTextOffset((Tellusim::Control::Type)type, (Tellusim::Control::State)state, *(Tellusim::Vector3f*)&offset);
	}
	-(void)setTextOffset_: (TS_ControlType)type state: (TS_ControlState)state offset: (TSVector3f)offset {
		[self ref].setTextOffset((Tellusim::Control::Type)type, (Tellusim::Control::State)state, *(Tellusim::Vector3f*)&offset);
	}
	-(TSColor)getTextColor: (TS_ControlType)type state: (TS_ControlState)state {
		Tellusim::Color ret = [self ref].getTextColor((Tellusim::Control::Type)type, (Tellusim::Control::State)state);
		return *(TSColor*)&ret;
	}
	-(TSColor)getTextColor_: (TS_ControlType)type state: (TS_ControlState)state {
		Tellusim::Color ret = [self ref].getTextColor((Tellusim::Control::Type)type, (Tellusim::Control::State)state);
		return *(TSColor*)&ret;
	}
	-(TSVector3f)getTextOffset: (TS_ControlType)type state: (TS_ControlState)state {
		Tellusim::Vector3f ret = [self ref].getTextOffset((Tellusim::Control::Type)type, (Tellusim::Control::State)state);
		return *(TSVector3f*)&ret;
	}
	-(TSVector3f)getTextOffset_: (TS_ControlType)type state: (TS_ControlState)state {
		Tellusim::Vector3f ret = [self ref].getTextOffset((Tellusim::Control::Type)type, (Tellusim::Control::State)state);
		return *(TSVector3f*)&ret;
	}
	-(void)setMeshColor: (TS_ControlMesh)mesh state: (TS_ControlState)state color: (TSColor)color {
		[self ref].setMeshColor((Tellusim::Control::Mesh)mesh, (Tellusim::Control::State)state, *(Tellusim::Color*)&color);
	}
	-(void)setMeshColor_: (TS_ControlMesh)mesh state: (TS_ControlState)state color: (TSColor)color {
		[self ref].setMeshColor((Tellusim::Control::Mesh)mesh, (Tellusim::Control::State)state, *(Tellusim::Color*)&color);
	}
	-(void)setMeshRegion: (TS_ControlMesh)mesh grid: (TSRect)grid region: (TSRect)region border: (TSVector2f)border {
		[self ref].setMeshRegion((Tellusim::Control::Mesh)mesh, *(Tellusim::Rect*)&grid, *(Tellusim::Rect*)&region, *(Tellusim::Vector2f*)&border);
	}
	-(void)setMeshRegion_: (TS_ControlMesh)mesh grid: (TSRect)grid region: (TSRect)region border: (TSVector2f)border {
		[self ref].setMeshRegion((Tellusim::Control::Mesh)mesh, *(Tellusim::Rect*)&grid, *(Tellusim::Rect*)&region, *(Tellusim::Vector2f*)&border);
	}
	-(void)setMeshRegions: (TS_ControlMesh)mesh grid: (TSRect)grid regions: (TSRect)regions border: (TSVector2f)border {
		[self ref].setMeshRegions((Tellusim::Control::Mesh)mesh, *(Tellusim::Rect*)&grid, *(Tellusim::Rect*)&regions, *(Tellusim::Vector2f*)&border);
	}
	-(void)setMeshRegions_: (TS_ControlMesh)mesh grid: (TSRect)grid regions: (TSRect)regions border: (TSVector2f)border {
		[self ref].setMeshRegions((Tellusim::Control::Mesh)mesh, *(Tellusim::Rect*)&grid, *(Tellusim::Rect*)&regions, *(Tellusim::Vector2f*)&border);
	}
	-(uint32_t)getMeshColor: (TS_ControlMesh)mesh state: (TS_ControlState)state {
		return [self ref].getMeshColor((Tellusim::Control::Mesh)mesh, (Tellusim::Control::State)state);
	}
	-(uint32_t)getMeshColor_: (TS_ControlMesh)mesh state: (TS_ControlState)state {
		return [self ref].getMeshColor((Tellusim::Control::Mesh)mesh, (Tellusim::Control::State)state);
	}
	-(TSRect)getMeshGrid: (TS_ControlMesh)mesh {
		Tellusim::Rect ret = [self ref].getMeshGrid((Tellusim::Control::Mesh)mesh);
		return *(TSRect*)&ret;
	}
	-(TSRect)getMeshGrid_: (TS_ControlMesh)mesh {
		Tellusim::Rect ret = [self ref].getMeshGrid((Tellusim::Control::Mesh)mesh);
		return *(TSRect*)&ret;
	}
	-(TSRect)getMeshMargin: (TS_ControlMesh)mesh {
		Tellusim::Rect ret = [self ref].getMeshMargin((Tellusim::Control::Mesh)mesh);
		return *(TSRect*)&ret;
	}
	-(TSRect)getMeshMargin_: (TS_ControlMesh)mesh {
		Tellusim::Rect ret = [self ref].getMeshMargin((Tellusim::Control::Mesh)mesh);
		return *(TSRect*)&ret;
	}
	-(TSRect)getMeshRegion: (TS_ControlMesh)mesh state: (TS_ControlState)state {
		Tellusim::Rect ret = [self ref].getMeshRegion((Tellusim::Control::Mesh)mesh, (Tellusim::Control::State)state);
		return *(TSRect*)&ret;
	}
	-(TSRect)getMeshRegion_: (TS_ControlMesh)mesh state: (TS_ControlState)state {
		Tellusim::Rect ret = [self ref].getMeshRegion((Tellusim::Control::Mesh)mesh, (Tellusim::Control::State)state);
		return *(TSRect*)&ret;
	}
	-(void)setGroupRadius: (float32_t)radius {
		[self ref].setGroupRadius(radius);
	}
	-(void)setGroupRadius_: (float32_t)radius {
		[self ref].setGroupRadius(radius);
	}
	-(void)setGroupColor: (TSColor)color {
		[self ref].setGroupColor(*(Tellusim::Color*)&color);
	}
	-(void)setGroupColor_: (TSColor)color {
		[self ref].setGroupColor(*(Tellusim::Color*)&color);
	}
	-(float32_t)getGroupRadius {
		return [self ref].getGroupRadius();
	}
	-(TSColor)getGroupColor {
		Tellusim::Color ret = [self ref].getGroupColor();
		return *(TSColor*)&ret;
	}
	-(void)setPanelRadius: (float32_t)radius {
		[self ref].setPanelRadius(radius);
	}
	-(void)setPanelRadius_: (float32_t)radius {
		[self ref].setPanelRadius(radius);
	}
	-(void)setPanelColor: (TSColor)color {
		[self ref].setPanelColor(*(Tellusim::Color*)&color);
	}
	-(void)setPanelColor_: (TSColor)color {
		[self ref].setPanelColor(*(Tellusim::Color*)&color);
	}
	-(float32_t)getPanelRadius {
		return [self ref].getPanelRadius();
	}
	-(TSColor)getPanelColor {
		Tellusim::Color ret = [self ref].getPanelColor();
		return *(TSColor*)&ret;
	}
	-(void)setCheckedColor: (TSColor)color {
		[self ref].setCheckedColor(*(Tellusim::Color*)&color);
	}
	-(void)setCheckedColor_: (TSColor)color {
		[self ref].setCheckedColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getCheckedColor {
		Tellusim::Color ret = [self ref].getCheckedColor();
		return *(TSColor*)&ret;
	}
	-(void)setMouse: (int32_t)x y: (int32_t)y buttons: (TS_ControlButton)buttons {
		[self ref].setMouse(x, y, (Tellusim::Control::Button)buttons);
	}
	-(void)setMouse_: (int32_t)x y: (int32_t)y buttons: (TS_ControlButton)buttons {
		[self ref].setMouse(x, y, (Tellusim::Control::Button)buttons);
	}
	-(void)setMouse_1: (float32_t)x y: (float32_t)y buttons: (TS_ControlButton)buttons {
		[self ref].setMouse(x, y, (Tellusim::Control::Button)buttons);
	}
	-(void)setMouse_1_: (float32_t)x y: (float32_t)y buttons: (TS_ControlButton)buttons {
		[self ref].setMouse(x, y, (Tellusim::Control::Button)buttons);
	}
	-(TSVector2f)getMouse {
		Tellusim::Vector2f ret = [self ref].getMouse();
		return *(TSVector2f*)&ret;
	}
	-(TS_ControlButton)getMouseButtons {
		return (TS_ControlButton)[self ref].getMouseButtons();
	}
	-(float32_t)getMouseX {
		return [self ref].getMouseX();
	}
	-(float32_t)getMouseY {
		return [self ref].getMouseY();
	}
	-(void)setMouseAxis: (TS_ControlAxis)axis delta: (float32_t)delta {
		[self ref].setMouseAxis((Tellusim::Control::Axis)axis, delta);
	}
	-(void)setMouseAxis_: (TS_ControlAxis)axis delta: (float32_t)delta {
		[self ref].setMouseAxis((Tellusim::Control::Axis)axis, delta);
	}
	-(void)setMouseAlign: (TS_ControlAlign)align {
		[self ref].setMouseAlign((Tellusim::Control::Align)align);
	}
	-(void)setMouseAlign_: (TS_ControlAlign)align {
		[self ref].setMouseAlign((Tellusim::Control::Align)align);
	}
	-(void)setMouseAlign_1: (TS_ControlAlign)align clear: (BOOL)clear {
		[self ref].setMouseAlign((Tellusim::Control::Align)align, (bool)clear);
	}
	-(void)setMouseAlign_1_: (TS_ControlAlign)align clear: (BOOL)clear {
		[self ref].setMouseAlign((Tellusim::Control::Align)align, (bool)clear);
	}
	-(TS_ControlAlign)getMouseAlign {
		return (TS_ControlAlign)[self ref].getMouseAlign();
	}
	-(BOOL)hasMouseAlign: (TS_ControlAlign)align {
		return [self ref].hasMouseAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasMouseAlign_: (TS_ControlAlign)align {
		return [self ref].hasMouseAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasMouseAligns: (TS_ControlAlign)aligns {
		return [self ref].hasMouseAligns((Tellusim::Control::Align)aligns);
	}
	-(BOOL)hasMouseAligns_: (TS_ControlAlign)aligns {
		return [self ref].hasMouseAligns((Tellusim::Control::Align)aligns);
	}
	-(BOOL)setKeyboardKey: (uint32_t)key code: (uint32_t)code value: (BOOL)value {
		return [self ref].setKeyboardKey(key, code, (bool)value);
	}
	-(BOOL)setKeyboardKey_: (uint32_t)key code: (uint32_t)code value: (BOOL)value {
		return [self ref].setKeyboardKey(key, code, (bool)value);
	}
	-(BOOL)getKeyboardKey: (uint32_t)key {
		return [self ref].getKeyboardKey(key);
	}
	-(BOOL)getKeyboardKey_: (uint32_t)key {
		return [self ref].getKeyboardKey(key);
	}
	-(BOOL)getKeyboardKey_1: (uint32_t)key clear: (BOOL)clear {
		return [self ref].getKeyboardKey(key, (bool)clear);
	}
	-(BOOL)getKeyboardKey_1_: (uint32_t)key clear: (BOOL)clear {
		return [self ref].getKeyboardKey(key, (bool)clear);
	}
	-(void)clearCurrentControl {
		[self ref].clearCurrentControl();
	}
	-(void)setCurrentControl: (TSControl*)control {
		[self ref].setCurrentControl([control ref]);
	}
	-(void)setCurrentControl_: (TSControl*)control {
		[self ref].setCurrentControl([control ref]);
	}
	-(void)setCurrentControl_1: (TSControl*)control grab: (BOOL)grab {
		[self ref].setCurrentControl([control ref], (bool)grab);
	}
	-(void)setCurrentControl_1_: (TSControl*)control grab: (BOOL)grab {
		[self ref].setCurrentControl([control ref], (bool)grab);
	}
	-(TSControl*)getCurrentControl {
		return [[TSControl alloc] init_ref:([self ref].getCurrentControl())];
	}
	-(BOOL)getControlGrab {
		return [self ref].getControlGrab();
	}
	-(void)clearFocusedControl {
		[self ref].clearFocusedControl();
	}
	-(void)setFocusedControl: (TSControl*)control {
		[self ref].setFocusedControl([control ref]);
	}
	-(void)setFocusedControl_: (TSControl*)control {
		[self ref].setFocusedControl([control ref]);
	}
	-(TSControl*)getFocusedControl {
		return [[TSControl alloc] init_ref:([self ref].getFocusedControl())];
	}
	-(BOOL)isFocusedControl {
		return [self ref].isFocusedControl();
	}
	-(void)clearMouseControl {
		[self ref].clearMouseControl();
	}
	-(void)setMouseControl: (TSControl*)control {
		[self ref].setMouseControl([control ref]);
	}
	-(void)setMouseControl_: (TSControl*)control {
		[self ref].setMouseControl([control ref]);
	}
	-(TSControl*)getMouseControl {
		return [[TSControl alloc] init_ref:([self ref].getMouseControl())];
	}
	-(BOOL)isMouseControl {
		return [self ref].isMouseControl();
	}
	-(void)clearInputControl {
		[self ref].clearInputControl();
	}
	-(void)setInputControl: (TSControl*)control {
		[self ref].setInputControl([control ref]);
	}
	-(void)setInputControl_: (TSControl*)control {
		[self ref].setInputControl([control ref]);
	}
	-(TSControl*)getInputControl {
		return [[TSControl alloc] init_ref:([self ref].getInputControl())];
	}
	-(BOOL)isInputControl {
		return [self ref].isInputControl();
	}
	-(void)clearModalControl {
		[self ref].clearModalControl();
	}
	-(void)setModalControl: (TSControl*)control {
		[self ref].setModalControl([control ref]);
	}
	-(void)setModalControl_: (TSControl*)control {
		[self ref].setModalControl([control ref]);
	}
	-(TSControl*)getModalControl {
		return [[TSControl alloc] init_ref:([self ref].getModalControl())];
	}
	-(BOOL)isModalControl {
		return [self ref].isModalControl();
	}
	-(BOOL)update {
		return [self ref].update();
	}
	-(BOOL)update_1: (uint32_t)scale {
		return [self ref].update(scale);
	}
	-(BOOL)update_1_: (uint32_t)scale {
		return [self ref].update(scale);
	}
	-(BOOL)update_2: (uint32_t)scale order: (int32_t)order {
		return [self ref].update(scale, order);
	}
	-(BOOL)update_2_: (uint32_t)scale order: (int32_t)order {
		return [self ref].update(scale, order);
	}
	-(void)setCopyText: (const char*)text {
		[self ref].setCopyText(text);
	}
	-(void)setCopyText_: (const char*)text {
		[self ref].setCopyText(text);
	}
	-(void)setCopyText_1: (const TSString*)text {
		[self ref].setCopyText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setCopyText_1_: (const TSString*)text {
		[self ref].setCopyText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getPasteText {
		return [NSString stringWithUTF8String:[self ref].getPasteText().get()];
	}
	-(void)setCopyCallback: (id<TSControlRootCopyCallback>)func {
		[self ref].setCopyCallback(Tellusim::makeTSControlRootCopyCallback(func));
	}
	-(void)setCopyCallback_: (id<TSControlRootCopyCallback>)func {
		[self ref].setCopyCallback(Tellusim::makeTSControlRootCopyCallback(func));
	}
	-(void)setPasteCallback: (id<TSControlRootPasteCallback>)func {
		[self ref].setPasteCallback(Tellusim::makeTSControlRootPasteCallback(func));
	}
	-(void)setPasteCallback_: (id<TSControlRootPasteCallback>)func {
		[self ref].setPasteCallback(Tellusim::makeTSControlRootPasteCallback(func));
	}
@end

// Tellusim::ControlText
@implementation TSControlText
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlText();
		return self;
	}
	-(id)init_5: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlText([parent pointer]);
		return self;
	}
	-(id)init_5_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlText([parent pointer]);
		return self;
	}
	-(id)init_6: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlText([parent pointer], text);
		return self;
	}
	-(id)init_6_: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlText([parent pointer], text);
		return self;
	}
	-(id)init_7: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlText([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_7_: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlText([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlText*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlText&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlText((Tellusim::ControlText&)ref);
		return self;
	}
	-(Tellusim::ControlText*)pointer {
		return (Tellusim::ControlText*)impl;
	}
	-(Tellusim::ControlText&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlText*)impl;
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlText([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlText*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlText*)copyPtr {
		return [[TSControlText alloc] init_ref:[self ref]];
	}
	-(TSControlText*)clonePtr {
		return [[TSControlText alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlText*)null {
		return [[TSControlText alloc] init_ptr:nullptr];
	}
	-(void)setMode: (TS_CanvasElementMode)mode {
		[self ref].setMode((Tellusim::CanvasElement::Mode)mode);
	}
	-(void)setMode_: (TS_CanvasElementMode)mode {
		[self ref].setMode((Tellusim::CanvasElement::Mode)mode);
	}
	-(TS_CanvasElementMode)getMode {
		return (TS_CanvasElementMode)[self ref].getMode();
	}
	-(void)setPipeline: (TSPipeline*)pipeline {
		[self ref].setPipeline([pipeline ref]);
	}
	-(void)setPipeline_: (TSPipeline*)pipeline {
		[self ref].setPipeline([pipeline ref]);
	}
	-(void)setPipeline_1: (TSPipeline*)pipeline func: (id<TSCanvasElementDrawCallback>)func {
		[self ref].setPipeline([pipeline ref], Tellusim::makeTSCanvasElementDrawCallback(func));
	}
	-(void)setPipeline_1_: (TSPipeline*)pipeline func: (id<TSCanvasElementDrawCallback>)func {
		[self ref].setPipeline([pipeline ref], Tellusim::makeTSCanvasElementDrawCallback(func));
	}
	-(TSPipeline*)getPipeline {
		return [[TSPipeline alloc] init_ref:([self ref].getPipeline())];
	}
	-(void)setColor: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_1: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setColor(r, g, b, a);
	}
	-(void)setColor_1_: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setColor(r, g, b, a);
	}
	-(TSColor)getColor {
		Tellusim::Color ret = [self ref].getColor();
		return *(TSColor*)&ret;
	}
	-(void)setFilter: (TS_SamplerFilter)filter {
		[self ref].setFilter((Tellusim::Sampler::Filter)filter);
	}
	-(void)setFilter_: (TS_SamplerFilter)filter {
		[self ref].setFilter((Tellusim::Sampler::Filter)filter);
	}
	-(TS_SamplerFilter)getFilter {
		return (TS_SamplerFilter)[self ref].getFilter();
	}
	-(void)setAnisotropy: (uint32_t)anisotropy {
		[self ref].setAnisotropy(anisotropy);
	}
	-(void)setAnisotropy_: (uint32_t)anisotropy {
		[self ref].setAnisotropy(anisotropy);
	}
	-(uint32_t)getAnisotropy {
		return [self ref].getAnisotropy();
	}
	-(void)setBlend: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlend_: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(TS_PipelineBlendOp)getBlendOp {
		return (TS_PipelineBlendOp)[self ref].getBlendOp();
	}
	-(TS_PipelineBlendFunc)getBlendSrcFunc {
		return (TS_PipelineBlendFunc)[self ref].getBlendSrcFunc();
	}
	-(TS_PipelineBlendFunc)getBlendDestFunc {
		return (TS_PipelineBlendFunc)[self ref].getBlendDestFunc();
	}
	-(void)setFontName: (const char*)name {
		[self ref].setFontName(name);
	}
	-(void)setFontName_: (const char*)name {
		[self ref].setFontName(name);
	}
	-(void)setFontName_1: (const TSString*)name {
		[self ref].setFontName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setFontName_1_: (const TSString*)name {
		[self ref].setFontName((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getFontName {
		return [NSString stringWithUTF8String:[self ref].getFontName().get()];
	}
	-(void)setFontColor: (TSColor)color {
		[self ref].setFontColor(*(Tellusim::Color*)&color);
	}
	-(void)setFontColor_: (TSColor)color {
		[self ref].setFontColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getFontColor {
		Tellusim::Color ret = [self ref].getFontColor();
		return *(TSColor*)&ret;
	}
	-(BOOL)setFontSize: (uint32_t)size {
		return [self ref].setFontSize(size);
	}
	-(BOOL)setFontSize_: (uint32_t)size {
		return [self ref].setFontSize(size);
	}
	-(uint32_t)getFontSize {
		return [self ref].getFontSize();
	}
	-(BOOL)setFontStyle: (TSFontStyle)style {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style);
	}
	-(BOOL)setFontStyle_: (TSFontStyle)style {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style);
	}
	-(TSFontStyle)getFontStyleConst {
		Tellusim::FontStyle ret = [self ref].getFontStyleConst();
		return *(TSFontStyle*)&ret;
	}
	-(TSFontStyle)getFontStyle {
		Tellusim::FontStyle ret = [self ref].getFontStyle();
		return *(TSFontStyle*)&ret;
	}
	-(void)setFontAlign: (TS_ControlAlign)align {
		[self ref].setFontAlign((Tellusim::Control::Align)align);
	}
	-(void)setFontAlign_: (TS_ControlAlign)align {
		[self ref].setFontAlign((Tellusim::Control::Align)align);
	}
	-(TS_ControlAlign)getFontAlign {
		return (TS_ControlAlign)[self ref].getFontAlign();
	}
	-(BOOL)hasFontAlign: (TS_ControlAlign)align {
		return [self ref].hasFontAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasFontAlign_: (TS_ControlAlign)align {
		return [self ref].hasFontAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasFontAligns: (TS_ControlAlign)aligns {
		return [self ref].hasFontAligns((Tellusim::Control::Align)aligns);
	}
	-(BOOL)hasFontAligns_: (TS_ControlAlign)aligns {
		return [self ref].hasFontAligns((Tellusim::Control::Align)aligns);
	}
	-(void)setText: (const char*)text {
		[self ref].setText(text);
	}
	-(void)setText_: (const char*)text {
		[self ref].setText(text);
	}
	-(void)setText_1: (const TSString*)text {
		[self ref].setText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setText_1_: (const TSString*)text {
		[self ref].setText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getText {
		return [NSString stringWithUTF8String:[self ref].getText().get()];
	}
	-(TSCanvasText*)getCanvasText {
		return [[TSCanvasText alloc] init_ref:([self ref].getCanvasText())];
	}
@end

// Tellusim::ControlRect
@implementation TSControlRect
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect();
		return self;
	}
	-(id)init_5: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect([parent pointer]);
		return self;
	}
	-(id)init_5_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect([parent pointer]);
		return self;
	}
	-(id)init_6: (TSControl*)parent texture: (TSTexture*)texture {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect([parent pointer], [texture ref]);
		return self;
	}
	-(id)init_6_: (TSControl*)parent texture: (TSTexture*)texture {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect([parent pointer], [texture ref]);
		return self;
	}
	-(id)init_7: (TSControl*)parent name: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect([parent pointer], name);
		return self;
	}
	-(id)init_7_: (TSControl*)parent name: (const char*)name {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect([parent pointer], name);
		return self;
	}
	-(id)init_8: (TSControl*)parent mode: (TS_CanvasElementMode)mode {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect([parent pointer], (Tellusim::CanvasElement::Mode)mode);
		return self;
	}
	-(id)init_8_: (TSControl*)parent mode: (TS_CanvasElementMode)mode {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect([parent pointer], (Tellusim::CanvasElement::Mode)mode);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlRect*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlRect&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect((Tellusim::ControlRect&)ref);
		return self;
	}
	-(Tellusim::ControlRect*)pointer {
		return (Tellusim::ControlRect*)impl;
	}
	-(Tellusim::ControlRect&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlRect*)impl;
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlRect([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlRect*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlRect*)copyPtr {
		return [[TSControlRect alloc] init_ref:[self ref]];
	}
	-(TSControlRect*)clonePtr {
		return [[TSControlRect alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlRect*)null {
		return [[TSControlRect alloc] init_ptr:nullptr];
	}
	-(void)setCallback: (BOOL)callback {
		[self ref].setCallback((bool)callback);
	}
	-(void)setCallback_: (BOOL)callback {
		[self ref].setCallback((bool)callback);
	}
	-(BOOL)getCallback {
		return [self ref].getCallback();
	}
	-(void)setFullscreen: (BOOL)fullscreen {
		[self ref].setFullscreen((bool)fullscreen);
	}
	-(void)setFullscreen_: (BOOL)fullscreen {
		[self ref].setFullscreen((bool)fullscreen);
	}
	-(BOOL)isFullscreen {
		return [self ref].isFullscreen();
	}
	-(void)setMode: (TS_CanvasElementMode)mode {
		[self ref].setMode((Tellusim::CanvasElement::Mode)mode);
	}
	-(void)setMode_: (TS_CanvasElementMode)mode {
		[self ref].setMode((Tellusim::CanvasElement::Mode)mode);
	}
	-(TS_CanvasElementMode)getMode {
		return (TS_CanvasElementMode)[self ref].getMode();
	}
	-(void)setPipeline: (TSPipeline*)pipeline {
		[self ref].setPipeline([pipeline ref]);
	}
	-(void)setPipeline_: (TSPipeline*)pipeline {
		[self ref].setPipeline([pipeline ref]);
	}
	-(void)setPipeline_1: (TSPipeline*)pipeline func: (id<TSCanvasElementDrawCallback>)func {
		[self ref].setPipeline([pipeline ref], Tellusim::makeTSCanvasElementDrawCallback(func));
	}
	-(void)setPipeline_1_: (TSPipeline*)pipeline func: (id<TSCanvasElementDrawCallback>)func {
		[self ref].setPipeline([pipeline ref], Tellusim::makeTSCanvasElementDrawCallback(func));
	}
	-(TSPipeline*)getPipeline {
		return [[TSPipeline alloc] init_ref:([self ref].getPipeline())];
	}
	-(void)setRadius: (float32_t)radius {
		[self ref].setRadius(radius);
	}
	-(void)setRadius_: (float32_t)radius {
		[self ref].setRadius(radius);
	}
	-(float32_t)getRadius {
		return [self ref].getRadius();
	}
	-(void)setColor: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_1: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setColor(r, g, b, a);
	}
	-(void)setColor_1_: (float32_t)r g: (float32_t)g b: (float32_t)b a: (float32_t)a {
		[self ref].setColor(r, g, b, a);
	}
	-(TSColor)getColor {
		Tellusim::Color ret = [self ref].getColor();
		return *(TSColor*)&ret;
	}
	-(void)setStrokeStyle: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(void)setStrokeStyle_: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(TSStrokeStyle)getStrokeStyleConst {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyleConst();
		return *(TSStrokeStyle*)&ret;
	}
	-(TSStrokeStyle)getStrokeStyle {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyle();
		return *(TSStrokeStyle*)&ret;
	}
	-(void)setGradientStyle: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(void)setGradientStyle_: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(TSGradientStyle)getGradientStyleConst {
		Tellusim::GradientStyle ret = [self ref].getGradientStyleConst();
		return *(TSGradientStyle*)&ret;
	}
	-(TSGradientStyle)getGradientStyle {
		Tellusim::GradientStyle ret = [self ref].getGradientStyle();
		return *(TSGradientStyle*)&ret;
	}
	-(void)setMipmap: (float32_t)mipmap {
		[self ref].setMipmap(mipmap);
	}
	-(void)setMipmap_: (float32_t)mipmap {
		[self ref].setMipmap(mipmap);
	}
	-(float32_t)getMipmap {
		return [self ref].getMipmap();
	}
	-(void)setFilter: (TS_SamplerFilter)filter {
		[self ref].setFilter((Tellusim::Sampler::Filter)filter);
	}
	-(void)setFilter_: (TS_SamplerFilter)filter {
		[self ref].setFilter((Tellusim::Sampler::Filter)filter);
	}
	-(TS_SamplerFilter)getFilter {
		return (TS_SamplerFilter)[self ref].getFilter();
	}
	-(void)setAnisotropy: (uint32_t)anisotropy {
		[self ref].setAnisotropy(anisotropy);
	}
	-(void)setAnisotropy_: (uint32_t)anisotropy {
		[self ref].setAnisotropy(anisotropy);
	}
	-(uint32_t)getAnisotropy {
		return [self ref].getAnisotropy();
	}
	-(void)setWrapMode: (TS_SamplerWrapMode)mode {
		[self ref].setWrapMode((Tellusim::Sampler::WrapMode)mode);
	}
	-(void)setWrapMode_: (TS_SamplerWrapMode)mode {
		[self ref].setWrapMode((Tellusim::Sampler::WrapMode)mode);
	}
	-(TS_SamplerWrapMode)getWrapMode {
		return (TS_SamplerWrapMode)[self ref].getWrapMode();
	}
	-(void)setBlend: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(void)setBlend_: (TS_PipelineBlendOp)op src: (TS_PipelineBlendFunc)src dest: (TS_PipelineBlendFunc)dest {
		[self ref].setBlend((Tellusim::Pipeline::BlendOp)op, (Tellusim::Pipeline::BlendFunc)src, (Tellusim::Pipeline::BlendFunc)dest);
	}
	-(TS_PipelineBlendOp)getBlendOp {
		return (TS_PipelineBlendOp)[self ref].getBlendOp();
	}
	-(TS_PipelineBlendFunc)getBlendSrcFunc {
		return (TS_PipelineBlendFunc)[self ref].getBlendSrcFunc();
	}
	-(TS_PipelineBlendFunc)getBlendDestFunc {
		return (TS_PipelineBlendFunc)[self ref].getBlendDestFunc();
	}
	-(void)setTexture: (TSTexture*)texture {
		[self ref].setTexture([texture ref]);
	}
	-(void)setTexture_: (TSTexture*)texture {
		[self ref].setTexture([texture ref]);
	}
	-(void)setTexture_1: (TSTexture*)texture linear: (BOOL)linear {
		[self ref].setTexture([texture ref], (bool)linear);
	}
	-(void)setTexture_1_: (TSTexture*)texture linear: (BOOL)linear {
		[self ref].setTexture([texture ref], (bool)linear);
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(BOOL)getTextureLinear {
		return [self ref].getTextureLinear();
	}
	-(void)setTextureName: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_1: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setTextureName_1_: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getTextureName {
		return [NSString stringWithUTF8String:[self ref].getTextureName().get()];
	}
	-(void)setTextureScale: (float32_t)scale_x scale_y: (float32_t)scale_y {
		[self ref].setTextureScale(scale_x, scale_y);
	}
	-(void)setTextureScale_: (float32_t)scale_x scale_y: (float32_t)scale_y {
		[self ref].setTextureScale(scale_x, scale_y);
	}
	-(float32_t)getTextureScaleX {
		return [self ref].getTextureScaleX();
	}
	-(float32_t)getTextureScaleY {
		return [self ref].getTextureScaleY();
	}
	-(void)setTextureFlip: (BOOL)flip_x flip_y: (BOOL)flip_y {
		[self ref].setTextureFlip((bool)flip_x, (bool)flip_y);
	}
	-(void)setTextureFlip_: (BOOL)flip_x flip_y: (BOOL)flip_y {
		[self ref].setTextureFlip((bool)flip_x, (bool)flip_y);
	}
	-(BOOL)getTextureFlipX {
		return [self ref].getTextureFlipX();
	}
	-(BOOL)getTextureFlipY {
		return [self ref].getTextureFlipY();
	}
	-(void)setTextureProj: (BOOL)projection {
		[self ref].setTextureProj((bool)projection);
	}
	-(void)setTextureProj_: (BOOL)projection {
		[self ref].setTextureProj((bool)projection);
	}
	-(BOOL)getTextureProj {
		return [self ref].getTextureProj();
	}
	-(void)setTexCoord: (TSRect)texcoord {
		[self ref].setTexCoord(*(Tellusim::Rect*)&texcoord);
	}
	-(void)setTexCoord_: (TSRect)texcoord {
		[self ref].setTexCoord(*(Tellusim::Rect*)&texcoord);
	}
	-(void)setTexCoord_1: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setTexCoord(left, right, bottom, top);
	}
	-(void)setTexCoord_1_: (float32_t)left right: (float32_t)right bottom: (float32_t)bottom top: (float32_t)top {
		[self ref].setTexCoord(left, right, bottom, top);
	}
	-(TSRect)getTexCoord {
		Tellusim::Rect ret = [self ref].getTexCoord();
		return *(TSRect*)&ret;
	}
	-(void)setPressedCallback: (id<TSControlRectPressedCallback>)func {
		[self ref].setPressedCallback(Tellusim::makeTSControlRectPressedCallback(func));
	}
	-(void)setPressedCallback_: (id<TSControlRectPressedCallback>)func {
		[self ref].setPressedCallback(Tellusim::makeTSControlRectPressedCallback(func));
	}
	-(void)setReleasedCallback: (id<TSControlRectReleasedCallback>)func {
		[self ref].setReleasedCallback(Tellusim::makeTSControlRectReleasedCallback(func));
	}
	-(void)setReleasedCallback_: (id<TSControlRectReleasedCallback>)func {
		[self ref].setReleasedCallback(Tellusim::makeTSControlRectReleasedCallback(func));
	}
	-(void)setClickedCallback: (id<TSControlRectClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlRectClickedCallback(func));
	}
	-(void)setClickedCallback_: (id<TSControlRectClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlRectClickedCallback(func));
	}
	-(void)setClicked2Callback: (id<TSControlRectClickedCallback>)func {
		[self ref].setClicked2Callback(Tellusim::makeTSControlRectClickedCallback(func));
	}
	-(void)setClicked2Callback_: (id<TSControlRectClickedCallback>)func {
		[self ref].setClicked2Callback(Tellusim::makeTSControlRectClickedCallback(func));
	}
	-(void)setClickedRightCallback: (id<TSControlRectClickedCallback>)func {
		[self ref].setClickedRightCallback(Tellusim::makeTSControlRectClickedCallback(func));
	}
	-(void)setClickedRightCallback_: (id<TSControlRectClickedCallback>)func {
		[self ref].setClickedRightCallback(Tellusim::makeTSControlRectClickedCallback(func));
	}
	-(TSCanvasRect*)getCanvasRect {
		return [[TSCanvasRect alloc] init_ref:([self ref].getCanvasRect())];
	}
	-(TSCanvasMesh*)getCanvasMesh {
		return [[TSCanvasMesh alloc] init_ref:([self ref].getCanvasMesh())];
	}
@end

// Tellusim::ControlGrid
@implementation TSControlGrid
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid();
		return self;
	}
	-(id)init_5: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid([parent pointer]);
		return self;
	}
	-(id)init_5_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid([parent pointer]);
		return self;
	}
	-(id)init_6: (TSControl*)parent columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid([parent pointer], columns);
		return self;
	}
	-(id)init_6_: (TSControl*)parent columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid([parent pointer], columns);
		return self;
	}
	-(id)init_7: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid([parent pointer], columns, x);
		return self;
	}
	-(id)init_7_: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid([parent pointer], columns, x);
		return self;
	}
	-(id)init_8: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid([parent pointer], columns, x, y);
		return self;
	}
	-(id)init_8_: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid([parent pointer], columns, x, y);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlGrid*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlGrid&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid((Tellusim::ControlGrid&)ref);
		return self;
	}
	-(Tellusim::ControlGrid*)pointer {
		return (Tellusim::ControlGrid*)impl;
	}
	-(Tellusim::ControlGrid&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlGrid*)impl;
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGrid([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlGrid*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlGrid*)copyPtr {
		return [[TSControlGrid alloc] init_ref:[self ref]];
	}
	-(TSControlGrid*)clonePtr {
		return [[TSControlGrid alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlGrid*)null {
		return [[TSControlGrid alloc] init_ptr:nullptr];
	}
	-(void)setColumns: (uint32_t)columns {
		[self ref].setColumns(columns);
	}
	-(void)setColumns_: (uint32_t)columns {
		[self ref].setColumns(columns);
	}
	-(uint32_t)getColumns {
		return [self ref].getColumns();
	}
	-(void)setSpacing: (TSVector2f)spacing {
		[self ref].setSpacing(*(Tellusim::Vector2f*)&spacing);
	}
	-(void)setSpacing_: (TSVector2f)spacing {
		[self ref].setSpacing(*(Tellusim::Vector2f*)&spacing);
	}
	-(void)setSpacing_1: (float32_t)x y: (float32_t)y {
		[self ref].setSpacing(x, y);
	}
	-(void)setSpacing_1_: (float32_t)x y: (float32_t)y {
		[self ref].setSpacing(x, y);
	}
	-(TSVector2f)getSpacing {
		Tellusim::Vector2f ret = [self ref].getSpacing();
		return *(TSVector2f*)&ret;
	}
	-(void)setColumnRatio: (uint32_t)index ratio: (float32_t)ratio {
		[self ref].setColumnRatio(index, ratio);
	}
	-(void)setColumnRatio_: (uint32_t)index ratio: (float32_t)ratio {
		[self ref].setColumnRatio(index, ratio);
	}
	-(float32_t)getColumnRatio: (uint32_t)index {
		return [self ref].getColumnRatio(index);
	}
	-(float32_t)getColumnRatio_: (uint32_t)index {
		return [self ref].getColumnRatio(index);
	}
	-(TSVector2f)getControlsSize {
		Tellusim::Vector2f ret = [self ref].getControlsSize();
		return *(TSVector2f*)&ret;
	}
@end

// Tellusim::ControlGroup
@implementation TSControlGroup
	-(id)init_8 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup();
		return self;
	}
	-(id)init_9: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer]);
		return self;
	}
	-(id)init_9_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer]);
		return self;
	}
	-(id)init_10: (TSControl*)parent above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], (bool)above);
		return self;
	}
	-(id)init_10_: (TSControl*)parent above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], (bool)above);
		return self;
	}
	-(id)init_11: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text);
		return self;
	}
	-(id)init_11_: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text);
		return self;
	}
	-(id)init_12: (TSControl*)parent text: (const char*)text above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, (bool)above);
		return self;
	}
	-(id)init_12_: (TSControl*)parent text: (const char*)text above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, (bool)above);
		return self;
	}
	-(id)init_13: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_13_: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_14: (TSControl*)parent text: (const TSString*)text above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], (text) ? [text ref] : Tellusim::String::null, (bool)above);
		return self;
	}
	-(id)init_14_: (TSControl*)parent text: (const TSString*)text above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], (text) ? [text ref] : Tellusim::String::null, (bool)above);
		return self;
	}
	-(id)init_15: (TSControl*)parent text: (const char*)text columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, columns);
		return self;
	}
	-(id)init_15_: (TSControl*)parent text: (const char*)text columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, columns);
		return self;
	}
	-(id)init_16: (TSControl*)parent text: (const char*)text columns: (uint32_t)columns above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, columns, (bool)above);
		return self;
	}
	-(id)init_16_: (TSControl*)parent text: (const char*)text columns: (uint32_t)columns above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, columns, (bool)above);
		return self;
	}
	-(id)init_17: (TSControl*)parent text: (const char*)text columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, columns, x, y);
		return self;
	}
	-(id)init_17_: (TSControl*)parent text: (const char*)text columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, columns, x, y);
		return self;
	}
	-(id)init_18: (TSControl*)parent text: (const char*)text columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, columns, x, y, (bool)above);
		return self;
	}
	-(id)init_18_: (TSControl*)parent text: (const char*)text columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y above: (BOOL)above {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([parent pointer], text, columns, x, y, (bool)above);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlGroup*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlGroup&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup((Tellusim::ControlGroup&)ref);
		return self;
	}
	-(Tellusim::ControlGroup*)pointer {
		return (Tellusim::ControlGroup*)impl;
	}
	-(Tellusim::ControlGroup&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlGroup*)impl;
	}
	-(id)initControlText: (TSControlText*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([base ref]);
		return self;
	}
	-(TSControlText*)getControlText {
		return [[TSControlText alloc] init_ref:([self ref].getControlText())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlGroup([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlGroup*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlGroup*)copyPtr {
		return [[TSControlGroup alloc] init_ref:[self ref]];
	}
	-(TSControlGroup*)clonePtr {
		return [[TSControlGroup alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlGroup*)null {
		return [[TSControlGroup alloc] init_ptr:nullptr];
	}
	-(void)setAbove: (BOOL)above {
		[self ref].setAbove((bool)above);
	}
	-(void)setAbove_: (BOOL)above {
		[self ref].setAbove((bool)above);
	}
	-(void)setAbove_1: (BOOL)above text: (BOOL)text {
		[self ref].setAbove((bool)above, (bool)text);
	}
	-(void)setAbove_1_: (BOOL)above text: (BOOL)text {
		[self ref].setAbove((bool)above, (bool)text);
	}
	-(BOOL)isAbove {
		return [self ref].isAbove();
	}
	-(BOOL)isBelow {
		return [self ref].isBelow();
	}
	-(void)setFoldable: (BOOL)foldable {
		[self ref].setFoldable((bool)foldable);
	}
	-(void)setFoldable_: (BOOL)foldable {
		[self ref].setFoldable((bool)foldable);
	}
	-(BOOL)isFoldable {
		return [self ref].isFoldable();
	}
	-(void)setExpanded: (BOOL)expanded {
		[self ref].setExpanded((bool)expanded);
	}
	-(void)setExpanded_: (BOOL)expanded {
		[self ref].setExpanded((bool)expanded);
	}
	-(BOOL)isExpanded {
		return [self ref].isExpanded();
	}
	-(void)setBackground: (BOOL)background {
		[self ref].setBackground((bool)background);
	}
	-(void)setBackground_: (BOOL)background {
		[self ref].setBackground((bool)background);
	}
	-(BOOL)getBackground {
		return [self ref].getBackground();
	}
	-(void)setGroupRadius: (float32_t)radius {
		[self ref].setGroupRadius(radius);
	}
	-(void)setGroupRadius_: (float32_t)radius {
		[self ref].setGroupRadius(radius);
	}
	-(float32_t)getGroupRadius {
		return [self ref].getGroupRadius();
	}
	-(void)setGroupColor: (TSColor)color {
		[self ref].setGroupColor(*(Tellusim::Color*)&color);
	}
	-(void)setGroupColor_: (TSColor)color {
		[self ref].setGroupColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getGroupColor {
		Tellusim::Color ret = [self ref].getGroupColor();
		return *(TSColor*)&ret;
	}
	-(void)setStrokeStyle: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(void)setStrokeStyle_: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(TSStrokeStyle)getStrokeStyleConst {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyleConst();
		return *(TSStrokeStyle*)&ret;
	}
	-(TSStrokeStyle)getStrokeStyle {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyle();
		return *(TSStrokeStyle*)&ret;
	}
	-(void)setGradientStyle: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(void)setGradientStyle_: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(TSGradientStyle)getGradientStyleConst {
		Tellusim::GradientStyle ret = [self ref].getGradientStyleConst();
		return *(TSGradientStyle*)&ret;
	}
	-(TSGradientStyle)getGradientStyle {
		Tellusim::GradientStyle ret = [self ref].getGradientStyle();
		return *(TSGradientStyle*)&ret;
	}
	-(void)setFoldedText: (const char*)text {
		[self ref].setFoldedText(text);
	}
	-(void)setFoldedText_: (const char*)text {
		[self ref].setFoldedText(text);
	}
	-(void)setFoldedText_1: (const TSString*)text {
		[self ref].setFoldedText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setFoldedText_1_: (const TSString*)text {
		[self ref].setFoldedText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getFoldedText {
		return [NSString stringWithUTF8String:[self ref].getFoldedText().get()];
	}
	-(void)setExpandedText: (const char*)text {
		[self ref].setExpandedText(text);
	}
	-(void)setExpandedText_: (const char*)text {
		[self ref].setExpandedText(text);
	}
	-(void)setExpandedText_1: (const TSString*)text {
		[self ref].setExpandedText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setExpandedText_1_: (const TSString*)text {
		[self ref].setExpandedText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getExpandedText {
		return [NSString stringWithUTF8String:[self ref].getExpandedText().get()];
	}
	-(void)setColumns: (uint32_t)columns {
		[self ref].setColumns(columns);
	}
	-(void)setColumns_: (uint32_t)columns {
		[self ref].setColumns(columns);
	}
	-(uint32_t)getColumns {
		return [self ref].getColumns();
	}
	-(void)setSpacing: (TSVector2f)spacing {
		[self ref].setSpacing(*(Tellusim::Vector2f*)&spacing);
	}
	-(void)setSpacing_: (TSVector2f)spacing {
		[self ref].setSpacing(*(Tellusim::Vector2f*)&spacing);
	}
	-(void)setSpacing_1: (float32_t)x y: (float32_t)y {
		[self ref].setSpacing(x, y);
	}
	-(void)setSpacing_1_: (float32_t)x y: (float32_t)y {
		[self ref].setSpacing(x, y);
	}
	-(TSVector2f)getSpacing {
		Tellusim::Vector2f ret = [self ref].getSpacing();
		return *(TSVector2f*)&ret;
	}
	-(void)setColumnRatio: (uint32_t)index ratio: (float32_t)ratio {
		[self ref].setColumnRatio(index, ratio);
	}
	-(void)setColumnRatio_: (uint32_t)index ratio: (float32_t)ratio {
		[self ref].setColumnRatio(index, ratio);
	}
	-(float32_t)getColumnRatio: (uint32_t)index {
		return [self ref].getColumnRatio(index);
	}
	-(float32_t)getColumnRatio_: (uint32_t)index {
		return [self ref].getColumnRatio(index);
	}
	-(TSVector2f)getControlsSize {
		Tellusim::Vector2f ret = [self ref].getControlsSize();
		return *(TSVector2f*)&ret;
	}
	-(void)setClickedCallback: (id<TSControlGroupClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlGroupClickedCallback(func));
	}
	-(void)setClickedCallback_: (id<TSControlGroupClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlGroupClickedCallback(func));
	}
	-(BOOL)isClicked {
		return [self ref].isClicked();
	}
	-(TSCanvasRect*)getCanvasRect {
		return [[TSCanvasRect alloc] init_ref:([self ref].getCanvasRect())];
	}
@end

// Tellusim::ControlPanel
@implementation TSControlPanel
	-(id)init_9 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel();
		return self;
	}
	-(id)init_10: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel([parent pointer]);
		return self;
	}
	-(id)init_10_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel([parent pointer]);
		return self;
	}
	-(id)init_11: (TSControl*)parent columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel([parent pointer], columns);
		return self;
	}
	-(id)init_11_: (TSControl*)parent columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel([parent pointer], columns);
		return self;
	}
	-(id)init_12: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel([parent pointer], columns, x, y);
		return self;
	}
	-(id)init_12_: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel([parent pointer], columns, x, y);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlPanel*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlPanel&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel((Tellusim::ControlPanel&)ref);
		return self;
	}
	-(Tellusim::ControlPanel*)pointer {
		return (Tellusim::ControlPanel*)impl;
	}
	-(Tellusim::ControlPanel&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlPanel*)impl;
	}
	-(id)initControlRect: (TSControlRect*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel([base ref]);
		return self;
	}
	-(TSControlRect*)getControlRect {
		return [[TSControlRect alloc] init_ref:([self ref].getControlRect())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlPanel([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlPanel*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlPanel*)copyPtr {
		return [[TSControlPanel alloc] init_ref:[self ref]];
	}
	-(TSControlPanel*)clonePtr {
		return [[TSControlPanel alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlPanel*)null {
		return [[TSControlPanel alloc] init_ptr:nullptr];
	}
	-(void)setColumns: (uint32_t)columns {
		[self ref].setColumns(columns);
	}
	-(void)setColumns_: (uint32_t)columns {
		[self ref].setColumns(columns);
	}
	-(uint32_t)getColumns {
		return [self ref].getColumns();
	}
	-(void)setSpacing: (TSVector2f)spacing {
		[self ref].setSpacing(*(Tellusim::Vector2f*)&spacing);
	}
	-(void)setSpacing_: (TSVector2f)spacing {
		[self ref].setSpacing(*(Tellusim::Vector2f*)&spacing);
	}
	-(void)setSpacing_1: (float32_t)x y: (float32_t)y {
		[self ref].setSpacing(x, y);
	}
	-(void)setSpacing_1_: (float32_t)x y: (float32_t)y {
		[self ref].setSpacing(x, y);
	}
	-(TSVector2f)getSpacing {
		Tellusim::Vector2f ret = [self ref].getSpacing();
		return *(TSVector2f*)&ret;
	}
	-(void)setColumnRatio: (uint32_t)index ratio: (float32_t)ratio {
		[self ref].setColumnRatio(index, ratio);
	}
	-(void)setColumnRatio_: (uint32_t)index ratio: (float32_t)ratio {
		[self ref].setColumnRatio(index, ratio);
	}
	-(float32_t)getColumnRatio: (uint32_t)index {
		return [self ref].getColumnRatio(index);
	}
	-(float32_t)getColumnRatio_: (uint32_t)index {
		return [self ref].getColumnRatio(index);
	}
	-(TSVector2f)getControlsSize {
		Tellusim::Vector2f ret = [self ref].getControlsSize();
		return *(TSVector2f*)&ret;
	}
@end

// Tellusim::ControlDialog
@implementation TSControlDialog
	-(id)init_13 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog();
		return self;
	}
	-(id)init_14: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog([parent pointer]);
		return self;
	}
	-(id)init_14_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog([parent pointer]);
		return self;
	}
	-(id)init_15: (TSControl*)parent columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog([parent pointer], columns);
		return self;
	}
	-(id)init_15_: (TSControl*)parent columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog([parent pointer], columns);
		return self;
	}
	-(id)init_16: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog([parent pointer], columns, x, y);
		return self;
	}
	-(id)init_16_: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog([parent pointer], columns, x, y);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlDialog*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlDialog&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog((Tellusim::ControlDialog&)ref);
		return self;
	}
	-(Tellusim::ControlDialog*)pointer {
		return (Tellusim::ControlDialog*)impl;
	}
	-(Tellusim::ControlDialog&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlDialog*)impl;
	}
	-(id)initControlPanel: (TSControlPanel*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog([base ref]);
		return self;
	}
	-(TSControlPanel*)getControlPanel {
		return [[TSControlPanel alloc] init_ref:([self ref].getControlPanel())];
	}
	-(id)initControlRect: (TSControlRect*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog([base ref]);
		return self;
	}
	-(TSControlRect*)getControlRect {
		return [[TSControlRect alloc] init_ref:([self ref].getControlRect())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlDialog([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlDialog*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlDialog*)copyPtr {
		return [[TSControlDialog alloc] init_ref:[self ref]];
	}
	-(TSControlDialog*)clonePtr {
		return [[TSControlDialog alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlDialog*)null {
		return [[TSControlDialog alloc] init_ptr:nullptr];
	}
	-(void)setConstrained: (BOOL)contrained {
		[self ref].setConstrained((bool)contrained);
	}
	-(void)setConstrained_: (BOOL)contrained {
		[self ref].setConstrained((bool)contrained);
	}
	-(BOOL)isConstrained {
		return [self ref].isConstrained();
	}
	-(void)setResizable: (BOOL)resizable {
		[self ref].setResizable((bool)resizable);
	}
	-(void)setResizable_: (BOOL)resizable {
		[self ref].setResizable((bool)resizable);
	}
	-(BOOL)isResizable {
		return [self ref].isResizable();
	}
	-(void)setResizeArea: (float32_t)area {
		[self ref].setResizeArea(area);
	}
	-(void)setResizeArea_: (float32_t)area {
		[self ref].setResizeArea(area);
	}
	-(float32_t)getResizeArea {
		return [self ref].getResizeArea();
	}
	-(TS_ControlAlign)getResizeAlign {
		return (TS_ControlAlign)[self ref].getResizeAlign();
	}
	-(BOOL)hasResizeAlign: (TS_ControlAlign)align {
		return [self ref].hasResizeAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasResizeAlign_: (TS_ControlAlign)align {
		return [self ref].hasResizeAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasResizeAligns: (TS_ControlAlign)aligns {
		return [self ref].hasResizeAligns((Tellusim::Control::Align)aligns);
	}
	-(BOOL)hasResizeAligns_: (TS_ControlAlign)aligns {
		return [self ref].hasResizeAligns((Tellusim::Control::Align)aligns);
	}
	-(void)setMousePosition: (TSVector2f)position {
		[self ref].setMousePosition(*(Tellusim::Vector2f*)&position);
	}
	-(void)setMousePosition_: (TSVector2f)position {
		[self ref].setMousePosition(*(Tellusim::Vector2f*)&position);
	}
	-(TSVector2f)getMousePosition {
		Tellusim::Vector2f ret = [self ref].getMousePosition();
		return *(TSVector2f*)&ret;
	}
	-(void)setUpdatedCallback: (id<TSControlDialogUpdatedCallback>)func {
		[self ref].setUpdatedCallback(Tellusim::makeTSControlDialogUpdatedCallback(func));
	}
	-(void)setUpdatedCallback_: (id<TSControlDialogUpdatedCallback>)func {
		[self ref].setUpdatedCallback(Tellusim::makeTSControlDialogUpdatedCallback(func));
	}
	-(BOOL)isUpdated {
		return [self ref].isUpdated();
	}
@end

// Tellusim::ControlWindow
@implementation TSControlWindow
	-(id)init_17 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow();
		return self;
	}
	-(id)init_18: (TSControlRoot**)root parent: (TSWindow*)parent window: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow((root) ? [*root pointer] : nullptr, [parent ref], [window ref]);
		return self;
	}
	-(id)init_18_: (TSControlRoot**)root parent: (TSWindow*)parent window: (TSWindow*)window {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow((root) ? [*root pointer] : nullptr, [parent ref], [window ref]);
		return self;
	}
	-(id)init_19: (TSControlRoot**)root parent: (TSWindow*)parent window: (TSWindow*)window columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow((root) ? [*root pointer] : nullptr, [parent ref], [window ref], columns);
		return self;
	}
	-(id)init_19_: (TSControlRoot**)root parent: (TSWindow*)parent window: (TSWindow*)window columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow((root) ? [*root pointer] : nullptr, [parent ref], [window ref], columns);
		return self;
	}
	-(id)init_20: (TSControlRoot**)root parent: (TSWindow*)parent window: (TSWindow*)window columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow((root) ? [*root pointer] : nullptr, [parent ref], [window ref], columns, x, y);
		return self;
	}
	-(id)init_20_: (TSControlRoot**)root parent: (TSWindow*)parent window: (TSWindow*)window columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow((root) ? [*root pointer] : nullptr, [parent ref], [window ref], columns, x, y);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlWindow*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlWindow&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow((Tellusim::ControlWindow&)ref);
		return self;
	}
	-(Tellusim::ControlWindow*)pointer {
		return (Tellusim::ControlWindow*)impl;
	}
	-(Tellusim::ControlWindow&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlWindow*)impl;
	}
	-(id)initControlDialog: (TSControlDialog*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow([base ref]);
		return self;
	}
	-(TSControlDialog*)getControlDialog {
		return [[TSControlDialog alloc] init_ref:([self ref].getControlDialog())];
	}
	-(id)initControlPanel: (TSControlPanel*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow([base ref]);
		return self;
	}
	-(TSControlPanel*)getControlPanel {
		return [[TSControlPanel alloc] init_ref:([self ref].getControlPanel())];
	}
	-(id)initControlRect: (TSControlRect*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow([base ref]);
		return self;
	}
	-(TSControlRect*)getControlRect {
		return [[TSControlRect alloc] init_ref:([self ref].getControlRect())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlWindow([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlWindow*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlWindow*)copyPtr {
		return [[TSControlWindow alloc] init_ref:[self ref]];
	}
	-(TSControlWindow*)clonePtr {
		return [[TSControlWindow alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlWindow*)null {
		return [[TSControlWindow alloc] init_ptr:nullptr];
	}
	-(TSWindow*)getParentWindow {
		return [[TSWindow alloc] init_ref:([self ref].getParentWindow())];
	}
	-(TSWindow*)getDialogWindow {
		return [[TSWindow alloc] init_ref:([self ref].getDialogWindow())];
	}
@end

// Tellusim::ControlCheck
@implementation TSControlCheck
	-(id)init_8 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck();
		return self;
	}
	-(id)init_9: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer]);
		return self;
	}
	-(id)init_9_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer]);
		return self;
	}
	-(id)init_10: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer], text);
		return self;
	}
	-(id)init_10_: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer], text);
		return self;
	}
	-(id)init_11: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_11_: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_12: (TSControl*)parent text: (const char*)text checked: (BOOL)checked {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer], text, (bool)checked);
		return self;
	}
	-(id)init_12_: (TSControl*)parent text: (const char*)text checked: (BOOL)checked {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer], text, (bool)checked);
		return self;
	}
	-(id)init_13: (TSControl*)parent text: (const TSString*)text checked: (BOOL)checked {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer], (text) ? [text ref] : Tellusim::String::null, (bool)checked);
		return self;
	}
	-(id)init_13_: (TSControl*)parent text: (const TSString*)text checked: (BOOL)checked {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([parent pointer], (text) ? [text ref] : Tellusim::String::null, (bool)checked);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlCheck*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlCheck&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck((Tellusim::ControlCheck&)ref);
		return self;
	}
	-(Tellusim::ControlCheck*)pointer {
		return (Tellusim::ControlCheck*)impl;
	}
	-(Tellusim::ControlCheck&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlCheck*)impl;
	}
	-(id)initControlText: (TSControlText*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([base ref]);
		return self;
	}
	-(TSControlText*)getControlText {
		return [[TSControlText alloc] init_ref:([self ref].getControlText())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCheck([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlCheck*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlCheck*)copyPtr {
		return [[TSControlCheck alloc] init_ref:[self ref]];
	}
	-(TSControlCheck*)clonePtr {
		return [[TSControlCheck alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlCheck*)null {
		return [[TSControlCheck alloc] init_ptr:nullptr];
	}
	-(void)setCheckText: (const char*)text {
		[self ref].setCheckText(text);
	}
	-(void)setCheckText_: (const char*)text {
		[self ref].setCheckText(text);
	}
	-(void)setCheckText_1: (const TSString*)text {
		[self ref].setCheckText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setCheckText_1_: (const TSString*)text {
		[self ref].setCheckText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getCheckText {
		return [NSString stringWithUTF8String:[self ref].getCheckText().get()];
	}
	-(void)setCheckColor: (TSColor)color {
		[self ref].setCheckColor(*(Tellusim::Color*)&color);
	}
	-(void)setCheckColor_: (TSColor)color {
		[self ref].setCheckColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getCheckColor {
		Tellusim::Color ret = [self ref].getCheckColor();
		return *(TSColor*)&ret;
	}
	-(void)setCheckedColor: (TSColor)color {
		[self ref].setCheckedColor(*(Tellusim::Color*)&color);
	}
	-(void)setCheckedColor_: (TSColor)color {
		[self ref].setCheckedColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getCheckedColor {
		Tellusim::Color ret = [self ref].getCheckedColor();
		return *(TSColor*)&ret;
	}
	-(BOOL)switchChecked {
		return [self ref].switchChecked();
	}
	-(BOOL)switchChecked_1: (BOOL)callback {
		return [self ref].switchChecked((bool)callback);
	}
	-(BOOL)switchChecked_1_: (BOOL)callback {
		return [self ref].switchChecked((bool)callback);
	}
	-(void)setChecked: (BOOL)checked {
		[self ref].setChecked((bool)checked);
	}
	-(void)setChecked_: (BOOL)checked {
		[self ref].setChecked((bool)checked);
	}
	-(void)setChecked_1: (BOOL)checked callback: (BOOL)callback {
		[self ref].setChecked((bool)checked, (bool)callback);
	}
	-(void)setChecked_1_: (BOOL)checked callback: (BOOL)callback {
		[self ref].setChecked((bool)checked, (bool)callback);
	}
	-(BOOL)isChecked {
		return [self ref].isChecked();
	}
	-(void)setClickedCallback: (id<TSControlCheckClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlCheckClickedCallback(func));
	}
	-(void)setClickedCallback_: (id<TSControlCheckClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlCheckClickedCallback(func));
	}
	-(BOOL)isClicked {
		return [self ref].isClicked();
	}
	-(TSCanvasMesh*)getCanvasMesh {
		return [[TSCanvasMesh alloc] init_ref:([self ref].getCanvasMesh())];
	}
@end

// Tellusim::ControlCombo
@implementation TSControlCombo
	-(id)init_8 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCombo();
		return self;
	}
	-(id)init_9: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCombo([parent pointer]);
		return self;
	}
	-(id)init_9_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCombo([parent pointer]);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlCombo*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlCombo&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCombo((Tellusim::ControlCombo&)ref);
		return self;
	}
	-(Tellusim::ControlCombo*)pointer {
		return (Tellusim::ControlCombo*)impl;
	}
	-(Tellusim::ControlCombo&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlCombo*)impl;
	}
	-(id)initControlText: (TSControlText*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCombo([base ref]);
		return self;
	}
	-(TSControlText*)getControlText {
		return [[TSControlText alloc] init_ref:([self ref].getControlText())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlCombo([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlCombo*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlCombo*)copyPtr {
		return [[TSControlCombo alloc] init_ref:[self ref]];
	}
	-(TSControlCombo*)clonePtr {
		return [[TSControlCombo alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlCombo*)null {
		return [[TSControlCombo alloc] init_ptr:nullptr];
	}
	-(void)setMultiSelection: (BOOL)multi_selection {
		[self ref].setMultiSelection((bool)multi_selection);
	}
	-(void)setMultiSelection_: (BOOL)multi_selection {
		[self ref].setMultiSelection((bool)multi_selection);
	}
	-(BOOL)isMultiSelection {
		return [self ref].isMultiSelection();
	}
	-(void)setComboText: (const char*)text {
		[self ref].setComboText(text);
	}
	-(void)setComboText_: (const char*)text {
		[self ref].setComboText(text);
	}
	-(void)setComboText_1: (const TSString*)text {
		[self ref].setComboText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setComboText_1_: (const TSString*)text {
		[self ref].setComboText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getComboText {
		return [NSString stringWithUTF8String:[self ref].getComboText().get()];
	}
	-(void)setComboColor: (TSColor)color {
		[self ref].setComboColor(*(Tellusim::Color*)&color);
	}
	-(void)setComboColor_: (TSColor)color {
		[self ref].setComboColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getComboColor {
		Tellusim::Color ret = [self ref].getComboColor();
		return *(TSColor*)&ret;
	}
	-(void)setItemsSpacing: (float32_t)spacing {
		[self ref].setItemsSpacing(spacing);
	}
	-(void)setItemsSpacing_: (float32_t)spacing {
		[self ref].setItemsSpacing(spacing);
	}
	-(float32_t)getItemsSpacing {
		return [self ref].getItemsSpacing();
	}
	-(void)clearItems {
		[self ref].clearItems();
	}
	-(uint32_t)addItem: (const char*)text {
		return [self ref].addItem(text);
	}
	-(uint32_t)addItem_: (const char*)text {
		return [self ref].addItem(text);
	}
	-(uint32_t)addItem_1: (const TSString*)text {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null);
	}
	-(uint32_t)addItem_1_: (const TSString*)text {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)addItem_2: (uint32_t)index text: (const char*)text {
		[self ref].addItem(index, text);
	}
	-(void)addItem_2_: (uint32_t)index text: (const char*)text {
		[self ref].addItem(index, text);
	}
	-(void)addItem_3: (uint32_t)index text: (const TSString*)text {
		[self ref].addItem(index, (text) ? [text ref] : Tellusim::String::null);
	}
	-(void)addItem_3_: (uint32_t)index text: (const TSString*)text {
		[self ref].addItem(index, (text) ? [text ref] : Tellusim::String::null);
	}
	-(void)removeItem: (uint32_t)index {
		[self ref].removeItem(index);
	}
	-(void)removeItem_: (uint32_t)index {
		[self ref].removeItem(index);
	}
	-(uint32_t)getNumItems {
		return [self ref].getNumItems();
	}
	-(BOOL)switchItemSelected: (uint32_t)index {
		return [self ref].switchItemSelected(index);
	}
	-(BOOL)switchItemSelected_: (uint32_t)index {
		return [self ref].switchItemSelected(index);
	}
	-(void)setItemSelected: (uint32_t)index selected: (BOOL)selected {
		[self ref].setItemSelected(index, (bool)selected);
	}
	-(void)setItemSelected_: (uint32_t)index selected: (BOOL)selected {
		[self ref].setItemSelected(index, (bool)selected);
	}
	-(BOOL)isItemSelected: (uint32_t)index {
		return [self ref].isItemSelected(index);
	}
	-(BOOL)isItemSelected_: (uint32_t)index {
		return [self ref].isItemSelected(index);
	}
	-(void)setItemText: (uint32_t)index text: (const char*)text {
		[self ref].setItemText(index, text);
	}
	-(void)setItemText_: (uint32_t)index text: (const char*)text {
		[self ref].setItemText(index, text);
	}
	-(void)setItemText_1: (uint32_t)index text: (const TSString*)text {
		[self ref].setItemText(index, (text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setItemText_1_: (uint32_t)index text: (const TSString*)text {
		[self ref].setItemText(index, (text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getItemText: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getItemText(index).get()];
	}
	-(NSString*)getItemText_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getItemText(index).get()];
	}
	-(uint32_t)findItemText: (const char*)text {
		return [self ref].findItemText(text);
	}
	-(uint32_t)findItemText_: (const char*)text {
		return [self ref].findItemText(text);
	}
	-(uint32_t)findItemText_1: (const TSString*)text {
		return [self ref].findItemText((text) ? [text ref] : Tellusim::String::null);
	}
	-(uint32_t)findItemText_1_: (const TSString*)text {
		return [self ref].findItemText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setItemColor: (uint32_t)index color: (TSColor)color {
		[self ref].setItemColor(index, *(Tellusim::Color*)&color);
	}
	-(void)setItemColor_: (uint32_t)index color: (TSColor)color {
		[self ref].setItemColor(index, *(Tellusim::Color*)&color);
	}
	-(TSColor)getItemColor: (uint32_t)index {
		Tellusim::Color ret = [self ref].getItemColor(index);
		return *(TSColor*)&ret;
	}
	-(TSColor)getItemColor_: (uint32_t)index {
		Tellusim::Color ret = [self ref].getItemColor(index);
		return *(TSColor*)&ret;
	}
	-(void)setCurrentIndex: (uint32_t)index {
		[self ref].setCurrentIndex(index);
	}
	-(void)setCurrentIndex_: (uint32_t)index {
		[self ref].setCurrentIndex(index);
	}
	-(void)setCurrentIndex_1: (uint32_t)index callback: (BOOL)callback {
		[self ref].setCurrentIndex(index, (bool)callback);
	}
	-(void)setCurrentIndex_1_: (uint32_t)index callback: (BOOL)callback {
		[self ref].setCurrentIndex(index, (bool)callback);
	}
	-(void)setCurrentText: (const char*)text {
		[self ref].setCurrentText(text);
	}
	-(void)setCurrentText_: (const char*)text {
		[self ref].setCurrentText(text);
	}
	-(void)setCurrentText_1: (const char*)text callback: (BOOL)callback {
		[self ref].setCurrentText(text, (bool)callback);
	}
	-(void)setCurrentText_1_: (const char*)text callback: (BOOL)callback {
		[self ref].setCurrentText(text, (bool)callback);
	}
	-(void)setCurrentText_2: (const TSString*)text {
		[self ref].setCurrentText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setCurrentText_2_: (const TSString*)text {
		[self ref].setCurrentText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setCurrentText_3: (const TSString*)text callback: (BOOL)callback {
		[self ref].setCurrentText((text) ? [text ref] : Tellusim::String::null, (bool)callback);
	}
	-(void)setCurrentText_3_: (const TSString*)text callback: (BOOL)callback {
		[self ref].setCurrentText((text) ? [text ref] : Tellusim::String::null, (bool)callback);
	}
	-(uint32_t)getCurrentIndex {
		return [self ref].getCurrentIndex();
	}
	-(NSString*)getCurrentText {
		return [NSString stringWithUTF8String:[self ref].getCurrentText().get()];
	}
	-(void)setClickedCallback: (id<TSControlComboClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlComboClickedCallback(func));
	}
	-(void)setClickedCallback_: (id<TSControlComboClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlComboClickedCallback(func));
	}
	-(BOOL)isClicked {
		return [self ref].isClicked();
	}
	-(void)setChangedCallback: (id<TSControlComboChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlComboChangedCallback(func));
	}
	-(void)setChangedCallback_: (id<TSControlComboChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlComboChangedCallback(func));
	}
	-(BOOL)isChanged {
		return [self ref].isChanged();
	}
	-(TSCanvasMesh*)getCanvasMesh {
		return [[TSCanvasMesh alloc] init_ref:([self ref].getCanvasMesh())];
	}
@end

// Tellusim::ControlButton
@implementation TSControlButton
	-(id)init_8 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton();
		return self;
	}
	-(id)init_9: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton([parent pointer]);
		return self;
	}
	-(id)init_9_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton([parent pointer]);
		return self;
	}
	-(id)init_10: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton([parent pointer], text);
		return self;
	}
	-(id)init_10_: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton([parent pointer], text);
		return self;
	}
	-(id)init_11: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_11_: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlButton*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlButton&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton((Tellusim::ControlButton&)ref);
		return self;
	}
	-(Tellusim::ControlButton*)pointer {
		return (Tellusim::ControlButton*)impl;
	}
	-(Tellusim::ControlButton&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlButton*)impl;
	}
	-(id)initControlText: (TSControlText*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton([base ref]);
		return self;
	}
	-(TSControlText*)getControlText {
		return [[TSControlText alloc] init_ref:([self ref].getControlText())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlButton([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlButton*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlButton*)copyPtr {
		return [[TSControlButton alloc] init_ref:[self ref]];
	}
	-(TSControlButton*)clonePtr {
		return [[TSControlButton alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlButton*)null {
		return [[TSControlButton alloc] init_ptr:nullptr];
	}
	-(void)setBackground: (BOOL)background {
		[self ref].setBackground((bool)background);
	}
	-(void)setBackground_: (BOOL)background {
		[self ref].setBackground((bool)background);
	}
	-(BOOL)getBackground {
		return [self ref].getBackground();
	}
	-(void)setButtonMode: (TS_CanvasElementMode)mode {
		[self ref].setButtonMode((Tellusim::CanvasElement::Mode)mode);
	}
	-(void)setButtonMode_: (TS_CanvasElementMode)mode {
		[self ref].setButtonMode((Tellusim::CanvasElement::Mode)mode);
	}
	-(TS_CanvasElementMode)getButtonMode {
		return (TS_CanvasElementMode)[self ref].getButtonMode();
	}
	-(void)setButtonRadius: (float32_t)radius {
		[self ref].setButtonRadius(radius);
	}
	-(void)setButtonRadius_: (float32_t)radius {
		[self ref].setButtonRadius(radius);
	}
	-(float32_t)getButtonRadius {
		return [self ref].getButtonRadius();
	}
	-(void)setButtonColor: (TSColor)color {
		[self ref].setButtonColor(*(Tellusim::Color*)&color);
	}
	-(void)setButtonColor_: (TSColor)color {
		[self ref].setButtonColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getButtonColor {
		Tellusim::Color ret = [self ref].getButtonColor();
		return *(TSColor*)&ret;
	}
	-(void)setStrokeStyle: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(void)setStrokeStyle_: (TSStrokeStyle)style {
		[self ref].setStrokeStyle(*(Tellusim::StrokeStyle*)&style);
	}
	-(TSStrokeStyle)getStrokeStyleConst {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyleConst();
		return *(TSStrokeStyle*)&ret;
	}
	-(TSStrokeStyle)getStrokeStyle {
		Tellusim::StrokeStyle ret = [self ref].getStrokeStyle();
		return *(TSStrokeStyle*)&ret;
	}
	-(void)setGradientStyle: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(void)setGradientStyle_: (TSGradientStyle)style {
		[self ref].setGradientStyle(*(Tellusim::GradientStyle*)&style);
	}
	-(TSGradientStyle)getGradientStyleConst {
		Tellusim::GradientStyle ret = [self ref].getGradientStyleConst();
		return *(TSGradientStyle*)&ret;
	}
	-(TSGradientStyle)getGradientStyle {
		Tellusim::GradientStyle ret = [self ref].getGradientStyle();
		return *(TSGradientStyle*)&ret;
	}
	-(void)setPressedCallback: (id<TSControlButtonPressedCallback>)func {
		[self ref].setPressedCallback(Tellusim::makeTSControlButtonPressedCallback(func));
	}
	-(void)setPressedCallback_: (id<TSControlButtonPressedCallback>)func {
		[self ref].setPressedCallback(Tellusim::makeTSControlButtonPressedCallback(func));
	}
	-(BOOL)isPressed {
		return [self ref].isPressed();
	}
	-(void)setReleasedCallback: (id<TSControlButtonReleasedCallback>)func {
		[self ref].setReleasedCallback(Tellusim::makeTSControlButtonReleasedCallback(func));
	}
	-(void)setReleasedCallback_: (id<TSControlButtonReleasedCallback>)func {
		[self ref].setReleasedCallback(Tellusim::makeTSControlButtonReleasedCallback(func));
	}
	-(BOOL)isReleased {
		return [self ref].isReleased();
	}
	-(void)setClickedCallback: (id<TSControlButtonClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlButtonClickedCallback(func));
	}
	-(void)setClickedCallback_: (id<TSControlButtonClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlButtonClickedCallback(func));
	}
	-(BOOL)isClicked {
		return [self ref].isClicked();
	}
	-(TSCanvasRect*)getCanvasRect {
		return [[TSCanvasRect alloc] init_ref:([self ref].getCanvasRect())];
	}
	-(TSCanvasMesh*)getCanvasMesh {
		return [[TSCanvasMesh alloc] init_ref:([self ref].getCanvasMesh())];
	}
@end

// Tellusim::ControlSlider
@implementation TSControlSlider
	-(id)init_8 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider();
		return self;
	}
	-(id)init_9: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer]);
		return self;
	}
	-(id)init_9_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer]);
		return self;
	}
	-(id)init_10: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text);
		return self;
	}
	-(id)init_10_: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text);
		return self;
	}
	-(id)init_11: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_11_: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_12: (TSControl*)parent text: (const char*)text digits: (uint32_t)digits {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, digits);
		return self;
	}
	-(id)init_12_: (TSControl*)parent text: (const char*)text digits: (uint32_t)digits {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, digits);
		return self;
	}
	-(id)init_13: (TSControl*)parent text: (const char*)text digits: (uint32_t)digits value: (float64_t)value {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, digits, value);
		return self;
	}
	-(id)init_13_: (TSControl*)parent text: (const char*)text digits: (uint32_t)digits value: (float64_t)value {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, digits, value);
		return self;
	}
	-(id)init_14: (TSControl*)parent text: (const char*)text digits: (uint32_t)digits value: (float64_t)value min: (float64_t)min max: (float64_t)max {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, digits, value, min, max);
		return self;
	}
	-(id)init_14_: (TSControl*)parent text: (const char*)text digits: (uint32_t)digits value: (float64_t)value min: (float64_t)min max: (float64_t)max {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, digits, value, min, max);
		return self;
	}
	-(id)init_15: (TSControl*)parent text: (const char*)text value: (float64_t)value min: (float64_t)min max: (float64_t)max {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, value, min, max);
		return self;
	}
	-(id)init_15_: (TSControl*)parent text: (const char*)text value: (float64_t)value min: (float64_t)min max: (float64_t)max {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, value, min, max);
		return self;
	}
	-(id)init_16: (TSControl*)parent text: (const char*)text value: (uint32_t)value min: (uint32_t)min max: (uint32_t)max {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, value, min, max);
		return self;
	}
	-(id)init_16_: (TSControl*)parent text: (const char*)text value: (uint32_t)value min: (uint32_t)min max: (uint32_t)max {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, value, min, max);
		return self;
	}
	-(id)init_17: (TSControl*)parent text: (const char*)text value: (int32_t)value min: (int32_t)min max: (int32_t)max {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, value, min, max);
		return self;
	}
	-(id)init_17_: (TSControl*)parent text: (const char*)text value: (int32_t)value min: (int32_t)min max: (int32_t)max {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([parent pointer], text, value, min, max);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlSlider*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlSlider&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider((Tellusim::ControlSlider&)ref);
		return self;
	}
	-(Tellusim::ControlSlider*)pointer {
		return (Tellusim::ControlSlider*)impl;
	}
	-(Tellusim::ControlSlider&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlSlider*)impl;
	}
	-(id)initControlText: (TSControlText*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([base ref]);
		return self;
	}
	-(TSControlText*)getControlText {
		return [[TSControlText alloc] init_ref:([self ref].getControlText())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSlider([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlSlider*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlSlider*)copyPtr {
		return [[TSControlSlider alloc] init_ref:[self ref]];
	}
	-(TSControlSlider*)clonePtr {
		return [[TSControlSlider alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlSlider*)null {
		return [[TSControlSlider alloc] init_ptr:nullptr];
	}
	-(void)setSliderColor: (TSColor)color {
		[self ref].setSliderColor(*(Tellusim::Color*)&color);
	}
	-(void)setSliderColor_: (TSColor)color {
		[self ref].setSliderColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getSliderColor {
		Tellusim::Color ret = [self ref].getSliderColor();
		return *(TSColor*)&ret;
	}
	-(void)setDigits: (uint32_t)digits {
		[self ref].setDigits(digits);
	}
	-(void)setDigits_: (uint32_t)digits {
		[self ref].setDigits(digits);
	}
	-(uint32_t)getDigits {
		return [self ref].getDigits();
	}
	-(void)setTextEnabled: (BOOL)enabled {
		[self ref].setTextEnabled((bool)enabled);
	}
	-(void)setTextEnabled_: (BOOL)enabled {
		[self ref].setTextEnabled((bool)enabled);
	}
	-(BOOL)isTextEnabled {
		return [self ref].isTextEnabled();
	}
	-(void)setStep: (float64_t)step {
		[self ref].setStep(step);
	}
	-(void)setStep_: (float64_t)step {
		[self ref].setStep(step);
	}
	-(float64_t)getStep {
		return [self ref].getStep();
	}
	-(void)setBase: (float64_t)base {
		[self ref].setBase(base);
	}
	-(void)setBase_: (float64_t)base {
		[self ref].setBase(base);
	}
	-(float64_t)getBase {
		return [self ref].getBase();
	}
	-(void)setFormat: (const char*)format {
		[self ref].setFormat(format);
	}
	-(void)setFormat_: (const char*)format {
		[self ref].setFormat(format);
	}
	-(void)setFormat_1: (const TSString*)format {
		[self ref].setFormat((format) ? [format ref] : Tellusim::String::null);
	}
	-(void)setFormat_1_: (const TSString*)format {
		[self ref].setFormat((format) ? [format ref] : Tellusim::String::null);
	}
	-(NSString*)getFormat {
		return [NSString stringWithUTF8String:[self ref].getFormat().get()];
	}
	-(void)setValue: (float64_t)value {
		[self ref].setValue(value);
	}
	-(void)setValue_: (float64_t)value {
		[self ref].setValue(value);
	}
	-(void)setValue_1: (float64_t)value callback: (BOOL)callback {
		[self ref].setValue(value, (bool)callback);
	}
	-(void)setValue_1_: (float64_t)value callback: (BOOL)callback {
		[self ref].setValue(value, (bool)callback);
	}
	-(void)setValue_2: (float64_t)value callback: (BOOL)callback exponent: (BOOL)exponent {
		[self ref].setValue(value, (bool)callback, (bool)exponent);
	}
	-(void)setValue_2_: (float64_t)value callback: (BOOL)callback exponent: (BOOL)exponent {
		[self ref].setValue(value, (bool)callback, (bool)exponent);
	}
	-(float64_t)getValue {
		return [self ref].getValue();
	}
	-(float64_t)getValue_1: (BOOL)exponent {
		return [self ref].getValue((bool)exponent);
	}
	-(float64_t)getValue_1_: (BOOL)exponent {
		return [self ref].getValue((bool)exponent);
	}
	-(float32_t)getValuef32 {
		return [self ref].getValuef32();
	}
	-(float32_t)getValuef32_1: (BOOL)exponent {
		return [self ref].getValuef32((bool)exponent);
	}
	-(float32_t)getValuef32_1_: (BOOL)exponent {
		return [self ref].getValuef32((bool)exponent);
	}
	-(uint32_t)getValueu32 {
		return [self ref].getValueu32();
	}
	-(uint32_t)getValueu32_1: (BOOL)exponent {
		return [self ref].getValueu32((bool)exponent);
	}
	-(uint32_t)getValueu32_1_: (BOOL)exponent {
		return [self ref].getValueu32((bool)exponent);
	}
	-(int32_t)getValuei32 {
		return [self ref].getValuei32();
	}
	-(int32_t)getValuei32_1: (BOOL)exponent {
		return [self ref].getValuei32((bool)exponent);
	}
	-(int32_t)getValuei32_1_: (BOOL)exponent {
		return [self ref].getValuei32((bool)exponent);
	}
	-(void)setRange: (float64_t)min max: (float64_t)max {
		[self ref].setRange(min, max);
	}
	-(void)setRange_: (float64_t)min max: (float64_t)max {
		[self ref].setRange(min, max);
	}
	-(void)setRange_1: (float64_t)min max: (float64_t)max exponent: (BOOL)exponent {
		[self ref].setRange(min, max, (bool)exponent);
	}
	-(void)setRange_1_: (float64_t)min max: (float64_t)max exponent: (BOOL)exponent {
		[self ref].setRange(min, max, (bool)exponent);
	}
	-(float64_t)getMinRange {
		return [self ref].getMinRange();
	}
	-(float64_t)getMinRange_1: (BOOL)exponent {
		return [self ref].getMinRange((bool)exponent);
	}
	-(float64_t)getMinRange_1_: (BOOL)exponent {
		return [self ref].getMinRange((bool)exponent);
	}
	-(float64_t)getMaxRange {
		return [self ref].getMaxRange();
	}
	-(float64_t)getMaxRange_1: (BOOL)exponent {
		return [self ref].getMaxRange((bool)exponent);
	}
	-(float64_t)getMaxRange_1_: (BOOL)exponent {
		return [self ref].getMaxRange((bool)exponent);
	}
	-(void)setHandleSize: (float32_t)size {
		[self ref].setHandleSize(size);
	}
	-(void)setHandleSize_: (float32_t)size {
		[self ref].setHandleSize(size);
	}
	-(float32_t)getHandleSize {
		return [self ref].getHandleSize();
	}
	-(void)setFormatCallback: (id<TSControlSliderFormatCallback>)func {
		[self ref].setFormatCallback(Tellusim::makeTSControlSliderFormatCallback(func));
	}
	-(void)setFormatCallback_: (id<TSControlSliderFormatCallback>)func {
		[self ref].setFormatCallback(Tellusim::makeTSControlSliderFormatCallback(func));
	}
	-(void)setReleasedCallback: (id<TSControlSliderReleasedCallback>)func {
		[self ref].setReleasedCallback(Tellusim::makeTSControlSliderReleasedCallback(func));
	}
	-(void)setReleasedCallback_: (id<TSControlSliderReleasedCallback>)func {
		[self ref].setReleasedCallback(Tellusim::makeTSControlSliderReleasedCallback(func));
	}
	-(BOOL)isReleased {
		return [self ref].isReleased();
	}
	-(void)setClickedCallback: (id<TSControlSliderClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlSliderClickedCallback(func));
	}
	-(void)setClickedCallback_: (id<TSControlSliderClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlSliderClickedCallback(func));
	}
	-(BOOL)isClicked {
		return [self ref].isClicked();
	}
	-(void)setChangedCallback: (id<TSControlSliderChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlSliderChangedCallback(func));
	}
	-(void)setChangedCallback_: (id<TSControlSliderChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlSliderChangedCallback(func));
	}
	-(BOOL)isChanged {
		return [self ref].isChanged();
	}
	-(BOOL)isChanged_1: (BOOL)clear {
		return [self ref].isChanged((bool)clear);
	}
	-(BOOL)isChanged_1_: (BOOL)clear {
		return [self ref].isChanged((bool)clear);
	}
	-(TSCanvasMesh*)getCanvasMesh {
		return [[TSCanvasMesh alloc] init_ref:([self ref].getCanvasMesh())];
	}
@end

// Tellusim::ControlScroll
@implementation TSControlScroll
	-(id)init_8 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll();
		return self;
	}
	-(id)init_9: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer]);
		return self;
	}
	-(id)init_9_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer]);
		return self;
	}
	-(id)init_10: (TSControl*)parent vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], (bool)vertical);
		return self;
	}
	-(id)init_10_: (TSControl*)parent vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], (bool)vertical);
		return self;
	}
	-(id)init_11: (TSControl*)parent value: (float64_t)value {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value);
		return self;
	}
	-(id)init_11_: (TSControl*)parent value: (float64_t)value {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value);
		return self;
	}
	-(id)init_12: (TSControl*)parent value: (float64_t)value vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, (bool)vertical);
		return self;
	}
	-(id)init_12_: (TSControl*)parent value: (float64_t)value vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, (bool)vertical);
		return self;
	}
	-(id)init_13: (TSControl*)parent value: (float64_t)value frame: (float64_t)frame range: (float64_t)range {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range);
		return self;
	}
	-(id)init_13_: (TSControl*)parent value: (float64_t)value frame: (float64_t)frame range: (float64_t)range {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range);
		return self;
	}
	-(id)init_14: (TSControl*)parent value: (float64_t)value frame: (float64_t)frame range: (float64_t)range vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range, (bool)vertical);
		return self;
	}
	-(id)init_14_: (TSControl*)parent value: (float64_t)value frame: (float64_t)frame range: (float64_t)range vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range, (bool)vertical);
		return self;
	}
	-(id)init_15: (TSControl*)parent value: (uint32_t)value frame: (uint32_t)frame range: (uint32_t)range {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range);
		return self;
	}
	-(id)init_15_: (TSControl*)parent value: (uint32_t)value frame: (uint32_t)frame range: (uint32_t)range {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range);
		return self;
	}
	-(id)init_16: (TSControl*)parent value: (uint32_t)value frame: (uint32_t)frame range: (uint32_t)range vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range, (bool)vertical);
		return self;
	}
	-(id)init_16_: (TSControl*)parent value: (uint32_t)value frame: (uint32_t)frame range: (uint32_t)range vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range, (bool)vertical);
		return self;
	}
	-(id)init_17: (TSControl*)parent value: (int32_t)value frame: (int32_t)frame range: (int32_t)range {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range);
		return self;
	}
	-(id)init_17_: (TSControl*)parent value: (int32_t)value frame: (int32_t)frame range: (int32_t)range {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range);
		return self;
	}
	-(id)init_18: (TSControl*)parent value: (int32_t)value frame: (int32_t)frame range: (int32_t)range vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range, (bool)vertical);
		return self;
	}
	-(id)init_18_: (TSControl*)parent value: (int32_t)value frame: (int32_t)frame range: (int32_t)range vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([parent pointer], value, frame, range, (bool)vertical);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlScroll*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlScroll&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll((Tellusim::ControlScroll&)ref);
		return self;
	}
	-(Tellusim::ControlScroll*)pointer {
		return (Tellusim::ControlScroll*)impl;
	}
	-(Tellusim::ControlScroll&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlScroll*)impl;
	}
	-(id)initControlText: (TSControlText*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([base ref]);
		return self;
	}
	-(TSControlText*)getControlText {
		return [[TSControlText alloc] init_ref:([self ref].getControlText())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlScroll([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlScroll*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlScroll*)copyPtr {
		return [[TSControlScroll alloc] init_ref:[self ref]];
	}
	-(TSControlScroll*)clonePtr {
		return [[TSControlScroll alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlScroll*)null {
		return [[TSControlScroll alloc] init_ptr:nullptr];
	}
	-(void)setVertical: (BOOL)vertical {
		[self ref].setVertical((bool)vertical);
	}
	-(void)setVertical_: (BOOL)vertical {
		[self ref].setVertical((bool)vertical);
	}
	-(void)setVertical_1: (BOOL)vertical text: (BOOL)text {
		[self ref].setVertical((bool)vertical, (bool)text);
	}
	-(void)setVertical_1_: (BOOL)vertical text: (BOOL)text {
		[self ref].setVertical((bool)vertical, (bool)text);
	}
	-(BOOL)isHorizontal {
		return [self ref].isHorizontal();
	}
	-(BOOL)isVertical {
		return [self ref].isVertical();
	}
	-(void)setPrevText: (const char*)text {
		[self ref].setPrevText(text);
	}
	-(void)setPrevText_: (const char*)text {
		[self ref].setPrevText(text);
	}
	-(void)setPrevText_1: (const TSString*)text {
		[self ref].setPrevText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setPrevText_1_: (const TSString*)text {
		[self ref].setPrevText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getPrevText {
		return [NSString stringWithUTF8String:[self ref].getPrevText().get()];
	}
	-(void)setNextText: (const char*)text {
		[self ref].setNextText(text);
	}
	-(void)setNextText_: (const char*)text {
		[self ref].setNextText(text);
	}
	-(void)setNextText_1: (const TSString*)text {
		[self ref].setNextText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setNextText_1_: (const TSString*)text {
		[self ref].setNextText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getNextText {
		return [NSString stringWithUTF8String:[self ref].getNextText().get()];
	}
	-(void)setScrollColor: (TSColor)color {
		[self ref].setScrollColor(*(Tellusim::Color*)&color);
	}
	-(void)setScrollColor_: (TSColor)color {
		[self ref].setScrollColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getScrollColor {
		Tellusim::Color ret = [self ref].getScrollColor();
		return *(TSColor*)&ret;
	}
	-(void)setStep: (float64_t)step {
		[self ref].setStep(step);
	}
	-(void)setStep_: (float64_t)step {
		[self ref].setStep(step);
	}
	-(float64_t)getStep {
		return [self ref].getStep();
	}
	-(void)setValue: (float64_t)value {
		[self ref].setValue(value);
	}
	-(void)setValue_: (float64_t)value {
		[self ref].setValue(value);
	}
	-(void)setValue_1: (float64_t)value callback: (BOOL)callback {
		[self ref].setValue(value, (bool)callback);
	}
	-(void)setValue_1_: (float64_t)value callback: (BOOL)callback {
		[self ref].setValue(value, (bool)callback);
	}
	-(float64_t)getValue {
		return [self ref].getValue();
	}
	-(void)setFrame: (float64_t)frame {
		[self ref].setFrame(frame);
	}
	-(void)setFrame_: (float64_t)frame {
		[self ref].setFrame(frame);
	}
	-(float64_t)getFrame {
		return [self ref].getFrame();
	}
	-(void)setRange: (float64_t)range {
		[self ref].setRange(range);
	}
	-(void)setRange_: (float64_t)range {
		[self ref].setRange(range);
	}
	-(float64_t)getRange {
		return [self ref].getRange();
	}
	-(void)setFrameAlign: (TS_ControlAlign)align {
		[self ref].setFrameAlign((Tellusim::Control::Align)align);
	}
	-(void)setFrameAlign_: (TS_ControlAlign)align {
		[self ref].setFrameAlign((Tellusim::Control::Align)align);
	}
	-(TS_ControlAlign)getFrameAlign {
		return (TS_ControlAlign)[self ref].getFrameAlign();
	}
	-(BOOL)hasFrameAlign: (TS_ControlAlign)align {
		return [self ref].hasFrameAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasFrameAlign_: (TS_ControlAlign)align {
		return [self ref].hasFrameAlign((Tellusim::Control::Align)align);
	}
	-(BOOL)hasFrameAligns: (TS_ControlAlign)aligns {
		return [self ref].hasFrameAligns((Tellusim::Control::Align)aligns);
	}
	-(BOOL)hasFrameAligns_: (TS_ControlAlign)aligns {
		return [self ref].hasFrameAligns((Tellusim::Control::Align)aligns);
	}
	-(void)setClickedCallback: (id<TSControlScrollClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlScrollClickedCallback(func));
	}
	-(void)setClickedCallback_: (id<TSControlScrollClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlScrollClickedCallback(func));
	}
	-(BOOL)isClicked {
		return [self ref].isClicked();
	}
	-(void)setChangedCallback: (id<TSControlScrollChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlScrollChangedCallback(func));
	}
	-(void)setChangedCallback_: (id<TSControlScrollChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlScrollChangedCallback(func));
	}
	-(BOOL)isChanged {
		return [self ref].isChanged();
	}
	-(BOOL)isChanged_1: (BOOL)clear {
		return [self ref].isChanged((bool)clear);
	}
	-(BOOL)isChanged_1_: (BOOL)clear {
		return [self ref].isChanged((bool)clear);
	}
	-(TSCanvasMesh*)getCanvasMesh {
		return [[TSCanvasMesh alloc] init_ref:([self ref].getCanvasMesh())];
	}
@end

// Tellusim::ControlSplit
@implementation TSControlSplit
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit();
		return self;
	}
	-(id)init_5: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit([parent pointer]);
		return self;
	}
	-(id)init_5_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit([parent pointer]);
		return self;
	}
	-(id)init_6: (TSControl*)parent vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit([parent pointer], (bool)vertical);
		return self;
	}
	-(id)init_6_: (TSControl*)parent vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit([parent pointer], (bool)vertical);
		return self;
	}
	-(id)init_7: (TSControl*)parent value: (float32_t)value {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit([parent pointer], value);
		return self;
	}
	-(id)init_7_: (TSControl*)parent value: (float32_t)value {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit([parent pointer], value);
		return self;
	}
	-(id)init_8: (TSControl*)parent value: (float32_t)value vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit([parent pointer], value, (bool)vertical);
		return self;
	}
	-(id)init_8_: (TSControl*)parent value: (float32_t)value vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit([parent pointer], value, (bool)vertical);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlSplit*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlSplit&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit((Tellusim::ControlSplit&)ref);
		return self;
	}
	-(Tellusim::ControlSplit*)pointer {
		return (Tellusim::ControlSplit*)impl;
	}
	-(Tellusim::ControlSplit&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlSplit*)impl;
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlSplit([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlSplit*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlSplit*)copyPtr {
		return [[TSControlSplit alloc] init_ref:[self ref]];
	}
	-(TSControlSplit*)clonePtr {
		return [[TSControlSplit alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlSplit*)null {
		return [[TSControlSplit alloc] init_ptr:nullptr];
	}
	-(void)setAbsolute: (BOOL)absolute {
		[self ref].setAbsolute((bool)absolute);
	}
	-(void)setAbsolute_: (BOOL)absolute {
		[self ref].setAbsolute((bool)absolute);
	}
	-(BOOL)isAbsolute {
		return [self ref].isAbsolute();
	}
	-(void)setVertical: (BOOL)vertical {
		[self ref].setVertical((bool)vertical);
	}
	-(void)setVertical_: (BOOL)vertical {
		[self ref].setVertical((bool)vertical);
	}
	-(BOOL)isHorizontal {
		return [self ref].isHorizontal();
	}
	-(BOOL)isVertical {
		return [self ref].isVertical();
	}
	-(void)setValue: (float32_t)value {
		[self ref].setValue(value);
	}
	-(void)setValue_: (float32_t)value {
		[self ref].setValue(value);
	}
	-(float32_t)getValue {
		return [self ref].getValue();
	}
	-(void)setHandleSize: (float32_t)size {
		[self ref].setHandleSize(size);
	}
	-(void)setHandleSize_: (float32_t)size {
		[self ref].setHandleSize(size);
	}
	-(float32_t)getHandleSize {
		return [self ref].getHandleSize();
	}
	-(TSVector2f)getControlsSize {
		Tellusim::Vector2f ret = [self ref].getControlsSize();
		return *(TSVector2f*)&ret;
	}
@end

// Tellusim::ControlArea
@implementation TSControlArea
	-(id)init_4 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea();
		return self;
	}
	-(id)init_5: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea([parent pointer]);
		return self;
	}
	-(id)init_5_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea([parent pointer]);
		return self;
	}
	-(id)init_6: (TSControl*)parent columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea([parent pointer], columns);
		return self;
	}
	-(id)init_6_: (TSControl*)parent columns: (uint32_t)columns {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea([parent pointer], columns);
		return self;
	}
	-(id)init_7: (TSControl*)parent horizontal: (BOOL)horizontal vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea([parent pointer], (bool)horizontal, (bool)vertical);
		return self;
	}
	-(id)init_7_: (TSControl*)parent horizontal: (BOOL)horizontal vertical: (BOOL)vertical {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea([parent pointer], (bool)horizontal, (bool)vertical);
		return self;
	}
	-(id)init_8: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea([parent pointer], columns, x, y);
		return self;
	}
	-(id)init_8_: (TSControl*)parent columns: (uint32_t)columns x: (float32_t)x y: (float32_t)y {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea([parent pointer], columns, x, y);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlArea*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlArea&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea((Tellusim::ControlArea&)ref);
		return self;
	}
	-(Tellusim::ControlArea*)pointer {
		return (Tellusim::ControlArea*)impl;
	}
	-(Tellusim::ControlArea&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlArea*)impl;
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlArea([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlArea*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlArea*)copyPtr {
		return [[TSControlArea alloc] init_ref:[self ref]];
	}
	-(TSControlArea*)clonePtr {
		return [[TSControlArea alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlArea*)null {
		return [[TSControlArea alloc] init_ptr:nullptr];
	}
	-(void)setAbsolute: (BOOL)absolute {
		[self ref].setAbsolute((bool)absolute);
	}
	-(void)setAbsolute_: (BOOL)absolute {
		[self ref].setAbsolute((bool)absolute);
	}
	-(BOOL)isAbsolute {
		return [self ref].isAbsolute();
	}
	-(void)setScalable: (BOOL)scalable {
		[self ref].setScalable((bool)scalable);
	}
	-(void)setScalable_: (BOOL)scalable {
		[self ref].setScalable((bool)scalable);
	}
	-(BOOL)isScalable {
		return [self ref].isScalable();
	}
	-(void)setScrollable: (BOOL)scrollable {
		[self ref].setScrollable((bool)scrollable);
	}
	-(void)setScrollable_: (BOOL)scrollable {
		[self ref].setScrollable((bool)scrollable);
	}
	-(BOOL)isScrollable {
		return [self ref].isScrollable();
	}
	-(void)setScale: (float32_t)scale {
		[self ref].setScale(scale);
	}
	-(void)setScale_: (float32_t)scale {
		[self ref].setScale(scale);
	}
	-(float32_t)getScale {
		return [self ref].getScale();
	}
	-(void)setScaleRange: (float32_t)min max: (float32_t)max {
		[self ref].setScaleRange(min, max);
	}
	-(void)setScaleRange_: (float32_t)min max: (float32_t)max {
		[self ref].setScaleRange(min, max);
	}
	-(float32_t)getMinScale {
		return [self ref].getMinScale();
	}
	-(float32_t)getMaxScale {
		return [self ref].getMaxScale();
	}
	-(void)setHorizontalStep: (float64_t)step {
		[self ref].setHorizontalStep(step);
	}
	-(void)setHorizontalStep_: (float64_t)step {
		[self ref].setHorizontalStep(step);
	}
	-(void)setVerticalStep: (float64_t)step {
		[self ref].setVerticalStep(step);
	}
	-(void)setVerticalStep_: (float64_t)step {
		[self ref].setVerticalStep(step);
	}
	-(void)setStep: (float64_t)horizontal vertical: (float64_t)vertical {
		[self ref].setStep(horizontal, vertical);
	}
	-(void)setStep_: (float64_t)horizontal vertical: (float64_t)vertical {
		[self ref].setStep(horizontal, vertical);
	}
	-(float64_t)getHorizontalStep {
		return [self ref].getHorizontalStep();
	}
	-(float64_t)getVerticalStep {
		return [self ref].getVerticalStep();
	}
	-(void)setHorizontalValue: (float64_t)value {
		[self ref].setHorizontalValue(value);
	}
	-(void)setHorizontalValue_: (float64_t)value {
		[self ref].setHorizontalValue(value);
	}
	-(void)setVerticalValue: (float64_t)value {
		[self ref].setVerticalValue(value);
	}
	-(void)setVerticalValue_: (float64_t)value {
		[self ref].setVerticalValue(value);
	}
	-(void)setValue: (float64_t)horizontal vertical: (float64_t)vertical {
		[self ref].setValue(horizontal, vertical);
	}
	-(void)setValue_: (float64_t)horizontal vertical: (float64_t)vertical {
		[self ref].setValue(horizontal, vertical);
	}
	-(float64_t)getHorizontalValue {
		return [self ref].getHorizontalValue();
	}
	-(float64_t)getVerticalValue {
		return [self ref].getVerticalValue();
	}
	-(void)setFrameAlign: (TS_ControlAlign)align {
		[self ref].setFrameAlign((Tellusim::Control::Align)align);
	}
	-(void)setFrameAlign_: (TS_ControlAlign)align {
		[self ref].setFrameAlign((Tellusim::Control::Align)align);
	}
	-(TS_ControlAlign)getFrameAlign {
		return (TS_ControlAlign)[self ref].getFrameAlign();
	}
	-(float64_t)getHorizontalFrame {
		return [self ref].getHorizontalFrame();
	}
	-(float64_t)getVerticalFrame {
		return [self ref].getVerticalFrame();
	}
	-(float64_t)getHorizontalRange {
		return [self ref].getHorizontalRange();
	}
	-(float64_t)getVerticalRange {
		return [self ref].getVerticalRange();
	}
	-(void)setHorizontalEnabled: (BOOL)enabled {
		[self ref].setHorizontalEnabled((bool)enabled);
	}
	-(void)setHorizontalEnabled_: (BOOL)enabled {
		[self ref].setHorizontalEnabled((bool)enabled);
	}
	-(void)setHorizontalEnabled_1: (BOOL)enabled dynamic: (BOOL)dynamic {
		[self ref].setHorizontalEnabled((bool)enabled, (bool)dynamic);
	}
	-(void)setHorizontalEnabled_1_: (BOOL)enabled dynamic: (BOOL)dynamic {
		[self ref].setHorizontalEnabled((bool)enabled, (bool)dynamic);
	}
	-(BOOL)isHorizontalEnabled {
		return [self ref].isHorizontalEnabled();
	}
	-(BOOL)isHorizontalDynamic {
		return [self ref].isHorizontalDynamic();
	}
	-(BOOL)isHorizontalHidden {
		return [self ref].isHorizontalHidden();
	}
	-(const TSControlScroll*)getHorizontalScroll {
		return [[TSControlScroll alloc] init_ref:([self ref].getHorizontalScroll())];
	}
	-(void)setVerticalEnabled: (BOOL)enabled {
		[self ref].setVerticalEnabled((bool)enabled);
	}
	-(void)setVerticalEnabled_: (BOOL)enabled {
		[self ref].setVerticalEnabled((bool)enabled);
	}
	-(void)setVerticalEnabled_1: (BOOL)enabled dynamic: (BOOL)dynamic {
		[self ref].setVerticalEnabled((bool)enabled, (bool)dynamic);
	}
	-(void)setVerticalEnabled_1_: (BOOL)enabled dynamic: (BOOL)dynamic {
		[self ref].setVerticalEnabled((bool)enabled, (bool)dynamic);
	}
	-(BOOL)isVerticalEnabled {
		return [self ref].isVerticalEnabled();
	}
	-(BOOL)isVerticalDynamic {
		return [self ref].isVerticalDynamic();
	}
	-(BOOL)isVerticalHidden {
		return [self ref].isVerticalHidden();
	}
	-(const TSControlScroll*)getVerticalScroll {
		return [[TSControlScroll alloc] init_ref:([self ref].getVerticalScroll())];
	}
	-(BOOL)setFontSize: (uint32_t)size {
		return [self ref].setFontSize(size);
	}
	-(BOOL)setFontSize_: (uint32_t)size {
		return [self ref].setFontSize(size);
	}
	-(uint32_t)getFontSize {
		return [self ref].getFontSize();
	}
	-(BOOL)setFontStyle: (TSFontStyle)style {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style);
	}
	-(BOOL)setFontStyle_: (TSFontStyle)style {
		return [self ref].setFontStyle(*(Tellusim::FontStyle*)&style);
	}
	-(TSFontStyle)getFontStyleConst {
		Tellusim::FontStyle ret = [self ref].getFontStyleConst();
		return *(TSFontStyle*)&ret;
	}
	-(TSFontStyle)getFontStyle {
		Tellusim::FontStyle ret = [self ref].getFontStyle();
		return *(TSFontStyle*)&ret;
	}
	-(void)setColumns: (uint32_t)columns {
		[self ref].setColumns(columns);
	}
	-(void)setColumns_: (uint32_t)columns {
		[self ref].setColumns(columns);
	}
	-(uint32_t)getColumns {
		return [self ref].getColumns();
	}
	-(void)setSpacing: (TSVector2f)spacing {
		[self ref].setSpacing(*(Tellusim::Vector2f*)&spacing);
	}
	-(void)setSpacing_: (TSVector2f)spacing {
		[self ref].setSpacing(*(Tellusim::Vector2f*)&spacing);
	}
	-(void)setSpacing_1: (float32_t)x y: (float32_t)y {
		[self ref].setSpacing(x, y);
	}
	-(void)setSpacing_1_: (float32_t)x y: (float32_t)y {
		[self ref].setSpacing(x, y);
	}
	-(TSVector2f)getSpacing {
		Tellusim::Vector2f ret = [self ref].getSpacing();
		return *(TSVector2f*)&ret;
	}
	-(void)setColumnRatio: (uint32_t)index ratio: (float32_t)ratio {
		[self ref].setColumnRatio(index, ratio);
	}
	-(void)setColumnRatio_: (uint32_t)index ratio: (float32_t)ratio {
		[self ref].setColumnRatio(index, ratio);
	}
	-(float32_t)getColumnRatio: (uint32_t)index {
		return [self ref].getColumnRatio(index);
	}
	-(float32_t)getColumnRatio_: (uint32_t)index {
		return [self ref].getColumnRatio(index);
	}
	-(TSVector2f)getControlsSize {
		Tellusim::Vector2f ret = [self ref].getControlsSize();
		return *(TSVector2f*)&ret;
	}
	-(TSVector2f)getControlsOffset {
		Tellusim::Vector2f ret = [self ref].getControlsOffset();
		return *(TSVector2f*)&ret;
	}
	-(TSRect)getViewRect {
		Tellusim::Rect ret = [self ref].getViewRect();
		return *(TSRect*)&ret;
	}
@end

// Tellusim::ControlTree
@implementation TSControlTree
	-(id)init_8 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlTree();
		return self;
	}
	-(id)init_9: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlTree([parent pointer]);
		return self;
	}
	-(id)init_9_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlTree([parent pointer]);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlTree*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlTree&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlTree((Tellusim::ControlTree&)ref);
		return self;
	}
	-(Tellusim::ControlTree*)pointer {
		return (Tellusim::ControlTree*)impl;
	}
	-(Tellusim::ControlTree&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlTree*)impl;
	}
	-(id)initControlText: (TSControlText*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlTree([base ref]);
		return self;
	}
	-(TSControlText*)getControlText {
		return [[TSControlText alloc] init_ref:([self ref].getControlText())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlTree([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlTree*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlTree*)copyPtr {
		return [[TSControlTree alloc] init_ref:[self ref]];
	}
	-(TSControlTree*)clonePtr {
		return [[TSControlTree alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlTree*)null {
		return [[TSControlTree alloc] init_ptr:nullptr];
	}
	-(void)setSelectable: (BOOL)selectable {
		[self ref].setSelectable((bool)selectable);
	}
	-(void)setSelectable_: (BOOL)selectable {
		[self ref].setSelectable((bool)selectable);
	}
	-(BOOL)isSelectable {
		return [self ref].isSelectable();
	}
	-(void)setMultiSelection: (BOOL)multi_selection {
		[self ref].setMultiSelection((bool)multi_selection);
	}
	-(void)setMultiSelection_: (BOOL)multi_selection {
		[self ref].setMultiSelection((bool)multi_selection);
	}
	-(BOOL)isMultiSelection {
		return [self ref].isMultiSelection();
	}
	-(void)setFoldedText: (const char*)text {
		[self ref].setFoldedText(text);
	}
	-(void)setFoldedText_: (const char*)text {
		[self ref].setFoldedText(text);
	}
	-(void)setFoldedText_1: (const TSString*)text {
		[self ref].setFoldedText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setFoldedText_1_: (const TSString*)text {
		[self ref].setFoldedText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getFoldedText {
		return [NSString stringWithUTF8String:[self ref].getFoldedText().get()];
	}
	-(void)setExpandedText: (const char*)text {
		[self ref].setExpandedText(text);
	}
	-(void)setExpandedText_: (const char*)text {
		[self ref].setExpandedText(text);
	}
	-(void)setExpandedText_1: (const TSString*)text {
		[self ref].setExpandedText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setExpandedText_1_: (const TSString*)text {
		[self ref].setExpandedText((text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getExpandedText {
		return [NSString stringWithUTF8String:[self ref].getExpandedText().get()];
	}
	-(void)setTexture: (TSTexture*)texture {
		[self ref].setTexture([texture ref]);
	}
	-(void)setTexture_: (TSTexture*)texture {
		[self ref].setTexture([texture ref]);
	}
	-(void)setTexture_1: (TSTexture*)texture rows: (uint32_t)rows {
		[self ref].setTexture([texture ref], rows);
	}
	-(void)setTexture_1_: (TSTexture*)texture rows: (uint32_t)rows {
		[self ref].setTexture([texture ref], rows);
	}
	-(void)setTexture_2: (TSTexture*)texture rows: (uint32_t)rows columns: (uint32_t)columns {
		[self ref].setTexture([texture ref], rows, columns);
	}
	-(void)setTexture_2_: (TSTexture*)texture rows: (uint32_t)rows columns: (uint32_t)columns {
		[self ref].setTexture([texture ref], rows, columns);
	}
	-(TSTexture*)getTexture {
		return [[TSTexture alloc] init_ref:([self ref].getTexture())];
	}
	-(void)setTextureName: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_: (const char*)name {
		[self ref].setTextureName(name);
	}
	-(void)setTextureName_1: (const char*)name rows: (uint32_t)rows {
		[self ref].setTextureName(name, rows);
	}
	-(void)setTextureName_1_: (const char*)name rows: (uint32_t)rows {
		[self ref].setTextureName(name, rows);
	}
	-(void)setTextureName_2: (const char*)name rows: (uint32_t)rows columns: (uint32_t)columns {
		[self ref].setTextureName(name, rows, columns);
	}
	-(void)setTextureName_2_: (const char*)name rows: (uint32_t)rows columns: (uint32_t)columns {
		[self ref].setTextureName(name, rows, columns);
	}
	-(void)setTextureName_3: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setTextureName_3_: (const TSString*)name {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setTextureName_4: (const TSString*)name rows: (uint32_t)rows {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, rows);
	}
	-(void)setTextureName_4_: (const TSString*)name rows: (uint32_t)rows {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, rows);
	}
	-(void)setTextureName_5: (const TSString*)name rows: (uint32_t)rows columns: (uint32_t)columns {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, rows, columns);
	}
	-(void)setTextureName_5_: (const TSString*)name rows: (uint32_t)rows columns: (uint32_t)columns {
		[self ref].setTextureName((name) ? [name ref] : Tellusim::String::null, rows, columns);
	}
	-(NSString*)getTextureName {
		return [NSString stringWithUTF8String:[self ref].getTextureName().get()];
	}
	-(void)setTextureGrid: (uint32_t)rows columns: (uint32_t)columns {
		[self ref].setTextureGrid(rows, columns);
	}
	-(void)setTextureGrid_: (uint32_t)rows columns: (uint32_t)columns {
		[self ref].setTextureGrid(rows, columns);
	}
	-(uint32_t)getTextureRows {
		return [self ref].getTextureRows();
	}
	-(uint32_t)getTextureColumns {
		return [self ref].getTextureColumns();
	}
	-(void)clearItems {
		[self ref].clearItems();
	}
	-(uint32_t)addItem: (const char*)text {
		return [self ref].addItem(text);
	}
	-(uint32_t)addItem_: (const char*)text {
		return [self ref].addItem(text);
	}
	-(uint32_t)addItem_1: (const char*)text parent: (uint32_t)parent {
		return [self ref].addItem(text, parent);
	}
	-(uint32_t)addItem_1_: (const char*)text parent: (uint32_t)parent {
		return [self ref].addItem(text, parent);
	}
	-(uint32_t)addItem_2: (const char*)text parent: (uint32_t)parent expanded: (BOOL)expanded {
		return [self ref].addItem(text, parent, (bool)expanded);
	}
	-(uint32_t)addItem_2_: (const char*)text parent: (uint32_t)parent expanded: (BOOL)expanded {
		return [self ref].addItem(text, parent, (bool)expanded);
	}
	-(uint32_t)addItem_3: (const TSString*)text {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null);
	}
	-(uint32_t)addItem_3_: (const TSString*)text {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null);
	}
	-(uint32_t)addItem_4: (const TSString*)text parent: (uint32_t)parent {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, parent);
	}
	-(uint32_t)addItem_4_: (const TSString*)text parent: (uint32_t)parent {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, parent);
	}
	-(uint32_t)addItem_5: (const TSString*)text parent: (uint32_t)parent expanded: (BOOL)expanded {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, parent, (bool)expanded);
	}
	-(uint32_t)addItem_5_: (const TSString*)text parent: (uint32_t)parent expanded: (BOOL)expanded {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, parent, (bool)expanded);
	}
	-(void)removeItem: (uint32_t)item {
		[self ref].removeItem(item);
	}
	-(void)removeItem_: (uint32_t)item {
		[self ref].removeItem(item);
	}
	-(void)removeItem_1: (uint32_t)item children: (BOOL)children {
		[self ref].removeItem(item, (bool)children);
	}
	-(void)removeItem_1_: (uint32_t)item children: (BOOL)children {
		[self ref].removeItem(item, (bool)children);
	}
	-(void)viewItem: (uint32_t)item {
		[self ref].viewItem(item);
	}
	-(void)viewItem_: (uint32_t)item {
		[self ref].viewItem(item);
	}
	-(uint32_t)getNumItems {
		return [self ref].getNumItems();
	}
	-(uint32_t)getItem: (uint32_t)index {
		return [self ref].getItem(index);
	}
	-(uint32_t)getItem_: (uint32_t)index {
		return [self ref].getItem(index);
	}
	-(BOOL)switchItemHidden: (uint32_t)item {
		return [self ref].switchItemHidden(item);
	}
	-(BOOL)switchItemHidden_: (uint32_t)item {
		return [self ref].switchItemHidden(item);
	}
	-(BOOL)switchItemHidden_1: (uint32_t)item children: (BOOL)children {
		return [self ref].switchItemHidden(item, (bool)children);
	}
	-(BOOL)switchItemHidden_1_: (uint32_t)item children: (BOOL)children {
		return [self ref].switchItemHidden(item, (bool)children);
	}
	-(void)setItemHidden: (uint32_t)item hidden: (BOOL)hidden {
		[self ref].setItemHidden(item, (bool)hidden);
	}
	-(void)setItemHidden_: (uint32_t)item hidden: (BOOL)hidden {
		[self ref].setItemHidden(item, (bool)hidden);
	}
	-(void)setItemHidden_1: (uint32_t)item hidden: (BOOL)hidden children: (BOOL)children {
		[self ref].setItemHidden(item, (bool)hidden, (bool)children);
	}
	-(void)setItemHidden_1_: (uint32_t)item hidden: (BOOL)hidden children: (BOOL)children {
		[self ref].setItemHidden(item, (bool)hidden, (bool)children);
	}
	-(BOOL)isItemHidden: (uint32_t)item {
		return [self ref].isItemHidden(item);
	}
	-(BOOL)isItemHidden_: (uint32_t)item {
		return [self ref].isItemHidden(item);
	}
	-(BOOL)switchItemExpanded: (uint32_t)item {
		return [self ref].switchItemExpanded(item);
	}
	-(BOOL)switchItemExpanded_: (uint32_t)item {
		return [self ref].switchItemExpanded(item);
	}
	-(BOOL)switchItemExpanded_1: (uint32_t)item children: (BOOL)children {
		return [self ref].switchItemExpanded(item, (bool)children);
	}
	-(BOOL)switchItemExpanded_1_: (uint32_t)item children: (BOOL)children {
		return [self ref].switchItemExpanded(item, (bool)children);
	}
	-(void)setItemExpanded: (uint32_t)item expanded: (BOOL)expanded {
		[self ref].setItemExpanded(item, (bool)expanded);
	}
	-(void)setItemExpanded_: (uint32_t)item expanded: (BOOL)expanded {
		[self ref].setItemExpanded(item, (bool)expanded);
	}
	-(void)setItemExpanded_1: (uint32_t)item expanded: (BOOL)expanded children: (BOOL)children {
		[self ref].setItemExpanded(item, (bool)expanded, (bool)children);
	}
	-(void)setItemExpanded_1_: (uint32_t)item expanded: (BOOL)expanded children: (BOOL)children {
		[self ref].setItemExpanded(item, (bool)expanded, (bool)children);
	}
	-(BOOL)isItemExpanded: (uint32_t)item {
		return [self ref].isItemExpanded(item);
	}
	-(BOOL)isItemExpanded_: (uint32_t)item {
		return [self ref].isItemExpanded(item);
	}
	-(BOOL)switchItemSelected: (uint32_t)item {
		return [self ref].switchItemSelected(item);
	}
	-(BOOL)switchItemSelected_: (uint32_t)item {
		return [self ref].switchItemSelected(item);
	}
	-(BOOL)switchItemSelected_1: (uint32_t)item children: (BOOL)children {
		return [self ref].switchItemSelected(item, (bool)children);
	}
	-(BOOL)switchItemSelected_1_: (uint32_t)item children: (BOOL)children {
		return [self ref].switchItemSelected(item, (bool)children);
	}
	-(void)setItemSelected: (uint32_t)item selected: (BOOL)selected {
		[self ref].setItemSelected(item, (bool)selected);
	}
	-(void)setItemSelected_: (uint32_t)item selected: (BOOL)selected {
		[self ref].setItemSelected(item, (bool)selected);
	}
	-(void)setItemSelected_1: (uint32_t)item selected: (BOOL)selected children: (BOOL)children {
		[self ref].setItemSelected(item, (bool)selected, (bool)children);
	}
	-(void)setItemSelected_1_: (uint32_t)item selected: (BOOL)selected children: (BOOL)children {
		[self ref].setItemSelected(item, (bool)selected, (bool)children);
	}
	-(BOOL)isItemSelected: (uint32_t)item {
		return [self ref].isItemSelected(item);
	}
	-(BOOL)isItemSelected_: (uint32_t)item {
		return [self ref].isItemSelected(item);
	}
	-(void)setItemParent: (uint32_t)item parent: (uint32_t)parent {
		[self ref].setItemParent(item, parent);
	}
	-(void)setItemParent_: (uint32_t)item parent: (uint32_t)parent {
		[self ref].setItemParent(item, parent);
	}
	-(uint32_t)getItemParent: (uint32_t)item {
		return [self ref].getItemParent(item);
	}
	-(uint32_t)getItemParent_: (uint32_t)item {
		return [self ref].getItemParent(item);
	}
	-(BOOL)isItemParent: (uint32_t)item parent: (uint32_t)parent {
		return [self ref].isItemParent(item, parent);
	}
	-(BOOL)isItemParent_: (uint32_t)item parent: (uint32_t)parent {
		return [self ref].isItemParent(item, parent);
	}
	-(BOOL)isItemParent_1: (uint32_t)item parent: (uint32_t)parent hierarchy: (BOOL)hierarchy {
		return [self ref].isItemParent(item, parent, (bool)hierarchy);
	}
	-(BOOL)isItemParent_1_: (uint32_t)item parent: (uint32_t)parent hierarchy: (BOOL)hierarchy {
		return [self ref].isItemParent(item, parent, (bool)hierarchy);
	}
	-(void)addItemChild: (uint32_t)item child: (uint32_t)child {
		[self ref].addItemChild(item, child);
	}
	-(void)addItemChild_: (uint32_t)item child: (uint32_t)child {
		[self ref].addItemChild(item, child);
	}
	-(void)removeItemChild: (uint32_t)item child: (uint32_t)child {
		[self ref].removeItemChild(item, child);
	}
	-(void)removeItemChild_: (uint32_t)item child: (uint32_t)child {
		[self ref].removeItemChild(item, child);
	}
	-(void)addItemChildren: (uint32_t)item children: (uint32_t*)children children_size: (uint32_t)children_size {
		Tellusim::Array<uint32_t> children_(children_size, children);
		[self ref].addItemChildren(item, children_);
	}
	-(void)addItemChildren_: (uint32_t)item children: (uint32_t*)children children_size: (uint32_t)children_size {
		Tellusim::Array<uint32_t> children_(children_size, children);
		[self ref].addItemChildren(item, children_);
	}
	-(void)removeItemChildren: (uint32_t)item children: (uint32_t*)children children_size: (uint32_t)children_size {
		Tellusim::Array<uint32_t> children_(children_size, children);
		[self ref].removeItemChildren(item, children_);
	}
	-(void)removeItemChildren_: (uint32_t)item children: (uint32_t*)children children_size: (uint32_t)children_size {
		Tellusim::Array<uint32_t> children_(children_size, children);
		[self ref].removeItemChildren(item, children_);
	}
	-(uint32_t)findItemChild: (uint32_t)item child: (uint32_t)child {
		return [self ref].findItemChild(item, child);
	}
	-(uint32_t)findItemChild_: (uint32_t)item child: (uint32_t)child {
		return [self ref].findItemChild(item, child);
	}
	-(BOOL)isItemChild: (uint32_t)item child: (uint32_t)child {
		return [self ref].isItemChild(item, child);
	}
	-(BOOL)isItemChild_: (uint32_t)item child: (uint32_t)child {
		return [self ref].isItemChild(item, child);
	}
	-(uint32_t)getNumItemChildren: (uint32_t)item {
		return [self ref].getNumItemChildren(item);
	}
	-(uint32_t)getNumItemChildren_: (uint32_t)item {
		return [self ref].getNumItemChildren(item);
	}
	-(uint32_t)getItemChild: (uint32_t)item index: (uint32_t)index {
		return [self ref].getItemChild(item, index);
	}
	-(uint32_t)getItemChild_: (uint32_t)item index: (uint32_t)index {
		return [self ref].getItemChild(item, index);
	}
	-(NSArray<NSNumber*>*)getItemChildren: (uint32_t)item {
		const auto &ret = [self ref].getItemChildren(item);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[NSNumber numberWithUnsignedInt:ret[i]]];
		return [array copy];
	}
	-(NSArray<NSNumber*>*)getItemChildren_: (uint32_t)item {
		const auto &ret = [self ref].getItemChildren(item);
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[NSNumber numberWithUnsignedInt:ret[i]]];
		return [array copy];
	}
	-(void)setItemText: (uint32_t)item text: (const char*)text {
		[self ref].setItemText(item, text);
	}
	-(void)setItemText_: (uint32_t)item text: (const char*)text {
		[self ref].setItemText(item, text);
	}
	-(void)setItemText_1: (uint32_t)item text: (const TSString*)text {
		[self ref].setItemText(item, (text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setItemText_1_: (uint32_t)item text: (const TSString*)text {
		[self ref].setItemText(item, (text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getItemText: (uint32_t)item {
		return [NSString stringWithUTF8String:[self ref].getItemText(item).get()];
	}
	-(NSString*)getItemText_: (uint32_t)item {
		return [NSString stringWithUTF8String:[self ref].getItemText(item).get()];
	}
	-(uint32_t)findItemText: (const char*)text {
		return [self ref].findItemText(text);
	}
	-(uint32_t)findItemText_: (const char*)text {
		return [self ref].findItemText(text);
	}
	-(uint32_t)findItemText_1: (const TSString*)text {
		return [self ref].findItemText((text) ? [text ref] : Tellusim::String::null);
	}
	-(uint32_t)findItemText_1_: (const TSString*)text {
		return [self ref].findItemText((text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setItemColor: (uint32_t)item color: (TSColor)color {
		[self ref].setItemColor(item, *(Tellusim::Color*)&color);
	}
	-(void)setItemColor_: (uint32_t)item color: (TSColor)color {
		[self ref].setItemColor(item, *(Tellusim::Color*)&color);
	}
	-(TSColor)getItemColor: (uint32_t)item {
		Tellusim::Color ret = [self ref].getItemColor(item);
		return *(TSColor*)&ret;
	}
	-(TSColor)getItemColor_: (uint32_t)item {
		Tellusim::Color ret = [self ref].getItemColor(item);
		return *(TSColor*)&ret;
	}
	-(void)setItemTexture: (uint32_t)item row: (uint32_t)row {
		[self ref].setItemTexture(item, row);
	}
	-(void)setItemTexture_: (uint32_t)item row: (uint32_t)row {
		[self ref].setItemTexture(item, row);
	}
	-(void)setItemTexture_1: (uint32_t)item row: (uint32_t)row column: (uint32_t)column {
		[self ref].setItemTexture(item, row, column);
	}
	-(void)setItemTexture_1_: (uint32_t)item row: (uint32_t)row column: (uint32_t)column {
		[self ref].setItemTexture(item, row, column);
	}
	-(uint32_t)getItemTextureRow: (uint32_t)item {
		return [self ref].getItemTextureRow(item);
	}
	-(uint32_t)getItemTextureRow_: (uint32_t)item {
		return [self ref].getItemTextureRow(item);
	}
	-(uint32_t)getItemTextureColumn: (uint32_t)item {
		return [self ref].getItemTextureColumn(item);
	}
	-(uint32_t)getItemTextureColumn_: (uint32_t)item {
		return [self ref].getItemTextureColumn(item);
	}
	-(void)setItemUserData: (uint32_t)item data: (void*)data {
		[self ref].setItemUserData(item, data);
	}
	-(void)setItemUserData_: (uint32_t)item data: (void*)data {
		[self ref].setItemUserData(item, data);
	}
	-(void*)getItemUserData: (uint32_t)item {
		return [self ref].getItemUserData(item);
	}
	-(void*)getItemUserData_: (uint32_t)item {
		return [self ref].getItemUserData(item);
	}
	-(void)setCurrentItem: (uint32_t)item {
		[self ref].setCurrentItem(item);
	}
	-(void)setCurrentItem_: (uint32_t)item {
		[self ref].setCurrentItem(item);
	}
	-(void)setCurrentItem_1: (uint32_t)item select: (BOOL)select {
		[self ref].setCurrentItem(item, (bool)select);
	}
	-(void)setCurrentItem_1_: (uint32_t)item select: (BOOL)select {
		[self ref].setCurrentItem(item, (bool)select);
	}
	-(void)setCurrentItem_2: (uint32_t)item select: (BOOL)select view: (BOOL)view {
		[self ref].setCurrentItem(item, (bool)select, (bool)view);
	}
	-(void)setCurrentItem_2_: (uint32_t)item select: (BOOL)select view: (BOOL)view {
		[self ref].setCurrentItem(item, (bool)select, (bool)view);
	}
	-(void)setCurrentItem_3: (uint32_t)item select: (BOOL)select view: (BOOL)view callback: (BOOL)callback {
		[self ref].setCurrentItem(item, (bool)select, (bool)view, (bool)callback);
	}
	-(void)setCurrentItem_3_: (uint32_t)item select: (BOOL)select view: (BOOL)view callback: (BOOL)callback {
		[self ref].setCurrentItem(item, (bool)select, (bool)view, (bool)callback);
	}
	-(uint32_t)getCurrentItem {
		return [self ref].getCurrentItem();
	}
	-(NSString*)getCurrentText {
		return [NSString stringWithUTF8String:[self ref].getCurrentText().get()];
	}
	-(void)setSelection {
		[self ref].setSelection();
	}
	-(void)clearSelection {
		[self ref].clearSelection();
	}
	-(void)inverseSelection {
		[self ref].inverseSelection();
	}
	-(uint32_t)getNumSelectedItems {
		return [self ref].getNumSelectedItems();
	}
	-(uint32_t)getSelectedItem: (uint32_t)index {
		return [self ref].getSelectedItem(index);
	}
	-(uint32_t)getSelectedItem_: (uint32_t)index {
		return [self ref].getSelectedItem(index);
	}
	-(NSArray<NSNumber*>*)getSelectedItems {
		const auto &ret = [self ref].getSelectedItems();
		NSMutableArray *array = [NSMutableArray arrayWithCapacity: ret.size()];
		for(uint32_t i = 0; i < ret.size(); i++) [array addObject:[NSNumber numberWithUnsignedInt:ret[i]]];
		return [array copy];
	}
	-(void)setChangedCallback: (id<TSControlTreeChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlTreeChangedCallback(func));
	}
	-(void)setChangedCallback_: (id<TSControlTreeChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlTreeChangedCallback(func));
	}
	-(void)setDraggedCallback: (id<TSControlTreeDraggedCallback>)func {
		[self ref].setDraggedCallback(Tellusim::makeTSControlTreeDraggedCallback(func));
	}
	-(void)setDraggedCallback_: (id<TSControlTreeDraggedCallback>)func {
		[self ref].setDraggedCallback(Tellusim::makeTSControlTreeDraggedCallback(func));
	}
	-(void)setDroppedCallback: (id<TSControlTreeDroppedCallback>)func {
		[self ref].setDroppedCallback(Tellusim::makeTSControlTreeDroppedCallback(func));
	}
	-(void)setDroppedCallback_: (id<TSControlTreeDroppedCallback>)func {
		[self ref].setDroppedCallback(Tellusim::makeTSControlTreeDroppedCallback(func));
	}
	-(void)setClickedCallback: (id<TSControlTreeClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlTreeClickedCallback(func));
	}
	-(void)setClickedCallback_: (id<TSControlTreeClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlTreeClickedCallback(func));
	}
	-(void)setClicked2Callback: (id<TSControlTreeClickedCallback>)func {
		[self ref].setClicked2Callback(Tellusim::makeTSControlTreeClickedCallback(func));
	}
	-(void)setClicked2Callback_: (id<TSControlTreeClickedCallback>)func {
		[self ref].setClicked2Callback(Tellusim::makeTSControlTreeClickedCallback(func));
	}
	-(void)setClickedRightCallback: (id<TSControlTreeClickedCallback>)func {
		[self ref].setClickedRightCallback(Tellusim::makeTSControlTreeClickedCallback(func));
	}
	-(void)setClickedRightCallback_: (id<TSControlTreeClickedCallback>)func {
		[self ref].setClickedRightCallback(Tellusim::makeTSControlTreeClickedCallback(func));
	}
	-(void)setExpandedCallback: (id<TSControlTreeExpandedCallback>)func {
		[self ref].setExpandedCallback(Tellusim::makeTSControlTreeExpandedCallback(func));
	}
	-(void)setExpandedCallback_: (id<TSControlTreeExpandedCallback>)func {
		[self ref].setExpandedCallback(Tellusim::makeTSControlTreeExpandedCallback(func));
	}
	-(void)setSelectedCallback: (id<TSControlTreeSelectedCallback>)func {
		[self ref].setSelectedCallback(Tellusim::makeTSControlTreeSelectedCallback(func));
	}
	-(void)setSelectedCallback_: (id<TSControlTreeSelectedCallback>)func {
		[self ref].setSelectedCallback(Tellusim::makeTSControlTreeSelectedCallback(func));
	}
@end

// Tellusim::ControlEdit
@implementation TSControlEdit
	-(id)init_8 {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit();
		return self;
	}
	-(id)init_9: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit([parent pointer]);
		return self;
	}
	-(id)init_9_: (TSControl*)parent {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit([parent pointer]);
		return self;
	}
	-(id)init_10: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit([parent pointer], text);
		return self;
	}
	-(id)init_10_: (TSControl*)parent text: (const char*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit([parent pointer], text);
		return self;
	}
	-(id)init_11: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_11_: (TSControl*)parent text: (const TSString*)text {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit([parent pointer], (text) ? [text ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_ptr: (Tellusim::ControlEdit*)ptr {
		self = [super init_ptr:nullptr];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::ControlEdit&)ref {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit((Tellusim::ControlEdit&)ref);
		return self;
	}
	-(Tellusim::ControlEdit*)pointer {
		return (Tellusim::ControlEdit*)impl;
	}
	-(Tellusim::ControlEdit&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::ControlEdit*)impl;
	}
	-(id)initControlText: (TSControlText*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit([base ref]);
		return self;
	}
	-(TSControlText*)getControlText {
		return [[TSControlText alloc] init_ref:([self ref].getControlText())];
	}
	-(id)initControl: (TSControl*)base {
		self = [super init_ptr:nullptr];
		impl = new Tellusim::ControlEdit([base ref]);
		return self;
	}
	-(TSControl*)getControl {
		return [[TSControl alloc] init_ref:([self ref].getControl())];
	}
	-(BOOL)equalPtr: (const TSControlEdit*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSControlEdit*)copyPtr {
		return [[TSControlEdit alloc] init_ref:[self ref]];
	}
	-(TSControlEdit*)clonePtr {
		return [[TSControlEdit alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSControlEdit*)null {
		return [[TSControlEdit alloc] init_ptr:nullptr];
	}
	-(void)setFrame: (BOOL)frame {
		[self ref].setFrame((bool)frame);
	}
	-(void)setFrame_: (BOOL)frame {
		[self ref].setFrame((bool)frame);
	}
	-(BOOL)getFrame {
		return [self ref].getFrame();
	}
	-(void)setBackground: (BOOL)background {
		[self ref].setBackground((bool)background);
	}
	-(void)setBackground_: (BOOL)background {
		[self ref].setBackground((bool)background);
	}
	-(BOOL)getBackground {
		return [self ref].getBackground();
	}
	-(void)setEditColor: (TSColor)color {
		[self ref].setEditColor(*(Tellusim::Color*)&color);
	}
	-(void)setEditColor_: (TSColor)color {
		[self ref].setEditColor(*(Tellusim::Color*)&color);
	}
	-(TSColor)getEditColor {
		Tellusim::Color ret = [self ref].getEditColor();
		return *(TSColor*)&ret;
	}
	-(void)setEditMode: (TS_ControlEditEditMode)mode {
		[self ref].setEditMode((Tellusim::ControlEdit::EditMode)mode);
	}
	-(void)setEditMode_: (TS_ControlEditEditMode)mode {
		[self ref].setEditMode((Tellusim::ControlEdit::EditMode)mode);
	}
	-(TS_ControlEditEditMode)getEditMode {
		return (TS_ControlEditEditMode)[self ref].getEditMode();
	}
	-(void)setPasswordCode: (uint32_t)code {
		[self ref].setPasswordCode(code);
	}
	-(void)setPasswordCode_: (uint32_t)code {
		[self ref].setPasswordCode(code);
	}
	-(uint32_t)getPasswordCode {
		return [self ref].getPasswordCode();
	}
	-(uint32_t)getNumCodes {
		return [self ref].getNumCodes();
	}
	-(const uint32_t*)getCodes {
		return [self ref].getCodes();
	}
	-(void)setCurrentIndex: (uint32_t)index {
		[self ref].setCurrentIndex(index);
	}
	-(void)setCurrentIndex_: (uint32_t)index {
		[self ref].setCurrentIndex(index);
	}
	-(void)setCurrentIndex_1: (uint32_t)index selection_index: (uint32_t)selection_index {
		[self ref].setCurrentIndex(index, selection_index);
	}
	-(void)setCurrentIndex_1_: (uint32_t)index selection_index: (uint32_t)selection_index {
		[self ref].setCurrentIndex(index, selection_index);
	}
	-(uint32_t)getCurrentIndex {
		return [self ref].getCurrentIndex();
	}
	-(uint32_t)getSelectionIndex {
		return [self ref].getSelectionIndex();
	}
	-(void)setSelection {
		[self ref].setSelection();
	}
	-(void)setSelection_1: (BOOL)current {
		[self ref].setSelection((bool)current);
	}
	-(void)setSelection_1_: (BOOL)current {
		[self ref].setSelection((bool)current);
	}
	-(void)clearSelection {
		[self ref].clearSelection();
	}
	-(NSString*)getSelectedText {
		return [NSString stringWithUTF8String:[self ref].getSelectedText().get()];
	}
	-(void)setClickedCallback: (id<TSControlEditClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlEditClickedCallback(func));
	}
	-(void)setClickedCallback_: (id<TSControlEditClickedCallback>)func {
		[self ref].setClickedCallback(Tellusim::makeTSControlEditClickedCallback(func));
	}
	-(BOOL)isClicked {
		return [self ref].isClicked();
	}
	-(void)setChangedCallback: (id<TSControlEditChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlEditChangedCallback(func));
	}
	-(void)setChangedCallback_: (id<TSControlEditChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSControlEditChangedCallback(func));
	}
	-(BOOL)isChanged {
		return [self ref].isChanged();
	}
	-(void)setReturnedCallback: (id<TSControlEditReturnedCallback>)func {
		[self ref].setReturnedCallback(Tellusim::makeTSControlEditReturnedCallback(func));
	}
	-(void)setReturnedCallback_: (id<TSControlEditReturnedCallback>)func {
		[self ref].setReturnedCallback(Tellusim::makeTSControlEditReturnedCallback(func));
	}
	-(BOOL)isReturned {
		return [self ref].isReturned();
	}
	-(TSCanvasMesh*)getCanvasMesh {
		return [[TSCanvasMesh alloc] init_ref:([self ref].getCanvasMesh())];
	}
@end

// Tellusim::DialogMessage
@implementation TSDialogMessage
	-(id)init {
		self = [super init];
		impl = new Tellusim::DialogMessage();
		return self;
	}
	-(id)init_1: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogMessage(title);
		return self;
	}
	-(id)init_1_: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogMessage(title);
		return self;
	}
	-(id)init_2: (const char*)title message: (const char*)message {
		self = [super init];
		impl = new Tellusim::DialogMessage(title, message);
		return self;
	}
	-(id)init_2_: (const char*)title message: (const char*)message {
		self = [super init];
		impl = new Tellusim::DialogMessage(title, message);
		return self;
	}
	-(id)init_3: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogMessage((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_3_: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogMessage((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4: (const TSString*)title message: (const char*)message {
		self = [super init];
		impl = new Tellusim::DialogMessage((title) ? [title ref] : Tellusim::String::null, message);
		return self;
	}
	-(id)init_4_: (const TSString*)title message: (const char*)message {
		self = [super init];
		impl = new Tellusim::DialogMessage((title) ? [title ref] : Tellusim::String::null, message);
		return self;
	}
	-(id)init_5: (const char*)title message: (const TSString*)message {
		self = [super init];
		impl = new Tellusim::DialogMessage(title, (message) ? [message ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_5_: (const char*)title message: (const TSString*)message {
		self = [super init];
		impl = new Tellusim::DialogMessage(title, (message) ? [message ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6: (const TSString*)title message: (const TSString*)message {
		self = [super init];
		impl = new Tellusim::DialogMessage((title) ? [title ref] : Tellusim::String::null, (message) ? [message ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6_: (const TSString*)title message: (const TSString*)message {
		self = [super init];
		impl = new Tellusim::DialogMessage((title) ? [title ref] : Tellusim::String::null, (message) ? [message ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_ptr: (Tellusim::DialogMessage*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::DialogMessage&)ref {
		self = [super init];
		impl = new Tellusim::DialogMessage((Tellusim::DialogMessage&)ref);
		return self;
	}
	-(Tellusim::DialogMessage*)pointer {
		return (Tellusim::DialogMessage*)impl;
	}
	-(Tellusim::DialogMessage&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::DialogMessage*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::DialogMessage*)impl;
	}
	-(BOOL)equalPtr: (const TSDialogMessage*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDialogMessage*)copyPtr {
		return [[TSDialogMessage alloc] init_ref:[self ref]];
	}
	-(TSDialogMessage*)clonePtr {
		return [[TSDialogMessage alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDialogMessage*)null {
		return [[TSDialogMessage alloc] init_ptr:nullptr];
	}
	-(void)setPosition: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(int32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(int32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(void)setTitle: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_1: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(void)setTitle_1_: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(NSString*)getTitle {
		return [NSString stringWithUTF8String:[self ref].getTitle().get()];
	}
	-(void)setMessage: (const char*)message {
		[self ref].setMessage(message);
	}
	-(void)setMessage_: (const char*)message {
		[self ref].setMessage(message);
	}
	-(void)setMessage_1: (const TSString*)message {
		[self ref].setMessage((message) ? [message ref] : Tellusim::String::null);
	}
	-(void)setMessage_1_: (const TSString*)message {
		[self ref].setMessage((message) ? [message ref] : Tellusim::String::null);
	}
	-(NSString*)getMessage {
		return [NSString stringWithUTF8String:[self ref].getMessage().get()];
	}
	-(void)setUpdateCallback: (id<TSDialogMessageUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogMessageUpdateCallback(func));
	}
	-(void)setUpdateCallback_: (id<TSDialogMessageUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogMessageUpdateCallback(func));
	}
	-(TS_DialogMessageResult)run {
		return (TS_DialogMessageResult)[self ref].run();
	}
	-(TS_DialogMessageResult)run_1: (TS_DialogMessageFlags)flags {
		return (TS_DialogMessageResult)[self ref].run((Tellusim::DialogMessage::Flags)flags);
	}
	-(TS_DialogMessageResult)run_1_: (TS_DialogMessageFlags)flags {
		return (TS_DialogMessageResult)[self ref].run((Tellusim::DialogMessage::Flags)flags);
	}
@end

// Tellusim::DialogFileOpen
@implementation TSDialogFileOpen
	-(id)init {
		self = [super init];
		impl = new Tellusim::DialogFileOpen();
		return self;
	}
	-(id)init_1: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogFileOpen(title);
		return self;
	}
	-(id)init_1_: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogFileOpen(title);
		return self;
	}
	-(id)init_2: (const char*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogFileOpen(title, name);
		return self;
	}
	-(id)init_2_: (const char*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogFileOpen(title, name);
		return self;
	}
	-(id)init_3: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogFileOpen((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_3_: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogFileOpen((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4: (const TSString*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogFileOpen((title) ? [title ref] : Tellusim::String::null, name);
		return self;
	}
	-(id)init_4_: (const TSString*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogFileOpen((title) ? [title ref] : Tellusim::String::null, name);
		return self;
	}
	-(id)init_5: (const char*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogFileOpen(title, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_5_: (const char*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogFileOpen(title, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6: (const TSString*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogFileOpen((title) ? [title ref] : Tellusim::String::null, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6_: (const TSString*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogFileOpen((title) ? [title ref] : Tellusim::String::null, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_ptr: (Tellusim::DialogFileOpen*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::DialogFileOpen&)ref {
		self = [super init];
		impl = new Tellusim::DialogFileOpen((Tellusim::DialogFileOpen&)ref);
		return self;
	}
	-(Tellusim::DialogFileOpen*)pointer {
		return (Tellusim::DialogFileOpen*)impl;
	}
	-(Tellusim::DialogFileOpen&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::DialogFileOpen*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::DialogFileOpen*)impl;
	}
	-(BOOL)equalPtr: (const TSDialogFileOpen*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDialogFileOpen*)copyPtr {
		return [[TSDialogFileOpen alloc] init_ref:[self ref]];
	}
	-(TSDialogFileOpen*)clonePtr {
		return [[TSDialogFileOpen alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDialogFileOpen*)null {
		return [[TSDialogFileOpen alloc] init_ptr:nullptr];
	}
	-(void)setPosition: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(int32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(int32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(void)setTitle: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_1: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(void)setTitle_1_: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(NSString*)getTitle {
		return [NSString stringWithUTF8String:[self ref].getTitle().get()];
	}
	-(void)setFilter: (const char*)filter {
		[self ref].setFilter(filter);
	}
	-(void)setFilter_: (const char*)filter {
		[self ref].setFilter(filter);
	}
	-(void)setFilter_1: (const TSString*)filter {
		[self ref].setFilter((filter) ? [filter ref] : Tellusim::String::null);
	}
	-(void)setFilter_1_: (const TSString*)filter {
		[self ref].setFilter((filter) ? [filter ref] : Tellusim::String::null);
	}
	-(NSString*)getFilter {
		return [NSString stringWithUTF8String:[self ref].getFilter().get()];
	}
	-(void)setFile: (const char*)name {
		[self ref].setFile(name);
	}
	-(void)setFile_: (const char*)name {
		[self ref].setFile(name);
	}
	-(void)setFile_1: (const TSString*)name {
		[self ref].setFile((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setFile_1_: (const TSString*)name {
		[self ref].setFile((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getFile {
		return [NSString stringWithUTF8String:[self ref].getFile().get()];
	}
	-(void)setUpdateCallback: (id<TSDialogFileOpenUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogFileOpenUpdateCallback(func));
	}
	-(void)setUpdateCallback_: (id<TSDialogFileOpenUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogFileOpenUpdateCallback(func));
	}
	-(TS_DialogFileOpenResult)run {
		return (TS_DialogFileOpenResult)[self ref].run();
	}
	-(TS_DialogFileOpenResult)run_1: (TS_DialogFileOpenFlags)flags {
		return (TS_DialogFileOpenResult)[self ref].run((Tellusim::DialogFileOpen::Flags)flags);
	}
	-(TS_DialogFileOpenResult)run_1_: (TS_DialogFileOpenFlags)flags {
		return (TS_DialogFileOpenResult)[self ref].run((Tellusim::DialogFileOpen::Flags)flags);
	}
@end

// Tellusim::DialogFileSave
@implementation TSDialogFileSave
	-(id)init {
		self = [super init];
		impl = new Tellusim::DialogFileSave();
		return self;
	}
	-(id)init_1: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogFileSave(title);
		return self;
	}
	-(id)init_1_: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogFileSave(title);
		return self;
	}
	-(id)init_2: (const char*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogFileSave(title, name);
		return self;
	}
	-(id)init_2_: (const char*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogFileSave(title, name);
		return self;
	}
	-(id)init_3: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogFileSave((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_3_: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogFileSave((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4: (const TSString*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogFileSave((title) ? [title ref] : Tellusim::String::null, name);
		return self;
	}
	-(id)init_4_: (const TSString*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogFileSave((title) ? [title ref] : Tellusim::String::null, name);
		return self;
	}
	-(id)init_5: (const char*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogFileSave(title, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_5_: (const char*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogFileSave(title, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6: (const TSString*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogFileSave((title) ? [title ref] : Tellusim::String::null, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6_: (const TSString*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogFileSave((title) ? [title ref] : Tellusim::String::null, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_ptr: (Tellusim::DialogFileSave*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::DialogFileSave&)ref {
		self = [super init];
		impl = new Tellusim::DialogFileSave((Tellusim::DialogFileSave&)ref);
		return self;
	}
	-(Tellusim::DialogFileSave*)pointer {
		return (Tellusim::DialogFileSave*)impl;
	}
	-(Tellusim::DialogFileSave&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::DialogFileSave*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::DialogFileSave*)impl;
	}
	-(BOOL)equalPtr: (const TSDialogFileSave*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDialogFileSave*)copyPtr {
		return [[TSDialogFileSave alloc] init_ref:[self ref]];
	}
	-(TSDialogFileSave*)clonePtr {
		return [[TSDialogFileSave alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDialogFileSave*)null {
		return [[TSDialogFileSave alloc] init_ptr:nullptr];
	}
	-(void)setPosition: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(int32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(int32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(void)setTitle: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_1: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(void)setTitle_1_: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(NSString*)getTitle {
		return [NSString stringWithUTF8String:[self ref].getTitle().get()];
	}
	-(void)setFilter: (const char*)filter {
		[self ref].setFilter(filter);
	}
	-(void)setFilter_: (const char*)filter {
		[self ref].setFilter(filter);
	}
	-(void)setFilter_1: (const TSString*)filter {
		[self ref].setFilter((filter) ? [filter ref] : Tellusim::String::null);
	}
	-(void)setFilter_1_: (const TSString*)filter {
		[self ref].setFilter((filter) ? [filter ref] : Tellusim::String::null);
	}
	-(NSString*)getFilter {
		return [NSString stringWithUTF8String:[self ref].getFilter().get()];
	}
	-(void)setFile: (const char*)name {
		[self ref].setFile(name);
	}
	-(void)setFile_: (const char*)name {
		[self ref].setFile(name);
	}
	-(void)setFile_1: (const TSString*)name {
		[self ref].setFile((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setFile_1_: (const TSString*)name {
		[self ref].setFile((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getFile {
		return [NSString stringWithUTF8String:[self ref].getFile().get()];
	}
	-(void)setUpdateCallback: (id<TSDialogFileSaveUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogFileSaveUpdateCallback(func));
	}
	-(void)setUpdateCallback_: (id<TSDialogFileSaveUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogFileSaveUpdateCallback(func));
	}
	-(TS_DialogFileSaveResult)run {
		return (TS_DialogFileSaveResult)[self ref].run();
	}
	-(TS_DialogFileSaveResult)run_1: (TS_DialogFileSaveFlags)flags {
		return (TS_DialogFileSaveResult)[self ref].run((Tellusim::DialogFileSave::Flags)flags);
	}
	-(TS_DialogFileSaveResult)run_1_: (TS_DialogFileSaveFlags)flags {
		return (TS_DialogFileSaveResult)[self ref].run((Tellusim::DialogFileSave::Flags)flags);
	}
@end

// Tellusim::DialogDirectory
@implementation TSDialogDirectory
	-(id)init {
		self = [super init];
		impl = new Tellusim::DialogDirectory();
		return self;
	}
	-(id)init_1: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogDirectory(title);
		return self;
	}
	-(id)init_1_: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogDirectory(title);
		return self;
	}
	-(id)init_2: (const char*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogDirectory(title, name);
		return self;
	}
	-(id)init_2_: (const char*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogDirectory(title, name);
		return self;
	}
	-(id)init_3: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogDirectory((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_3_: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogDirectory((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4: (const TSString*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogDirectory((title) ? [title ref] : Tellusim::String::null, name);
		return self;
	}
	-(id)init_4_: (const TSString*)title name: (const char*)name {
		self = [super init];
		impl = new Tellusim::DialogDirectory((title) ? [title ref] : Tellusim::String::null, name);
		return self;
	}
	-(id)init_5: (const char*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogDirectory(title, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_5_: (const char*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogDirectory(title, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6: (const TSString*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogDirectory((title) ? [title ref] : Tellusim::String::null, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6_: (const TSString*)title name: (const TSString*)name {
		self = [super init];
		impl = new Tellusim::DialogDirectory((title) ? [title ref] : Tellusim::String::null, (name) ? [name ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_ptr: (Tellusim::DialogDirectory*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::DialogDirectory&)ref {
		self = [super init];
		impl = new Tellusim::DialogDirectory((Tellusim::DialogDirectory&)ref);
		return self;
	}
	-(Tellusim::DialogDirectory*)pointer {
		return (Tellusim::DialogDirectory*)impl;
	}
	-(Tellusim::DialogDirectory&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::DialogDirectory*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::DialogDirectory*)impl;
	}
	-(BOOL)equalPtr: (const TSDialogDirectory*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDialogDirectory*)copyPtr {
		return [[TSDialogDirectory alloc] init_ref:[self ref]];
	}
	-(TSDialogDirectory*)clonePtr {
		return [[TSDialogDirectory alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDialogDirectory*)null {
		return [[TSDialogDirectory alloc] init_ptr:nullptr];
	}
	-(void)setPosition: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(int32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(int32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(void)setTitle: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_1: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(void)setTitle_1_: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(NSString*)getTitle {
		return [NSString stringWithUTF8String:[self ref].getTitle().get()];
	}
	-(void)setDirectory: (const char*)name {
		[self ref].setDirectory(name);
	}
	-(void)setDirectory_: (const char*)name {
		[self ref].setDirectory(name);
	}
	-(void)setDirectory_1: (const TSString*)name {
		[self ref].setDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	-(void)setDirectory_1_: (const TSString*)name {
		[self ref].setDirectory((name) ? [name ref] : Tellusim::String::null);
	}
	-(NSString*)getDirectory {
		return [NSString stringWithUTF8String:[self ref].getDirectory().get()];
	}
	-(void)setUpdateCallback: (id<TSDialogDirectoryUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogDirectoryUpdateCallback(func));
	}
	-(void)setUpdateCallback_: (id<TSDialogDirectoryUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogDirectoryUpdateCallback(func));
	}
	-(TS_DialogDirectoryResult)run {
		return (TS_DialogDirectoryResult)[self ref].run();
	}
	-(TS_DialogDirectoryResult)run_1: (TS_DialogDirectoryFlags)flags {
		return (TS_DialogDirectoryResult)[self ref].run((Tellusim::DialogDirectory::Flags)flags);
	}
	-(TS_DialogDirectoryResult)run_1_: (TS_DialogDirectoryFlags)flags {
		return (TS_DialogDirectoryResult)[self ref].run((Tellusim::DialogDirectory::Flags)flags);
	}
@end

// Tellusim::DialogProgress
@implementation TSDialogProgress
	-(id)init {
		self = [super init];
		impl = new Tellusim::DialogProgress();
		return self;
	}
	-(id)init_1: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogProgress(title);
		return self;
	}
	-(id)init_1_: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogProgress(title);
		return self;
	}
	-(id)init_2: (const char*)title message: (const char*)message {
		self = [super init];
		impl = new Tellusim::DialogProgress(title, message);
		return self;
	}
	-(id)init_2_: (const char*)title message: (const char*)message {
		self = [super init];
		impl = new Tellusim::DialogProgress(title, message);
		return self;
	}
	-(id)init_3: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogProgress((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_3_: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogProgress((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4: (const TSString*)title message: (const char*)message {
		self = [super init];
		impl = new Tellusim::DialogProgress((title) ? [title ref] : Tellusim::String::null, message);
		return self;
	}
	-(id)init_4_: (const TSString*)title message: (const char*)message {
		self = [super init];
		impl = new Tellusim::DialogProgress((title) ? [title ref] : Tellusim::String::null, message);
		return self;
	}
	-(id)init_5: (const char*)title message: (const TSString*)message {
		self = [super init];
		impl = new Tellusim::DialogProgress(title, (message) ? [message ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_5_: (const char*)title message: (const TSString*)message {
		self = [super init];
		impl = new Tellusim::DialogProgress(title, (message) ? [message ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6: (const TSString*)title message: (const TSString*)message {
		self = [super init];
		impl = new Tellusim::DialogProgress((title) ? [title ref] : Tellusim::String::null, (message) ? [message ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_6_: (const TSString*)title message: (const TSString*)message {
		self = [super init];
		impl = new Tellusim::DialogProgress((title) ? [title ref] : Tellusim::String::null, (message) ? [message ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_ptr: (Tellusim::DialogProgress*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::DialogProgress&)ref {
		self = [super init];
		impl = new Tellusim::DialogProgress((Tellusim::DialogProgress&)ref);
		return self;
	}
	-(Tellusim::DialogProgress*)pointer {
		return (Tellusim::DialogProgress*)impl;
	}
	-(Tellusim::DialogProgress&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::DialogProgress*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::DialogProgress*)impl;
	}
	-(BOOL)equalPtr: (const TSDialogProgress*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDialogProgress*)copyPtr {
		return [[TSDialogProgress alloc] init_ref:[self ref]];
	}
	-(TSDialogProgress*)clonePtr {
		return [[TSDialogProgress alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDialogProgress*)null {
		return [[TSDialogProgress alloc] init_ptr:nullptr];
	}
	-(void)setPosition: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(int32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(int32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(void)setTitle: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_1: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(void)setTitle_1_: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(NSString*)getTitle {
		return [NSString stringWithUTF8String:[self ref].getTitle().get()];
	}
	-(void)setMessage: (const char*)message {
		[self ref].setMessage(message);
	}
	-(void)setMessage_: (const char*)message {
		[self ref].setMessage(message);
	}
	-(void)setMessage_1: (const TSString*)message {
		[self ref].setMessage((message) ? [message ref] : Tellusim::String::null);
	}
	-(void)setMessage_1_: (const TSString*)message {
		[self ref].setMessage((message) ? [message ref] : Tellusim::String::null);
	}
	-(NSString*)getMessage {
		return [NSString stringWithUTF8String:[self ref].getMessage().get()];
	}
	-(void)setProgress: (uint32_t)progress {
		[self ref].setProgress(progress);
	}
	-(void)setProgress_: (uint32_t)progress {
		[self ref].setProgress(progress);
	}
	-(uint32_t)getProgress {
		return [self ref].getProgress();
	}
	-(TS_DialogProgressResult)run {
		return (TS_DialogProgressResult)[self ref].run();
	}
	-(TS_DialogProgressResult)run_1: (TS_DialogProgressFlags)flags {
		return (TS_DialogProgressResult)[self ref].run((Tellusim::DialogProgress::Flags)flags);
	}
	-(TS_DialogProgressResult)run_1_: (TS_DialogProgressFlags)flags {
		return (TS_DialogProgressResult)[self ref].run((Tellusim::DialogProgress::Flags)flags);
	}
	-(void)close {
		[self ref].close();
	}
@end

// Tellusim::DialogColor
@implementation TSDialogColor
	-(id)init {
		self = [super init];
		impl = new Tellusim::DialogColor();
		return self;
	}
	-(id)init_1: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogColor(title);
		return self;
	}
	-(id)init_1_: (const char*)title {
		self = [super init];
		impl = new Tellusim::DialogColor(title);
		return self;
	}
	-(id)init_2: (const char*)title color: (TSColor)color {
		self = [super init];
		impl = new Tellusim::DialogColor(title, *(Tellusim::Color*)&color);
		return self;
	}
	-(id)init_2_: (const char*)title color: (TSColor)color {
		self = [super init];
		impl = new Tellusim::DialogColor(title, *(Tellusim::Color*)&color);
		return self;
	}
	-(id)init_3: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogColor((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_3_: (const TSString*)title {
		self = [super init];
		impl = new Tellusim::DialogColor((title) ? [title ref] : Tellusim::String::null);
		return self;
	}
	-(id)init_4: (const TSString*)title color: (TSColor)color {
		self = [super init];
		impl = new Tellusim::DialogColor((title) ? [title ref] : Tellusim::String::null, *(Tellusim::Color*)&color);
		return self;
	}
	-(id)init_4_: (const TSString*)title color: (TSColor)color {
		self = [super init];
		impl = new Tellusim::DialogColor((title) ? [title ref] : Tellusim::String::null, *(Tellusim::Color*)&color);
		return self;
	}
	-(id)init_ptr: (Tellusim::DialogColor*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::DialogColor&)ref {
		self = [super init];
		impl = new Tellusim::DialogColor((Tellusim::DialogColor&)ref);
		return self;
	}
	-(Tellusim::DialogColor*)pointer {
		return (Tellusim::DialogColor*)impl;
	}
	-(Tellusim::DialogColor&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::DialogColor*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::DialogColor*)impl;
	}
	-(BOOL)equalPtr: (const TSDialogColor*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDialogColor*)copyPtr {
		return [[TSDialogColor alloc] init_ref:[self ref]];
	}
	-(TSDialogColor*)clonePtr {
		return [[TSDialogColor alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDialogColor*)null {
		return [[TSDialogColor alloc] init_ptr:nullptr];
	}
	-(void)setPosition: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(int32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(int32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(void)setTitle: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_: (const char*)title {
		[self ref].setTitle(title);
	}
	-(void)setTitle_1: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(void)setTitle_1_: (const TSString*)title {
		[self ref].setTitle((title) ? [title ref] : Tellusim::String::null);
	}
	-(NSString*)getTitle {
		return [NSString stringWithUTF8String:[self ref].getTitle().get()];
	}
	-(void)setColor: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_: (TSColor)color {
		[self ref].setColor(*(Tellusim::Color*)&color);
	}
	-(void)setColor_1: (TSColor)color callback: (BOOL)callback {
		[self ref].setColor(*(Tellusim::Color*)&color, (bool)callback);
	}
	-(void)setColor_1_: (TSColor)color callback: (BOOL)callback {
		[self ref].setColor(*(Tellusim::Color*)&color, (bool)callback);
	}
	-(TSColor)getColor {
		Tellusim::Color ret = [self ref].getColor();
		return *(TSColor*)&ret;
	}
	-(void)setChangedCallback: (id<TSDialogColorChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSDialogColorChangedCallback(func));
	}
	-(void)setChangedCallback_: (id<TSDialogColorChangedCallback>)func {
		[self ref].setChangedCallback(Tellusim::makeTSDialogColorChangedCallback(func));
	}
	-(void)setUpdateCallback: (id<TSDialogColorUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogColorUpdateCallback(func));
	}
	-(void)setUpdateCallback_: (id<TSDialogColorUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogColorUpdateCallback(func));
	}
	-(TS_DialogColorResult)run {
		return (TS_DialogColorResult)[self ref].run();
	}
	-(TS_DialogColorResult)run_1: (TS_DialogColorFlags)flags {
		return (TS_DialogColorResult)[self ref].run((Tellusim::DialogColor::Flags)flags);
	}
	-(TS_DialogColorResult)run_1_: (TS_DialogColorFlags)flags {
		return (TS_DialogColorResult)[self ref].run((Tellusim::DialogColor::Flags)flags);
	}
@end

// Tellusim::DialogMenu
@implementation TSDialogMenu
	-(id)init {
		self = [super init];
		impl = new Tellusim::DialogMenu();
		return self;
	}
	-(id)init_ptr: (Tellusim::DialogMenu*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::DialogMenu&)ref {
		self = [super init];
		impl = new Tellusim::DialogMenu((Tellusim::DialogMenu&)ref);
		return self;
	}
	-(Tellusim::DialogMenu*)pointer {
		return (Tellusim::DialogMenu*)impl;
	}
	-(Tellusim::DialogMenu&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::DialogMenu*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::DialogMenu*)impl;
	}
	-(BOOL)equalPtr: (const TSDialogMenu*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDialogMenu*)copyPtr {
		return [[TSDialogMenu alloc] init_ref:[self ref]];
	}
	-(TSDialogMenu*)clonePtr {
		return [[TSDialogMenu alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDialogMenu*)null {
		return [[TSDialogMenu alloc] init_ptr:nullptr];
	}
	-(void)setPosition: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(void)setPosition_: (int32_t)x y: (int32_t)y {
		[self ref].setPosition(x, y);
	}
	-(int32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(int32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(uint32_t)getNumItems {
		return [self ref].getNumItems();
	}
	-(void)setItemText: (uint32_t)index text: (const char*)text {
		[self ref].setItemText(index, text);
	}
	-(void)setItemText_: (uint32_t)index text: (const char*)text {
		[self ref].setItemText(index, text);
	}
	-(void)setItemText_1: (uint32_t)index text: (const TSString*)text {
		[self ref].setItemText(index, (text) ? [text ref] : Tellusim::String::null);
	}
	-(void)setItemText_1_: (uint32_t)index text: (const TSString*)text {
		[self ref].setItemText(index, (text) ? [text ref] : Tellusim::String::null);
	}
	-(NSString*)getItemText: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getItemText(index).get()];
	}
	-(NSString*)getItemText_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getItemText(index).get()];
	}
	-(void)setItemKey: (uint32_t)index key: (const char*)key {
		[self ref].setItemKey(index, key);
	}
	-(void)setItemKey_: (uint32_t)index key: (const char*)key {
		[self ref].setItemKey(index, key);
	}
	-(NSString*)getItemKey: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getItemKey(index).get()];
	}
	-(NSString*)getItemKey_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getItemKey(index).get()];
	}
	-(void)setItemImage: (uint32_t)index image: (const TSImage*)image {
		[self ref].setItemImage(index, [image ref]);
	}
	-(void)setItemImage_: (uint32_t)index image: (const TSImage*)image {
		[self ref].setItemImage(index, [image ref]);
	}
	-(TSImage*)getItemImage: (uint32_t)index {
		return [[TSImage alloc] init_ref:([self ref].getItemImage(index))];
	}
	-(TSImage*)getItemImage_: (uint32_t)index {
		return [[TSImage alloc] init_ref:([self ref].getItemImage(index))];
	}
	-(void)setItemChecked: (uint32_t)index checked: (BOOL)checked {
		[self ref].setItemChecked(index, (bool)checked);
	}
	-(void)setItemChecked_: (uint32_t)index checked: (BOOL)checked {
		[self ref].setItemChecked(index, (bool)checked);
	}
	-(void)setItemChecked_1: (uint32_t)index checked: (BOOL)checked callback: (BOOL)callback {
		[self ref].setItemChecked(index, (bool)checked, (bool)callback);
	}
	-(void)setItemChecked_1_: (uint32_t)index checked: (BOOL)checked callback: (BOOL)callback {
		[self ref].setItemChecked(index, (bool)checked, (bool)callback);
	}
	-(BOOL)isItemChecked: (uint32_t)index {
		return [self ref].isItemChecked(index);
	}
	-(BOOL)isItemChecked_: (uint32_t)index {
		return [self ref].isItemChecked(index);
	}
	-(void)setItemEnabled: (uint32_t)index enabled: (BOOL)enabled {
		[self ref].setItemEnabled(index, (bool)enabled);
	}
	-(void)setItemEnabled_: (uint32_t)index enabled: (BOOL)enabled {
		[self ref].setItemEnabled(index, (bool)enabled);
	}
	-(BOOL)isItemEnabled: (uint32_t)index {
		return [self ref].isItemEnabled(index);
	}
	-(BOOL)isItemEnabled_: (uint32_t)index {
		return [self ref].isItemEnabled(index);
	}
	-(void)setItemHidden: (uint32_t)index hidden: (BOOL)hidden {
		[self ref].setItemHidden(index, (bool)hidden);
	}
	-(void)setItemHidden_: (uint32_t)index hidden: (BOOL)hidden {
		[self ref].setItemHidden(index, (bool)hidden);
	}
	-(BOOL)isItemHidden: (uint32_t)index {
		return [self ref].isItemHidden(index);
	}
	-(BOOL)isItemHidden_: (uint32_t)index {
		return [self ref].isItemHidden(index);
	}
	-(void)setItemsGroup: (uint32_t)index size: (uint32_t)size {
		[self ref].setItemsGroup(index, size);
	}
	-(void)setItemsGroup_: (uint32_t)index size: (uint32_t)size {
		[self ref].setItemsGroup(index, size);
	}
	-(uint32_t)getItemGroupIndex: (uint32_t)index {
		return [self ref].getItemGroupIndex(index);
	}
	-(uint32_t)getItemGroupIndex_: (uint32_t)index {
		return [self ref].getItemGroupIndex(index);
	}
	-(uint32_t)getItemGroupSize: (uint32_t)index {
		return [self ref].getItemGroupSize(index);
	}
	-(uint32_t)getItemGroupSize_: (uint32_t)index {
		return [self ref].getItemGroupSize(index);
	}
	-(uint32_t)addItem: (const char*)text {
		return [self ref].addItem(text);
	}
	-(uint32_t)addItem_: (const char*)text {
		return [self ref].addItem(text);
	}
	-(uint32_t)addItem_1: (const char*)text key: (const char*)key {
		return [self ref].addItem(text, key);
	}
	-(uint32_t)addItem_1_: (const char*)text key: (const char*)key {
		return [self ref].addItem(text, key);
	}
	-(uint32_t)addItem_2: (const TSString*)text {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null);
	}
	-(uint32_t)addItem_2_: (const TSString*)text {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null);
	}
	-(uint32_t)addItem_3: (const TSString*)text key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, key);
	}
	-(uint32_t)addItem_3_: (const TSString*)text key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, key);
	}
	-(uint32_t)addItem_4: (const char*)text image: (const TSImage*)image {
		return [self ref].addItem(text, [image ref]);
	}
	-(uint32_t)addItem_4_: (const char*)text image: (const TSImage*)image {
		return [self ref].addItem(text, [image ref]);
	}
	-(uint32_t)addItem_5: (const char*)text image: (const TSImage*)image key: (const char*)key {
		return [self ref].addItem(text, [image ref], key);
	}
	-(uint32_t)addItem_5_: (const char*)text image: (const TSImage*)image key: (const char*)key {
		return [self ref].addItem(text, [image ref], key);
	}
	-(uint32_t)addItem_6: (const TSString*)text image: (const TSImage*)image {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref]);
	}
	-(uint32_t)addItem_6_: (const TSString*)text image: (const TSImage*)image {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref]);
	}
	-(uint32_t)addItem_7: (const TSString*)text image: (const TSImage*)image key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], key);
	}
	-(uint32_t)addItem_7_: (const TSString*)text image: (const TSImage*)image key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], key);
	}
	-(uint32_t)addItem_8: (const char*)text func: (id<TSDialogMenuClickedCallback>)func {
		return [self ref].addItem(text, Tellusim::makeTSDialogMenuClickedCallback(func));
	}
	-(uint32_t)addItem_8_: (const char*)text func: (id<TSDialogMenuClickedCallback>)func {
		return [self ref].addItem(text, Tellusim::makeTSDialogMenuClickedCallback(func));
	}
	-(uint32_t)addItem_9: (const char*)text func: (id<TSDialogMenuClickedCallback>)func key: (const char*)key {
		return [self ref].addItem(text, Tellusim::makeTSDialogMenuClickedCallback(func), key);
	}
	-(uint32_t)addItem_9_: (const char*)text func: (id<TSDialogMenuClickedCallback>)func key: (const char*)key {
		return [self ref].addItem(text, Tellusim::makeTSDialogMenuClickedCallback(func), key);
	}
	-(uint32_t)addItem_10: (const TSString*)text func: (id<TSDialogMenuClickedCallback>)func {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, Tellusim::makeTSDialogMenuClickedCallback(func));
	}
	-(uint32_t)addItem_10_: (const TSString*)text func: (id<TSDialogMenuClickedCallback>)func {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, Tellusim::makeTSDialogMenuClickedCallback(func));
	}
	-(uint32_t)addItem_11: (const TSString*)text func: (id<TSDialogMenuClickedCallback>)func key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, Tellusim::makeTSDialogMenuClickedCallback(func), key);
	}
	-(uint32_t)addItem_11_: (const TSString*)text func: (id<TSDialogMenuClickedCallback>)func key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, Tellusim::makeTSDialogMenuClickedCallback(func), key);
	}
	-(uint32_t)addItem_12: (const char*)text image: (const TSImage*)image func: (id<TSDialogMenuClickedCallback>)func {
		return [self ref].addItem(text, [image ref], Tellusim::makeTSDialogMenuClickedCallback(func));
	}
	-(uint32_t)addItem_12_: (const char*)text image: (const TSImage*)image func: (id<TSDialogMenuClickedCallback>)func {
		return [self ref].addItem(text, [image ref], Tellusim::makeTSDialogMenuClickedCallback(func));
	}
	-(uint32_t)addItem_13: (const char*)text image: (const TSImage*)image func: (id<TSDialogMenuClickedCallback>)func key: (const char*)key {
		return [self ref].addItem(text, [image ref], Tellusim::makeTSDialogMenuClickedCallback(func), key);
	}
	-(uint32_t)addItem_13_: (const char*)text image: (const TSImage*)image func: (id<TSDialogMenuClickedCallback>)func key: (const char*)key {
		return [self ref].addItem(text, [image ref], Tellusim::makeTSDialogMenuClickedCallback(func), key);
	}
	-(uint32_t)addItem_14: (const TSString*)text image: (const TSImage*)image func: (id<TSDialogMenuClickedCallback>)func {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], Tellusim::makeTSDialogMenuClickedCallback(func));
	}
	-(uint32_t)addItem_14_: (const TSString*)text image: (const TSImage*)image func: (id<TSDialogMenuClickedCallback>)func {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], Tellusim::makeTSDialogMenuClickedCallback(func));
	}
	-(uint32_t)addItem_15: (const TSString*)text image: (const TSImage*)image func: (id<TSDialogMenuClickedCallback>)func key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], Tellusim::makeTSDialogMenuClickedCallback(func), key);
	}
	-(uint32_t)addItem_15_: (const TSString*)text image: (const TSImage*)image func: (id<TSDialogMenuClickedCallback>)func key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], Tellusim::makeTSDialogMenuClickedCallback(func), key);
	}
	-(uint32_t)addItem_16: (const char*)text checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func {
		return [self ref].addItem(text, (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func));
	}
	-(uint32_t)addItem_16_: (const char*)text checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func {
		return [self ref].addItem(text, (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func));
	}
	-(uint32_t)addItem_17: (const char*)text checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func key: (const char*)key {
		return [self ref].addItem(text, (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func), key);
	}
	-(uint32_t)addItem_17_: (const char*)text checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func key: (const char*)key {
		return [self ref].addItem(text, (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func), key);
	}
	-(uint32_t)addItem_18: (const TSString*)text checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func));
	}
	-(uint32_t)addItem_18_: (const TSString*)text checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func));
	}
	-(uint32_t)addItem_19: (const TSString*)text checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func), key);
	}
	-(uint32_t)addItem_19_: (const TSString*)text checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func), key);
	}
	-(uint32_t)addItem_20: (const char*)text image: (const TSImage*)image checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func {
		return [self ref].addItem(text, [image ref], (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func));
	}
	-(uint32_t)addItem_20_: (const char*)text image: (const TSImage*)image checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func {
		return [self ref].addItem(text, [image ref], (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func));
	}
	-(uint32_t)addItem_21: (const char*)text image: (const TSImage*)image checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func key: (const char*)key {
		return [self ref].addItem(text, [image ref], (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func), key);
	}
	-(uint32_t)addItem_21_: (const char*)text image: (const TSImage*)image checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func key: (const char*)key {
		return [self ref].addItem(text, [image ref], (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func), key);
	}
	-(uint32_t)addItem_22: (const TSString*)text image: (const TSImage*)image checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func));
	}
	-(uint32_t)addItem_22_: (const TSString*)text image: (const TSImage*)image checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func));
	}
	-(uint32_t)addItem_23: (const TSString*)text image: (const TSImage*)image checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func), key);
	}
	-(uint32_t)addItem_23_: (const TSString*)text image: (const TSImage*)image checked: (BOOL)checked func: (id<TSDialogMenuChangedCallback>)func key: (const char*)key {
		return [self ref].addItem((text) ? [text ref] : Tellusim::String::null, [image ref], (bool)checked, Tellusim::makeTSDialogMenuChangedCallback(func), key);
	}
	-(void)setUpdateCallback: (id<TSDialogMenuUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogMenuUpdateCallback(func));
	}
	-(void)setUpdateCallback_: (id<TSDialogMenuUpdateCallback>)func {
		[self ref].setUpdateCallback(Tellusim::makeTSDialogMenuUpdateCallback(func));
	}
	-(TS_DialogMenuResult)run {
		return (TS_DialogMenuResult)[self ref].run();
	}
	-(TS_DialogMenuResult)run_1: (TS_DialogMenuFlags)flags {
		return (TS_DialogMenuResult)[self ref].run((Tellusim::DialogMenu::Flags)flags);
	}
	-(TS_DialogMenuResult)run_1_: (TS_DialogMenuFlags)flags {
		return (TS_DialogMenuResult)[self ref].run((Tellusim::DialogMenu::Flags)flags);
	}
@end

// Tellusim::CubeFilter
@implementation TSCubeFilter
	-(id)init {
		self = [super init];
		impl = new Tellusim::CubeFilter();
		return self;
	}
	-(id)init_ptr: (Tellusim::CubeFilter*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::CubeFilter&)ref {
		self = [super init];
		impl = new Tellusim::CubeFilter((Tellusim::CubeFilter&)ref);
		return self;
	}
	-(Tellusim::CubeFilter*)pointer {
		return (Tellusim::CubeFilter*)impl;
	}
	-(Tellusim::CubeFilter&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::CubeFilter*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::CubeFilter*)impl;
	}
	-(BOOL)equalPtr: (const TSCubeFilter*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSCubeFilter*)copyPtr {
		return [[TSCubeFilter alloc] init_ref:[self ref]];
	}
	-(TSCubeFilter*)clonePtr {
		return [[TSCubeFilter alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSCubeFilter*)null {
		return [[TSCubeFilter alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_CubeFilterMode)mode {
		return [self ref].isCreated((Tellusim::CubeFilter::Mode)mode);
	}
	-(BOOL)isCreated_: (TS_CubeFilterMode)mode {
		return [self ref].isCreated((Tellusim::CubeFilter::Mode)mode);
	}
	-(uint32_t)getGroupSize {
		return [self ref].getGroupSize();
	}
	-(uint32_t)getMaxOrder {
		return [self ref].getMaxOrder();
	}
	-(uint32_t)getMaxSize {
		return [self ref].getMaxSize();
	}
	-(uint32_t)getHarmonics {
		return [self ref].getHarmonics();
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_CubeFilterMode)mode {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Mode)mode);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_CubeFilterMode)mode {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Mode)mode);
	}
	-(BOOL)create_1: (const TSDevice*)device mode: (TS_CubeFilterMode)mode order: (uint32_t)order {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Mode)mode, order);
	}
	-(BOOL)create_1_: (const TSDevice*)device mode: (TS_CubeFilterMode)mode order: (uint32_t)order {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Mode)mode, order);
	}
	-(BOOL)create_2: (const TSDevice*)device mode: (TS_CubeFilterMode)mode order: (uint32_t)order size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Mode)mode, order, size);
	}
	-(BOOL)create_2_: (const TSDevice*)device mode: (TS_CubeFilterMode)mode order: (uint32_t)order size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Mode)mode, order, size);
	}
	-(BOOL)create_3: (const TSDevice*)device mode: (TS_CubeFilterMode)mode order: (uint32_t)order size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Mode)mode, order, size, groups);
	}
	-(BOOL)create_3_: (const TSDevice*)device mode: (TS_CubeFilterMode)mode order: (uint32_t)order size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Mode)mode, order, size, groups);
	}
	-(BOOL)create_4: (const TSDevice*)device flags: (TS_CubeFilterFlags)flags {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Flags)flags);
	}
	-(BOOL)create_4_: (const TSDevice*)device flags: (TS_CubeFilterFlags)flags {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Flags)flags);
	}
	-(BOOL)create_5: (const TSDevice*)device flags: (TS_CubeFilterFlags)flags order: (uint32_t)order {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Flags)flags, order);
	}
	-(BOOL)create_5_: (const TSDevice*)device flags: (TS_CubeFilterFlags)flags order: (uint32_t)order {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Flags)flags, order);
	}
	-(BOOL)create_6: (const TSDevice*)device flags: (TS_CubeFilterFlags)flags order: (uint32_t)order size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Flags)flags, order, size);
	}
	-(BOOL)create_6_: (const TSDevice*)device flags: (TS_CubeFilterFlags)flags order: (uint32_t)order size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Flags)flags, order, size);
	}
	-(BOOL)create_7: (const TSDevice*)device flags: (TS_CubeFilterFlags)flags order: (uint32_t)order size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Flags)flags, order, size, groups);
	}
	-(BOOL)create_7_: (const TSDevice*)device flags: (TS_CubeFilterFlags)flags order: (uint32_t)order size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::CubeFilter::Flags)flags, order, size, groups);
	}
	-(BOOL)dispatch: (TSCompute*)compute buffer: (TSBuffer*)buffer offset: (uint32_t)offset texture: (TSTexture*)texture slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], [buffer ref], offset, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)dispatch_: (TSCompute*)compute buffer: (TSBuffer*)buffer offset: (uint32_t)offset texture: (TSTexture*)texture slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], [buffer ref], offset, [texture ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute buffer: (TSBuffer*)buffer offset: (uint32_t)offset texture: (TSTexture*)texture {
		return [self ref].dispatch([compute ref], [buffer ref], offset, [texture ref]);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute buffer: (TSBuffer*)buffer offset: (uint32_t)offset texture: (TSTexture*)texture {
		return [self ref].dispatch([compute ref], [buffer ref], offset, [texture ref]);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute texture: (TSTexture*)texture slice: (TSSlice)slice buffer: (TSBuffer*)buffer offset: (uint32_t)offset {
		return [self ref].dispatch([compute ref], [texture ref], *(Tellusim::Slice*)&slice, [buffer ref], offset);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute texture: (TSTexture*)texture slice: (TSSlice)slice buffer: (TSBuffer*)buffer offset: (uint32_t)offset {
		return [self ref].dispatch([compute ref], [texture ref], *(Tellusim::Slice*)&slice, [buffer ref], offset);
	}
	-(BOOL)dispatch_3: (TSCompute*)compute texture: (TSTexture*)texture buffer: (TSBuffer*)buffer offset: (uint32_t)offset {
		return [self ref].dispatch([compute ref], [texture ref], [buffer ref], offset);
	}
	-(BOOL)dispatch_3_: (TSCompute*)compute texture: (TSTexture*)texture buffer: (TSBuffer*)buffer offset: (uint32_t)offset {
		return [self ref].dispatch([compute ref], [texture ref], [buffer ref], offset);
	}
@end

// Tellusim::DecoderJPEG
@implementation TSDecoderJPEG
	-(id)init {
		self = [super init];
		impl = new Tellusim::DecoderJPEG();
		return self;
	}
	-(id)init_ptr: (Tellusim::DecoderJPEG*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::DecoderJPEG&)ref {
		self = [super init];
		impl = new Tellusim::DecoderJPEG((Tellusim::DecoderJPEG&)ref);
		return self;
	}
	-(Tellusim::DecoderJPEG*)pointer {
		return (Tellusim::DecoderJPEG*)impl;
	}
	-(Tellusim::DecoderJPEG&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::DecoderJPEG*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::DecoderJPEG*)impl;
	}
	-(BOOL)equalPtr: (const TSDecoderJPEG*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDecoderJPEG*)copyPtr {
		return [[TSDecoderJPEG alloc] init_ref:[self ref]];
	}
	-(TSDecoderJPEG*)clonePtr {
		return [[TSDecoderJPEG alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDecoderJPEG*)null {
		return [[TSDecoderJPEG alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_DecoderJPEGMode)mode {
		return [self ref].isCreated((Tellusim::DecoderJPEG::Mode)mode);
	}
	-(BOOL)isCreated_: (TS_DecoderJPEGMode)mode {
		return [self ref].isCreated((Tellusim::DecoderJPEG::Mode)mode);
	}
	+(BOOL)isYUV: (TS_DecoderJPEGMode)mode {
		return Tellusim::DecoderJPEG::isYUV((Tellusim::DecoderJPEG::Mode)mode);
	}
	+(BOOL)isYUV_: (TS_DecoderJPEGMode)mode {
		return Tellusim::DecoderJPEG::isYUV((Tellusim::DecoderJPEG::Mode)mode);
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_DecoderJPEGMode)mode {
		return [self ref].create([device ref], (Tellusim::DecoderJPEG::Mode)mode);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_DecoderJPEGMode)mode {
		return [self ref].create([device ref], (Tellusim::DecoderJPEG::Mode)mode);
	}
	-(BOOL)create_1: (const TSDevice*)device flags: (TS_DecoderJPEGFlags)flags {
		return [self ref].create([device ref], (Tellusim::DecoderJPEG::Flags)flags);
	}
	-(BOOL)create_1_: (const TSDevice*)device flags: (TS_DecoderJPEGFlags)flags {
		return [self ref].create([device ref], (Tellusim::DecoderJPEG::Flags)flags);
	}
	+(BOOL)load: (const char*)name image: (TSImage*)image mode: (TS_DecoderJPEGMode*)mode size: (TSSize*)size {
		TS_ASSERT(mode);
		return Tellusim::DecoderJPEG::load(name, [image ref], (Tellusim::DecoderJPEG::Mode&)*mode, *(Tellusim::Size*)size);
	}
	+(BOOL)load_: (const char*)name image: (TSImage*)image mode: (TS_DecoderJPEGMode*)mode size: (TSSize*)size {
		TS_ASSERT(mode);
		return Tellusim::DecoderJPEG::load(name, [image ref], (Tellusim::DecoderJPEG::Mode&)*mode, *(Tellusim::Size*)size);
	}
	+(BOOL)load_1: (TSStream*)stream image: (TSImage*)image mode: (TS_DecoderJPEGMode*)mode size: (TSSize*)size {
		TS_ASSERT(mode);
		return Tellusim::DecoderJPEG::load([stream ref], [image ref], (Tellusim::DecoderJPEG::Mode&)*mode, *(Tellusim::Size*)size);
	}
	+(BOOL)load_1_: (TSStream*)stream image: (TSImage*)image mode: (TS_DecoderJPEGMode*)mode size: (TSSize*)size {
		TS_ASSERT(mode);
		return Tellusim::DecoderJPEG::load([stream ref], [image ref], (Tellusim::DecoderJPEG::Mode&)*mode, *(Tellusim::Size*)size);
	}
	-(TSTexture*)loadTexture: (const TSDevice*)device name: (const char*)name {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([device ref], name))];
	}
	-(TSTexture*)loadTexture_: (const TSDevice*)device name: (const char*)name {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([device ref], name))];
	}
	-(TSTexture*)loadTexture_1: (const TSDevice*)device name: (const char*)name flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([device ref], name, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture_1_: (const TSDevice*)device name: (const char*)name flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([device ref], name, (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture_2: (const TSDevice*)device stream: (TSStream*)stream {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([device ref], [stream ref]))];
	}
	-(TSTexture*)loadTexture_2_: (const TSDevice*)device stream: (TSStream*)stream {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([device ref], [stream ref]))];
	}
	-(TSTexture*)loadTexture_3: (const TSDevice*)device stream: (TSStream*)stream flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([device ref], [stream ref], (Tellusim::Texture::Flags)flags))];
	}
	-(TSTexture*)loadTexture_3_: (const TSDevice*)device stream: (TSStream*)stream flags: (TS_TextureFlags)flags {
		return [[TSTexture alloc] init_ref:([self ref].loadTexture([device ref], [stream ref], (Tellusim::Texture::Flags)flags))];
	}
	-(BOOL)dispatch: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref]);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref]);
	}
	-(BOOL)dispatchYUV: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatchYUV([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatchYUV_: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatchYUV([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatchYUV_1: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatchYUV([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatchYUV_1_: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatchYUV([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatchYUV_2: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatchYUV([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref]);
	}
	-(BOOL)dispatchYUV_2_: (TSCompute*)compute mode: (TS_DecoderJPEGMode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatchYUV([compute ref], (Tellusim::DecoderJPEG::Mode)mode, [dest ref], [src ref]);
	}
@end

// Tellusim::EncoderBC15
@implementation TSEncoderBC15
	-(id)init {
		self = [super init];
		impl = new Tellusim::EncoderBC15();
		return self;
	}
	-(id)init_ptr: (Tellusim::EncoderBC15*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::EncoderBC15&)ref {
		self = [super init];
		impl = new Tellusim::EncoderBC15((Tellusim::EncoderBC15&)ref);
		return self;
	}
	-(Tellusim::EncoderBC15*)pointer {
		return (Tellusim::EncoderBC15*)impl;
	}
	-(Tellusim::EncoderBC15&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::EncoderBC15*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::EncoderBC15*)impl;
	}
	-(BOOL)equalPtr: (const TSEncoderBC15*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSEncoderBC15*)copyPtr {
		return [[TSEncoderBC15 alloc] init_ref:[self ref]];
	}
	-(TSEncoderBC15*)clonePtr {
		return [[TSEncoderBC15 alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSEncoderBC15*)null {
		return [[TSEncoderBC15 alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_EncoderBC15Mode)mode {
		return [self ref].isCreated((Tellusim::EncoderBC15::Mode)mode);
	}
	-(BOOL)isCreated_: (TS_EncoderBC15Mode)mode {
		return [self ref].isCreated((Tellusim::EncoderBC15::Mode)mode);
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_EncoderBC15Mode)mode {
		return [self ref].create([device ref], (Tellusim::EncoderBC15::Mode)mode);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_EncoderBC15Mode)mode {
		return [self ref].create([device ref], (Tellusim::EncoderBC15::Mode)mode);
	}
	-(BOOL)create_1: (const TSDevice*)device flags: (TS_EncoderBC15Flags)flags {
		return [self ref].create([device ref], (Tellusim::EncoderBC15::Flags)flags);
	}
	-(BOOL)create_1_: (const TSDevice*)device flags: (TS_EncoderBC15Flags)flags {
		return [self ref].create([device ref], (Tellusim::EncoderBC15::Flags)flags);
	}
	-(BOOL)dispatch: (TSCompute*)compute mode: (TS_EncoderBC15Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC15::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_: (TSCompute*)compute mode: (TS_EncoderBC15Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC15::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute mode: (TS_EncoderBC15Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC15::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute mode: (TS_EncoderBC15Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC15::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute mode: (TS_EncoderBC15Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC15::Mode)mode, [dest ref], [src ref]);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute mode: (TS_EncoderBC15Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC15::Mode)mode, [dest ref], [src ref]);
	}
@end

// Tellusim::EncoderBC67
@implementation TSEncoderBC67
	-(id)init {
		self = [super init];
		impl = new Tellusim::EncoderBC67();
		return self;
	}
	-(id)init_ptr: (Tellusim::EncoderBC67*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::EncoderBC67&)ref {
		self = [super init];
		impl = new Tellusim::EncoderBC67((Tellusim::EncoderBC67&)ref);
		return self;
	}
	-(Tellusim::EncoderBC67*)pointer {
		return (Tellusim::EncoderBC67*)impl;
	}
	-(Tellusim::EncoderBC67&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::EncoderBC67*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::EncoderBC67*)impl;
	}
	-(BOOL)equalPtr: (const TSEncoderBC67*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSEncoderBC67*)copyPtr {
		return [[TSEncoderBC67 alloc] init_ref:[self ref]];
	}
	-(TSEncoderBC67*)clonePtr {
		return [[TSEncoderBC67 alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSEncoderBC67*)null {
		return [[TSEncoderBC67 alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_EncoderBC67Mode)mode {
		return [self ref].isCreated((Tellusim::EncoderBC67::Mode)mode);
	}
	-(BOOL)isCreated_: (TS_EncoderBC67Mode)mode {
		return [self ref].isCreated((Tellusim::EncoderBC67::Mode)mode);
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_EncoderBC67Mode)mode {
		return [self ref].create([device ref], (Tellusim::EncoderBC67::Mode)mode);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_EncoderBC67Mode)mode {
		return [self ref].create([device ref], (Tellusim::EncoderBC67::Mode)mode);
	}
	-(BOOL)create_1: (const TSDevice*)device flags: (TS_EncoderBC67Flags)flags {
		return [self ref].create([device ref], (Tellusim::EncoderBC67::Flags)flags);
	}
	-(BOOL)create_1_: (const TSDevice*)device flags: (TS_EncoderBC67Flags)flags {
		return [self ref].create([device ref], (Tellusim::EncoderBC67::Flags)flags);
	}
	-(BOOL)dispatch: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice, components);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice, components);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_3: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice, components);
	}
	-(BOOL)dispatch_3_: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice, components);
	}
	-(BOOL)dispatch_4: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref]);
	}
	-(BOOL)dispatch_4_: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref]);
	}
	-(BOOL)dispatch_5: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], components);
	}
	-(BOOL)dispatch_5_: (TSCompute*)compute mode: (TS_EncoderBC67Mode)mode dest: (TSTexture*)dest src: (TSTexture*)src components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderBC67::Mode)mode, [dest ref], [src ref], components);
	}
@end

// Tellusim::EncoderASTC
@implementation TSEncoderASTC
	-(id)init {
		self = [super init];
		impl = new Tellusim::EncoderASTC();
		return self;
	}
	-(id)init_ptr: (Tellusim::EncoderASTC*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::EncoderASTC&)ref {
		self = [super init];
		impl = new Tellusim::EncoderASTC((Tellusim::EncoderASTC&)ref);
		return self;
	}
	-(Tellusim::EncoderASTC*)pointer {
		return (Tellusim::EncoderASTC*)impl;
	}
	-(Tellusim::EncoderASTC&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::EncoderASTC*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::EncoderASTC*)impl;
	}
	-(BOOL)equalPtr: (const TSEncoderASTC*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSEncoderASTC*)copyPtr {
		return [[TSEncoderASTC alloc] init_ref:[self ref]];
	}
	-(TSEncoderASTC*)clonePtr {
		return [[TSEncoderASTC alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSEncoderASTC*)null {
		return [[TSEncoderASTC alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_EncoderASTCMode)mode {
		return [self ref].isCreated((Tellusim::EncoderASTC::Mode)mode);
	}
	-(BOOL)isCreated_: (TS_EncoderASTCMode)mode {
		return [self ref].isCreated((Tellusim::EncoderASTC::Mode)mode);
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_EncoderASTCMode)mode {
		return [self ref].create([device ref], (Tellusim::EncoderASTC::Mode)mode);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_EncoderASTCMode)mode {
		return [self ref].create([device ref], (Tellusim::EncoderASTC::Mode)mode);
	}
	-(BOOL)create_1: (const TSDevice*)device flags: (TS_EncoderASTCFlags)flags {
		return [self ref].create([device ref], (Tellusim::EncoderASTC::Flags)flags);
	}
	-(BOOL)create_1_: (const TSDevice*)device flags: (TS_EncoderASTCFlags)flags {
		return [self ref].create([device ref], (Tellusim::EncoderASTC::Flags)flags);
	}
	-(BOOL)dispatch: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice, components);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice, components);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_3: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice, components);
	}
	-(BOOL)dispatch_3_: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice, components);
	}
	-(BOOL)dispatch_4: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref]);
	}
	-(BOOL)dispatch_4_: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref]);
	}
	-(BOOL)dispatch_5: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], components);
	}
	-(BOOL)dispatch_5_: (TSCompute*)compute mode: (TS_EncoderASTCMode)mode dest: (TSTexture*)dest src: (TSTexture*)src components: (uint32_t)components {
		return [self ref].dispatch([compute ref], (Tellusim::EncoderASTC::Mode)mode, [dest ref], [src ref], components);
	}
@end

// Tellusim::MeshModel
@implementation TSMeshModel
	-(id)init {
		self = [super init];
		impl = new Tellusim::MeshModel();
		return self;
	}
	-(id)init_ptr: (Tellusim::MeshModel*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(Tellusim::MeshModel*)pointer {
		return (Tellusim::MeshModel*)impl;
	}
	-(Tellusim::MeshModel&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::MeshModel*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::MeshModel*)impl;
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(TS_MeshModelFlags)getFlags {
		return (TS_MeshModelFlags)[self ref].getFlags();
	}
	-(BOOL)hasFlag: (TS_MeshModelFlags)flags {
		return [self ref].hasFlag((Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)hasFlag_: (TS_MeshModelFlags)flags {
		return [self ref].hasFlag((Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)hasFlags: (TS_MeshModelFlags)flags {
		return [self ref].hasFlags((Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)hasFlags_: (TS_MeshModelFlags)flags {
		return [self ref].hasFlags((Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)load: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name {
		return [self ref].load([device ref], [pipeline ref], name);
	}
	-(BOOL)load_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name {
		return [self ref].load([device ref], [pipeline ref], name);
	}
	-(BOOL)load_1: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name flags: (TS_MeshModelFlags)flags {
		return [self ref].load([device ref], [pipeline ref], name, (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)load_1_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name flags: (TS_MeshModelFlags)flags {
		return [self ref].load([device ref], [pipeline ref], name, (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)load_2: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name flags: (TS_MeshModelFlags)flags async: (TSAsync**)async {
		return [self ref].load([device ref], [pipeline ref], name, (Tellusim::MeshModel::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_2_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name flags: (TS_MeshModelFlags)flags async: (TSAsync**)async {
		return [self ref].load([device ref], [pipeline ref], name, (Tellusim::MeshModel::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_3: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline stream: (TSStream*)stream {
		return [self ref].load([device ref], [pipeline ref], [stream ref]);
	}
	-(BOOL)load_3_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline stream: (TSStream*)stream {
		return [self ref].load([device ref], [pipeline ref], [stream ref]);
	}
	-(BOOL)load_4: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline stream: (TSStream*)stream flags: (TS_MeshModelFlags)flags {
		return [self ref].load([device ref], [pipeline ref], [stream ref], (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)load_4_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline stream: (TSStream*)stream flags: (TS_MeshModelFlags)flags {
		return [self ref].load([device ref], [pipeline ref], [stream ref], (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)load_5: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline stream: (TSStream*)stream flags: (TS_MeshModelFlags)flags async: (TSAsync**)async {
		return [self ref].load([device ref], [pipeline ref], [stream ref], (Tellusim::MeshModel::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)load_5_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline stream: (TSStream*)stream flags: (TS_MeshModelFlags)flags async: (TSAsync**)async {
		return [self ref].load([device ref], [pipeline ref], [stream ref], (Tellusim::MeshModel::Flags)flags, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name {
		return [self ref].create([device ref], [pipeline ref], name);
	}
	-(BOOL)create_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name {
		return [self ref].create([device ref], [pipeline ref], name);
	}
	-(BOOL)create_1: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name flags: (TS_MeshModelFlags)flags {
		return [self ref].create([device ref], [pipeline ref], name, (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)create_1_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline name: (const char*)name flags: (TS_MeshModelFlags)flags {
		return [self ref].create([device ref], [pipeline ref], name, (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)create_2: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline mesh: (const TSMesh*)mesh {
		return [self ref].create([device ref], [pipeline ref], [mesh ref]);
	}
	-(BOOL)create_2_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline mesh: (const TSMesh*)mesh {
		return [self ref].create([device ref], [pipeline ref], [mesh ref]);
	}
	-(BOOL)create_3: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline mesh: (const TSMesh*)mesh flags: (TS_MeshModelFlags)flags {
		return [self ref].create([device ref], [pipeline ref], [mesh ref], (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)create_3_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline mesh: (const TSMesh*)mesh flags: (TS_MeshModelFlags)flags {
		return [self ref].create([device ref], [pipeline ref], [mesh ref], (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)create_4: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline geometry: (const TSMeshGeometry*)geometry {
		return [self ref].create([device ref], [pipeline ref], [geometry ref]);
	}
	-(BOOL)create_4_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline geometry: (const TSMeshGeometry*)geometry {
		return [self ref].create([device ref], [pipeline ref], [geometry ref]);
	}
	-(BOOL)create_5: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline geometry: (const TSMeshGeometry*)geometry flags: (TS_MeshModelFlags)flags {
		return [self ref].create([device ref], [pipeline ref], [geometry ref], (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)create_5_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline geometry: (const TSMeshGeometry*)geometry flags: (TS_MeshModelFlags)flags {
		return [self ref].create([device ref], [pipeline ref], [geometry ref], (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)create_6: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline geometries: (TSMeshGeometry**)geometries geometries_size: (uint32_t)geometries_size {
		Tellusim::Array<Tellusim::MeshGeometry> geometries_(geometries_size);
		for(uint32_t i = 0; i < geometries_size; i++) if(geometries[i]) geometries_[i] = [geometries[i] ref];
		return [self ref].create([device ref], [pipeline ref], geometries_);
	}
	-(BOOL)create_6_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline geometries: (TSMeshGeometry**)geometries geometries_size: (uint32_t)geometries_size {
		Tellusim::Array<Tellusim::MeshGeometry> geometries_(geometries_size);
		for(uint32_t i = 0; i < geometries_size; i++) if(geometries[i]) geometries_[i] = [geometries[i] ref];
		return [self ref].create([device ref], [pipeline ref], geometries_);
	}
	-(BOOL)create_7: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline geometries: (TSMeshGeometry**)geometries geometries_size: (uint32_t)geometries_size flags: (TS_MeshModelFlags)flags {
		Tellusim::Array<Tellusim::MeshGeometry> geometries_(geometries_size);
		for(uint32_t i = 0; i < geometries_size; i++) if(geometries[i]) geometries_[i] = [geometries[i] ref];
		return [self ref].create([device ref], [pipeline ref], geometries_, (Tellusim::MeshModel::Flags)flags);
	}
	-(BOOL)create_7_: (const TSDevice*)device pipeline: (const TSPipeline*)pipeline geometries: (TSMeshGeometry**)geometries geometries_size: (uint32_t)geometries_size flags: (TS_MeshModelFlags)flags {
		Tellusim::Array<Tellusim::MeshGeometry> geometries_(geometries_size);
		for(uint32_t i = 0; i < geometries_size; i++) if(geometries[i]) geometries_[i] = [geometries[i] ref];
		return [self ref].create([device ref], [pipeline ref], geometries_, (Tellusim::MeshModel::Flags)flags);
	}
	-(void)setVertexBufferCallback: (id<TSMeshModelCreateCallback>)func {
		[self ref].setVertexBufferCallback(Tellusim::makeTSMeshModelCreateCallback(func));
	}
	-(void)setVertexBufferCallback_: (id<TSMeshModelCreateCallback>)func {
		[self ref].setVertexBufferCallback(Tellusim::makeTSMeshModelCreateCallback(func));
	}
	-(void)setIndexBufferCallback: (id<TSMeshModelCreateCallback>)func {
		[self ref].setIndexBufferCallback(Tellusim::makeTSMeshModelCreateCallback(func));
	}
	-(void)setIndexBufferCallback_: (id<TSMeshModelCreateCallback>)func {
		[self ref].setIndexBufferCallback(Tellusim::makeTSMeshModelCreateCallback(func));
	}
	-(void)setMeshBufferCallback: (id<TSMeshModelCreateCallback>)func {
		[self ref].setMeshBufferCallback(Tellusim::makeTSMeshModelCreateCallback(func));
	}
	-(void)setMeshBufferCallback_: (id<TSMeshModelCreateCallback>)func {
		[self ref].setMeshBufferCallback(Tellusim::makeTSMeshModelCreateCallback(func));
	}
	-(void)setBuffers: (TSCommand*)command {
		[self ref].setBuffers([command ref]);
	}
	-(void)setBuffers_: (TSCommand*)command {
		[self ref].setBuffers([command ref]);
	}
	-(void)setBuffers_1: (TSCommand*)command index: (uint32_t)index {
		[self ref].setBuffers([command ref], index);
	}
	-(void)setBuffers_1_: (TSCommand*)command index: (uint32_t)index {
		[self ref].setBuffers([command ref], index);
	}
	-(void)setBuffers_2: (TSCommand*)command index: (uint32_t)index pipeline: (const TSPipeline**)pipeline {
		[self ref].setBuffers([command ref], index, (pipeline) ? [*pipeline pointer] : nullptr);
	}
	-(void)setBuffers_2_: (TSCommand*)command index: (uint32_t)index pipeline: (const TSPipeline**)pipeline {
		[self ref].setBuffers([command ref], index, (pipeline) ? [*pipeline pointer] : nullptr);
	}
	-(void)draw: (TSCommand*)command {
		[self ref].draw([command ref]);
	}
	-(void)draw_: (TSCommand*)command {
		[self ref].draw([command ref]);
	}
	-(void)draw_1: (TSCommand*)command geometry: (uint32_t)geometry {
		[self ref].draw([command ref], geometry);
	}
	-(void)draw_1_: (TSCommand*)command geometry: (uint32_t)geometry {
		[self ref].draw([command ref], geometry);
	}
	-(void)draw_2: (TSCommand*)command geometry: (uint32_t)geometry material: (uint32_t)material {
		[self ref].draw([command ref], geometry, material);
	}
	-(void)draw_2_: (TSCommand*)command geometry: (uint32_t)geometry material: (uint32_t)material {
		[self ref].draw([command ref], geometry, material);
	}
	-(void)drawInstanced: (TSCommand*)command geometry: (uint32_t)geometry num_instances: (uint32_t)num_instances {
		[self ref].drawInstanced([command ref], geometry, num_instances);
	}
	-(void)drawInstanced_: (TSCommand*)command geometry: (uint32_t)geometry num_instances: (uint32_t)num_instances {
		[self ref].drawInstanced([command ref], geometry, num_instances);
	}
	-(void)drawInstanced_1: (TSCommand*)command geometry: (uint32_t)geometry num_instances: (uint32_t)num_instances base_instance: (uint32_t)base_instance {
		[self ref].drawInstanced([command ref], geometry, num_instances, base_instance);
	}
	-(void)drawInstanced_1_: (TSCommand*)command geometry: (uint32_t)geometry num_instances: (uint32_t)num_instances base_instance: (uint32_t)base_instance {
		[self ref].drawInstanced([command ref], geometry, num_instances, base_instance);
	}
	-(void)drawInstanced_2: (TSCommand*)command geometry: (uint32_t)geometry material: (uint32_t)material num_instances: (uint32_t)num_instances base_instance: (uint32_t)base_instance {
		[self ref].drawInstanced([command ref], geometry, material, num_instances, base_instance);
	}
	-(void)drawInstanced_2_: (TSCommand*)command geometry: (uint32_t)geometry material: (uint32_t)material num_instances: (uint32_t)num_instances base_instance: (uint32_t)base_instance {
		[self ref].drawInstanced([command ref], geometry, material, num_instances, base_instance);
	}
	-(uint32_t)getNumVertices {
		return [self ref].getNumVertices();
	}
	-(uint32_t)getNumVertexBuffers {
		return [self ref].getNumVertexBuffers();
	}
	-(uint32_t)getVertexBufferStride: (uint32_t)index {
		return [self ref].getVertexBufferStride(index);
	}
	-(uint32_t)getVertexBufferStride_: (uint32_t)index {
		return [self ref].getVertexBufferStride(index);
	}
	-(size_t)getVertexBufferOffset: (uint32_t)index {
		return [self ref].getVertexBufferOffset(index);
	}
	-(size_t)getVertexBufferOffset_: (uint32_t)index {
		return [self ref].getVertexBufferOffset(index);
	}
	-(TSBuffer*)getVertexBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getVertexBuffer())];
	}
	-(uint32_t)getNumIndices {
		return [self ref].getNumIndices();
	}
	-(TS_Format)getIndexFormat {
		return (TS_Format)[self ref].getIndexFormat();
	}
	-(TSBuffer*)getIndexBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getIndexBuffer())];
	}
	-(uint32_t)getNumMeshlets {
		return [self ref].getNumMeshlets();
	}
	-(TSBuffer*)getMeshletBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getMeshletBuffer())];
	}
	-(uint32_t)getNumGeometries {
		return [self ref].getNumGeometries();
	}
	-(uint32_t)getNumGeometryIndices: (uint32_t)geometry {
		return [self ref].getNumGeometryIndices(geometry);
	}
	-(uint32_t)getNumGeometryIndices_: (uint32_t)geometry {
		return [self ref].getNumGeometryIndices(geometry);
	}
	-(uint32_t)getNumGeometryVertices: (uint32_t)geometry {
		return [self ref].getNumGeometryVertices(geometry);
	}
	-(uint32_t)getNumGeometryVertices_: (uint32_t)geometry {
		return [self ref].getNumGeometryVertices(geometry);
	}
	-(uint32_t)getNumGeometryMeshlets: (uint32_t)geometry {
		return [self ref].getNumGeometryMeshlets(geometry);
	}
	-(uint32_t)getNumGeometryMeshlets_: (uint32_t)geometry {
		return [self ref].getNumGeometryMeshlets(geometry);
	}
	-(uint32_t)getGeometryBaseIndex: (uint32_t)geometry {
		return [self ref].getGeometryBaseIndex(geometry);
	}
	-(uint32_t)getGeometryBaseIndex_: (uint32_t)geometry {
		return [self ref].getGeometryBaseIndex(geometry);
	}
	-(uint32_t)getGeometryBaseVertex: (uint32_t)geometry {
		return [self ref].getGeometryBaseVertex(geometry);
	}
	-(uint32_t)getGeometryBaseVertex_: (uint32_t)geometry {
		return [self ref].getGeometryBaseVertex(geometry);
	}
	-(uint32_t)getGeometryBaseMeshlet: (uint32_t)geometry {
		return [self ref].getGeometryBaseMeshlet(geometry);
	}
	-(uint32_t)getGeometryBaseMeshlet_: (uint32_t)geometry {
		return [self ref].getGeometryBaseMeshlet(geometry);
	}
	-(uint32_t)getNumMaterials: (uint32_t)geometry {
		return [self ref].getNumMaterials(geometry);
	}
	-(uint32_t)getNumMaterials_: (uint32_t)geometry {
		return [self ref].getNumMaterials(geometry);
	}
	-(uint32_t)getNumMaterialIndices: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getNumMaterialIndices(geometry, material);
	}
	-(uint32_t)getNumMaterialIndices_: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getNumMaterialIndices(geometry, material);
	}
	-(uint32_t)getNumMaterialVertices: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getNumMaterialVertices(geometry, material);
	}
	-(uint32_t)getNumMaterialVertices_: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getNumMaterialVertices(geometry, material);
	}
	-(uint32_t)getNumMaterialMeshlets: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getNumMaterialMeshlets(geometry, material);
	}
	-(uint32_t)getNumMaterialMeshlets_: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getNumMaterialMeshlets(geometry, material);
	}
	-(uint32_t)getMaterialBaseIndex: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getMaterialBaseIndex(geometry, material);
	}
	-(uint32_t)getMaterialBaseIndex_: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getMaterialBaseIndex(geometry, material);
	}
	-(uint32_t)getMaterialBaseVertex: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getMaterialBaseVertex(geometry, material);
	}
	-(uint32_t)getMaterialBaseVertex_: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getMaterialBaseVertex(geometry, material);
	}
	-(uint32_t)getMaterialBaseMeshlet: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getMaterialBaseMeshlet(geometry, material);
	}
	-(uint32_t)getMaterialBaseMeshlet_: (uint32_t)geometry material: (uint32_t)material {
		return [self ref].getMaterialBaseMeshlet(geometry, material);
	}
	-(size_t)getMemory {
		return [self ref].getMemory();
	}
@end

// Tellusim::SeparableFilter
@implementation TSSeparableFilter
	-(id)init {
		self = [super init];
		impl = new Tellusim::SeparableFilter();
		return self;
	}
	-(id)init_ptr: (Tellusim::SeparableFilter*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::SeparableFilter&)ref {
		self = [super init];
		impl = new Tellusim::SeparableFilter((Tellusim::SeparableFilter&)ref);
		return self;
	}
	-(Tellusim::SeparableFilter*)pointer {
		return (Tellusim::SeparableFilter*)impl;
	}
	-(Tellusim::SeparableFilter&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::SeparableFilter*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::SeparableFilter*)impl;
	}
	-(BOOL)equalPtr: (const TSSeparableFilter*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSSeparableFilter*)copyPtr {
		return [[TSSeparableFilter alloc] init_ref:[self ref]];
	}
	-(TSSeparableFilter*)clonePtr {
		return [[TSSeparableFilter alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSSeparableFilter*)null {
		return [[TSSeparableFilter alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_Format)format size: (uint32_t)size {
		return [self ref].isCreated((Tellusim::Format)format, size);
	}
	-(BOOL)isCreated_: (TS_Format)format size: (uint32_t)size {
		return [self ref].isCreated((Tellusim::Format)format, size);
	}
	-(void)setInputSource: (TS_SeparableFilterMode)mode src: (const char*)src {
		[self ref].setInputSource((Tellusim::SeparableFilter::Mode)mode, src);
	}
	-(void)setInputSource_: (TS_SeparableFilterMode)mode src: (const char*)src {
		[self ref].setInputSource((Tellusim::SeparableFilter::Mode)mode, src);
	}
	-(NSString*)getInputSource: (TS_SeparableFilterMode)mode {
		return [NSString stringWithUTF8String:[self ref].getInputSource((Tellusim::SeparableFilter::Mode)mode).get()];
	}
	-(NSString*)getInputSource_: (TS_SeparableFilterMode)mode {
		return [NSString stringWithUTF8String:[self ref].getInputSource((Tellusim::SeparableFilter::Mode)mode).get()];
	}
	-(void)setOutputSource: (TS_SeparableFilterMode)mode src: (const char*)src {
		[self ref].setOutputSource((Tellusim::SeparableFilter::Mode)mode, src);
	}
	-(void)setOutputSource_: (TS_SeparableFilterMode)mode src: (const char*)src {
		[self ref].setOutputSource((Tellusim::SeparableFilter::Mode)mode, src);
	}
	-(NSString*)getOutputSource: (TS_SeparableFilterMode)mode {
		return [NSString stringWithUTF8String:[self ref].getOutputSource((Tellusim::SeparableFilter::Mode)mode).get()];
	}
	-(NSString*)getOutputSource_: (TS_SeparableFilterMode)mode {
		return [NSString stringWithUTF8String:[self ref].getOutputSource((Tellusim::SeparableFilter::Mode)mode).get()];
	}
	-(BOOL)create: (const TSDevice*)device format: (TS_Format)format size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::Format)format, size);
	}
	-(BOOL)create_: (const TSDevice*)device format: (TS_Format)format size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::Format)format, size);
	}
	-(BOOL)create_1: (const TSDevice*)device format: (TS_Format)format size: (uint32_t)size flags: (TS_SeparableFilterFlags)flags {
		return [self ref].create([device ref], (Tellusim::Format)format, size, (Tellusim::SeparableFilter::Flags)flags);
	}
	-(BOOL)create_1_: (const TSDevice*)device format: (TS_Format)format size: (uint32_t)size flags: (TS_SeparableFilterFlags)flags {
		return [self ref].create([device ref], (Tellusim::Format)format, size, (Tellusim::SeparableFilter::Flags)flags);
	}
	-(void)setWeights: (TS_SeparableFilterMode)mode weights: (TSVector4f*)weights weights_size: (uint32_t)weights_size {
		Tellusim::Array<Tellusim::Vector4f> weights_(weights_size, (const Tellusim::Vector4f*)weights);
		[self ref].setWeights((Tellusim::SeparableFilter::Mode)mode, weights_);
	}
	-(void)setWeights_: (TS_SeparableFilterMode)mode weights: (TSVector4f*)weights weights_size: (uint32_t)weights_size {
		Tellusim::Array<Tellusim::Vector4f> weights_(weights_size, (const Tellusim::Vector4f*)weights);
		[self ref].setWeights((Tellusim::SeparableFilter::Mode)mode, weights_);
	}
	-(void)setWeights_1: (TS_SeparableFilterMode)mode weights: (TSVector4f*)weights weights_size: (uint32_t)weights_size normalize: (BOOL)normalize {
		Tellusim::Array<Tellusim::Vector4f> weights_(weights_size, (const Tellusim::Vector4f*)weights);
		[self ref].setWeights((Tellusim::SeparableFilter::Mode)mode, weights_, (bool)normalize);
	}
	-(void)setWeights_1_: (TS_SeparableFilterMode)mode weights: (TSVector4f*)weights weights_size: (uint32_t)weights_size normalize: (BOOL)normalize {
		Tellusim::Array<Tellusim::Vector4f> weights_(weights_size, (const Tellusim::Vector4f*)weights);
		[self ref].setWeights((Tellusim::SeparableFilter::Mode)mode, weights_, (bool)normalize);
	}
	-(void)setWeights_2: (TS_SeparableFilterMode)mode weights: (float32_t*)weights weights_size: (uint32_t)weights_size {
		Tellusim::Array<float32_t> weights_(weights_size, weights);
		[self ref].setWeights((Tellusim::SeparableFilter::Mode)mode, weights_);
	}
	-(void)setWeights_2_: (TS_SeparableFilterMode)mode weights: (float32_t*)weights weights_size: (uint32_t)weights_size {
		Tellusim::Array<float32_t> weights_(weights_size, weights);
		[self ref].setWeights((Tellusim::SeparableFilter::Mode)mode, weights_);
	}
	-(void)setWeights_3: (TS_SeparableFilterMode)mode weights: (float32_t*)weights weights_size: (uint32_t)weights_size normalize: (BOOL)normalize {
		Tellusim::Array<float32_t> weights_(weights_size, weights);
		[self ref].setWeights((Tellusim::SeparableFilter::Mode)mode, weights_, (bool)normalize);
	}
	-(void)setWeights_3_: (TS_SeparableFilterMode)mode weights: (float32_t*)weights weights_size: (uint32_t)weights_size normalize: (BOOL)normalize {
		Tellusim::Array<float32_t> weights_(weights_size, weights);
		[self ref].setWeights((Tellusim::SeparableFilter::Mode)mode, weights_, (bool)normalize);
	}
	-(void)setGaussianWeights: (uint32_t)size sigma: (TSVector4f)sigma {
		[self ref].setGaussianWeights(size, *(Tellusim::Vector4f*)&sigma);
	}
	-(void)setGaussianWeights_: (uint32_t)size sigma: (TSVector4f)sigma {
		[self ref].setGaussianWeights(size, *(Tellusim::Vector4f*)&sigma);
	}
	-(void)setGaussianWeights_1: (uint32_t)size sigma: (float32_t)sigma {
		[self ref].setGaussianWeights(size, sigma);
	}
	-(void)setGaussianWeights_1_: (uint32_t)size sigma: (float32_t)sigma {
		[self ref].setGaussianWeights(size, sigma);
	}
	-(void)setSobelXWeights: (uint32_t)size {
		[self ref].setSobelXWeights(size);
	}
	-(void)setSobelXWeights_: (uint32_t)size {
		[self ref].setSobelXWeights(size);
	}
	-(void)setSobelYWeights: (uint32_t)size {
		[self ref].setSobelYWeights(size);
	}
	-(void)setSobelYWeights_: (uint32_t)size {
		[self ref].setSobelYWeights(size);
	}
	-(void)setBoxWeights: (uint32_t)size {
		[self ref].setBoxWeights(size);
	}
	-(void)setBoxWeights_: (uint32_t)size {
		[self ref].setBoxWeights(size);
	}
	-(BOOL)dispatch: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice values: (TSVector4f)values {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice, *(Tellusim::Vector4f*)&values);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice values: (TSVector4f)values {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice, *(Tellusim::Vector4f*)&values);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_3: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice values: (TSVector4f)values {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice, *(Tellusim::Vector4f*)&values);
	}
	-(BOOL)dispatch_3_: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice values: (TSVector4f)values {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice, *(Tellusim::Vector4f*)&values);
	}
	-(BOOL)dispatch_4: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref]);
	}
	-(BOOL)dispatch_4_: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref]);
	}
	-(BOOL)dispatch_5: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src values: (TSVector4f)values {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Vector4f*)&values);
	}
	-(BOOL)dispatch_5_: (TSCompute*)compute mode: (TS_SeparableFilterMode)mode size: (uint32_t)size dest: (TSTexture*)dest src: (TSTexture*)src values: (TSVector4f)values {
		return [self ref].dispatch([compute ref], (Tellusim::SeparableFilter::Mode)mode, size, [dest ref], [src ref], *(Tellusim::Vector4f*)&values);
	}
@end

// Tellusim::PrefixScan
@implementation TSPrefixScan
	-(id)init {
		self = [super init];
		impl = new Tellusim::PrefixScan();
		return self;
	}
	-(id)init_ptr: (Tellusim::PrefixScan*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::PrefixScan&)ref {
		self = [super init];
		impl = new Tellusim::PrefixScan((Tellusim::PrefixScan&)ref);
		return self;
	}
	-(Tellusim::PrefixScan*)pointer {
		return (Tellusim::PrefixScan*)impl;
	}
	-(Tellusim::PrefixScan&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::PrefixScan*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::PrefixScan*)impl;
	}
	-(BOOL)equalPtr: (const TSPrefixScan*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSPrefixScan*)copyPtr {
		return [[TSPrefixScan alloc] init_ref:[self ref]];
	}
	-(TSPrefixScan*)clonePtr {
		return [[TSPrefixScan alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSPrefixScan*)null {
		return [[TSPrefixScan alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_PrefixScanFlags)flags {
		return [self ref].isCreated((Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)isCreated_: (TS_PrefixScanFlags)flags {
		return [self ref].isCreated((Tellusim::PrefixScan::Flags)flags);
	}
	-(uint32_t)getGroupSize {
		return [self ref].getGroupSize();
	}
	-(uint32_t)getScanElements {
		return [self ref].getScanElements();
	}
	-(uint32_t)getMaxElements {
		return [self ref].getMaxElements();
	}
	-(uint32_t)getMaxRegions {
		return [self ref].getMaxRegions();
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_PrefixScanMode)mode {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Mode)mode);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_PrefixScanMode)mode {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Mode)mode);
	}
	-(BOOL)create_1: (const TSDevice*)device mode: (TS_PrefixScanMode)mode groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Mode)mode, groups);
	}
	-(BOOL)create_1_: (const TSDevice*)device mode: (TS_PrefixScanMode)mode groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Mode)mode, groups);
	}
	-(BOOL)create_2: (const TSDevice*)device mode: (TS_PrefixScanMode)mode groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Mode)mode, groups, regions);
	}
	-(BOOL)create_2_: (const TSDevice*)device mode: (TS_PrefixScanMode)mode groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Mode)mode, groups, regions);
	}
	-(BOOL)create_3: (const TSDevice*)device mode: (TS_PrefixScanMode)mode groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Mode)mode, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_3_: (const TSDevice*)device mode: (TS_PrefixScanMode)mode groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Mode)mode, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_4: (const TSDevice*)device flags: (TS_PrefixScanFlags)flags {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)create_4_: (const TSDevice*)device flags: (TS_PrefixScanFlags)flags {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)create_5: (const TSDevice*)device flags: (TS_PrefixScanFlags)flags groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Flags)flags, groups);
	}
	-(BOOL)create_5_: (const TSDevice*)device flags: (TS_PrefixScanFlags)flags groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Flags)flags, groups);
	}
	-(BOOL)create_6: (const TSDevice*)device flags: (TS_PrefixScanFlags)flags groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Flags)flags, groups, regions);
	}
	-(BOOL)create_6_: (const TSDevice*)device flags: (TS_PrefixScanFlags)flags groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Flags)flags, groups, regions);
	}
	-(BOOL)create_7: (const TSDevice*)device flags: (TS_PrefixScanFlags)flags groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Flags)flags, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_7_: (const TSDevice*)device flags: (TS_PrefixScanFlags)flags groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::PrefixScan::Flags)flags, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)dispatch: (TSCompute*)compute data: (TSBuffer*)data offset: (uint32_t)offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], [data ref], offset, size);
	}
	-(BOOL)dispatch_: (TSCompute*)compute data: (TSBuffer*)data offset: (uint32_t)offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], [data ref], offset, size);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count offsets: (const uint32_t*)offsets sizes: (const uint32_t*)sizes {
		return [self ref].dispatch([compute ref], [data ref], count, offsets, sizes);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count offsets: (const uint32_t*)offsets sizes: (const uint32_t*)sizes {
		return [self ref].dispatch([compute ref], [data ref], count, offsets, sizes);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count offsets: (const uint32_t*)offsets sizes: (const uint32_t*)sizes flags: (TS_PrefixScanFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], count, offsets, sizes, (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count offsets: (const uint32_t*)offsets sizes: (const uint32_t*)sizes flags: (TS_PrefixScanFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], count, offsets, sizes, (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)dispatchIndirect: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_1: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_PrefixScanFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)dispatchIndirect_1_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_PrefixScanFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)dispatchIndirect_2: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_PrefixScanFlags)flags max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::PrefixScan::Flags)flags, max_size);
	}
	-(BOOL)dispatchIndirect_2_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_PrefixScanFlags)flags max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::PrefixScan::Flags)flags, max_size);
	}
	-(BOOL)dispatchIndirect_3: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_3_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_4: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_PrefixScanFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)dispatchIndirect_4_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_PrefixScanFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)dispatchIndirect_5: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_PrefixScanFlags)flags max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::PrefixScan::Flags)flags, max_size);
	}
	-(BOOL)dispatchIndirect_5_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_PrefixScanFlags)flags max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::PrefixScan::Flags)flags, max_size);
	}
	-(BOOL)dispatchIndirect_6: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset);
	}
	-(BOOL)dispatchIndirect_6_: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset);
	}
	-(BOOL)dispatchIndirect_7: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_PrefixScanFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)dispatchIndirect_7_: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_PrefixScanFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::PrefixScan::Flags)flags);
	}
	-(BOOL)dispatchIndirect_8: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_PrefixScanFlags)flags max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::PrefixScan::Flags)flags, max_size);
	}
	-(BOOL)dispatchIndirect_8_: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_PrefixScanFlags)flags max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::PrefixScan::Flags)flags, max_size);
	}
@end

// Tellusim::RadixSort
@implementation TSRadixSort
	-(id)init {
		self = [super init];
		impl = new Tellusim::RadixSort();
		return self;
	}
	-(id)init_ptr: (Tellusim::RadixSort*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::RadixSort&)ref {
		self = [super init];
		impl = new Tellusim::RadixSort((Tellusim::RadixSort&)ref);
		return self;
	}
	-(Tellusim::RadixSort*)pointer {
		return (Tellusim::RadixSort*)impl;
	}
	-(Tellusim::RadixSort&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::RadixSort*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::RadixSort*)impl;
	}
	-(BOOL)equalPtr: (const TSRadixSort*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSRadixSort*)copyPtr {
		return [[TSRadixSort alloc] init_ref:[self ref]];
	}
	-(TSRadixSort*)clonePtr {
		return [[TSRadixSort alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSRadixSort*)null {
		return [[TSRadixSort alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_RadixSortFlags)flags {
		return [self ref].isCreated((Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)isCreated_: (TS_RadixSortFlags)flags {
		return [self ref].isCreated((Tellusim::RadixSort::Flags)flags);
	}
	-(uint32_t)getDataSize {
		return [self ref].getDataSize();
	}
	-(uint32_t)getGroupSize {
		return [self ref].getGroupSize();
	}
	-(uint32_t)getSortElements {
		return [self ref].getSortElements();
	}
	-(uint32_t)getUpdateElements {
		return [self ref].getUpdateElements();
	}
	-(uint32_t)getMaxElements {
		return [self ref].getMaxElements();
	}
	-(uint32_t)getMaxRegions {
		return [self ref].getMaxRegions();
	}
	-(TSPrefixScan*)getPrefixScan {
		return [[TSPrefixScan alloc] init_ref:([self ref].getPrefixScan())];
	}
	-(TSBuffer*)getDataBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getDataBuffer())];
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_RadixSortMode)mode scan: (TSPrefixScan*)scan size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::RadixSort::Mode)mode, [scan ref], size);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_RadixSortMode)mode scan: (TSPrefixScan*)scan size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::RadixSort::Mode)mode, [scan ref], size);
	}
	-(BOOL)create_1: (const TSDevice*)device mode: (TS_RadixSortMode)mode scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::RadixSort::Mode)mode, [scan ref], size, groups);
	}
	-(BOOL)create_1_: (const TSDevice*)device mode: (TS_RadixSortMode)mode scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::RadixSort::Mode)mode, [scan ref], size, groups);
	}
	-(BOOL)create_2: (const TSDevice*)device mode: (TS_RadixSortMode)mode scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::RadixSort::Mode)mode, [scan ref], size, groups, regions);
	}
	-(BOOL)create_2_: (const TSDevice*)device mode: (TS_RadixSortMode)mode scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::RadixSort::Mode)mode, [scan ref], size, groups, regions);
	}
	-(BOOL)create_3: (const TSDevice*)device mode: (TS_RadixSortMode)mode scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::RadixSort::Mode)mode, [scan ref], size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_3_: (const TSDevice*)device mode: (TS_RadixSortMode)mode scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::RadixSort::Mode)mode, [scan ref], size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_4: (const TSDevice*)device flags: (TS_RadixSortFlags)flags scan: (TSPrefixScan*)scan size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::RadixSort::Flags)flags, [scan ref], size);
	}
	-(BOOL)create_4_: (const TSDevice*)device flags: (TS_RadixSortFlags)flags scan: (TSPrefixScan*)scan size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::RadixSort::Flags)flags, [scan ref], size);
	}
	-(BOOL)create_5: (const TSDevice*)device flags: (TS_RadixSortFlags)flags scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::RadixSort::Flags)flags, [scan ref], size, groups);
	}
	-(BOOL)create_5_: (const TSDevice*)device flags: (TS_RadixSortFlags)flags scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::RadixSort::Flags)flags, [scan ref], size, groups);
	}
	-(BOOL)create_6: (const TSDevice*)device flags: (TS_RadixSortFlags)flags scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::RadixSort::Flags)flags, [scan ref], size, groups, regions);
	}
	-(BOOL)create_6_: (const TSDevice*)device flags: (TS_RadixSortFlags)flags scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::RadixSort::Flags)flags, [scan ref], size, groups, regions);
	}
	-(BOOL)create_7: (const TSDevice*)device flags: (TS_RadixSortFlags)flags scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::RadixSort::Flags)flags, [scan ref], size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_7_: (const TSDevice*)device flags: (TS_RadixSortFlags)flags scan: (TSPrefixScan*)scan size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::RadixSort::Flags)flags, [scan ref], size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)dispatch: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size);
	}
	-(BOOL)dispatch_: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatch_3: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes);
	}
	-(BOOL)dispatch_3_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes);
	}
	-(BOOL)dispatch_4: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatch_4_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatch_5: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatch_5_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatchIndirect: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_1: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_1_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_2: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatchIndirect_2_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatchIndirect_3: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags, bits, max_size);
	}
	-(BOOL)dispatchIndirect_3_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags, bits, max_size);
	}
	-(BOOL)dispatchIndirect_4: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_4_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_5: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_5_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_6: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatchIndirect_6_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatchIndirect_7: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags, bits, max_size);
	}
	-(BOOL)dispatchIndirect_7_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::RadixSort::Flags)flags, bits, max_size);
	}
	-(BOOL)dispatchIndirect_8: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset);
	}
	-(BOOL)dispatchIndirect_8_: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset);
	}
	-(BOOL)dispatchIndirect_9: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_9_: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_RadixSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::RadixSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_10: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatchIndirect_10_: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::RadixSort::Flags)flags, bits);
	}
	-(BOOL)dispatchIndirect_11: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::RadixSort::Flags)flags, bits, max_size);
	}
	-(BOOL)dispatchIndirect_11_: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_RadixSortFlags)flags bits: (uint32_t)bits max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::RadixSort::Flags)flags, bits, max_size);
	}
@end

// Tellusim::BitonicSort
@implementation TSBitonicSort
	-(id)init {
		self = [super init];
		impl = new Tellusim::BitonicSort();
		return self;
	}
	-(id)init_ptr: (Tellusim::BitonicSort*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::BitonicSort&)ref {
		self = [super init];
		impl = new Tellusim::BitonicSort((Tellusim::BitonicSort&)ref);
		return self;
	}
	-(Tellusim::BitonicSort*)pointer {
		return (Tellusim::BitonicSort*)impl;
	}
	-(Tellusim::BitonicSort&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::BitonicSort*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::BitonicSort*)impl;
	}
	-(BOOL)equalPtr: (const TSBitonicSort*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSBitonicSort*)copyPtr {
		return [[TSBitonicSort alloc] init_ref:[self ref]];
	}
	-(TSBitonicSort*)clonePtr {
		return [[TSBitonicSort alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSBitonicSort*)null {
		return [[TSBitonicSort alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_BitonicSortFlags)flags {
		return [self ref].isCreated((Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)isCreated_: (TS_BitonicSortFlags)flags {
		return [self ref].isCreated((Tellusim::BitonicSort::Flags)flags);
	}
	-(uint32_t)getDataSize {
		return [self ref].getDataSize();
	}
	-(uint32_t)getGroupSize {
		return [self ref].getGroupSize();
	}
	-(uint32_t)getSortElements {
		return [self ref].getSortElements();
	}
	-(uint32_t)getMaxRegions {
		return [self ref].getMaxRegions();
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_BitonicSortMode)mode size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Mode)mode, size);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_BitonicSortMode)mode size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Mode)mode, size);
	}
	-(BOOL)create_1: (const TSDevice*)device mode: (TS_BitonicSortMode)mode size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Mode)mode, size, groups);
	}
	-(BOOL)create_1_: (const TSDevice*)device mode: (TS_BitonicSortMode)mode size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Mode)mode, size, groups);
	}
	-(BOOL)create_2: (const TSDevice*)device mode: (TS_BitonicSortMode)mode size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Mode)mode, size, groups, regions);
	}
	-(BOOL)create_2_: (const TSDevice*)device mode: (TS_BitonicSortMode)mode size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Mode)mode, size, groups, regions);
	}
	-(BOOL)create_3: (const TSDevice*)device mode: (TS_BitonicSortMode)mode size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Mode)mode, size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_3_: (const TSDevice*)device mode: (TS_BitonicSortMode)mode size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Mode)mode, size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_4: (const TSDevice*)device flags: (TS_BitonicSortFlags)flags size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Flags)flags, size);
	}
	-(BOOL)create_4_: (const TSDevice*)device flags: (TS_BitonicSortFlags)flags size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Flags)flags, size);
	}
	-(BOOL)create_5: (const TSDevice*)device flags: (TS_BitonicSortFlags)flags size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Flags)flags, size, groups);
	}
	-(BOOL)create_5_: (const TSDevice*)device flags: (TS_BitonicSortFlags)flags size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Flags)flags, size, groups);
	}
	-(BOOL)create_6: (const TSDevice*)device flags: (TS_BitonicSortFlags)flags size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Flags)flags, size, groups, regions);
	}
	-(BOOL)create_6_: (const TSDevice*)device flags: (TS_BitonicSortFlags)flags size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Flags)flags, size, groups, regions);
	}
	-(BOOL)create_7: (const TSDevice*)device flags: (TS_BitonicSortFlags)flags size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Flags)flags, size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_7_: (const TSDevice*)device flags: (TS_BitonicSortFlags)flags size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::BitonicSort::Flags)flags, size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)dispatch: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size);
	}
	-(BOOL)dispatch_: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size, (Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute data: (TSBuffer*)data keys_offset: (uint32_t)keys_offset data_offset: (uint32_t)data_offset size: (uint32_t)size flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], keys_offset, data_offset, size, (Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes);
	}
	-(BOOL)dispatch_3: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes, (Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)dispatch_3_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count keys_offsets: (const uint32_t*)keys_offsets data_offsets: (const uint32_t*)data_offsets sizes: (const uint32_t*)sizes flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatch([compute ref], [data ref], count, keys_offsets, data_offsets, sizes, (Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_1: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_1_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, (Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_2: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_2_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_3: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_3_: (TSCompute*)compute data: (TSBuffer*)data count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], count, [dispatch ref], offset, (Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_4: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset);
	}
	-(BOOL)dispatchIndirect_4_: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset);
	}
	-(BOOL)dispatchIndirect_5: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::BitonicSort::Flags)flags);
	}
	-(BOOL)dispatchIndirect_5_: (TSCompute*)compute data: (TSBuffer*)data count: (TSBuffer*)count dispatch: (TSBuffer*)dispatch count_offset: (uint32_t)count_offset dispatch_offset: (uint32_t)dispatch_offset flags: (TS_BitonicSortFlags)flags {
		return [self ref].dispatchIndirect([compute ref], [data ref], [count ref], [dispatch ref], count_offset, dispatch_offset, (Tellusim::BitonicSort::Flags)flags);
	}
@end

// Tellusim::SpatialGrid
@implementation TSSpatialGrid
	-(id)init {
		self = [super init];
		impl = new Tellusim::SpatialGrid();
		return self;
	}
	-(id)init_ptr: (Tellusim::SpatialGrid*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::SpatialGrid&)ref {
		self = [super init];
		impl = new Tellusim::SpatialGrid((Tellusim::SpatialGrid&)ref);
		return self;
	}
	-(Tellusim::SpatialGrid*)pointer {
		return (Tellusim::SpatialGrid*)impl;
	}
	-(Tellusim::SpatialGrid&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::SpatialGrid*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::SpatialGrid*)impl;
	}
	-(BOOL)equalPtr: (const TSSpatialGrid*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSSpatialGrid*)copyPtr {
		return [[TSSpatialGrid alloc] init_ref:[self ref]];
	}
	-(TSSpatialGrid*)clonePtr {
		return [[TSSpatialGrid alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSSpatialGrid*)null {
		return [[TSSpatialGrid alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(uint32_t)getGroupSize {
		return [self ref].getGroupSize();
	}
	-(TSRadixSort*)getRadixSort {
		return [[TSRadixSort alloc] init_ref:([self ref].getRadixSort())];
	}
	-(BOOL)create: (const TSDevice*)device sort: (TSRadixSort*)sort {
		return [self ref].create([device ref], [sort ref]);
	}
	-(BOOL)create_: (const TSDevice*)device sort: (TSRadixSort*)sort {
		return [self ref].create([device ref], [sort ref]);
	}
	-(BOOL)create_1: (const TSDevice*)device sort: (TSRadixSort*)sort groups: (uint32_t)groups {
		return [self ref].create([device ref], [sort ref], groups);
	}
	-(BOOL)create_1_: (const TSDevice*)device sort: (TSRadixSort*)sort groups: (uint32_t)groups {
		return [self ref].create([device ref], [sort ref], groups);
	}
	-(BOOL)dispatch: (TSCompute*)compute data: (TSBuffer*)data offset: (uint32_t)offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], [data ref], offset, size);
	}
	-(BOOL)dispatch_: (TSCompute*)compute data: (TSBuffer*)data offset: (uint32_t)offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], [data ref], offset, size);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute data: (TSBuffer*)data offset: (uint32_t)offset size: (uint32_t)size bits: (uint32_t)bits {
		return [self ref].dispatch([compute ref], [data ref], offset, size, bits);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute data: (TSBuffer*)data offset: (uint32_t)offset size: (uint32_t)size bits: (uint32_t)bits {
		return [self ref].dispatch([compute ref], [data ref], offset, size, bits);
	}
	-(BOOL)dispatchIndirect: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_1: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, max_size);
	}
	-(BOOL)dispatchIndirect_1_: (TSCompute*)compute data: (TSBuffer*)data dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], [data ref], [dispatch ref], offset, max_size);
	}
@end

// Tellusim::SpatialTree
@implementation TSSpatialTree
	-(id)init {
		self = [super init];
		impl = new Tellusim::SpatialTree();
		return self;
	}
	-(id)init_ptr: (Tellusim::SpatialTree*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::SpatialTree&)ref {
		self = [super init];
		impl = new Tellusim::SpatialTree((Tellusim::SpatialTree&)ref);
		return self;
	}
	-(Tellusim::SpatialTree*)pointer {
		return (Tellusim::SpatialTree*)impl;
	}
	-(Tellusim::SpatialTree&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::SpatialTree*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::SpatialTree*)impl;
	}
	-(BOOL)equalPtr: (const TSSpatialTree*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSSpatialTree*)copyPtr {
		return [[TSSpatialTree alloc] init_ref:[self ref]];
	}
	-(TSSpatialTree*)clonePtr {
		return [[TSSpatialTree alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSSpatialTree*)null {
		return [[TSSpatialTree alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_SpatialTreeFlags)flags {
		return [self ref].isCreated((Tellusim::SpatialTree::Flags)flags);
	}
	-(BOOL)isCreated_: (TS_SpatialTreeFlags)flags {
		return [self ref].isCreated((Tellusim::SpatialTree::Flags)flags);
	}
	-(uint32_t)getGroupSize {
		return [self ref].getGroupSize();
	}
	-(uint32_t)getBoundsNodes {
		return [self ref].getBoundsNodes();
	}
	-(uint32_t)getMaxNodes {
		return [self ref].getMaxNodes();
	}
	-(uint32_t)getMaxRegions {
		return [self ref].getMaxRegions();
	}
	-(TSRadixSort*)getRadixSort {
		return [[TSRadixSort alloc] init_ref:([self ref].getRadixSort())];
	}
	-(TSBuffer*)getHashBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getHashBuffer())];
	}
	-(TSBuffer*)getParentsBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getParentsBuffer())];
	}
	-(TSBuffer*)getCounterBuffer {
		return [[TSBuffer alloc] init_ref:([self ref].getCounterBuffer())];
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_SpatialTreeMode)mode sort: (TSRadixSort*)sort size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Mode)mode, [sort ref], size);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_SpatialTreeMode)mode sort: (TSRadixSort*)sort size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Mode)mode, [sort ref], size);
	}
	-(BOOL)create_1: (const TSDevice*)device mode: (TS_SpatialTreeMode)mode sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Mode)mode, [sort ref], size, groups);
	}
	-(BOOL)create_1_: (const TSDevice*)device mode: (TS_SpatialTreeMode)mode sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Mode)mode, [sort ref], size, groups);
	}
	-(BOOL)create_2: (const TSDevice*)device mode: (TS_SpatialTreeMode)mode sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Mode)mode, [sort ref], size, groups, regions);
	}
	-(BOOL)create_2_: (const TSDevice*)device mode: (TS_SpatialTreeMode)mode sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Mode)mode, [sort ref], size, groups, regions);
	}
	-(BOOL)create_3: (const TSDevice*)device mode: (TS_SpatialTreeMode)mode sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Mode)mode, [sort ref], size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_3_: (const TSDevice*)device mode: (TS_SpatialTreeMode)mode sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Mode)mode, [sort ref], size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_4: (const TSDevice*)device flags: (TS_SpatialTreeFlags)flags sort: (TSRadixSort*)sort size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Flags)flags, [sort ref], size);
	}
	-(BOOL)create_4_: (const TSDevice*)device flags: (TS_SpatialTreeFlags)flags sort: (TSRadixSort*)sort size: (uint32_t)size {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Flags)flags, [sort ref], size);
	}
	-(BOOL)create_5: (const TSDevice*)device flags: (TS_SpatialTreeFlags)flags sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Flags)flags, [sort ref], size, groups);
	}
	-(BOOL)create_5_: (const TSDevice*)device flags: (TS_SpatialTreeFlags)flags sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Flags)flags, [sort ref], size, groups);
	}
	-(BOOL)create_6: (const TSDevice*)device flags: (TS_SpatialTreeFlags)flags sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Flags)flags, [sort ref], size, groups, regions);
	}
	-(BOOL)create_6_: (const TSDevice*)device flags: (TS_SpatialTreeFlags)flags sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Flags)flags, [sort ref], size, groups, regions);
	}
	-(BOOL)create_7: (const TSDevice*)device flags: (TS_SpatialTreeFlags)flags sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Flags)flags, [sort ref], size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_7_: (const TSDevice*)device flags: (TS_SpatialTreeFlags)flags sort: (TSRadixSort*)sort size: (uint32_t)size groups: (uint32_t)groups regions: (uint32_t)regions async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::SpatialTree::Flags)flags, [sort ref], size, groups, regions, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)dispatch: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes offset: (uint32_t)offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], offset, size);
	}
	-(BOOL)dispatch_: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes offset: (uint32_t)offset size: (uint32_t)size {
		return [self ref].dispatch([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], offset, size);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes offset: (uint32_t)offset size: (uint32_t)size flags: (TS_SpatialTreeFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], offset, size, (Tellusim::SpatialTree::Flags)flags);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes offset: (uint32_t)offset size: (uint32_t)size flags: (TS_SpatialTreeFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], offset, size, (Tellusim::SpatialTree::Flags)flags);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes count: (uint32_t)count offsets: (const uint32_t*)offsets sizes: (const uint32_t*)sizes {
		return [self ref].dispatch([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], count, offsets, sizes);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes count: (uint32_t)count offsets: (const uint32_t*)offsets sizes: (const uint32_t*)sizes {
		return [self ref].dispatch([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], count, offsets, sizes);
	}
	-(BOOL)dispatch_3: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes count: (uint32_t)count offsets: (const uint32_t*)offsets sizes: (const uint32_t*)sizes flags: (TS_SpatialTreeFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], count, offsets, sizes, (Tellusim::SpatialTree::Flags)flags);
	}
	-(BOOL)dispatch_3_: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes count: (uint32_t)count offsets: (const uint32_t*)offsets sizes: (const uint32_t*)sizes flags: (TS_SpatialTreeFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], count, offsets, sizes, (Tellusim::SpatialTree::Flags)flags);
	}
	-(BOOL)dispatchIndirect: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_1: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], [dispatch ref], offset, max_size);
	}
	-(BOOL)dispatchIndirect_1_: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], [dispatch ref], offset, max_size);
	}
	-(BOOL)dispatchIndirect_2: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], count, [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_2_: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset {
		return [self ref].dispatchIndirect([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], count, [dispatch ref], offset);
	}
	-(BOOL)dispatchIndirect_3: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], count, [dispatch ref], offset, max_size);
	}
	-(BOOL)dispatchIndirect_3_: (TSCompute*)compute hash: (TS_SpatialTreeHash)hash nodes: (TSBuffer*)nodes count: (uint32_t)count dispatch: (TSBuffer*)dispatch offset: (uint32_t)offset max_size: (uint32_t)max_size {
		return [self ref].dispatchIndirect([compute ref], (Tellusim::SpatialTree::Hash)hash, [nodes ref], count, [dispatch ref], offset, max_size);
	}
@end

// Tellusim::FourierTransform
@implementation TSFourierTransform
	-(id)init {
		self = [super init];
		impl = new Tellusim::FourierTransform();
		return self;
	}
	-(id)init_ptr: (Tellusim::FourierTransform*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::FourierTransform&)ref {
		self = [super init];
		impl = new Tellusim::FourierTransform((Tellusim::FourierTransform&)ref);
		return self;
	}
	-(Tellusim::FourierTransform*)pointer {
		return (Tellusim::FourierTransform*)impl;
	}
	-(Tellusim::FourierTransform&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::FourierTransform*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::FourierTransform*)impl;
	}
	-(BOOL)equalPtr: (const TSFourierTransform*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSFourierTransform*)copyPtr {
		return [[TSFourierTransform alloc] init_ref:[self ref]];
	}
	-(TSFourierTransform*)clonePtr {
		return [[TSFourierTransform alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSFourierTransform*)null {
		return [[TSFourierTransform alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated: (TS_FourierTransformMode)mode {
		return [self ref].isCreated((Tellusim::FourierTransform::Mode)mode);
	}
	-(BOOL)isCreated_: (TS_FourierTransformMode)mode {
		return [self ref].isCreated((Tellusim::FourierTransform::Mode)mode);
	}
	-(BOOL)isCreated_1: (TS_FourierTransformFlags)flags {
		return [self ref].isCreated((Tellusim::FourierTransform::Flags)flags);
	}
	-(BOOL)isCreated_1_: (TS_FourierTransformFlags)flags {
		return [self ref].isCreated((Tellusim::FourierTransform::Flags)flags);
	}
	-(uint32_t)getMaxWidth {
		return [self ref].getMaxWidth();
	}
	-(uint32_t)getMaxHeight {
		return [self ref].getMaxHeight();
	}
	-(BOOL)create: (const TSDevice*)device mode: (TS_FourierTransformMode)mode width: (uint32_t)width height: (uint32_t)height {
		return [self ref].create([device ref], (Tellusim::FourierTransform::Mode)mode, width, height);
	}
	-(BOOL)create_: (const TSDevice*)device mode: (TS_FourierTransformMode)mode width: (uint32_t)width height: (uint32_t)height {
		return [self ref].create([device ref], (Tellusim::FourierTransform::Mode)mode, width, height);
	}
	-(BOOL)create_1: (const TSDevice*)device mode: (TS_FourierTransformMode)mode width: (uint32_t)width height: (uint32_t)height async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::FourierTransform::Mode)mode, width, height, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_1_: (const TSDevice*)device mode: (TS_FourierTransformMode)mode width: (uint32_t)width height: (uint32_t)height async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::FourierTransform::Mode)mode, width, height, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_2: (const TSDevice*)device flags: (TS_FourierTransformFlags)flags width: (uint32_t)width height: (uint32_t)height {
		return [self ref].create([device ref], (Tellusim::FourierTransform::Flags)flags, width, height);
	}
	-(BOOL)create_2_: (const TSDevice*)device flags: (TS_FourierTransformFlags)flags width: (uint32_t)width height: (uint32_t)height {
		return [self ref].create([device ref], (Tellusim::FourierTransform::Flags)flags, width, height);
	}
	-(BOOL)create_3: (const TSDevice*)device flags: (TS_FourierTransformFlags)flags width: (uint32_t)width height: (uint32_t)height async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::FourierTransform::Flags)flags, width, height, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_3_: (const TSDevice*)device flags: (TS_FourierTransformFlags)flags width: (uint32_t)width height: (uint32_t)height async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::FourierTransform::Flags)flags, width, height, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)dispatch: (TSCompute*)compute mode: (TS_FourierTransformMode)mode op: (TS_FourierTransformOperation)op dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::FourierTransform::Mode)mode, (Tellusim::FourierTransform::Operation)op, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_: (TSCompute*)compute mode: (TS_FourierTransformMode)mode op: (TS_FourierTransformOperation)op dest: (TSTexture*)dest src: (TSTexture*)src dest_slice: (TSSlice)dest_slice src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::FourierTransform::Mode)mode, (Tellusim::FourierTransform::Operation)op, [dest ref], [src ref], *(Tellusim::Slice*)&dest_slice, *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute mode: (TS_FourierTransformMode)mode op: (TS_FourierTransformOperation)op dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::FourierTransform::Mode)mode, (Tellusim::FourierTransform::Operation)op, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute mode: (TS_FourierTransformMode)mode op: (TS_FourierTransformOperation)op dest: (TSTexture*)dest src: (TSTexture*)src src_slice: (TSSlice)src_slice {
		return [self ref].dispatch([compute ref], (Tellusim::FourierTransform::Mode)mode, (Tellusim::FourierTransform::Operation)op, [dest ref], [src ref], *(Tellusim::Slice*)&src_slice);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute mode: (TS_FourierTransformMode)mode op: (TS_FourierTransformOperation)op dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::FourierTransform::Mode)mode, (Tellusim::FourierTransform::Operation)op, [dest ref], [src ref]);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute mode: (TS_FourierTransformMode)mode op: (TS_FourierTransformOperation)op dest: (TSTexture*)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], (Tellusim::FourierTransform::Mode)mode, (Tellusim::FourierTransform::Operation)op, [dest ref], [src ref]);
	}
@end

// Tellusim::TensorGraph
@implementation TSTensorGraph
	-(id)init {
		self = [super init];
		impl = new Tellusim::TensorGraph();
		return self;
	}
	-(id)init_ptr: (Tellusim::TensorGraph*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::TensorGraph&)ref {
		self = [super init];
		impl = new Tellusim::TensorGraph((Tellusim::TensorGraph&)ref);
		return self;
	}
	-(Tellusim::TensorGraph*)pointer {
		return (Tellusim::TensorGraph*)impl;
	}
	-(Tellusim::TensorGraph&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::TensorGraph*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::TensorGraph*)impl;
	}
	-(BOOL)equalPtr: (const TSTensorGraph*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSTensorGraph*)copyPtr {
		return [[TSTensorGraph alloc] init_ref:[self ref]];
	}
	-(TSTensorGraph*)clonePtr {
		return [[TSTensorGraph alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSTensorGraph*)null {
		return [[TSTensorGraph alloc] init_ptr:nullptr];
	}
	-(void)clear {
		[self ref].clear();
	}
	-(BOOL)isCreated {
		return [self ref].isCreated();
	}
	-(BOOL)create: (const TSDevice*)device {
		return [self ref].create([device ref]);
	}
	-(BOOL)create_: (const TSDevice*)device {
		return [self ref].create([device ref]);
	}
	-(BOOL)create_1: (const TSDevice*)device flags: (TS_TensorGraphFlags)flags {
		return [self ref].create([device ref], (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)create_1_: (const TSDevice*)device flags: (TS_TensorGraphFlags)flags {
		return [self ref].create([device ref], (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)create_2: (const TSDevice*)device flags: (TS_TensorGraphFlags)flags masks: (TS_TensorGraphMasks)masks {
		return [self ref].create([device ref], (Tellusim::TensorGraph::Flags)flags, (Tellusim::TensorGraph::Masks)masks);
	}
	-(BOOL)create_2_: (const TSDevice*)device flags: (TS_TensorGraphFlags)flags masks: (TS_TensorGraphMasks)masks {
		return [self ref].create([device ref], (Tellusim::TensorGraph::Flags)flags, (Tellusim::TensorGraph::Masks)masks);
	}
	-(BOOL)create_3: (const TSDevice*)device flags: (TS_TensorGraphFlags)flags masks: (TS_TensorGraphMasks)masks async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::TensorGraph::Flags)flags, (Tellusim::TensorGraph::Masks)masks, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)create_3_: (const TSDevice*)device flags: (TS_TensorGraphFlags)flags masks: (TS_TensorGraphMasks)masks async: (TSAsync**)async {
		return [self ref].create([device ref], (Tellusim::TensorGraph::Flags)flags, (Tellusim::TensorGraph::Masks)masks, (async) ? [*async pointer] : nullptr);
	}
	-(BOOL)dispatch: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor)dest {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)&dest);
	}
	-(BOOL)dispatch_: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor)dest {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)&dest);
	}
	-(BOOL)dispatch_1: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor)dest flags: (TS_TensorGraphFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)&dest, (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)dispatch_1_: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor)dest flags: (TS_TensorGraphFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)&dest, (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)dispatch_2: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0);
	}
	-(BOOL)dispatch_2_: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0);
	}
	-(BOOL)dispatch_3: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 flags: (TS_TensorGraphFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)dispatch_3_: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 flags: (TS_TensorGraphFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)dispatch_4: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 src_1: (TSTensor)src_1 {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, *(Tellusim::Tensor*)&src_1);
	}
	-(BOOL)dispatch_4_: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 src_1: (TSTensor)src_1 {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, *(Tellusim::Tensor*)&src_1);
	}
	-(BOOL)dispatch_5: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 src_1: (TSTensor)src_1 flags: (TS_TensorGraphFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, *(Tellusim::Tensor*)&src_1, (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)dispatch_5_: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 src_1: (TSTensor)src_1 flags: (TS_TensorGraphFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, *(Tellusim::Tensor*)&src_1, (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)dispatch_6: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 src_1: (TSTensor)src_1 src_2: (TSTensor)src_2 {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, *(Tellusim::Tensor*)&src_1, *(Tellusim::Tensor*)&src_2);
	}
	-(BOOL)dispatch_6_: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 src_1: (TSTensor)src_1 src_2: (TSTensor)src_2 {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, *(Tellusim::Tensor*)&src_1, *(Tellusim::Tensor*)&src_2);
	}
	-(BOOL)dispatch_7: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 src_1: (TSTensor)src_1 src_2: (TSTensor)src_2 flags: (TS_TensorGraphFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, *(Tellusim::Tensor*)&src_1, *(Tellusim::Tensor*)&src_2, (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)dispatch_7_: (TSCompute*)compute op: (TS_TensorGraphOperation)op dest: (TSTensor*)dest src_0: (TSTensor)src_0 src_1: (TSTensor)src_1 src_2: (TSTensor)src_2 flags: (TS_TensorGraphFlags)flags {
		return [self ref].dispatch([compute ref], (Tellusim::TensorGraph::Operation)op, *(Tellusim::Tensor*)dest, *(Tellusim::Tensor*)&src_0, *(Tellusim::Tensor*)&src_1, *(Tellusim::Tensor*)&src_2, (Tellusim::TensorGraph::Flags)flags);
	}
	-(BOOL)dispatch_8: (TSCompute*)compute dest: (TSTensor)dest src: (TSTexture*)src region: (TSRegion)region {
		return [self ref].dispatch([compute ref], *(Tellusim::Tensor*)&dest, [src ref], *(Tellusim::Region*)&region);
	}
	-(BOOL)dispatch_8_: (TSCompute*)compute dest: (TSTensor)dest src: (TSTexture*)src region: (TSRegion)region {
		return [self ref].dispatch([compute ref], *(Tellusim::Tensor*)&dest, [src ref], *(Tellusim::Region*)&region);
	}
	-(BOOL)dispatch_9: (TSCompute*)compute dest: (TSTensor)dest src: (TSTexture*)src region: (TSRegion)region slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], *(Tellusim::Tensor*)&dest, [src ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)dispatch_9_: (TSCompute*)compute dest: (TSTensor)dest src: (TSTexture*)src region: (TSRegion)region slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], *(Tellusim::Tensor*)&dest, [src ref], *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)dispatch_10: (TSCompute*)compute dest: (TSTensor)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], *(Tellusim::Tensor*)&dest, [src ref]);
	}
	-(BOOL)dispatch_10_: (TSCompute*)compute dest: (TSTensor)dest src: (TSTexture*)src {
		return [self ref].dispatch([compute ref], *(Tellusim::Tensor*)&dest, [src ref]);
	}
	-(BOOL)dispatch_11: (TSCompute*)compute dest: (TSTensor)dest src: (TSTexture*)src slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], *(Tellusim::Tensor*)&dest, [src ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)dispatch_11_: (TSCompute*)compute dest: (TSTensor)dest src: (TSTexture*)src slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], *(Tellusim::Tensor*)&dest, [src ref], *(Tellusim::Slice*)&slice);
	}
	-(BOOL)dispatch_12: (TSCompute*)compute dest: (TSTexture*)dest src: (TSTensor)src region: (TSRegion)region {
		return [self ref].dispatch([compute ref], [dest ref], *(Tellusim::Tensor*)&src, *(Tellusim::Region*)&region);
	}
	-(BOOL)dispatch_12_: (TSCompute*)compute dest: (TSTexture*)dest src: (TSTensor)src region: (TSRegion)region {
		return [self ref].dispatch([compute ref], [dest ref], *(Tellusim::Tensor*)&src, *(Tellusim::Region*)&region);
	}
	-(BOOL)dispatch_13: (TSCompute*)compute dest: (TSTexture*)dest src: (TSTensor)src region: (TSRegion)region slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], [dest ref], *(Tellusim::Tensor*)&src, *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)dispatch_13_: (TSCompute*)compute dest: (TSTexture*)dest src: (TSTensor)src region: (TSRegion)region slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], [dest ref], *(Tellusim::Tensor*)&src, *(Tellusim::Region*)&region, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)dispatch_14: (TSCompute*)compute dest: (TSTexture*)dest src: (TSTensor)src {
		return [self ref].dispatch([compute ref], [dest ref], *(Tellusim::Tensor*)&src);
	}
	-(BOOL)dispatch_14_: (TSCompute*)compute dest: (TSTexture*)dest src: (TSTensor)src {
		return [self ref].dispatch([compute ref], [dest ref], *(Tellusim::Tensor*)&src);
	}
	-(BOOL)dispatch_15: (TSCompute*)compute dest: (TSTexture*)dest src: (TSTensor)src slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], [dest ref], *(Tellusim::Tensor*)&src, *(Tellusim::Slice*)&slice);
	}
	-(BOOL)dispatch_15_: (TSCompute*)compute dest: (TSTexture*)dest src: (TSTensor)src slice: (TSSlice)slice {
		return [self ref].dispatch([compute ref], [dest ref], *(Tellusim::Tensor*)&src, *(Tellusim::Slice*)&slice);
	}
@end

// Tellusim::Desktop
@implementation TSDesktop
	-(id)init {
		self = [super init];
		impl = new Tellusim::Desktop();
		return self;
	}
	-(id)init_ptr: (Tellusim::Desktop*)ptr {
		self = [super init];
		impl = ptr;
		return self;
	}
	-(id)init_ref: (const Tellusim::Desktop&)ref {
		self = [super init];
		impl = new Tellusim::Desktop((Tellusim::Desktop&)ref);
		return self;
	}
	-(Tellusim::Desktop*)pointer {
		return (Tellusim::Desktop*)impl;
	}
	-(Tellusim::Desktop&)ref {
		TS_ASSERT(impl);
		return *(Tellusim::Desktop*)impl;
	}
	-(void)dealloc {
		delete (Tellusim::Desktop*)impl;
	}
	-(BOOL)equalPtr: (const TSDesktop*)ptr {
		return ([self ref] == [ptr ref]);
	}
	-(TSDesktop*)copyPtr {
		return [[TSDesktop alloc] init_ref:[self ref]];
	}
	-(TSDesktop*)clonePtr {
		return [[TSDesktop alloc] init_ref:[self ref].clonePtr()];
	}
	-(void)clearPtr {
		if(impl) [self ref].clearPtr();
	}
	-(void)destroyPtr {
		if(impl) [self ref].destroyPtr();
	}
	-(void)acquirePtr {
		if(impl) [self ref].acquirePtr();
	}
	-(void)unacquirePtr {
		if(impl) [self ref].unacquirePtr();
	}
	-(BOOL)isValidPtr {
		return (impl && [self ref].isValidPtr());
	}
	-(BOOL)isOwnerPtr {
		return (impl && [self ref].isOwnerPtr());
	}
	-(BOOL)isConstPtr {
		return (impl && [self ref].isConstPtr());
	}
	-(uint32_t)getCountPtr {
		return (impl) ? [self ref].getCountPtr() : 0;
	}
	-(const void*)getInternalPtr {
		return (impl) ? [self ref].getInternalPtr() : nullptr;
	}
	-(size_t)getSelfPtr {
		return (size_t)impl;
	}
	+(TSDesktop*)null {
		return [[TSDesktop alloc] init_ptr:nullptr];
	}
	-(BOOL)update {
		return [self ref].update();
	}
	-(uint32_t)getWidth {
		return [self ref].getWidth();
	}
	-(uint32_t)getHeight {
		return [self ref].getHeight();
	}
	-(int32_t)getPositionX {
		return [self ref].getPositionX();
	}
	-(int32_t)getPositionY {
		return [self ref].getPositionY();
	}
	-(float32_t)getScale {
		return [self ref].getScale();
	}
	-(uint32_t)getNumScreens {
		return [self ref].getNumScreens();
	}
	-(NSString*)getScreenName: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getScreenName(index).get()];
	}
	-(NSString*)getScreenName_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getScreenName(index).get()];
	}
	-(NSString*)getScreenDevice: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getScreenDevice(index).get()];
	}
	-(NSString*)getScreenDevice_: (uint32_t)index {
		return [NSString stringWithUTF8String:[self ref].getScreenDevice(index).get()];
	}
	-(uint32_t)getScreenWidth: (uint32_t)index {
		return [self ref].getScreenWidth(index);
	}
	-(uint32_t)getScreenWidth_: (uint32_t)index {
		return [self ref].getScreenWidth(index);
	}
	-(uint32_t)getScreenHeight: (uint32_t)index {
		return [self ref].getScreenHeight(index);
	}
	-(uint32_t)getScreenHeight_: (uint32_t)index {
		return [self ref].getScreenHeight(index);
	}
	-(int32_t)getScreenPositionX: (uint32_t)index {
		return [self ref].getScreenPositionX(index);
	}
	-(int32_t)getScreenPositionX_: (uint32_t)index {
		return [self ref].getScreenPositionX(index);
	}
	-(int32_t)getScreenPositionY: (uint32_t)index {
		return [self ref].getScreenPositionY(index);
	}
	-(int32_t)getScreenPositionY_: (uint32_t)index {
		return [self ref].getScreenPositionY(index);
	}
	-(uint32_t)getScreenFrequency: (uint32_t)index {
		return [self ref].getScreenFrequency(index);
	}
	-(uint32_t)getScreenFrequency_: (uint32_t)index {
		return [self ref].getScreenFrequency(index);
	}
	-(uint32_t)getNumModes: (uint32_t)index {
		return [self ref].getNumModes(index);
	}
	-(uint32_t)getNumModes_: (uint32_t)index {
		return [self ref].getNumModes(index);
	}
	-(uint32_t)getModeWidth: (uint32_t)index mode: (uint32_t)mode {
		return [self ref].getModeWidth(index, mode);
	}
	-(uint32_t)getModeWidth_: (uint32_t)index mode: (uint32_t)mode {
		return [self ref].getModeWidth(index, mode);
	}
	-(uint32_t)getModeHeight: (uint32_t)index mode: (uint32_t)mode {
		return [self ref].getModeHeight(index, mode);
	}
	-(uint32_t)getModeHeight_: (uint32_t)index mode: (uint32_t)mode {
		return [self ref].getModeHeight(index, mode);
	}
	-(uint32_t)getModeIndex: (uint32_t)index width: (uint32_t)width height: (uint32_t)height {
		return [self ref].getModeIndex(index, width, height);
	}
	-(uint32_t)getModeIndex_: (uint32_t)index width: (uint32_t)width height: (uint32_t)height {
		return [self ref].getModeIndex(index, width, height);
	}
	-(BOOL)setMode: (uint32_t)index width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setMode(index, width, height);
	}
	-(BOOL)setMode_: (uint32_t)index width: (uint32_t)width height: (uint32_t)height {
		return [self ref].setMode(index, width, height);
	}
	-(BOOL)restoreMode: (uint32_t)index {
		return [self ref].restoreMode(index);
	}
	-(BOOL)restoreMode_: (uint32_t)index {
		return [self ref].restoreMode(index);
	}
	-(uint32_t)getWidth_1: (uint32_t)index {
		return [self ref].getWidth(index);
	}
	-(uint32_t)getWidth_1_: (uint32_t)index {
		return [self ref].getWidth(index);
	}
	-(uint32_t)getHeight_1: (uint32_t)index {
		return [self ref].getHeight(index);
	}
	-(uint32_t)getHeight_1_: (uint32_t)index {
		return [self ref].getHeight(index);
	}
	-(int32_t)getPositionX_1: (uint32_t)index {
		return [self ref].getPositionX(index);
	}
	-(int32_t)getPositionX_1_: (uint32_t)index {
		return [self ref].getPositionX(index);
	}
	-(int32_t)getPositionY_1: (uint32_t)index {
		return [self ref].getPositionY(index);
	}
	-(int32_t)getPositionY_1_: (uint32_t)index {
		return [self ref].getPositionY(index);
	}
	-(uint32_t)getScreenIndex: (int32_t)x y: (int32_t)y {
		return [self ref].getScreenIndex(x, y);
	}
	-(uint32_t)getScreenIndex_: (int32_t)x y: (int32_t)y {
		return [self ref].getScreenIndex(x, y);
	}
	-(BOOL)setMouse: (int32_t)x y: (int32_t)y {
		return [self ref].setMouse(x, y);
	}
	-(BOOL)setMouse_: (int32_t)x y: (int32_t)y {
		return [self ref].setMouse(x, y);
	}
	-(BOOL)getMouse: (int32_t*)x y: (int32_t*)y {
		TS_ASSERT(x);
		TS_ASSERT(y);
		return [self ref].getMouse(*x, *y);
	}
	-(BOOL)getMouse_: (int32_t*)x y: (int32_t*)y {
		TS_ASSERT(x);
		TS_ASSERT(y);
		return [self ref].getMouse(*x, *y);
	}
@end

/// Tellusim
TS_CAPI @implementation TSBase
	+(NSString*)getPlatformName: (TS_Platform)platform {
		return [NSString stringWithUTF8String:Tellusim::getPlatformName((Tellusim::Platform)platform)];
	}
	+(NSString*)getPlatformName_: (TS_Platform)platform {
		return [NSString stringWithUTF8String:Tellusim::getPlatformName((Tellusim::Platform)platform)];
	}
	+(TS_Platform)findPlatformName: (const char*)name {
		return (TS_Platform)Tellusim::findPlatformName(name);
	}
	+(TS_Platform)findPlatformName_: (const char*)name {
		return (TS_Platform)Tellusim::findPlatformName(name);
	}
	+(BOOL)isPlatformAvailable: (TS_Platform)platform {
		return Tellusim::isPlatformAvailable((Tellusim::Platform)platform);
	}
	+(BOOL)isPlatformAvailable_: (TS_Platform)platform {
		return Tellusim::isPlatformAvailable((Tellusim::Platform)platform);
	}
	+(NSString*)getFormatName: (TS_Format)format {
		return [NSString stringWithUTF8String:Tellusim::getFormatName((Tellusim::Format)format)];
	}
	+(NSString*)getFormatName_: (TS_Format)format {
		return [NSString stringWithUTF8String:Tellusim::getFormatName((Tellusim::Format)format)];
	}
	+(TS_Format)findFormatName: (const char*)name {
		return (TS_Format)Tellusim::findFormatName(name);
	}
	+(TS_Format)findFormatName_: (const char*)name {
		return (TS_Format)Tellusim::findFormatName(name);
	}
	+(NSString*)getGLSLFormatName: (TS_Format)format {
		return [NSString stringWithUTF8String:Tellusim::getGLSLFormatName((Tellusim::Format)format)];
	}
	+(NSString*)getGLSLFormatName_: (TS_Format)format {
		return [NSString stringWithUTF8String:Tellusim::getGLSLFormatName((Tellusim::Format)format)];
	}
	+(TS_Format)findGLSLFormatName: (const char*)name {
		return (TS_Format)Tellusim::findGLSLFormatName(name);
	}
	+(TS_Format)findGLSLFormatName_: (const char*)name {
		return (TS_Format)Tellusim::findGLSLFormatName(name);
	}
	+(BOOL)isColorFormat: (TS_Format)format {
		return Tellusim::isColorFormat((Tellusim::Format)format);
	}
	+(BOOL)isColorFormat_: (TS_Format)format {
		return Tellusim::isColorFormat((Tellusim::Format)format);
	}
	+(BOOL)isDepthFormat: (TS_Format)format {
		return Tellusim::isDepthFormat((Tellusim::Format)format);
	}
	+(BOOL)isDepthFormat_: (TS_Format)format {
		return Tellusim::isDepthFormat((Tellusim::Format)format);
	}
	+(BOOL)isPixelFormat: (TS_Format)format {
		return Tellusim::isPixelFormat((Tellusim::Format)format);
	}
	+(BOOL)isPixelFormat_: (TS_Format)format {
		return Tellusim::isPixelFormat((Tellusim::Format)format);
	}
	+(BOOL)isPlainFormat: (TS_Format)format {
		return Tellusim::isPlainFormat((Tellusim::Format)format);
	}
	+(BOOL)isPlainFormat_: (TS_Format)format {
		return Tellusim::isPlainFormat((Tellusim::Format)format);
	}
	+(BOOL)isMixedFormat: (TS_Format)format {
		return Tellusim::isMixedFormat((Tellusim::Format)format);
	}
	+(BOOL)isMixedFormat_: (TS_Format)format {
		return Tellusim::isMixedFormat((Tellusim::Format)format);
	}
	+(BOOL)isBlockFormat: (TS_Format)format {
		return Tellusim::isBlockFormat((Tellusim::Format)format);
	}
	+(BOOL)isBlockFormat_: (TS_Format)format {
		return Tellusim::isBlockFormat((Tellusim::Format)format);
	}
	+(BOOL)isStencilFormat: (TS_Format)format {
		return Tellusim::isStencilFormat((Tellusim::Format)format);
	}
	+(BOOL)isStencilFormat_: (TS_Format)format {
		return Tellusim::isStencilFormat((Tellusim::Format)format);
	}
	+(TS_Format)toPixelFormat: (TS_Format)format {
		return (TS_Format)Tellusim::toPixelFormat((Tellusim::Format)format);
	}
	+(TS_Format)toPixelFormat_: (TS_Format)format {
		return (TS_Format)Tellusim::toPixelFormat((Tellusim::Format)format);
	}
	+(BOOL)isNormFormat: (TS_Format)format {
		return Tellusim::isNormFormat((Tellusim::Format)format);
	}
	+(BOOL)isNormFormat_: (TS_Format)format {
		return Tellusim::isNormFormat((Tellusim::Format)format);
	}
	+(BOOL)isSRGBFormat: (TS_Format)format {
		return Tellusim::isSRGBFormat((Tellusim::Format)format);
	}
	+(BOOL)isSRGBFormat_: (TS_Format)format {
		return Tellusim::isSRGBFormat((Tellusim::Format)format);
	}
	+(BOOL)isSignedFormat: (TS_Format)format {
		return Tellusim::isSignedFormat((Tellusim::Format)format);
	}
	+(BOOL)isSignedFormat_: (TS_Format)format {
		return Tellusim::isSignedFormat((Tellusim::Format)format);
	}
	+(BOOL)isUnsignedFormat: (TS_Format)format {
		return Tellusim::isUnsignedFormat((Tellusim::Format)format);
	}
	+(BOOL)isUnsignedFormat_: (TS_Format)format {
		return Tellusim::isUnsignedFormat((Tellusim::Format)format);
	}
	+(BOOL)isIntegerFormat: (TS_Format)format {
		return Tellusim::isIntegerFormat((Tellusim::Format)format);
	}
	+(BOOL)isIntegerFormat_: (TS_Format)format {
		return Tellusim::isIntegerFormat((Tellusim::Format)format);
	}
	+(BOOL)isFloatFormat: (TS_Format)format {
		return Tellusim::isFloatFormat((Tellusim::Format)format);
	}
	+(BOOL)isFloatFormat_: (TS_Format)format {
		return Tellusim::isFloatFormat((Tellusim::Format)format);
	}
	+(TS_Format)toNormFormat: (TS_Format)format {
		return (TS_Format)Tellusim::toNormFormat((Tellusim::Format)format);
	}
	+(TS_Format)toNormFormat_: (TS_Format)format {
		return (TS_Format)Tellusim::toNormFormat((Tellusim::Format)format);
	}
	+(TS_Format)toSRGBFormat: (TS_Format)format {
		return (TS_Format)Tellusim::toSRGBFormat((Tellusim::Format)format);
	}
	+(TS_Format)toSRGBFormat_: (TS_Format)format {
		return (TS_Format)Tellusim::toSRGBFormat((Tellusim::Format)format);
	}
	+(TS_Format)toSignedFormat: (TS_Format)format {
		return (TS_Format)Tellusim::toSignedFormat((Tellusim::Format)format);
	}
	+(TS_Format)toSignedFormat_: (TS_Format)format {
		return (TS_Format)Tellusim::toSignedFormat((Tellusim::Format)format);
	}
	+(TS_Format)toUnsignedFormat: (TS_Format)format {
		return (TS_Format)Tellusim::toUnsignedFormat((Tellusim::Format)format);
	}
	+(TS_Format)toUnsignedFormat_: (TS_Format)format {
		return (TS_Format)Tellusim::toUnsignedFormat((Tellusim::Format)format);
	}
	+(TS_Format)toFloatFormat: (TS_Format)format {
		return (TS_Format)Tellusim::toFloatFormat((Tellusim::Format)format);
	}
	+(TS_Format)toFloatFormat_: (TS_Format)format {
		return (TS_Format)Tellusim::toFloatFormat((Tellusim::Format)format);
	}
	+(BOOL)isi8Format: (TS_Format)format {
		return Tellusim::isi8Format((Tellusim::Format)format);
	}
	+(BOOL)isi8Format_: (TS_Format)format {
		return Tellusim::isi8Format((Tellusim::Format)format);
	}
	+(BOOL)isu8Format: (TS_Format)format {
		return Tellusim::isu8Format((Tellusim::Format)format);
	}
	+(BOOL)isu8Format_: (TS_Format)format {
		return Tellusim::isu8Format((Tellusim::Format)format);
	}
	+(BOOL)is8BitFormat: (TS_Format)format {
		return Tellusim::is8BitFormat((Tellusim::Format)format);
	}
	+(BOOL)is8BitFormat_: (TS_Format)format {
		return Tellusim::is8BitFormat((Tellusim::Format)format);
	}
	+(TS_Format)to8BitFormat: (TS_Format)format {
		return (TS_Format)Tellusim::to8BitFormat((Tellusim::Format)format);
	}
	+(TS_Format)to8BitFormat_: (TS_Format)format {
		return (TS_Format)Tellusim::to8BitFormat((Tellusim::Format)format);
	}
	+(BOOL)isi16Format: (TS_Format)format {
		return Tellusim::isi16Format((Tellusim::Format)format);
	}
	+(BOOL)isi16Format_: (TS_Format)format {
		return Tellusim::isi16Format((Tellusim::Format)format);
	}
	+(BOOL)isu16Format: (TS_Format)format {
		return Tellusim::isu16Format((Tellusim::Format)format);
	}
	+(BOOL)isu16Format_: (TS_Format)format {
		return Tellusim::isu16Format((Tellusim::Format)format);
	}
	+(BOOL)isf16Format: (TS_Format)format {
		return Tellusim::isf16Format((Tellusim::Format)format);
	}
	+(BOOL)isf16Format_: (TS_Format)format {
		return Tellusim::isf16Format((Tellusim::Format)format);
	}
	+(BOOL)is16BitFormat: (TS_Format)format {
		return Tellusim::is16BitFormat((Tellusim::Format)format);
	}
	+(BOOL)is16BitFormat_: (TS_Format)format {
		return Tellusim::is16BitFormat((Tellusim::Format)format);
	}
	+(TS_Format)to16BitFormat: (TS_Format)format {
		return (TS_Format)Tellusim::to16BitFormat((Tellusim::Format)format);
	}
	+(TS_Format)to16BitFormat_: (TS_Format)format {
		return (TS_Format)Tellusim::to16BitFormat((Tellusim::Format)format);
	}
	+(BOOL)isi32Format: (TS_Format)format {
		return Tellusim::isi32Format((Tellusim::Format)format);
	}
	+(BOOL)isi32Format_: (TS_Format)format {
		return Tellusim::isi32Format((Tellusim::Format)format);
	}
	+(BOOL)isu32Format: (TS_Format)format {
		return Tellusim::isu32Format((Tellusim::Format)format);
	}
	+(BOOL)isu32Format_: (TS_Format)format {
		return Tellusim::isu32Format((Tellusim::Format)format);
	}
	+(BOOL)isf32Format: (TS_Format)format {
		return Tellusim::isf32Format((Tellusim::Format)format);
	}
	+(BOOL)isf32Format_: (TS_Format)format {
		return Tellusim::isf32Format((Tellusim::Format)format);
	}
	+(BOOL)is32BitFormat: (TS_Format)format {
		return Tellusim::is32BitFormat((Tellusim::Format)format);
	}
	+(BOOL)is32BitFormat_: (TS_Format)format {
		return Tellusim::is32BitFormat((Tellusim::Format)format);
	}
	+(TS_Format)to32BitFormat: (TS_Format)format {
		return (TS_Format)Tellusim::to32BitFormat((Tellusim::Format)format);
	}
	+(TS_Format)to32BitFormat_: (TS_Format)format {
		return (TS_Format)Tellusim::to32BitFormat((Tellusim::Format)format);
	}
	+(BOOL)isi64Format: (TS_Format)format {
		return Tellusim::isi64Format((Tellusim::Format)format);
	}
	+(BOOL)isi64Format_: (TS_Format)format {
		return Tellusim::isi64Format((Tellusim::Format)format);
	}
	+(BOOL)isu64Format: (TS_Format)format {
		return Tellusim::isu64Format((Tellusim::Format)format);
	}
	+(BOOL)isu64Format_: (TS_Format)format {
		return Tellusim::isu64Format((Tellusim::Format)format);
	}
	+(BOOL)isf64Format: (TS_Format)format {
		return Tellusim::isf64Format((Tellusim::Format)format);
	}
	+(BOOL)isf64Format_: (TS_Format)format {
		return Tellusim::isf64Format((Tellusim::Format)format);
	}
	+(BOOL)is64BitFormat: (TS_Format)format {
		return Tellusim::is64BitFormat((Tellusim::Format)format);
	}
	+(BOOL)is64BitFormat_: (TS_Format)format {
		return Tellusim::is64BitFormat((Tellusim::Format)format);
	}
	+(BOOL)isBC15Format: (TS_Format)format {
		return Tellusim::isBC15Format((Tellusim::Format)format);
	}
	+(BOOL)isBC15Format_: (TS_Format)format {
		return Tellusim::isBC15Format((Tellusim::Format)format);
	}
	+(BOOL)isBC67Format: (TS_Format)format {
		return Tellusim::isBC67Format((Tellusim::Format)format);
	}
	+(BOOL)isBC67Format_: (TS_Format)format {
		return Tellusim::isBC67Format((Tellusim::Format)format);
	}
	+(BOOL)isETC2Format: (TS_Format)format {
		return Tellusim::isETC2Format((Tellusim::Format)format);
	}
	+(BOOL)isETC2Format_: (TS_Format)format {
		return Tellusim::isETC2Format((Tellusim::Format)format);
	}
	+(BOOL)isASTCFormat: (TS_Format)format {
		return Tellusim::isASTCFormat((Tellusim::Format)format);
	}
	+(BOOL)isASTCFormat_: (TS_Format)format {
		return Tellusim::isASTCFormat((Tellusim::Format)format);
	}
	+(uint32_t)getFormatComponents: (TS_Format)format {
		return Tellusim::getFormatComponents((Tellusim::Format)format);
	}
	+(uint32_t)getFormatComponents_: (TS_Format)format {
		return Tellusim::getFormatComponents((Tellusim::Format)format);
	}
	+(TS_Format)toFormatComponents: (TS_Format)format components: (uint32_t)components {
		return (TS_Format)Tellusim::toFormatComponents((Tellusim::Format)format, components);
	}
	+(TS_Format)toFormatComponents_: (TS_Format)format components: (uint32_t)components {
		return (TS_Format)Tellusim::toFormatComponents((Tellusim::Format)format, components);
	}
	+(uint32_t)getFormatPixelSize: (TS_Format)format {
		return Tellusim::getFormatPixelSize((Tellusim::Format)format);
	}
	+(uint32_t)getFormatPixelSize_: (TS_Format)format {
		return Tellusim::getFormatPixelSize((Tellusim::Format)format);
	}
	+(uint32_t)getFormatBlockSize: (TS_Format)format {
		return Tellusim::getFormatBlockSize((Tellusim::Format)format);
	}
	+(uint32_t)getFormatBlockSize_: (TS_Format)format {
		return Tellusim::getFormatBlockSize((Tellusim::Format)format);
	}
	+(uint32_t)getFormatBlockWidth: (TS_Format)format {
		return Tellusim::getFormatBlockWidth((Tellusim::Format)format);
	}
	+(uint32_t)getFormatBlockWidth_: (TS_Format)format {
		return Tellusim::getFormatBlockWidth((Tellusim::Format)format);
	}
	+(uint32_t)getFormatBlockHeight: (TS_Format)format {
		return Tellusim::getFormatBlockHeight((Tellusim::Format)format);
	}
	+(uint32_t)getFormatBlockHeight_: (TS_Format)format {
		return Tellusim::getFormatBlockHeight((Tellusim::Format)format);
	}
	+(uint32_t)getPixelFormatValue: (TS_Format)format value: (float32_t[ 4])value src: (const void*)src {
		return Tellusim::getPixelFormatValue((Tellusim::Format)format, value, src);
	}
	+(uint32_t)getPixelFormatValue_: (TS_Format)format value: (float32_t[ 4])value src: (const void*)src {
		return Tellusim::getPixelFormatValue((Tellusim::Format)format, value, src);
	}
	+(uint32_t)getPixelFormatValue_1: (TS_Format)format value: (float32_t[ 4])value src: (const void*)src stride: (uint32_t)stride {
		return Tellusim::getPixelFormatValue((Tellusim::Format)format, value, src, stride);
	}
	+(uint32_t)getPixelFormatValue_1_: (TS_Format)format value: (float32_t[ 4])value src: (const void*)src stride: (uint32_t)stride {
		return Tellusim::getPixelFormatValue((Tellusim::Format)format, value, src, stride);
	}
	+(uint32_t)setPixelFormatValue: (TS_Format)format dest: (void*)dest value: (const float32_t[ 4])value {
		return Tellusim::setPixelFormatValue((Tellusim::Format)format, dest, value);
	}
	+(uint32_t)setPixelFormatValue_: (TS_Format)format dest: (void*)dest value: (const float32_t[ 4])value {
		return Tellusim::setPixelFormatValue((Tellusim::Format)format, dest, value);
	}
	+(uint32_t)setPixelFormatValue_1: (TS_Format)format dest: (void*)dest value: (const float32_t[ 4])value stride: (uint32_t)stride {
		return Tellusim::setPixelFormatValue((Tellusim::Format)format, dest, value, stride);
	}
	+(uint32_t)setPixelFormatValue_1_: (TS_Format)format dest: (void*)dest value: (const float32_t[ 4])value stride: (uint32_t)stride {
		return Tellusim::setPixelFormatValue((Tellusim::Format)format, dest, value, stride);
	}
@end

/// Tellusim::Allocator
TS_CAPI @implementation TSAllocator
	+(void*)allocate: (size_t)size {
		return Tellusim::Allocator::allocate(size);
	}
	+(void*)allocate_: (size_t)size {
		return Tellusim::Allocator::allocate(size);
	}
	+(void*)reallocate: (void*)ptr old_size: (size_t)old_size new_size: (size_t)new_size {
		return Tellusim::Allocator::reallocate(ptr, old_size, new_size);
	}
	+(void*)reallocate_: (void*)ptr old_size: (size_t)old_size new_size: (size_t)new_size {
		return Tellusim::Allocator::reallocate(ptr, old_size, new_size);
	}
	+(void)free: (const void*)ptr size: (size_t)size {
		return Tellusim::Allocator::free(ptr, size);
	}
	+(void)free_: (const void*)ptr size: (size_t)size {
		return Tellusim::Allocator::free(ptr, size);
	}
	+(size_t)getMemory {
		return Tellusim::Allocator::getMemory();
	}
	+(size_t)getAllocations {
		return Tellusim::Allocator::getAllocations();
	}
@end

/// Tellusim::Log
TS_CAPI @implementation TSLog
	+(void)setLevel: (TS_LogLevel)level {
		return Tellusim::Log::setLevel((Tellusim::Log::Level)level);
	}
	+(void)setLevel_: (TS_LogLevel)level {
		return Tellusim::Log::setLevel((Tellusim::Log::Level)level);
	}
	+(TS_LogLevel)getLevel {
		return (TS_LogLevel)Tellusim::Log::getLevel();
	}
	+(void)unlockCallback {
		return Tellusim::Log::unlockCallback();
	}
	+(void)lockCallback {
		return Tellusim::Log::lockCallback();
	}
	+(void)print: (const char*)str {
		return Tellusim::Log::print(str);
	}
	+(void)print_: (const char*)str {
		return Tellusim::Log::print(str);
	}
	+(void)vprintf: (const char*)str args: (va_list)args {
		return Tellusim::Log::vprintf(str, args);
	}
	+(void)vprintf_: (const char*)str args: (va_list)args {
		return Tellusim::Log::vprintf(str, args);
	}
	+(void)print_1: (TS_LogLevel)level str: (const char*)str {
		return Tellusim::Log::print((Tellusim::Log::Level)level, str);
	}
	+(void)print_1_: (TS_LogLevel)level str: (const char*)str {
		return Tellusim::Log::print((Tellusim::Log::Level)level, str);
	}
	+(void)printe: (TS_LogLevel)level str: (const char*)str {
		return Tellusim::Log::printe((Tellusim::Log::Level)level, str);
	}
	+(void)printe_: (TS_LogLevel)level str: (const char*)str {
		return Tellusim::Log::printe((Tellusim::Log::Level)level, str);
	}
	+(void)vprintf_1: (TS_LogLevel)level str: (const char*)str args: (va_list)args {
		return Tellusim::Log::vprintf((Tellusim::Log::Level)level, str, args);
	}
	+(void)vprintf_1_: (TS_LogLevel)level str: (const char*)str args: (va_list)args {
		return Tellusim::Log::vprintf((Tellusim::Log::Level)level, str, args);
	}
	+(void)vprintef: (TS_LogLevel)level str: (const char*)str args: (va_list)args {
		return Tellusim::Log::vprintef((Tellusim::Log::Level)level, str, args);
	}
	+(void)vprintef_: (TS_LogLevel)level str: (const char*)str args: (va_list)args {
		return Tellusim::Log::vprintef((Tellusim::Log::Level)level, str, args);
	}
@end

/// Tellusim::Time
TS_CAPI @implementation TSTime_
	+(uint64_t)current {
		return Tellusim::Time::current();
	}
	+(float64_t)seconds {
		return Tellusim::Time::seconds();
	}
	+(void)sleep: (uint32_t)usec {
		return Tellusim::Time::sleep(usec);
	}
	+(void)sleep_: (uint32_t)usec {
		return Tellusim::Time::sleep(usec);
	}
@end

/// Tellusim::System
TS_CAPI @implementation TSSystem
	+(uint32_t)getThreadID {
		return Tellusim::System::getThreadID();
	}
	+(BOOL)setEnvironment: (const char*)name value: (const char*)value {
		return Tellusim::System::setEnvironment(name, value);
	}
	+(BOOL)setEnvironment_: (const char*)name value: (const char*)value {
		return Tellusim::System::setEnvironment(name, value);
	}
	+(BOOL)setEnvironment_1: (const TSString*)name value: (const char*)value {
		return Tellusim::System::setEnvironment((name) ? [name ref] : Tellusim::String::null, value);
	}
	+(BOOL)setEnvironment_1_: (const TSString*)name value: (const char*)value {
		return Tellusim::System::setEnvironment((name) ? [name ref] : Tellusim::String::null, value);
	}
	+(NSString*)getEnvironment: (const char*)name {
		return [NSString stringWithUTF8String:Tellusim::System::getEnvironment(name).get()];
	}
	+(NSString*)getEnvironment_: (const char*)name {
		return [NSString stringWithUTF8String:Tellusim::System::getEnvironment(name).get()];
	}
	+(NSString*)getEnvironment_1: (const TSString*)name {
		return [NSString stringWithUTF8String:Tellusim::System::getEnvironment((name) ? [name ref] : Tellusim::String::null).get()];
	}
	+(NSString*)getEnvironment_1_: (const TSString*)name {
		return [NSString stringWithUTF8String:Tellusim::System::getEnvironment((name) ? [name ref] : Tellusim::String::null).get()];
	}
	+(void*)loadLibrary: (const char*)name {
		return Tellusim::System::loadLibrary(name);
	}
	+(void*)loadLibrary_: (const char*)name {
		return Tellusim::System::loadLibrary(name);
	}
	+(void*)loadLibrary_1: (const TSString*)name {
		return Tellusim::System::loadLibrary((name) ? [name ref] : Tellusim::String::null);
	}
	+(void*)loadLibrary_1_: (const TSString*)name {
		return Tellusim::System::loadLibrary((name) ? [name ref] : Tellusim::String::null);
	}
	+(void*)getFunction: (void*)handle name: (const char*)name {
		return Tellusim::System::getFunction(handle, name);
	}
	+(void*)getFunction_: (void*)handle name: (const char*)name {
		return Tellusim::System::getFunction(handle, name);
	}
	+(void*)getFunction_1: (void*)handle name: (const TSString*)name {
		return Tellusim::System::getFunction(handle, (name) ? [name ref] : Tellusim::String::null);
	}
	+(void*)getFunction_1_: (void*)handle name: (const TSString*)name {
		return Tellusim::System::getFunction(handle, (name) ? [name ref] : Tellusim::String::null);
	}
	+(void)closeLibrary: (void*)handle {
		return Tellusim::System::closeLibrary(handle);
	}
	+(void)closeLibrary_: (void*)handle {
		return Tellusim::System::closeLibrary(handle);
	}
	+(BOOL)exec: (const char*)command {
		return Tellusim::System::exec(command);
	}
	+(BOOL)exec_: (const char*)command {
		return Tellusim::System::exec(command);
	}
	+(BOOL)exec_1: (const char*)command wait: (BOOL)wait {
		return Tellusim::System::exec(command, (bool)wait);
	}
	+(BOOL)exec_1_: (const char*)command wait: (BOOL)wait {
		return Tellusim::System::exec(command, (bool)wait);
	}
	+(BOOL)exec_2: (const TSString*)command {
		return Tellusim::System::exec((command) ? [command ref] : Tellusim::String::null);
	}
	+(BOOL)exec_2_: (const TSString*)command {
		return Tellusim::System::exec((command) ? [command ref] : Tellusim::String::null);
	}
	+(BOOL)exec_3: (const TSString*)command wait: (BOOL)wait {
		return Tellusim::System::exec((command) ? [command ref] : Tellusim::String::null, (bool)wait);
	}
	+(BOOL)exec_3_: (const TSString*)command wait: (BOOL)wait {
		return Tellusim::System::exec((command) ? [command ref] : Tellusim::String::null, (bool)wait);
	}
	+(BOOL)open: (const char*)command {
		return Tellusim::System::open(command);
	}
	+(BOOL)open_: (const char*)command {
		return Tellusim::System::open(command);
	}
	+(BOOL)open_1: (const TSString*)command {
		return Tellusim::System::open((command) ? [command ref] : Tellusim::String::null);
	}
	+(BOOL)open_1_: (const TSString*)command {
		return Tellusim::System::open((command) ? [command ref] : Tellusim::String::null);
	}
@end

/// Tellusim::MeshGraph
TS_CAPI @implementation TSMeshGraph
	+(BOOL)create: (TSMesh*)dest src: (TSMesh*)src max_attributes: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives {
		return Tellusim::MeshGraph::create([dest ref], [src ref], max_attributes, max_primitives);
	}
	+(BOOL)create_: (TSMesh*)dest src: (TSMesh*)src max_attributes: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives {
		return Tellusim::MeshGraph::create([dest ref], [src ref], max_attributes, max_primitives);
	}
	+(BOOL)create_1: (TSMesh*)dest src: (TSMesh*)src max_attributes: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives func: (id<TSMeshGraphProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshGraphProgressCallback(func);
		return Tellusim::MeshGraph::create([dest ref], [src ref], max_attributes, max_primitives, (func) ? &func_ts : nullptr);
	}
	+(BOOL)create_1_: (TSMesh*)dest src: (TSMesh*)src max_attributes: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives func: (id<TSMeshGraphProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshGraphProgressCallback(func);
		return Tellusim::MeshGraph::create([dest ref], [src ref], max_attributes, max_primitives, (func) ? &func_ts : nullptr);
	}
	+(BOOL)create_2: (TSMesh*)dest src: (TSMesh*)src max_attributes: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives func: (id<TSMeshGraphProgressCallback>)func async: (TSAsync**)async {
		auto func_ts = Tellusim::makeTSMeshGraphProgressCallback(func);
		return Tellusim::MeshGraph::create([dest ref], [src ref], max_attributes, max_primitives, (func) ? &func_ts : nullptr, (async) ? [*async pointer] : nullptr);
	}
	+(BOOL)create_2_: (TSMesh*)dest src: (TSMesh*)src max_attributes: (uint32_t)max_attributes max_primitives: (uint32_t)max_primitives func: (id<TSMeshGraphProgressCallback>)func async: (TSAsync**)async {
		auto func_ts = Tellusim::makeTSMeshGraphProgressCallback(func);
		return Tellusim::MeshGraph::create([dest ref], [src ref], max_attributes, max_primitives, (func) ? &func_ts : nullptr, (async) ? [*async pointer] : nullptr);
	}
@end

/// Tellusim::MeshReduce
TS_CAPI @implementation TSMeshReduce
	+(BOOL)collapse: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio {
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio);
	}
	+(BOOL)collapse_: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio {
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio);
	}
	+(BOOL)collapse_1: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio threshold: (float32_t)threshold {
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold);
	}
	+(BOOL)collapse_1_: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio threshold: (float32_t)threshold {
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold);
	}
	+(BOOL)collapse_2: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshReduceProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshReduceProgressCallback(func);
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr);
	}
	+(BOOL)collapse_2_: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshReduceProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshReduceProgressCallback(func);
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr);
	}
	+(BOOL)collapse_3: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio {
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio);
	}
	+(BOOL)collapse_3_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio {
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio);
	}
	+(BOOL)collapse_4: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold {
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold);
	}
	+(BOOL)collapse_4_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold {
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold);
	}
	+(BOOL)collapse_5: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshReduceProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshReduceProgressCallback(func);
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr);
	}
	+(BOOL)collapse_5_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshReduceProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshReduceProgressCallback(func);
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr);
	}
	+(BOOL)collapse_6: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshReduceProgressCallback>)func position: (uint32_t)position {
		auto func_ts = Tellusim::makeTSMeshReduceProgressCallback(func);
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr, position);
	}
	+(BOOL)collapse_6_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshReduceProgressCallback>)func position: (uint32_t)position {
		auto func_ts = Tellusim::makeTSMeshReduceProgressCallback(func);
		return Tellusim::MeshReduce::collapse([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr, position);
	}
@end

/// Tellusim::MeshRefine
TS_CAPI @implementation TSMeshRefine
	+(BOOL)subdiv: (TSMesh*)dest src: (const TSMesh*)src steps: (uint32_t)steps {
		return Tellusim::MeshRefine::subdiv([dest ref], [src ref], steps);
	}
	+(BOOL)subdiv_: (TSMesh*)dest src: (const TSMesh*)src steps: (uint32_t)steps {
		return Tellusim::MeshRefine::subdiv([dest ref], [src ref], steps);
	}
	+(BOOL)subdiv_1: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src steps: (uint32_t)steps {
		return Tellusim::MeshRefine::subdiv([dest ref], [src ref], steps);
	}
	+(BOOL)subdiv_1_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src steps: (uint32_t)steps {
		return Tellusim::MeshRefine::subdiv([dest ref], [src ref], steps);
	}
	+(BOOL)subdiv_2: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src steps: (uint32_t)steps position: (uint32_t)position {
		return Tellusim::MeshRefine::subdiv([dest ref], [src ref], steps, position);
	}
	+(BOOL)subdiv_2_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src steps: (uint32_t)steps position: (uint32_t)position {
		return Tellusim::MeshRefine::subdiv([dest ref], [src ref], steps, position);
	}
@end

/// Tellusim::MeshSolid
TS_CAPI @implementation TSMeshSolid
	+(BOOL)create: (TSMesh*)dest src: (const TSMesh*)src {
		return Tellusim::MeshSolid::create([dest ref], [src ref]);
	}
	+(BOOL)create_: (TSMesh*)dest src: (const TSMesh*)src {
		return Tellusim::MeshSolid::create([dest ref], [src ref]);
	}
	+(BOOL)create_1: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio {
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio);
	}
	+(BOOL)create_1_: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio {
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio);
	}
	+(BOOL)create_2: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio threshold: (float32_t)threshold {
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold);
	}
	+(BOOL)create_2_: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio threshold: (float32_t)threshold {
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold);
	}
	+(BOOL)create_3: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshSolidProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshSolidProgressCallback(func);
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr);
	}
	+(BOOL)create_3_: (TSMesh*)dest src: (const TSMesh*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshSolidProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshSolidProgressCallback(func);
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr);
	}
	+(BOOL)create_4: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src {
		return Tellusim::MeshSolid::create([dest ref], [src ref]);
	}
	+(BOOL)create_4_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src {
		return Tellusim::MeshSolid::create([dest ref], [src ref]);
	}
	+(BOOL)create_5: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio {
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio);
	}
	+(BOOL)create_5_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio {
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio);
	}
	+(BOOL)create_6: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold {
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold);
	}
	+(BOOL)create_6_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold {
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold);
	}
	+(BOOL)create_7: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshSolidProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshSolidProgressCallback(func);
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr);
	}
	+(BOOL)create_7_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshSolidProgressCallback>)func {
		auto func_ts = Tellusim::makeTSMeshSolidProgressCallback(func);
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr);
	}
	+(BOOL)create_8: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshSolidProgressCallback>)func position: (uint32_t)position {
		auto func_ts = Tellusim::makeTSMeshSolidProgressCallback(func);
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr, position);
	}
	+(BOOL)create_8_: (TSMeshGeometry*)dest src: (const TSMeshGeometry*)src ratio: (float32_t)ratio threshold: (float32_t)threshold func: (id<TSMeshSolidProgressCallback>)func position: (uint32_t)position {
		auto func_ts = Tellusim::makeTSMeshSolidProgressCallback(func);
		return Tellusim::MeshSolid::create([dest ref], [src ref], ratio, threshold, (func) ? &func_ts : nullptr, position);
	}
@end

} /* extern "C" */
