// 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 <math/TellusimExpression.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>
#include <core/TellusimAtomic.h>

#include "../include/TellusimReflectionImpl.h"

/*
 */
namespace Tellusim {
	
	// Tellusim names
	static const char *reflection_names[] = {
		"App", "int32_t", "argc", "char**", "argv", "clear", "void", "getPlatform", "Platform", "getDevice", "uint32_t", "getWidth", "getHeight", "getMultisample", "getNumArguments", "getArgument", "String",
		"num", "getArguments", "Array", "isArgument", "bool", "const char*", "name", "create", "platform", "version", "setPlatform", "device", "setSize", "width", "height", "multisample", "isBuildDebug",
		"isBuildFloat64", "getBuildDate", "getBuildInfo", "getVersion", "getAPIHash", "uint64_t", "Async", "init", "shutdown", "isInitialized", "getNumCores", "getNumThreads", "append", "const Async::Task&",
		"task", "getNumTasks", "check", "run", "Task", "mask", "const Async::Task*", "tasks", "const Array<Async::Task>&", "wait", "clonePtr", "clearPtr", "destroyPtr", "acquirePtr", "unacquirePtr", "isValidPtr",
		"isOwnerPtr", "isConstPtr", "getCountPtr", "getInternalPtr", "Stream", "move", "isOpened", "isMapped", "isAvailable", "getSize", "size_t", "getName", "tell", "seek", "offset", "seekBack", "seekCur",
		"int64_t", "getData", "uint8_t", "read", "void*", "dest", "size", "write", "const void*", "src", "flush", "puts", "str", "const String&", "vprintf", "format", "va_list", "args", "gets", "bool*", "status",
		"readi8", "int8_t", "writei8", "value", "readu8", "writeu8", "readi16", "int16_t", "writei16", "readu16", "uint16_t", "writeu16", "readi32", "writei32", "readu32", "writeu32", "readi64", "writei64",
		"readu64", "writeu64", "readf32", "float32_t", "writef32", "readf64", "float64_t", "writef64", "readi32e", "writei32e", "readu32e", "writeu32e", "readi64e", "writei64e", "readu64e", "writeu64e",
		"readString", "writeString", "char", "term", "readToken", "String&", "readLine", "empty", "readStream", "Stream&", "writeStream", "readZip", "writeZip", "level", "writeZipFast", "writeZipBest",
		"readLz4", "writeLz4", "writeLz4Fast", "writeLz4Best", "decodeZip", "window", "encodeZip", "encodeZipFast", "encodeZipBest", "decodeLz4", "encodeLz4", "encodeLz4Fast", "encodeLz4Best", "Blob",
		"const uint8_t*", "data", "const uint8_t(*)[256]", "blob", "const Blob&", "release", "setName", "setCapacity", "getCapacity", "setData", "encodeBase64", "decodeBase64", "getMD5", "uint32_t[4]",
		"hash", "getSHA1", "uint32_t[5]", "File", "open", "mode", "fd", "popen", "command", "close", "isFile", "getMTime", "remove", "Socket", "Socket::Type", "type", "port", "connect", "sec", "usec", "accept", "Socket&",
		"socket", "select", "setTimeout", "getTimeout", "setBlock", "block", "getBlock", "setDelay", "delay", "getDelay", "getPort", "getFD", "getType", "Type", "getAddress", "delimiter", "SocketSSL", "handshake",
		"SocketSSL&", "load", "stream", "isConnected", "Source", "callback", "isSource", "setCallback", "Source::OpenCallback*", "open_func", "Source::IsCallback*", "is_func", "getOpenCallback", "OpenCallback",
		"getIsCallback", "IsCallback", "getCallbackData", "Date", "time", "local", "setTime", "getTime", "setString", "getString", "setYear", "year", "setMonth", "month", "setDate", "date", "setDay", "day",
		"setHours", "hours", "setMinutes", "minutes", "setSeconds", "seconds", "getYear", "getMonth", "getDate", "getDay", "getHours", "getMinutes", "getSeconds", "getTimeZone", "Info", "getSystemMemory",
		"getSystemUptime", "getSystemName", "getSystemVersion", "getKernelVersion", "getCPUCount", "getCPUName", "index", "getCPUVendor", "getCPUCores", "getCPUThreads", "getCPUFrequency", "getCPUTemperature",
		"getCPUUtilization", "getCPUFanSpeed", "getCPUPower", "getGPUCount", "getGPUName", "getGPUVendor", "getGPUSerial", "getGPUDevice", "getGPUVersion", "getGPUMemory", "getGPUScreens", "getGPUFrequency",
		"getGPUTemperature", "getGPUUtilization", "getGPUFanSpeed", "getGPUPower", "isGPUThrottling", "Directory", "children", "getNumFiles", "getFileName", "getFileAttributes", "Attributes",
		"getFileMTime", "getFileATime", "getFileCTime", "getFileSize", "getFiles", "getNumDirectories", "getDirectoryName", "getDirectoryAttributes", "getDirectoryCTime", "getDirectorySize",
		"getDirectories", "setFileAttributes", "Directory::Attributes", "attributes", "setFileMTime", "removeFile", "copyFile", "new_name", "isDirectory", "changeDirectory", "createDirectory",
		"removeDirectory", "copyDirectory", "rename", "getCurrentDirectory", "getHomeDirectory", "getTempDirectory", "getConfigDirectory", "getDocumentsDirectory", "getDriveNames", "Archive",
		"findFile", "openFile", "Image", "Image::Flags", "flags", "Image::Type", "Format", "const Size&", "layers", "isLoaded", "isAllocated", "getTypeName", "is2DType", "is3DType", "isCubeType", "getFormat",
		"getFormatName", "isColorFormat", "isDepthFormat", "isPixelFormat", "isPlainFormat", "isMixedFormat", "isBlockFormat", "isStencilFormat", "isNormFormat", "isSRGBFormat", "isFloatFormat",
		"isSignedFormat", "isUnsignedFormat", "isIntegerFormat", "isi8Format", "isu8Format", "is8BitFormat", "isi16Format", "isu16Format", "isf16Format", "is16BitFormat", "isi32Format", "isu32Format",
		"isf32Format", "is32BitFormat", "isi64Format", "isu64Format", "isf64Format", "is64BitFormat", "isBC15Format", "isBC67Format", "isETC2Format", "isASTCFormat", "getComponents", "getPixelSize",
		"getBlockSize", "getBlockWidth", "getBlockHeight", "getDepth", "getFaces", "getLayers", "getMipmaps", "findMipmap", "mipmap", "hasLayers", "hasMipmaps", "Size", "getRegion", "Region", "getSlice",
		"Slice", "setMetaInfo", "getMetaInfo", "getDescription", "getOffset", "const Slice&", "slice", "alignment", "getStride", "getMipmapSize", "getLayerSize", "getDataSize", "create2D", "create3D",
		"createCube", "depth", "info", "Async*", "async", "save", "quality", "swap", "component_0", "component_1", "copy", "const Image&", "dest_component", "src_component", "flipX", "const Region&", "region",
		"flipY", "const Origin&", "dest_origin", "src_region", "dest_slice", "src_slice", "toType", "toFormat", "getComponent", "component", "getRotated", "angle", "getResized", "Image::Filter", "min",
		"mag", "getMipmapped", "filter", "compare", "image", "origin", "stride", "getMemory", "MeshNode", "Mesh&", "mesh", "MeshNode*", "parent", "clone", "getIndex", "setMesh", "getMesh", "Mesh", "setParent",
		"MeshNode&", "getParent", "isRoot", "reserveChildren", "num_children", "addChild", "child", "removeChild", "releaseChildren", "findChild", "const MeshNode&", "getNumChildren", "getChildren",
		"getChild", "clearGeometries", "reserveGeometries", "num_geometries", "addGeometry", "MeshGeometry&", "geometry", "removeGeometry", "replaceGeometry", "old_geometry", "findGeometry", "const MeshGeometry&",
		"getNumGeometries", "getGeometries", "getGeometry", "MeshGeometry", "clearAttachments", "reserveAttachments", "num_attachments", "addAttachment", "MeshAttachment&", "attachment", "removeAttachment",
		"replaceAttachment", "old_attachment", "findAttachment", "const MeshAttachment&", "getNumAttachments", "getAttachments", "getAttachment", "MeshAttachment", "setLocalTransform", "const Matrix4x3d&",
		"transform", "getLocalTransform", "Matrix4x3d", "setGlobalTransform", "getGlobalTransform", "setPivotTransform", "getPivotTransform", "setMorphTransform", "const Vector4f&", "getMorphTransform",
		"Vector4f", "createLocalTransforms", "itransform", "createGlobalTransforms", "setTransform", "const Vector3d&", "scale", "MeshIndices", "MeshIndices::Type", "isUnknown", "isPoint", "isLine",
		"isTriangle", "isQuadrilateral", "isTetrahedron", "isPrimitive", "isSolid", "isVolume", "isMaterial", "isGroup", "isJoint", "isEdge", "getPrimitiveSize", "setGeometry", "discard", "getBytes",
		"repeat", "set", "value_0", "value_1", "value_2", "value_3", "get", "uint32_t&", "getPtr", "isDirect", "isUniform", "getMinIndex", "getMaxIndex", "const MeshIndices&", "indices", "addIndices", "expand",
		"const MeshAttribute&", "position_attribute", "MeshAttribute", "MeshAttribute::Type", "isPosition", "isBasis", "isNormal", "isTangent", "isBinormal", "isSpatial", "isNormalized", "isTexCoord",
		"isWeights", "isJoints", "isColor", "isVertex", "isCrease", "isPacked", "setIndex", "setIndices", "MeshIndices&", "getIndices", "const Array<uint32_t>&", "setValue", "getValue", "attribute",
		"const Matrix4x3f&", "threshold", "spatial", "addAttribute", "morphAttribute", "k", "packAttributes", "attribute_0", "attribute_1", "unpackAttributes", "MeshAttribute&", "optimizeAttribute",
		"toDirect", "getCovarianceMatrix", "Matrix4x3f", "getMinTransform", "getBoundBox", "BoundBoxf", "getBoundSphere", "BoundSpheref", "MeshJoint", "setNode", "node", "getNode", "getNodeIndex",
		"setBoundBox", "const BoundBoxf&", "box", "setBoundSphere", "const BoundSpheref&", "sphere", "setITransform", "getITransform", "const MeshJoint&", "joint", "MeshMaterial", "clearParameters",
		"removeParameter", "copyParameters", "const MeshMaterial&", "material", "findParameter", "hasParameter", "getNumParameters", "getParameterType", "addParameter", "const Matrix3x2f&",
		"const Color&", "color", "layout", "Blob&", "getParameterFlags", "Flags", "hasParameterFlag", "MeshMaterial::Flags", "hasParameterFlags", "getParameterBool", "getParameterScalarf32", "getParameterVector4f",
		"vector", "getParameterMatrix3x2f", "Matrix3x2f", "matrix", "getParameterColor", "Color", "getParameterName", "getParameterLayout", "getParameterImage", "getParameterBlob", "setParent0",
		"setParent1", "getParent0", "getParent1", "addChild0", "addChild1", "clearIndices", "reserveIndices", "num_indices", "removeIndices", "replaceIndices", "old_indices", "findIndices", "hasIndices",
		"hasSolidIndices", "getNumIndices", "clearAttributes", "reserveAttributes", "num_attributes", "removeAttribute", "replaceAttribute", "old_attribute", "replaceAttributeIndices", "findAttribute",
		"hasAttribute", "getNumAttributes", "getAttribute", "getAttributes", "clearJoints", "reserveJoints", "num_joints", "addJoint", "MeshJoint&", "removeJoint", "replaceJoint", "old_joint", "findJoint",
		"getNumJoints", "getJoints", "getJoint", "clearMaterials", "reserveMaterials", "num_materials", "addMaterial", "MeshMaterial&", "removeMaterial", "replaceMaterial", "old_material", "findMaterial",
		"getNumMaterials", "getMaterials", "getMaterial", "const Vector3f&", "apply", "getTransform", "setJointITransform", "getJointITransform", "setMinVisibility", "distance", "setMaxVisibility",
		"setVisibilityRange", "max", "getMinVisibility", "getMaxVisibility", "hasVisibilityRange", "setVisibilityError", "error", "getVisibilityError", "createBounds", "force", "position", "createBasis",
		"normal", "tangent", "createNormals", "createTangents", "texcoord", "createIslands", "max_attributes", "max_primitives", "optimizeIndices", "cache", "transparent", "optimizeAttributes",
		"optimizeMaterials", "isOptimized", "validate", "MeshTransform", "getMinTime", "getMaxTime", "setTranslate", "translate", "setRotate", "const Quaternionf&", "rotate", "setScale", "setMorph",
		"morph", "getTranslate", "Vector3d", "getRotate", "Quaternionf", "getScale", "Vector3f", "getMorph", "hasTransformKeys", "setTranslateKeys", "const MeshTransform::TranslateKeys&", "keys",
		"getTranslateKeys", "TranslateKeys", "hasTranslateKeys", "setRotateKeys", "const MeshTransform::RotateKeys&", "getRotateKeys", "RotateKeys", "hasRotateKeys", "setScaleKeys", "const MeshTransform::ScaleKeys&",
		"getScaleKeys", "ScaleKeys", "hasScaleKeys", "setMorphKeys", "const MeshTransform::MorphKeys&", "getMorphKeys", "MorphKeys", "hasMorphKeys", "MeshAnimation", "setNumTransforms", "num_transforms",
		"getNumTransforms", "getTransforms", "loop", "from", "to", "BoundBoxd", "optimizeTransforms", "MeshAttachment::Type", "setType", "isLight", "isCamera", "MeshAttachment::Flags", "Mesh::Flags",
		"setBasis", "Mesh::Axis", "front", "right", "up", "Mesh::Basis", "basis", "getFrontAxis", "Axis", "getRightAxis", "getUpAxis", "getBasis", "Basis", "getFrontAxisName", "getRightAxisName", "getUpAxisName",
		"getBasisName", "clearNodes", "reserveNodes", "num_nodes", "addNode", "removeNode", "findNode", "getNumNodes", "getNodes", "hasGeometryIndices", "hasGeometryAttribute", "getNumGeometryPositions",
		"getNumGeometryPrimitives", "clearAnimations", "reserveAnimations", "num_animations", "addAnimation", "MeshAnimation&", "animation", "removeAnimation", "replaceAnimation", "old_animation",
		"findAnimation", "const MeshAnimation&", "getNumAnimations", "getAnimations", "getAnimation", "optimizeWinding", "clockwise", "optimizeGeometries", "optimizeAnimations", "optimizeOrder",
		"mergeGeometries", "Json", "Json::Type", "Json*", "owner", "compact", "getRoot", "Json&", "isChild", "getPathName", "isNull", "isBool", "isNumber", "isString", "isObject", "isArray", "radix", "digits",
		"exponent", "getDataBool", "getDatai32", "getDatau32", "getDatau64", "getDataf32", "getDataf64", "getNumber", "const char**", "values", "const String*", "const int32_t*", "const uint32_t*",
		"const float32_t*", "const float64_t*", "String*", "int32_t*", "uint32_t*", "float32_t*", "float64_t*", "Xml", "Xml*", "Xml&", "wrap", "isAttribute", "removeAttributes", "getAttributeName",
		"setAttributes", "setAttribute", "getAttributei32", "getAttributeu32", "getAttributeu64", "getAttributef32", "getAttributef64", "Buffer", "getPlatformName", "isCreated", "Buffer::Flags",
		"getFlags", "hasFlag", "hasFlags", "getFlagsName", "getPageSize", "BufferTable", "isOwner", "D3D12Buffer", "ID3D12Resource*", "buffer", "state", "getD3D12Buffer", "ID3D12Resource", "getUnorderedAccessView",
		"getShaderResourceView", "getBufferAddress", "setBufferState", "getBufferState", "getSharedHandle", "getInteropHandle", "D3D11Buffer", "ID3D11Buffer*", "getD3D11Buffer", "ID3D11Buffer",
		"ID3D11UnorderedAccessView", "ID3D11ShaderResourceView", "MTLBuffer", "getMTLBuffer", "getSharedPtr", "VKBuffer", "VkBuffer", "access", "getVKBuffer", "getBufferView", "VkBufferView",
		"setBufferAccess", "getBufferAccess", "GLBuffer", "target", "buffer_id", "getTarget", "getBufferID", "GLESBuffer", "CUBuffer", "getBufferPtr", "getBufferData", "getBufferEvent", "CUevent",
		"getArrayFormat", "getArrayChannels", "getSharedMemory", "CUexternalMemory", "HIPBuffer", "FUBuffer", "const Array<Buffer>&", "buffers", "setMask", "getMask", "getNumBuffers", "getBuffer",
		"Command", "setPipeline", "Pipeline&", "pipeline", "getPipeline", "Pipeline", "setViewport", "const Viewport&", "viewport", "setViewports", "const Viewport*", "viewports", "num_viewports",
		"setScissor", "const Scissor&", "scissor", "setScissors", "const Scissor*", "scissors", "num_scissors", "setSampler", "Sampler&", "sampler", "setSamplers", "const Array<Sampler>&", "samplers",
		"const InitializerList<Sampler>&", "setTexture", "Texture&", "texture", "setTextures", "const Array<Texture>&", "textures", "const InitializerList<Texture>&", "setSurfaceTexture",
		"setSurfaceTextures", "getUniformData", "setUniformData", "setUniformBuffer", "Buffer&", "setUniformOffset", "relative", "setUniformBuffers", "const Array<size_t>&", "offsets", "const InitializerList<Buffer>&",
		"const InitializerList<size_t>&", "getStorageData", "setStorageData", "setStorageBuffer", "setStorageOffset", "setStorageBuffers", "setTracing", "Tracing&", "tracing", "setTracings",
		"const Array<Tracing>&", "tracings", "const InitializerList<Tracing>&", "setTexelBuffer", "setTexelBuffers", "setTextureTable", "TextureTable&", "table", "setTextureTables", "const Array<TextureTable>&",
		"tables", "const InitializerList<TextureTable>&", "setStorageTable", "BufferTable&", "setStorageTables", "const Array<BufferTable>&", "const InitializerList<BufferTable>&", "getVertexData",
		"setVertexData", "setVertexBuffer", "setVertexOffset", "setVertexBuffers", "getIndexData", "setIndexData", "setIndexBuffer", "setIndexOffset", "const InitializerList<uint16_t>&", "getIndirectData",
		"setIndirectData", "setIndirectBuffer", "setIndirectOffset", "setBlendColor", "r", "g", "b", "a", "setStencilRef", "ref", "drawArrays", "num_vertices", "base_vertex", "drawArraysInstanced",
		"num_instances", "base_instance", "drawArraysIndirect", "num_draws", "drawElements", "base_index", "drawElementsInstanced", "drawElementsIndirect", "drawMesh", "drawMeshIndirect", "beginConditional",
		"endConditional", "beginQuery", "Query&", "query", "endQuery", "D3D12Command", "getD3D12Command", "ID3D12GraphicsCommandList", "update", "MTLCommand", "getEncoder", "encoder", "enqueue", "VKCommand",
		"getVKCommand", "VkCommandBuffer", "getSamplerDescriptor", "VkDescriptorSet", "getImageDescriptor", "getBufferDescriptor", "getTracingDescriptor", "getTexelDescriptor", "FUCommand",
		"const Array<Command>&", "commands", "getNumCommands", "getCommand", "Compute", "setKernel", "Kernel&", "kernel", "getKernel", "Kernel", "setTraversal", "Traversal&", "traversal", "getTraversal",
		"Traversal", "dispatch", "const Texture&", "dispatchIndirect", "setBuffer", "copyBuffer", "dest_offset", "src_offset", "clearBuffer", "copyTexture", "clearTexture", "barrier", "D3D12Compute",
		"MTLCompute", "VKCompute", "FUCompute", "const Array<Compute>&", "computes", "getNumComputes", "getCompute", "Context", "finish", "D3D12Context", "ID3D12Device*", "ID3D12CommandQueue*",
		"queue", "getFactory", "IDXGIFactory4", "ID3D12Device", "getQueue", "ID3D12CommandQueue", "getProcAddress", "result", "D3D11Context", "ID3D11Device*", "IDXGIFactory", "ID3D11Device", "getD3D11Context",
		"ID3D11DeviceContext", "MTLContext", "getRenderEncoder", "descriptor", "getComputeEncoder", "getTracingEncoder", "getBlitEncoder", "endEncoder", "VKContext", "VkInstance", "instance",
		"PFN_vkGetInstanceProcAddr", "func", "VkPhysicalDevice", "adapter", "VkDevice", "family", "getInstance", "getAdapter", "VkQueue", "getFamily", "getNumQueues", "getQueueFlags", "getQueueFamily",
		"addContextExtension", "addAdapterExtension", "addAdapterFeatures", "features", "getInstanceProcAddress", "getDeviceProcAddress", "PFN_vkGetDeviceProcAddr", "GLContext", "context",
		"getGLDisplay", "getGLVisual", "getGLConfig", "getGLSurface", "getGLContext", "GLESContext", "getGLESDisplay", "getGLESConfig", "getGLESContext", "WGContext", "WGPUInstance", "WGPUAdapter",
		"WGPUDevice", "CUContext", "getCUContext", "CUcontext", "getStream", "CUstream", "HIPContext", "getHIPContext", "Query", "isBegan", "isEnded", "Query::Type", "getTypeSize", "isTime", "isClock",
		"isSamples", "isSamples1", "isStatistics", "isTimeType", "isSamplesType", "getSamples", "getStatistics", "Statistics", "FUQuery", "const Array<Query>&", "queries", "getNumQueries", "getQuery",
		"Fence", "Fence::Flags", "VKFence", "getVKFence", "VkFence", "getSemaphore", "VkSemaphore", "FUFence", "const Array<Fence>&", "fences", "getNumFences", "getFence", "Shader", "saveState", "Shader::Type",
		"isControl", "isEvaluate", "isGeometry", "isFragment", "isCompute", "isTask", "isMesh", "isRayGen", "isRayMiss", "isClosest", "isFirstHit", "isIntersection", "isCallable", "isGraphicsType",
		"isTessellationType", "isTracingType", "isMeshType", "getMacros", "setSamplerOffset", "getSamplerOffset", "setTextureOffset", "getTextureOffset", "setSurfaceOffset", "getSurfaceOffset",
		"getUniformOffset", "getStorageOffset", "setTracingOffset", "getTracingOffset", "setTexelOffset", "getTexelOffset", "setTableOffset", "getTableOffset", "setPatchSize", "getPatchSize",
		"setInputSize", "getInputSize", "setOutputSize", "getOutputSize", "macros", "includes", "loadGLSL", "createGLSL", "loadSPIRV", "createSPIRV", "hasCache", "setCache", "loadCache", "saveCache",
		"clearCache", "isMacro", "setMacro", "setMacros", "removeMacro", "clearMacros", "isInclude", "setInclude", "removeInclude", "clearIncludes", "preprocessor", "ShaderCompiler", "setFlags", "ShaderCompiler::Flags",
		"getBinary", "getSource", "D3D12Shader", "getShaderBlob", "ID3DBlob", "D3D11Shader", "getD3D11Shader", "MTLShader", "setIndirect", "enabled", "isIndirect", "getLibrary", "getFunction", "VKShader",
		"getModule", "VkShaderModule", "GLShader", "attachShader", "program_id", "getShaderType", "getShaderID", "GLESShader", "CUShader", "CUmodule", "CUfunction", "HIPShader", "FUShader", "const Array<Shader>&",
		"shaders", "getNumShaders", "getShader", "Sampler", "setParameters", "const Sampler&", "setFilter", "Sampler::Filter", "getFilter", "Filter", "isPointFilter", "setAnisotropy", "anisotropy",
		"getAnisotropy", "hasAnisotropy", "setWrapMode", "Sampler::WrapMode", "mode_s", "mode_t", "mode_r", "setWrapModeS", "getWrapModeS", "WrapMode", "setWrapModeT", "getWrapModeT", "setWrapModeR",
		"getWrapModeR", "setLod", "bias", "setLodMin", "getLodMin", "setLodMax", "getLodMax", "setLodBias", "getLodBias", "setBorderColor", "getBorderColor", "setCompareFunc", "Sampler::CompareFunc",
		"getCompareFunc", "CompareFunc", "setReductionMode", "Sampler::ReductionMode", "getReductionMode", "ReductionMode", "MTLSampler", "FUSampler", "getNumSamplers", "getSampler", "Texture",
		"Texture::Type", "Texture::Flags", "hasMultisample", "hasFaces", "getTileWidth", "getTileHeight", "getTileDepth", "getTileMipmaps", "getTileSize", "TextureTable", "D3D12Texture", "getDXGIFormat",
		"getD3D12Texture", "getRenderTargetView", "getDepthStencilView", "setTextureState", "getTextureState", "D3D11Texture", "ID3D11Texture2D*", "getD3D11Texture", "ID3D11Texture2D", "ID3D11RenderTargetView",
		"ID3D11DepthStencilView", "MTLTexture", "getPixelFormat", "getTextureType", "getMTLTexture", "VKTexture", "VkImage", "texture_format", "getVKTexture", "getTextureView", "VkImageView",
		"setTextureLayout", "getTextureLayout", "getTextureRange", "range", "GLTexture", "texture_id", "getInternalFormat", "getTextureID", "GLESTexture", "CUTexture", "getTextureArray", "CUmipmappedArray",
		"getTextureLevel", "CUarray", "HIPTexture", "getChannelFormat", "FUTexture", "getNumTextures", "getTexture", "Tracing", "isBuilt", "Tracing::Type", "Tracing::Flags", "isInstanceType", "isTriangleType",
		"isBoundType", "isGeometryType", "const Tracing&", "setInstanceBuffer", "setNumInstances", "getNumInstances", "getInstanceBuffer", "getInstanceOffset", "getIndirectBuffer", "getIndirectOffset",
		"addVertexBuffer", "setNumVertices", "getNumVertices", "getVertexFormat", "getVertexStride", "getVertexBuffer", "getVertexOffset", "addIndexBuffer", "setNumIndices", "getIndexFormat",
		"getIndexBuffer", "getIndexOffset", "addBoundBuffer", "num_bounds", "setBoundBuffer", "setNumBounds", "getNumBounds", "getBoundStride", "getBoundBuffer", "getBoundOffset", "getTracingAddress",
		"getBuildSize", "getUpdateSize", "D3D12Tracing", "getGeometryDesc", "getBuildInputs", "getPrebuildInfo", "getBuildDesc", "getTracingBuffer", "MTLTracing", "getPrimitiveDesc", "getInstanceDesc",
		"getAccelerationStructure", "VKTracing", "getBuildGeometryInfo", "getBuildSizeInfo", "VkAccelerationStructureKHR", "FUTracing", "getNumTracings", "getTracing", "Target", "begin", "Fence&",
		"fence", "end", "Surface&", "surface", "isEnabled", "getColorFormat", "getDepthFormat", "isFlipped", "isAtomic", "setClearColor", "setColorTexture", "Target::Operation", "op", "setColorResolve",
		"getNumTargets", "getClearColor", "getColorOp", "Operation", "getColorTexture", "getColorResolve", "getColorTextureSlice", "getColorResolveSlice", "setClearDepth", "stencil", "setDepthTexture",
		"setDepthResolve", "getClearDepth", "getClearStencil", "getDepthOp", "getDepthTexture", "getDepthResolve", "getDepthTextureSlice", "getDepthResolveSlice", "D3D12Target", "getRenderTargetViews",
		"D3D11Target", "MTLTarget", "getDescriptor", "VKTarget", "getRenderPass", "VkRenderPass", "getFramebuffer", "VkFramebuffer", "GLTarget", "getFramebufferID", "GLESTarget", "FUTarget", "const Array<Target>&",
		"targets", "Device", "Context&", "Window&", "getVendor", "getFeatures", "Features", "hasQuery", "hasShader", "hasTarget", "hasTexture", "hasSurface", "createDevice", "frames", "createCommandDevice",
		"createComputeDevice", "createCopyDevice", "createQuery", "createFence", "shared", "createBuffer", "createSampler", "createTexture", "createTexture2D", "createTexture3D", "createTextureCube",
		"loadTexture", "image_flags", "createTracing", "instance_buffer", "instance_offset", "vertex_format", "vertex_stride", "index_format", "bound_stride", "bound_buffer", "bound_offset", "createBufferTable",
		"createTextureTable", "createShader", "loadShader", "loadShaderGLSL", "loadShaderSPIRV", "createShaderGLSL", "createShaderSPIRV", "createKernel", "const Kernel&", "releaseKernel", "createPipeline",
		"const Pipeline&", "releasePipeline", "createTraversal", "const Traversal&", "releaseTraversal", "createTarget", "createCompute", "createCommand", "Target&", "mapBuffer", "unmapBuffer",
		"flushBuffer", "flushBuffers", "releaseBuffer", "releaseSampler", "Image&", "bindTexture", "const Region*", "regions", "num_regions", "const Slice*", "slices", "num_slices", "commit", "createMipmaps",
		"flushTexture", "flushTextures", "releaseTexture", "const Tracing::Instance*", "instances", "buildTracing", "buildTracings", "copyTracing", "copyTracings", "flushTracing", "flushTracings",
		"releaseTracing", "setBufferTable", "releaseBufferTable", "releaseTextureTable", "copyQuery", "copyQueries", "const InitializerList<Query>&", "waitFence", "signalFence", "execute", "Device&",
		"flip", "D3D12Device", "getD3D12Device", "D3D11Device", "getD3D11Device", "MTLDevice", "getMTLDevice", "VKDevice", "waitVKFence", "timeout", "reset", "signalVKFence", "waitSemaphore", "semaphore",
		"signalSemaphore", "hasMemoryType", "getMemoryIndex", "types", "getVKDevice", "FUDevice", "const Array<Device>&", "devices", "getNumDevices", "setShader", "Shader&", "shader", "getComputeShader",
		"addSampler", "setSamplerArray", "array", "getSamplerArray", "addTexture", "setTextureArray", "addSurface", "setSurfaces", "getNumSurfaces", "setSurfaceArray", "getSurfaceArray", "addUniform",
		"BindFlags", "setUniforms", "getNumUniforms", "setUniformFlags", "getUniformFlags", "addStorage", "setStorages", "getNumStorages", "setStorageFlags", "getStorageFlags", "addTracing", "addTexel",
		"setTexels", "getNumTexels", "addTable", "TableType", "getNumTables", "setTableType", "getTableType", "getTableSize", "setTableFlags", "getTableFlags", "setGroupSize", "getGroupSizeX", "getGroupSizeY",
		"getGroupSizeZ", "D3D12Kernel", "getRootSignature", "ID3D12RootSignature", "MTLKernel", "getComputeFunction", "FUKernel", "const Array<Kernel>&", "kernels", "getNumKernels", "addShader",
		"getVertexShader", "getControlShader", "getEvaluateShader", "getGeometryShader", "getFragmentShader", "getTaskShader", "getMeshShader", "Shader::Mask", "setSamplerMask", "getSamplerMask",
		"Mask", "setSamplerMasks", "getSamplerMasks", "setTextureMask", "getTextureMask", "setTextureMasks", "getTextureMasks", "setSurfaceMask", "getSurfaceMask", "setSurfaceMasks", "getSurfaceMasks",
		"setUniformMask", "getUniformMask", "setUniformMasks", "getUniformMasks", "setStorageMask", "getStorageMask", "setStorageMasks", "getStorageMasks", "setTracingMask", "getTracingMask",
		"setTracingMasks", "getTracingMasks", "setTexelMask", "getTexelMask", "setTexelMasks", "getTexelMasks", "setTableMask", "getTableMask", "getVertexRate", "Pipeline::Attribute", "vertex",
		"rate", "setAttributeType", "setAttributeFormat", "setAttributeVertex", "setAttributeOffset", "setAttributeStride", "setAttributeRate", "getAttributeType", "Attribute", "getAttributeFormat",
		"getAttributeVertex", "getAttributeOffset", "getAttributeStride", "getAttributeRate", "setPrimitive", "Pipeline::Primitive", "primitive", "getPrimitive", "Primitive", "setFillMode",
		"Pipeline::FillMode", "getFillMode", "FillMode", "setCullMode", "Pipeline::CullMode", "getCullMode", "CullMode", "setFrontMode", "Pipeline::FrontMode", "getFrontMode", "FrontMode", "setDepthBias",
		"slope", "clamp", "getDepthBias", "getDepthSlope", "getDepthClamp", "setMultisample", "setSampleMask", "sample_mask", "getSampleMask", "setDepthClip", "getDepthClip", "setDepthReplace",
		"getDepthReplace", "setScissorTest", "getScissorTest", "setRasterDiscard", "getRasterDiscard", "setSampleShading", "getSampleShading", "setAlphaToCoverage", "getAlphaToCoverage", "setMultisampleRaster",
		"getMultisampleRaster", "setConservativeRaster", "getConservativeRaster", "setNumViewports", "getNumViewports", "setNumClipDistances", "num_distances", "getNumClipDistances", "setBlend",
		"Pipeline::BlendOp", "Pipeline::BlendFunc", "setBlendAlpha", "getBlendColorOp", "BlendOp", "getBlendAlphaOp", "getBlendSrcColorFunc", "BlendFunc", "getBlendSrcAlphaFunc", "getBlendDestColorFunc",
		"getBlendDestAlphaFunc", "setColorMask", "Pipeline::ColorMask", "setColorFormat", "getColorMask", "ColorMask", "setDepthMask", "Pipeline::DepthMask", "setDepthFunc", "Pipeline::DepthFunc",
		"setDepthFormat", "getDepthMask", "DepthMask", "getDepthFunc", "DepthFunc", "setStencilMask", "setStencilBackMask", "setStencilFrontMask", "setStencilFunc", "Pipeline::StencilFunc",
		"Pipeline::StencilOp", "dpass_op", "setStencilBackFunc", "setStencilFrontFunc", "fail_op", "dfail_op", "getStencilBackMask", "getStencilBackFunc", "StencilFunc", "getStencilBackFailOp",
		"StencilOp", "getStencilBackDepthFailOp", "getStencilBackDepthPassOp", "getStencilFrontMask", "getStencilFrontFunc", "getStencilFrontFailOp", "getStencilFrontDepthFailOp", "getStencilFrontDepthPassOp",
		"D3D12Pipeline", "MTLPipeline", "getVertexFunction", "getFragmentFunction", "FUPipeline", "const Array<Pipeline>&", "pipelines", "getNumPipelines", "getRayGenShader", "setRecursionDepth",
		"getRecursionDepth", "D3D12Traversal", "FUTraversal", "const Array<Traversal>&", "traversals", "getNumTraversals", "Surface", "setColorLayer", "layer", "setDepthLayer", "getColorLayer",
		"getDepthLayer", "getColorLayers", "getDepthLayers", "hasColorLayers", "hasDepthLayers", "D3D12Surface", "D3D12Context&", "setSwapChain", "IDXGISwapChain*", "swap_chain", "getSwapChain",
		"IDXGISwapChain", "setRenderTarget", "render_target", "setDepthStencil", "depth_stencil", "getRenderTarget", "getDepthStencil", "setRenderTargetView", "render_target_view", "setDepthStencilView",
		"depth_stencil_view", "getColorDXGIFormat", "getDepthDXGIFormat", "D3D11Surface", "D3D11Context&", "getContext", "ID3D11RenderTargetView*", "ID3D11DepthStencilView*", "MTLSurface",
		"MTLContext&", "setDescriptor", "getColorPixelFormat", "getDepthPixelFormat", "VKSurface", "VKContext&", "setColorImage", "setDepthImage", "getColorImage", "getDepthImage", "setColorImageView",
		"image_view", "setDepthImageView", "getColorImageView", "getDepthImageView", "setRenderPass", "render_pass", "setFramebuffer", "framebuffer", "GLSurface", "GLContext&", "setColorTextureID",
		"setDepthTextureID", "getColorTextureID", "getDepthTextureID", "setFramebufferID", "framebuffer_id", "getColorInternalFormat", "getDepthInternalFormat", "GLESSurface", "GLESContext&",
		"Window", "getNumWindows", "getWindow", "setSurface", "getSurface", "getHandle", "title", "Window::Flags", "grab", "render", "present", "setRefreshRate", "getRefreshRate", "setHidden", "hidden",
		"isHidden", "setFocused", "focused", "isFocused", "setMinimized", "minimized", "isMinimized", "setFullscreen", "fullscreen", "isFullscreen", "isOccluded", "setTitle", "getTitle", "setIcon",
		"getIcon", "x", "y", "setPosition", "getPositionX", "getPositionY", "getDpiX", "getDpiY", "setMouse", "getMouseX", "getMouseY", "setMouseDelta", "dx", "dy", "getMouseDX", "getMouseDY", "setMouseHidden",
		"isMouseHidden", "setMouseClipped", "clipped", "isMouseClipped", "isMouseInside", "setMouseCursor", "Window::Cursor", "cursor", "getMouseCursor", "Cursor", "setMouseButtons", "Window::Button",
		"buttons", "getMouseButtons", "Button", "setMouseButton", "button", "getMouseButton", "releaseMouseButtons", "clearMouseButtons", "setMouseAxis", "Window::Axis", "axis", "getMouseAxis",
		"clearMouseAxis", "setMousePressedCallback", "const Window::MousePressedCallback&", "getMousePressedCallback", "MousePressedCallback", "setMouseReleasedCallback", "const Window::MouseReleasedCallback&",
		"getMouseReleasedCallback", "MouseReleasedCallback", "setMouseChangedCallback", "const Window::MouseChangedCallback&", "getMouseChangedCallback", "MouseChangedCallback", "setMouseRotatedCallback",
		"const Window::MouseRotatedCallback&", "getMouseRotatedCallback", "MouseRotatedCallback", "getNumTouches", "addTouch", "getTouchX", "touch", "getTouchY", "findTouch", "clearTouches",
		"setTouchChangedCallback", "const Window::TouchChangedCallback&", "getTouchChangedCallback", "TouchChangedCallback", "setKeyboardKey", "key", "getKeyboardKey", "setKeyboardPressedCallback",
		"const Window::KeyboardPressedCallback&", "getKeyboardPressedCallback", "KeyboardPressedCallback", "setKeyboardReleasedCallback", "const Window::KeyboardReleasedCallback&",
		"getKeyboardReleasedCallback", "KeyboardReleasedCallback", "setSizeChangedCallback", "const Window::SizeChangedCallback&", "getSizeChangedCallback", "SizeChangedCallback", "setFocusChangedCallback",
		"const Window::FocusChangedCallback&", "getFocusChangedCallback", "FocusChangedCallback", "setCloseClickedCallback", "const Window::CloseClickedCallback&", "getCloseClickedCallback",
		"CloseClickedCallback", "setPauseChangedCallback", "const Window::PauseChangedCallback&", "getPauseChangedCallback", "PauseChangedCallback", "setFileDroppedCallback", "const Window::FileDroppedCallback&",
		"getFileDroppedCallback", "FileDroppedCallback", "setUpdateCallback", "const Window::UpdateCallback&", "getUpdateCallback", "UpdateCallback", "setPresentCallback", "const Window::PresentCallback&",
		"getPresentCallback", "PresentCallback", "getMainLoopCallback", "MainLoopCallback", "const Window::MainLoopCallback&", "isRunning", "stop", "setCopyText", "text", "getPasteText", "Font",
		"getAdvance", "const FontStyle&", "style", "code", "getRect", "Rect", "const FontBatch*", "batches", "num_batches", "const FontBatch32*", "const Device&", "draw", "Command&", "CanvasElement",
		"CanvasElement::Type", "isText", "isRect", "isEllipse", "isShape", "isStrip", "setCanvas", "Canvas&", "canvas", "getCanvas", "Canvas", "setMode", "CanvasElement::Mode", "getMode", "Mode", "setAlign",
		"CanvasElement::Align", "align", "getAlign", "Align", "hasAlign", "hasAligns", "aligns", "setOrder", "order", "getOrder", "setEnabled", "clearColor", "setColor", "CanvasElement::Stack", "getColor",
		"Stack", "clearTransform", "const Matrix4x4f&", "Matrix4x4f", "getTransformOp", "clearScissor", "const Rect&", "getScissor", "getScissorOp", "setMipmap", "getMipmap", "getWrapMode", "linear",
		"getTextureLinear", "getBlendOp", "getBlendSrcFunc", "getBlendDestFunc", "getStencilRef", "getStencilFunc", "getStencilFailOp", "getStencilDepthFailOp", "getStencilDepthPassOp", "setDrawCallback",
		"const CanvasElement::DrawCallback&", "getDrawCallback", "DrawCallback", "CanvasText", "setFontName", "getFontName", "setFontColor", "getFontColor", "setFontSize", "getFontSize", "setFontScale",
		"getFontScale", "setFontStyle", "getFontStyleConst", "FontStyle", "getFontStyle", "z", "getPosition", "setText", "getText", "clearBatches", "setBatches", "const Array<FontBatch>&", "CanvasMesh",
		"setTextureName", "getTextureName", "setGradientStyle", "const GradientStyle&", "getGradientStyleConst", "GradientStyle", "getGradientStyle", "clearVertices", "reserveVertices", "setVertices",
		"const CanvasVertex*", "vertices", "addVertices", "getVertices", "CanvasVertex", "setVertex", "const CanvasVertex&", "getVertex", "setVertexPosition", "getVertexPosition", "setVertexTexCoord",
		"const Vector2f&", "s", "t", "getVertexTexCoord", "Vector2f", "setVertexColor", "getVertexColor", "addVertex", "addIndex", "i0", "i1", "i2", "i3", "setRect", "rect", "CanvasRect", "radius", "setRadius",
		"getRadius", "setStrokeColor", "getStrokeColor", "setStrokeStyle", "const StrokeStyle&", "getStrokeStyleConst", "StrokeStyle", "getStrokeStyle", "setTexCoord", "left", "bottom", "top", "getTexCoord",
		"CanvasTriangle", "setPosition0", "setPosition1", "setPosition2", "position_0", "position_1", "position_2", "getPosition0", "getPosition1", "getPosition2", "CanvasEllipse", "CanvasShape",
		"cubic", "setCubic", "isCubic", "setThreshold", "getThreshold", "createSVG", "clearPositions", "setNumPositions", "num_positions", "reservePositions", "getNumPositions", "setPositions",
		"const Vector3f*", "positions", "addPositions", "getPositions", "addPosition", "CanvasStrip", "setWidth", "setOffset", "createQuadratic", "p0", "p1", "p2", "createCubic", "p3", "Canvas*", "const Target&",
		"setPipelineHash", "getPipelineHash", "getViewport", "Viewport", "raiseChild", "lowerChild", "const Canvas&", "addElement", "CanvasElement&", "element", "removeElement", "raiseElement",
		"lowerElement", "findElement", "const CanvasElement&", "isElement", "getNumElements", "getElements", "getElement", "isFont", "addFont", "removeFont", "getFont", "isTexture", "removeTexture",
		"setCreateCallback", "const Canvas::CreateCallback&", "getCreateCallback", "CreateCallback", "setPipelineCallback", "const Canvas::PipelineCallback&", "getPipelineCallback", "PipelineCallback",
		"setBeginCallback", "const Canvas::BeginCallback&", "getBeginCallback", "BeginCallback", "const Canvas::DrawCallback&", "getNumDrawPipelines", "getNumDrawElements", "getNumDrawCommands",
		"Control", "Control*", "Control::Type", "isGrid", "isPanel", "isDialog", "isWindow", "isCheck", "isCombo", "isButton", "isSlider", "isScroll", "isSplit", "isArea", "isTree", "isEdit", "Control::Align",
		"isSpacer", "wasEnabled", "wasUpdated", "setDisabled", "disabled", "isDisabled", "ControlRoot", "getPanel", "ControlPanel", "Control&", "isParentEnabled", "isParentDisabled", "const Control&",
		"getOffsetX", "getOffsetY", "setMargin", "horizontal", "vertical", "margin", "getMargin", "getState", "State", "setFontBlob", "border", "setTextureBlob", "getTextureWidth", "getTextureHeight",
		"setTextColor", "Control::State", "setTextOffset", "getTextColor", "getTextOffset", "setMeshColor", "Control::Mesh", "setMeshRegion", "grid", "setMeshRegions", "getMeshColor", "getMeshGrid",
		"getMeshMargin", "getMeshRegion", "setGroupRadius", "setGroupColor", "getGroupRadius", "getGroupColor", "setPanelRadius", "setPanelColor", "getPanelRadius", "getPanelColor", "setCheckedColor",
		"getCheckedColor", "Control::Button", "getMouse", "Control::Axis", "delta", "setMouseAlign", "getMouseAlign", "hasMouseAlign", "hasMouseAligns", "clearCurrentControl", "setCurrentControl",
		"control", "getCurrentControl", "getControlGrab", "clearFocusedControl", "setFocusedControl", "getFocusedControl", "isFocusedControl", "clearMouseControl", "setMouseControl", "getMouseControl",
		"isMouseControl", "clearInputControl", "setInputControl", "getInputControl", "isInputControl", "clearModalControl", "setModalControl", "getModalControl", "isModalControl", "setCopyCallback",
		"const ControlRoot::CopyCallback&", "getCopyCallback", "CopyCallback", "setPasteCallback", "const ControlRoot::PasteCallback&", "getPasteCallback", "PasteCallback", "ControlText",
		"setFontAlign", "getFontAlign", "hasFontAlign", "hasFontAligns", "getCanvasText", "ControlRect", "getCallback", "setTextureScale", "scale_x", "scale_y", "getTextureScaleX", "getTextureScaleY",
		"setTextureFlip", "flip_x", "flip_y", "getTextureFlipX", "getTextureFlipY", "setTextureProj", "projection", "getTextureProj", "setPressedCallback", "const ControlRect::PressedCallback&",
		"getPressedCallback", "PressedCallback", "setReleasedCallback", "const ControlRect::ReleasedCallback&", "getReleasedCallback", "ReleasedCallback", "setClickedCallback", "const ControlRect::ClickedCallback&",
		"setClicked2Callback", "setClickedRightCallback", "getClickedCallback", "ClickedCallback", "getClicked2Callback", "getClickedRightCallback", "getCanvasRect", "getCanvasMesh", "ControlGrid",
		"columns", "setColumns", "getColumns", "setSpacing", "spacing", "getSpacing", "setColumnRatio", "ratio", "getColumnRatio", "getControlsSize", "ControlGroup", "above", "setAbove", "isAbove",
		"isBelow", "setFoldable", "foldable", "isFoldable", "setExpanded", "expanded", "isExpanded", "setBackground", "background", "getBackground", "setFoldedText", "getFoldedText", "setExpandedText",
		"getExpandedText", "const ControlGroup::ClickedCallback&", "isClicked", "ControlDialog", "setConstrained", "contrained", "isConstrained", "setResizable", "resizable", "isResizable",
		"setResizeArea", "area", "getResizeArea", "getResizeAlign", "hasResizeAlign", "hasResizeAligns", "setMousePosition", "getMousePosition", "setUpdatedCallback", "const ControlDialog::UpdatedCallback&",
		"getUpdatedCallback", "UpdatedCallback", "isUpdated", "ControlWindow", "ControlRoot*", "root", "getParentWindow", "getDialogWindow", "ControlCheck", "checked", "setCheckText", "getCheckText",
		"setCheckColor", "getCheckColor", "switchChecked", "setChecked", "isChecked", "const ControlCheck::ClickedCallback&", "ControlCombo", "const InitializerList<const char*>&", "items",
		"setMultiSelection", "multi_selection", "isMultiSelection", "setComboText", "getComboText", "setComboColor", "getComboColor", "setItemsSpacing", "getItemsSpacing", "clearItems", "addItem",
		"addItems", "removeItem", "getNumItems", "switchItemSelected", "setItemSelected", "selected", "isItemSelected", "setItemText", "getItemText", "findItemText", "setItemColor", "getItemColor",
		"setCurrentIndex", "setCurrentText", "getCurrentIndex", "getCurrentText", "const ControlCombo::ClickedCallback&", "setChangedCallback", "const ControlCombo::ChangedCallback&",
		"getChangedCallback", "ChangedCallback", "isChanged", "ControlButton", "setButtonMode", "getButtonMode", "setButtonRadius", "getButtonRadius", "setButtonColor", "getButtonColor", "const ControlButton::PressedCallback&",
		"isPressed", "const ControlButton::ReleasedCallback&", "isReleased", "const ControlButton::ClickedCallback&", "ControlSlider", "setSliderColor", "getSliderColor", "setDigits", "getDigits",
		"setTextEnabled", "isTextEnabled", "setStep", "step", "getStep", "setBase", "base", "getBase", "setFormat", "getValuef32", "getValueu32", "getValuei32", "setRange", "getMinRange", "getMaxRange",
		"setHandleSize", "getHandleSize", "setFormatCallback", "const ControlSlider::FormatCallback&", "getFormatCallback", "FormatCallback", "const ControlSlider::ReleasedCallback&",
		"const ControlSlider::ClickedCallback&", "const ControlSlider::ChangedCallback&", "ControlScroll", "frame", "setVertical", "isHorizontal", "isVertical", "setPrevText", "getPrevText",
		"setNextText", "getNextText", "setScrollColor", "getScrollColor", "setFrame", "getFrame", "getRange", "setFrameAlign", "getFrameAlign", "hasFrameAlign", "hasFrameAligns", "const ControlScroll::ClickedCallback&",
		"const ControlScroll::ChangedCallback&", "ControlSplit", "setAbsolute", "absolute", "isAbsolute", "ControlArea", "setScalable", "scalable", "isScalable", "setScrollable", "scrollable",
		"isScrollable", "setScaleRange", "getMinScale", "getMaxScale", "setHorizontalStep", "setVerticalStep", "getHorizontalStep", "getVerticalStep", "setHorizontalValue", "setVerticalValue",
		"getHorizontalValue", "getVerticalValue", "getHorizontalFrame", "getVerticalFrame", "getHorizontalRange", "getVerticalRange", "setHorizontalEnabled", "dynamic", "isHorizontalEnabled",
		"isHorizontalDynamic", "isHorizontalHidden", "getHorizontalScroll", "setVerticalEnabled", "isVerticalEnabled", "isVerticalDynamic", "isVerticalHidden", "getVerticalScroll", "getControlsOffset",
		"getViewRect", "ControlTree", "setSelectable", "selectable", "isSelectable", "rows", "setTextureGrid", "getTextureRows", "getTextureColumns", "item", "viewItem", "getItem", "switchItemHidden",
		"setItemHidden", "isItemHidden", "switchItemExpanded", "setItemExpanded", "isItemExpanded", "setItemParent", "getItemParent", "isItemParent", "hierarchy", "addItemChild", "removeItemChild",
		"addItemChildren", "removeItemChildren", "findItemChild", "isItemChild", "getNumItemChildren", "getItemChild", "getItemChildren", "setItemTexture", "row", "column", "getItemTextureRow",
		"getItemTextureColumn", "setItemUserData", "getItemUserData", "setCurrentItem", "view", "getCurrentItem", "setSelection", "clearSelection", "inverseSelection", "getNumSelectedItems",
		"getSelectedItem", "getSelectedItems", "const ControlTree::ChangedCallback&", "setDraggedCallback", "const ControlTree::DraggedCallback&", "getDraggedCallback", "DraggedCallback",
		"setDroppedCallback", "const ControlTree::DroppedCallback&", "getDroppedCallback", "DroppedCallback", "const ControlTree::ClickedCallback&", "setExpandedCallback", "const ControlTree::ExpandedCallback&",
		"getExpandedCallback", "ExpandedCallback", "setSelectedCallback", "const ControlTree::SelectedCallback&", "getSelectedCallback", "SelectedCallback", "ControlEdit", "setEditColor",
		"getEditColor", "setEditMode", "ControlEdit::EditMode", "getEditMode", "EditMode", "setPasswordCode", "getPasswordCode", "getNumCodes", "getCodes", "selection_index", "getSelectionIndex",
		"current", "getSelectedText", "const ControlEdit::ClickedCallback&", "const ControlEdit::ChangedCallback&", "setReturnedCallback", "const ControlEdit::ReturnedCallback&", "getReturnedCallback",
		"ReturnedCallback", "isReturned", "DialogMessage", "message", "setMessage", "getMessage", "const DialogMessage::UpdateCallback&", "Result", "DialogMessage::Flags", "DialogFileOpen",
		"setFile", "getFile", "const DialogFileOpen::UpdateCallback&", "DialogFileOpen::Flags", "DialogFileSave", "const DialogFileSave::UpdateCallback&", "DialogFileSave::Flags", "DialogDirectory",
		"setDirectory", "getDirectory", "const DialogDirectory::UpdateCallback&", "DialogDirectory::Flags", "DialogProgress", "setProgress", "progress", "getProgress", "DialogProgress::Flags",
		"DialogColor", "const DialogColor::ChangedCallback&", "const DialogColor::UpdateCallback&", "DialogColor::Flags", "DialogMenu", "setItemKey", "getItemKey", "setItemImage", "getItemImage",
		"setItemChecked", "isItemChecked", "setItemEnabled", "isItemEnabled", "setItemsGroup", "getItemGroupIndex", "getItemGroupSize", "const DialogMenu::ClickedCallback&", "getItemClickedCallback",
		"const DialogMenu::ChangedCallback&", "getItemChangedCallback", "const DialogMenu::UpdateCallback&", "DialogMenu::Flags", "CubeFilter", "CubeFilter::Mode", "getGroupSize", "getMaxOrder",
		"getMaxSize", "getHarmonics", "groups", "CubeFilter::Flags", "Compute&", "compute", "DecoderJPEG", "DecoderJPEG::Mode", "isYUV", "DecoderJPEG::Flags", "DecoderJPEG::Mode&", "Size&", "dispatchYUV",
		"EncoderBC15", "EncoderBC15::Mode", "EncoderBC15::Flags", "EncoderBC67", "EncoderBC67::Mode", "EncoderBC67::Flags", "components", "EncoderASTC", "EncoderASTC::Mode", "EncoderASTC::Flags",
		"MeshModel", "MeshModel::Flags", "const Mesh&", "const Array<MeshGeometry>&", "geometries", "setVertexBufferCallback", "const MeshModel::CreateCallback&", "setIndexBufferCallback",
		"setMeshBufferCallback", "setBuffers", "const Pipeline*", "drawInstanced", "getNumVertexBuffers", "getVertexBufferStride", "getVertexBufferOffset", "getNumMeshlets", "getMeshletBuffer",
		"getNumGeometryIndices", "getNumGeometryVertices", "getNumGeometryMeshlets", "getGeometryBaseIndex", "getGeometryBaseVertex", "getGeometryBaseMeshlet", "getNumMaterialIndices",
		"getNumMaterialVertices", "getNumMaterialMeshlets", "getMaterialBaseIndex", "getMaterialBaseVertex", "getMaterialBaseMeshlet", "SeparableFilter", "setInputSource", "SeparableFilter::Mode",
		"getInputSource", "setOutputSource", "getOutputSource", "SeparableFilter::Flags", "setWeights", "const Array<Vector4f>&", "weights", "normalize", "const Array<float32_t>&", "setGaussianWeights",
		"sigma", "setSobelXWeights", "setSobelYWeights", "setBoxWeights", "PrefixScan", "PrefixScan::Flags", "getScanElements", "getMaxElements", "getMaxRegions", "PrefixScan::Mode", "count",
		"sizes", "max_size", "count_offset", "dispatch_offset", "RadixSort", "RadixSort::Flags", "getSortElements", "getUpdateElements", "getPrefixScan", "getDataBuffer", "RadixSort::Mode", "PrefixScan&",
		"scan", "keys_offset", "data_offset", "bits", "keys_offsets", "data_offsets", "BitonicSort", "BitonicSort::Flags", "BitonicSort::Mode", "SpatialGrid", "getRadixSort", "RadixSort&", "sort",
		"SpatialTree", "SpatialTree::Flags", "getBoundsNodes", "getMaxNodes", "getHashBuffer", "getParentsBuffer", "getCounterBuffer", "SpatialTree::Mode", "SpatialTree::Hash", "nodes", "FourierTransform",
		"FourierTransform::Mode", "FourierTransform::Flags", "getMaxWidth", "getMaxHeight", "FourierTransform::Operation", "TensorGraph", "TensorGraph::Flags", "TensorGraph::Masks", "masks",
		"TensorGraph::Operation", "const Tensor&", "Tensor&", "src_0", "src_1", "src_2", "Desktop", "getNumScreens", "getScreenName", "getScreenDevice", "getScreenWidth", "getScreenHeight", "getScreenPositionX",
		"getScreenPositionY", "getScreenFrequency", "getNumModes", "getModeWidth", "getModeHeight", "getModeIndex", "restoreMode", "getScreenIndex", "int32_t&"
	};
	
	// Tellusim::App
	class ReflectionApp : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return App::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<App, TypeList<int32_t, char**>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<App>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(App::*)()>(&App::clear));
					case 1: return FunctionPtr(new FunctionImpl<Platform(App::*)() const>(&App::getPlatform));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(App::*)() const>(&App::getDevice));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(App::*)() const>(&App::getWidth));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(App::*)() const>(&App::getHeight));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(App::*)() const>(&App::getMultisample));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(App::*)() const>(&App::getNumArguments));
					case 7: return FunctionPtr(new FunctionImpl<const String&(App::*)(uint32_t) const>(&App::getArgument));
					case 8: return FunctionPtr(new FunctionImpl<const Array<String>&(App::*)() const>(&App::getArguments));
					case 9: return FunctionPtr(new FunctionImpl<bool(App::*)(const char*) const>(&App::isArgument));
					case 10: return FunctionPtr(new FunctionImpl<const String&(App::*)(const char*) const>(&App::getArgument));
					case 11: return FunctionPtr(new FunctionImpl<bool(App::*)(Platform, uint32_t)>(&App::create, Tellusim::PlatformUnknown, App::Version));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(Platform, uint32_t)>(&App::setPlatform, (Platform)0, Maxu32));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(uint32_t, uint32_t, uint32_t)>(&App::setSize, {}, {}, 0));
					case 14: return FunctionPtr(new FunctionImpl<bool()>(&App::isBuildDebug));
					case 15: return FunctionPtr(new FunctionImpl<bool()>(&App::isBuildFloat64));
					case 16: return FunctionPtr(new FunctionImpl<String()>(&App::getBuildDate));
					case 17: return FunctionPtr(new FunctionImpl<String()>(&App::getBuildInfo));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t()>(&App::getVersion));
					case 19: return FunctionPtr(new FunctionImpl<uint64_t()>(&App::getAPIHash));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1, 3 };
			static constexpr uint16_t constructor_arg_names[] = { 2, 4 };
			static constexpr uint16_t function_names[] = { 5, 7, 9, 11, 12, 13, 14, 15, 18, 20, 15, 24, 27, 29, 33, 34, 35, 36, 37, 38 };
			static constexpr uint16_t function_types[] = { 6, 8, 10, 10, 10, 10, 10, 16, 19, 21, 16, 21, 6, 6, 21, 21, 16, 16, 10, 39 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 5, 7, 10, 10, 10, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_types[] = { 10, 22, 22, 8, 10, 8, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 17, 23, 23, 25, 26, 25, 28, 30, 31, 32 };
	};
	constexpr uint16_t ReflectionApp::constructor_bases[];
	constexpr uint16_t ReflectionApp::constructor_arg_types[];
	constexpr uint16_t ReflectionApp::constructor_arg_names[];
	constexpr uint16_t ReflectionApp::function_names[];
	constexpr uint16_t ReflectionApp::function_types[];
	constexpr uint16_t ReflectionApp::function_bases[];
	constexpr uint16_t ReflectionApp::function_arg_types[];
	constexpr uint16_t ReflectionApp::function_arg_names[];
	static ReflectionApp reflection_app;
	
	// Tellusim::Async
	class ReflectionAsync : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Async::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Async, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Async>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(Async::*)(uint32_t)>(&Async::init, 0));
					case 1: return FunctionPtr(new FunctionImpl<bool(Async::*)()>(&Async::shutdown));
					case 2: return FunctionPtr(new FunctionImpl<bool(Async::*)() const>(&Async::isInitialized));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t()>(&Async::getNumCores));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(Async::*)() const>(&Async::getNumThreads));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Async::*)(const Async::Task&)>(&Async::append));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(Async::*)()>(&Async::clear));
					case 7: return FunctionPtr(new FunctionImpl<uint32_t(Async::*)(bool) const>(&Async::getNumTasks, false));
					case 8: return FunctionPtr(new FunctionImpl<Async::Task(Async::*)(uint32_t)>(&Async::run));
					case 9: return FunctionPtr(new FunctionImpl<Async::Task(Async::*)(uint64_t)>(&Async::run, ~0ull));
					case 10: return FunctionPtr(new FunctionImpl<bool(Async::*)(const Async::Task*, uint32_t) const>(&Async::check));
					case 11: return FunctionPtr(new FunctionImpl<bool(Async::*)(const Array<Async::Task>&) const>(&Async::check));
					case 12: return FunctionPtr(new FunctionImpl<bool(Async::*)() const>(&Async::check));
					case 13: return FunctionPtr(new FunctionImpl<bool(Async::*)(const Async::Task*, uint32_t) const>(&Async::wait));
					case 14: return FunctionPtr(new FunctionImpl<bool(Async::*)(const Array<Async::Task>&) const>(&Async::wait));
					case 15: return FunctionPtr(new FunctionImpl<bool(Async::*)() const>(&Async::wait));
					case 16: return FunctionPtr(new FunctionImpl<Async(Async::*)() const>(&Async::clonePtr));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(Async::*)()>(&Async::clearPtr));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(Async::*)()>(&Async::destroyPtr));
					case 19: return FunctionPtr(new FunctionImpl<Async&(Async::*)()>(&Async::acquirePtr));
					case 20: return FunctionPtr(new FunctionImpl<Async&(Async::*)()>(&Async::unacquirePtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(Async::*)() const>(&Async::isValidPtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(Async::*)() const>(&Async::isOwnerPtr));
					case 23: return FunctionPtr(new FunctionImpl<bool(Async::*)() const>(&Async::isConstPtr));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(Async::*)() const>(&Async::getCountPtr));
					case 25: return FunctionPtr(new FunctionImpl<const void*(Async::*)() const>(&Async::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 41, 42, 43, 44, 45, 46, 5, 49, 51, 51, 50, 50, 50, 57, 57, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 21, 21, 10, 10, 6, 6, 10, 52, 52, 21, 21, 21, 21, 21, 21, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 2, 2, 3, 4, 5, 7, 8, 8, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11 };
			static constexpr uint16_t function_arg_types[] = { 10, 47, 21, 10, 39, 54, 10, 56, 54, 10, 56 };
			static constexpr uint16_t function_arg_names[] = { 17, 48, 50, 53, 53, 55, 17, 55, 55, 17, 55 };
	};
	constexpr uint16_t ReflectionAsync::constructor_bases[];
	constexpr uint16_t ReflectionAsync::constructor_arg_types[];
	constexpr uint16_t ReflectionAsync::constructor_arg_names[];
	constexpr uint16_t ReflectionAsync::function_names[];
	constexpr uint16_t ReflectionAsync::function_types[];
	constexpr uint16_t ReflectionAsync::function_bases[];
	constexpr uint16_t ReflectionAsync::function_arg_types[];
	constexpr uint16_t ReflectionAsync::function_arg_names[];
	static ReflectionAsync reflection_async;
	
	// Tellusim::Stream
	class ReflectionStream : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Stream::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Stream, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Stream>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Stream(Stream::*)()>(&Stream::move));
					case 1: return FunctionPtr(new FunctionImpl<bool(Stream::*)() const>(&Stream::isOpened));
					case 2: return FunctionPtr(new FunctionImpl<bool(Stream::*)() const>(&Stream::isMapped));
					case 3: return FunctionPtr(new FunctionImpl<bool(Stream::*)() const>(&Stream::isAvailable));
					case 4: return FunctionPtr(new FunctionImpl<size_t(Stream::*)() const>(&Stream::getSize));
					case 5: return FunctionPtr(new FunctionImpl<String(Stream::*)() const>(&Stream::getName));
					case 6: return FunctionPtr(new FunctionImpl<size_t(Stream::*)()>(&Stream::tell));
					case 7: return FunctionPtr(new FunctionImpl<bool(Stream::*)(size_t)>(&Stream::seek));
					case 8: return FunctionPtr(new FunctionImpl<bool(Stream::*)(size_t)>(&Stream::seekBack));
					case 9: return FunctionPtr(new FunctionImpl<bool(Stream::*)(int64_t)>(&Stream::seekCur));
					case 10: return FunctionPtr(new FunctionImpl<const uint8_t*(Stream::*)() const>(&Stream::getData));
					case 11: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(void*, size_t)>(&Stream::read));
					case 12: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(const void*, size_t)>(&Stream::write));
					case 13: return FunctionPtr(new FunctionImpl<bool(Stream::*)()>(&Stream::flush));
					case 14: return FunctionPtr(new FunctionImpl<bool(Stream::*)(const char*)>(&Stream::puts));
					case 15: return FunctionPtr(new FunctionImpl<bool(Stream::*)(const String&)>(&Stream::puts));
					case 16: return FunctionPtr(new FunctionImpl<bool(Stream::*)(const char*, va_list)>(&Stream::vprintf));
					case 17: return FunctionPtr(new FunctionImpl<String(Stream::*)(bool*)>(&Stream::gets, nullptr));
					case 18: return FunctionPtr(new FunctionImpl<int8_t(Stream::*)(bool*)>(&Stream::readi8, nullptr));
					case 19: return FunctionPtr(new FunctionImpl<bool(Stream::*)(int8_t)>(&Stream::writei8));
					case 20: return FunctionPtr(new FunctionImpl<uint8_t(Stream::*)(bool*)>(&Stream::readu8, nullptr));
					case 21: return FunctionPtr(new FunctionImpl<bool(Stream::*)(uint8_t)>(&Stream::writeu8));
					case 22: return FunctionPtr(new FunctionImpl<int16_t(Stream::*)(bool*)>(&Stream::readi16, nullptr));
					case 23: return FunctionPtr(new FunctionImpl<bool(Stream::*)(int16_t)>(&Stream::writei16));
					case 24: return FunctionPtr(new FunctionImpl<uint16_t(Stream::*)(bool*)>(&Stream::readu16, nullptr));
					case 25: return FunctionPtr(new FunctionImpl<bool(Stream::*)(uint16_t)>(&Stream::writeu16));
					case 26: return FunctionPtr(new FunctionImpl<int32_t(Stream::*)(bool*)>(&Stream::readi32, nullptr));
					case 27: return FunctionPtr(new FunctionImpl<bool(Stream::*)(int32_t)>(&Stream::writei32));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(Stream::*)(bool*)>(&Stream::readu32, nullptr));
					case 29: return FunctionPtr(new FunctionImpl<bool(Stream::*)(uint32_t)>(&Stream::writeu32));
					case 30: return FunctionPtr(new FunctionImpl<int64_t(Stream::*)(bool*)>(&Stream::readi64, nullptr));
					case 31: return FunctionPtr(new FunctionImpl<bool(Stream::*)(int64_t)>(&Stream::writei64));
					case 32: return FunctionPtr(new FunctionImpl<uint64_t(Stream::*)(bool*)>(&Stream::readu64, nullptr));
					case 33: return FunctionPtr(new FunctionImpl<bool(Stream::*)(uint64_t)>(&Stream::writeu64));
					case 34: return FunctionPtr(new FunctionImpl<float32_t(Stream::*)(bool*)>(&Stream::readf32, nullptr));
					case 35: return FunctionPtr(new FunctionImpl<bool(Stream::*)(float32_t)>(&Stream::writef32));
					case 36: return FunctionPtr(new FunctionImpl<float64_t(Stream::*)(bool*)>(&Stream::readf64, nullptr));
					case 37: return FunctionPtr(new FunctionImpl<bool(Stream::*)(float64_t)>(&Stream::writef64));
					case 38: return FunctionPtr(new FunctionImpl<int32_t(Stream::*)(bool*)>(&Stream::readi32e, nullptr));
					case 39: return FunctionPtr(new FunctionImpl<bool(Stream::*)(int32_t)>(&Stream::writei32e));
					case 40: return FunctionPtr(new FunctionImpl<uint32_t(Stream::*)(bool*)>(&Stream::readu32e, nullptr));
					case 41: return FunctionPtr(new FunctionImpl<bool(Stream::*)(uint32_t)>(&Stream::writeu32e));
					case 42: return FunctionPtr(new FunctionImpl<int64_t(Stream::*)(bool*)>(&Stream::readi64e, nullptr));
					case 43: return FunctionPtr(new FunctionImpl<bool(Stream::*)(int64_t)>(&Stream::writei64e));
					case 44: return FunctionPtr(new FunctionImpl<uint64_t(Stream::*)(bool*)>(&Stream::readu64e, nullptr));
					case 45: return FunctionPtr(new FunctionImpl<bool(Stream::*)(uint64_t)>(&Stream::writeu64e));
					case 46: return FunctionPtr(new FunctionImpl<String(Stream::*)(bool*)>(&Stream::readString, nullptr));
					case 47: return FunctionPtr(new FunctionImpl<bool(Stream::*)(const String&)>(&Stream::writeString));
					case 48: return FunctionPtr(new FunctionImpl<bool(Stream::*)(const char*)>(&Stream::writeString));
					case 49: return FunctionPtr(new FunctionImpl<String(Stream::*)(char, bool*, uint32_t)>(&Stream::readString, {}, nullptr, Maxu32));
					case 50: return FunctionPtr(new FunctionImpl<bool(Stream::*)(const String&, char)>(&Stream::writeString));
					case 51: return FunctionPtr(new FunctionImpl<bool(Stream::*)(const char*, char)>(&Stream::writeString));
					case 52: return FunctionPtr(new FunctionImpl<String(Stream::*)(bool*)>(&Stream::readToken, nullptr));
					case 53: return FunctionPtr(new FunctionImpl<bool(Stream::*)(String&, bool)>(&Stream::readToken, {}, true));
					case 54: return FunctionPtr(new FunctionImpl<String(Stream::*)(bool*)>(&Stream::readLine, nullptr));
					case 55: return FunctionPtr(new FunctionImpl<bool(Stream::*)(String&, bool, bool)>(&Stream::readLine, {}, false, true));
					case 56: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*)>(&Stream::readStream, Stream::null, 0, nullptr));
					case 57: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*)>(&Stream::writeStream, Stream::null, 0, nullptr));
					case 58: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(void*, size_t)>(&Stream::readZip));
					case 59: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(const void*, size_t, int32_t)>(&Stream::writeZip, {}, {}, -1));
					case 60: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(const void*, size_t)>(&Stream::writeZipFast));
					case 61: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(const void*, size_t)>(&Stream::writeZipBest));
					case 62: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(void*, size_t)>(&Stream::readLz4));
					case 63: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(const void*, size_t, int32_t)>(&Stream::writeLz4, {}, {}, -1));
					case 64: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(const void*, size_t)>(&Stream::writeLz4Fast));
					case 65: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(const void*, size_t)>(&Stream::writeLz4Best));
					case 66: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*, int32_t)>(&Stream::decodeZip, Stream::null, 0, nullptr, 15));
					case 67: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*, int32_t)>(&Stream::encodeZip, Stream::null, 0, nullptr, -1));
					case 68: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*)>(&Stream::encodeZipFast, Stream::null, 0, nullptr));
					case 69: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*)>(&Stream::encodeZipBest, Stream::null, 0, nullptr));
					case 70: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*)>(&Stream::decodeLz4, Stream::null, 0, nullptr));
					case 71: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*, int32_t)>(&Stream::encodeLz4, Stream::null, 0, nullptr, -1));
					case 72: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*)>(&Stream::encodeLz4Fast, Stream::null, 0, nullptr));
					case 73: return FunctionPtr(new FunctionImpl<size_t(Stream::*)(Stream&, size_t, bool*)>(&Stream::encodeLz4Best, Stream::null, 0, nullptr));
					case 74: return FunctionPtr(new FunctionImpl<Stream(Stream::*)() const>(&Stream::clonePtr));
					case 75: return FunctionPtr(new FunctionVoidImpl<void(Stream::*)()>(&Stream::clearPtr));
					case 76: return FunctionPtr(new FunctionVoidImpl<void(Stream::*)()>(&Stream::destroyPtr));
					case 77: return FunctionPtr(new FunctionImpl<Stream&(Stream::*)()>(&Stream::acquirePtr));
					case 78: return FunctionPtr(new FunctionImpl<Stream&(Stream::*)()>(&Stream::unacquirePtr));
					case 79: return FunctionPtr(new FunctionImpl<bool(Stream::*)() const>(&Stream::isValidPtr));
					case 80: return FunctionPtr(new FunctionImpl<bool(Stream::*)() const>(&Stream::isOwnerPtr));
					case 81: return FunctionPtr(new FunctionImpl<bool(Stream::*)() const>(&Stream::isConstPtr));
					case 82: return FunctionPtr(new FunctionImpl<uint32_t(Stream::*)() const>(&Stream::getCountPtr));
					case 83: return FunctionPtr(new FunctionImpl<const void*(Stream::*)() const>(&Stream::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 69, 70, 71, 72, 73, 75, 76, 77, 79, 80, 82, 84, 88, 91, 92, 92, 95, 99, 102, 104, 106, 107, 108, 110, 111, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 124, 125, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 137, 136, 137, 137, 140, 140, 142, 142, 144, 146, 147, 148, 150, 151, 152, 153, 154, 155, 156, 158, 159, 160, 161, 162, 163, 164, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 68, 21, 21, 21, 74, 16, 74, 21, 21, 21, 83, 74, 74, 21, 21, 21, 21, 16, 103, 21, 83, 21, 109, 21, 112, 21, 1, 21, 10, 21, 81, 21, 39, 21, 123, 21, 126, 21, 1, 21, 10, 21, 81, 21, 39, 21, 16, 21, 21, 16, 21, 21, 16, 21, 16, 21, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 3, 5, 7, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 46, 48, 50, 51, 53, 54, 57, 60, 63, 65, 68, 70, 72, 74, 77, 79, 81, 85, 89, 92, 95, 98, 102, 105, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108 };
			static constexpr uint16_t function_arg_types[] = { 74, 74, 81, 85, 74, 89, 74, 22, 94, 22, 97, 100, 100, 103, 100, 83, 100, 109, 100, 112, 100, 1, 100, 10, 100, 81, 100, 39, 100, 123, 100, 126, 100, 1, 100, 10, 100, 81, 100, 39, 100, 94, 22, 138, 100, 10, 94, 138, 22, 138, 100, 141, 21, 100, 141, 21, 21, 145, 74, 100, 145, 74, 100, 85, 74, 89, 74, 1, 89, 74, 89, 74, 85, 74, 89, 74, 1, 89, 74, 89, 74, 145, 74, 100, 1, 145, 74, 100, 1, 145, 74, 100, 145, 74, 100, 145, 74, 100, 145, 74, 100, 1, 145, 74, 100, 145, 74, 100 };
			static constexpr uint16_t function_arg_names[] = { 78, 78, 78, 86, 87, 90, 87, 93, 93, 96, 98, 101, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 105, 101, 93, 93, 139, 101, 87, 93, 139, 93, 139, 101, 86, 5, 101, 86, 143, 5, 86, 87, 101, 90, 87, 101, 86, 87, 90, 87, 149, 90, 87, 90, 87, 86, 87, 90, 87, 149, 90, 87, 90, 87, 90, 87, 101, 157, 86, 87, 101, 149, 86, 87, 101, 86, 87, 101, 90, 87, 101, 86, 87, 101, 149, 86, 87, 101, 86, 87, 101 };
	};
	constexpr uint16_t ReflectionStream::constructor_bases[];
	constexpr uint16_t ReflectionStream::constructor_arg_types[];
	constexpr uint16_t ReflectionStream::constructor_arg_names[];
	constexpr uint16_t ReflectionStream::function_names[];
	constexpr uint16_t ReflectionStream::function_types[];
	constexpr uint16_t ReflectionStream::function_bases[];
	constexpr uint16_t ReflectionStream::function_arg_types[];
	constexpr uint16_t ReflectionStream::function_arg_names[];
	static ReflectionStream reflection_stream;
	
	// Tellusim::Blob
	class ReflectionBlob : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Blob::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_stream;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Blob, TypeList<const char*>>(nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<Blob, TypeList<const String&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<Blob, TypeList<const uint8_t*, size_t, const char*>>({}, {}, nullptr));
					case 3: return ConstructorPtr(new ConstructorImpl<Blob, TypeList<const uint8_t(*)[256], const char*>>({}, nullptr));
					case 4: return ConstructorPtr(new ConstructorImpl<Blob, TypeList<const Blob&, bool>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Blob>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)()>(&Blob::release));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)()>(&Blob::clear));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)(const char*)>(&Blob::setName));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)(const String&)>(&Blob::setName));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)(size_t)>(&Blob::setSize));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)(size_t)>(&Blob::setCapacity));
					case 6: return FunctionPtr(new FunctionImpl<size_t(Blob::*)() const>(&Blob::getCapacity));
					case 7: return FunctionPtr(new FunctionImpl<bool(Blob::*)(const uint8_t*, size_t)>(&Blob::setData));
					case 8: return FunctionPtr(new FunctionImpl<bool(Blob::*)(const uint8_t(*)[256])>(&Blob::setData));
					case 9: return FunctionPtr(new FunctionImpl<bool(Blob::*)(const Blob&)>(&Blob::setData));
					case 10: return FunctionPtr(new FunctionImpl<const uint8_t*(Blob::*)() const>(&Blob::getData));
					case 11: return FunctionPtr(new FunctionImpl<uint8_t*(Blob::*)()>(&Blob::getData));
					case 12: return FunctionPtr(new FunctionImpl<String(Blob::*)(size_t)>(&Blob::encodeBase64, 0));
					case 13: return FunctionPtr(new FunctionImpl<bool(Blob::*)(const char*)>(&Blob::decodeBase64));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)(uint32_t[4], size_t)>(&Blob::getMD5, {}, 0));
					case 15: return FunctionPtr(new FunctionImpl<String(Blob::*)(size_t)>(&Blob::getMD5, 0));
					case 16: return FunctionPtr(new FunctionImpl<String(const String&)>(&Blob::getMD5));
					case 17: return FunctionPtr(new FunctionImpl<String(const void*, size_t)>(&Blob::getMD5));
					case 18: return FunctionPtr(new FunctionImpl<String(Stream&, size_t)>(&Blob::getMD5, Stream::null, 0));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)(uint32_t[5], size_t)>(&Blob::getSHA1, {}, 0));
					case 20: return FunctionPtr(new FunctionImpl<String(Blob::*)(size_t)>(&Blob::getSHA1, 0));
					case 21: return FunctionPtr(new FunctionImpl<String(const String&)>(&Blob::getSHA1));
					case 22: return FunctionPtr(new FunctionImpl<String(const void*, size_t)>(&Blob::getSHA1));
					case 23: return FunctionPtr(new FunctionImpl<String(Stream&, size_t)>(&Blob::getSHA1, Stream::null, 0));
					case 24: return FunctionPtr(new FunctionImpl<Blob(Blob::*)() const>(&Blob::clonePtr));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)()>(&Blob::clearPtr));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(Blob::*)()>(&Blob::destroyPtr));
					case 27: return FunctionPtr(new FunctionImpl<Blob&(Blob::*)()>(&Blob::acquirePtr));
					case 28: return FunctionPtr(new FunctionImpl<Blob&(Blob::*)()>(&Blob::unacquirePtr));
					case 29: return FunctionPtr(new FunctionImpl<bool(Blob::*)() const>(&Blob::isValidPtr));
					case 30: return FunctionPtr(new FunctionImpl<bool(Blob::*)() const>(&Blob::isOwnerPtr));
					case 31: return FunctionPtr(new FunctionImpl<bool(Blob::*)() const>(&Blob::isConstPtr));
					case 32: return FunctionPtr(new FunctionImpl<uint32_t(Blob::*)() const>(&Blob::getCountPtr));
					case 33: return FunctionPtr(new FunctionImpl<const void*(Blob::*)() const>(&Blob::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 1, 2, 5, 7, 9 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 94, 166, 74, 22, 168, 22, 170, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 23, 167, 87, 23, 169, 23, 169, 69 };
			static constexpr uint16_t function_names[] = { 171, 5, 172, 172, 29, 173, 174, 175, 175, 175, 82, 82, 176, 177, 178, 178, 178, 178, 178, 181, 181, 181, 181, 181, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 6, 6, 6, 74, 21, 21, 21, 83, 83, 16, 21, 6, 16, 16, 16, 16, 6, 16, 16, 16, 16, 165, 165, 165, 165, 165, 165, 165, 165, 165, 165 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 1, 2, 3, 4, 4, 6, 7, 8, 8, 8, 9, 10, 12, 13, 14, 16, 18, 20, 21, 22, 24, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26 };
			static constexpr uint16_t function_arg_types[] = { 22, 94, 74, 74, 166, 74, 168, 170, 74, 22, 179, 74, 74, 94, 89, 74, 145, 74, 182, 74, 74, 94, 89, 74, 145, 74 };
			static constexpr uint16_t function_arg_names[] = { 23, 23, 87, 87, 167, 87, 169, 169, 87, 90, 180, 87, 87, 93, 90, 87, 90, 87, 180, 87, 87, 93, 90, 87, 90, 87 };
	};
	constexpr uint16_t ReflectionBlob::constructor_bases[];
	constexpr uint16_t ReflectionBlob::constructor_arg_types[];
	constexpr uint16_t ReflectionBlob::constructor_arg_names[];
	constexpr uint16_t ReflectionBlob::function_names[];
	constexpr uint16_t ReflectionBlob::function_types[];
	constexpr uint16_t ReflectionBlob::function_bases[];
	constexpr uint16_t ReflectionBlob::function_arg_types[];
	constexpr uint16_t ReflectionBlob::function_arg_names[];
	static ReflectionBlob reflection_blob;
	
	// Tellusim::File
	class ReflectionFile : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return File::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_stream;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<File, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<File>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(File::*)(const char*, const char*)>(&File::open));
					case 1: return FunctionPtr(new FunctionImpl<bool(File::*)(const String&, const char*)>(&File::open));
					case 2: return FunctionPtr(new FunctionImpl<bool(File::*)(int32_t, const char*, const char*)>(&File::open));
					case 3: return FunctionPtr(new FunctionImpl<bool(File::*)(const char*, const char*)>(&File::popen));
					case 4: return FunctionPtr(new FunctionImpl<bool(File::*)(const String&, const char*)>(&File::popen));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(File::*)()>(&File::close));
					case 6: return FunctionPtr(new FunctionImpl<bool(const char*)>(&File::isFile));
					case 7: return FunctionPtr(new FunctionImpl<bool(const String&)>(&File::isFile));
					case 8: return FunctionPtr(new FunctionImpl<uint64_t(const char*)>(&File::getMTime));
					case 9: return FunctionPtr(new FunctionImpl<size_t(const char*)>(&File::getSize));
					case 10: return FunctionPtr(new FunctionImpl<bool(const char*)>(&File::remove));
					case 11: return FunctionPtr(new FunctionImpl<File(File::*)() const>(&File::clonePtr));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(File::*)()>(&File::clearPtr));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(File::*)()>(&File::destroyPtr));
					case 14: return FunctionPtr(new FunctionImpl<File&(File::*)()>(&File::acquirePtr));
					case 15: return FunctionPtr(new FunctionImpl<File&(File::*)()>(&File::unacquirePtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(File::*)() const>(&File::isValidPtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(File::*)() const>(&File::isOwnerPtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(File::*)() const>(&File::isConstPtr));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(File::*)() const>(&File::getCountPtr));
					case 20: return FunctionPtr(new FunctionImpl<const void*(File::*)() const>(&File::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 184, 184, 184, 187, 187, 189, 190, 190, 191, 73, 192, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 21, 21, 21, 21, 6, 21, 21, 39, 74, 21, 183, 183, 183, 183, 183, 183, 183, 183, 183, 183 };
			static constexpr uint16_t function_bases[] = { 0, 2, 4, 7, 9, 11, 11, 12, 13, 14, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16 };
			static constexpr uint16_t function_arg_types[] = { 22, 22, 94, 22, 1, 22, 22, 22, 22, 94, 22, 22, 94, 22, 22, 22 };
			static constexpr uint16_t function_arg_names[] = { 23, 185, 23, 185, 186, 23, 185, 188, 185, 188, 185, 23, 23, 23, 23, 23 };
	};
	constexpr uint16_t ReflectionFile::constructor_bases[];
	constexpr uint16_t ReflectionFile::constructor_arg_types[];
	constexpr uint16_t ReflectionFile::constructor_arg_names[];
	constexpr uint16_t ReflectionFile::function_names[];
	constexpr uint16_t ReflectionFile::function_types[];
	constexpr uint16_t ReflectionFile::function_bases[];
	constexpr uint16_t ReflectionFile::function_arg_types[];
	constexpr uint16_t ReflectionFile::function_arg_names[];
	static ReflectionFile reflection_file;
	
	// Tellusim::Socket
	class ReflectionSocket : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Socket::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_stream;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Socket, TypeList<Socket::Type>>(Socket::TypeStream));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Socket>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(Socket::*)(uint16_t, uint16_t)>(&Socket::open, {}, 32));
					case 1: return FunctionPtr(new FunctionImpl<bool(Socket::*)(const char*, uint16_t)>(&Socket::open));
					case 2: return FunctionPtr(new FunctionImpl<bool(Socket::*)(const String&, uint16_t)>(&Socket::open));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Socket::*)()>(&Socket::close));
					case 4: return FunctionPtr(new FunctionImpl<bool(Socket::*)(uint32_t, uint32_t)>(&Socket::connect, {}, 0));
					case 5: return FunctionPtr(new FunctionImpl<bool(Socket::*)(Socket&)>(&Socket::accept));
					case 6: return FunctionPtr(new FunctionImpl<bool(Socket::*)(uint32_t, uint32_t)>(&Socket::select, {}, 0));
					case 7: return FunctionPtr(new FunctionImpl<bool(Socket::*)(uint32_t)>(&Socket::setTimeout));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(Socket::*)() const>(&Socket::getTimeout));
					case 9: return FunctionPtr(new FunctionImpl<bool(Socket::*)(bool)>(&Socket::setBlock));
					case 10: return FunctionPtr(new FunctionImpl<bool(Socket::*)() const>(&Socket::getBlock));
					case 11: return FunctionPtr(new FunctionImpl<bool(Socket::*)(bool)>(&Socket::setDelay));
					case 12: return FunctionPtr(new FunctionImpl<bool(Socket::*)() const>(&Socket::getDelay));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(Socket::*)(const char*)>(&Socket::setName));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(Socket::*)(const String&)>(&Socket::setName));
					case 15: return FunctionPtr(new FunctionImpl<uint16_t(Socket::*)() const>(&Socket::getPort));
					case 16: return FunctionPtr(new FunctionImpl<int32_t(Socket::*)() const>(&Socket::getFD));
					case 17: return FunctionPtr(new FunctionImpl<Socket::Type(Socket::*)() const>(&Socket::getType));
					case 18: return FunctionPtr(new FunctionImpl<String(const char*)>(&Socket::getAddress, nullptr));
					case 19: return FunctionPtr(new FunctionImpl<Socket(Socket::*)() const>(&Socket::clonePtr));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(Socket::*)()>(&Socket::clearPtr));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(Socket::*)()>(&Socket::destroyPtr));
					case 22: return FunctionPtr(new FunctionImpl<Socket&(Socket::*)()>(&Socket::acquirePtr));
					case 23: return FunctionPtr(new FunctionImpl<Socket&(Socket::*)()>(&Socket::unacquirePtr));
					case 24: return FunctionPtr(new FunctionImpl<bool(Socket::*)() const>(&Socket::isValidPtr));
					case 25: return FunctionPtr(new FunctionImpl<bool(Socket::*)() const>(&Socket::isOwnerPtr));
					case 26: return FunctionPtr(new FunctionImpl<bool(Socket::*)() const>(&Socket::isConstPtr));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(Socket::*)() const>(&Socket::getCountPtr));
					case 28: return FunctionPtr(new FunctionImpl<const void*(Socket::*)() const>(&Socket::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 1 };
			static constexpr uint16_t constructor_arg_types[] = { 194 };
			static constexpr uint16_t constructor_arg_names[] = { 195 };
			static constexpr uint16_t function_names[] = { 184, 184, 184, 189, 197, 200, 203, 204, 205, 206, 208, 209, 211, 172, 172, 212, 213, 214, 216, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 21, 21, 6, 21, 21, 21, 21, 10, 21, 21, 21, 21, 6, 6, 112, 1, 215, 16, 193, 193, 193, 193, 193, 193, 193, 193, 193, 193 };
			static constexpr uint16_t function_bases[] = { 0, 2, 4, 6, 6, 8, 9, 11, 12, 12, 13, 13, 14, 14, 15, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17 };
			static constexpr uint16_t function_arg_types[] = { 112, 112, 22, 112, 94, 112, 10, 10, 201, 10, 10, 10, 21, 21, 22, 94, 22 };
			static constexpr uint16_t function_arg_names[] = { 196, 17, 23, 196, 23, 196, 198, 199, 202, 198, 199, 198, 207, 210, 23, 23, 217 };
	};
	constexpr uint16_t ReflectionSocket::constructor_bases[];
	constexpr uint16_t ReflectionSocket::constructor_arg_types[];
	constexpr uint16_t ReflectionSocket::constructor_arg_names[];
	constexpr uint16_t ReflectionSocket::function_names[];
	constexpr uint16_t ReflectionSocket::function_types[];
	constexpr uint16_t ReflectionSocket::function_bases[];
	constexpr uint16_t ReflectionSocket::function_arg_types[];
	constexpr uint16_t ReflectionSocket::function_arg_names[];
	static ReflectionSocket reflection_socket;
	
	// Tellusim::SocketSSL
	class ReflectionSocketSSL : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return SocketSSL::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_socket;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<SocketSSL, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<SocketSSL>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)(const char*)>(&SocketSSL::handshake, nullptr));
					case 1: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)(SocketSSL&)>(&SocketSSL::accept));
					case 2: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)(Socket&)>(&SocketSSL::accept));
					case 3: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)(Stream&)>(&SocketSSL::load));
					case 4: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)(const char*)>(&SocketSSL::load));
					case 5: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)(const String&)>(&SocketSSL::load));
					case 6: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)() const>(&SocketSSL::isConnected));
					case 7: return FunctionPtr(new FunctionImpl<SocketSSL(SocketSSL::*)() const>(&SocketSSL::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(SocketSSL::*)()>(&SocketSSL::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(SocketSSL::*)()>(&SocketSSL::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<SocketSSL&(SocketSSL::*)()>(&SocketSSL::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<SocketSSL&(SocketSSL::*)()>(&SocketSSL::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)() const>(&SocketSSL::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)() const>(&SocketSSL::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(SocketSSL::*)() const>(&SocketSSL::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(SocketSSL::*)() const>(&SocketSSL::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(SocketSSL::*)() const>(&SocketSSL::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 219, 200, 200, 221, 221, 221, 223, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 21, 21, 21, 21, 21, 21, 218, 218, 218, 218, 218, 218, 218, 218, 218, 218 };
			static constexpr uint16_t function_bases[] = { 0, 1, 2, 3, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 };
			static constexpr uint16_t function_arg_types[] = { 22, 220, 201, 145, 22, 94 };
			static constexpr uint16_t function_arg_names[] = { 23, 202, 202, 222, 23, 23 };
	};
	constexpr uint16_t ReflectionSocketSSL::constructor_bases[];
	constexpr uint16_t ReflectionSocketSSL::constructor_arg_types[];
	constexpr uint16_t ReflectionSocketSSL::constructor_arg_names[];
	constexpr uint16_t ReflectionSocketSSL::function_names[];
	constexpr uint16_t ReflectionSocketSSL::function_types[];
	constexpr uint16_t ReflectionSocketSSL::function_bases[];
	constexpr uint16_t ReflectionSocketSSL::function_arg_types[];
	constexpr uint16_t ReflectionSocketSSL::function_arg_names[];
	static ReflectionSocketSSL reflection_socket_ssl;
	
	// Tellusim::Source
	class ReflectionSource : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Source::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_stream;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Source, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Source, TypeList<const uint8_t*, size_t, const char*>>({}, {}, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Source>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(Source::*)(const char*, bool, bool)>(&Source::open, {}, true, false));
					case 1: return FunctionPtr(new FunctionImpl<bool(Source::*)(const String&, bool, bool)>(&Source::open, {}, true, false));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(Source::*)()>(&Source::close));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Source::*)(const char*, size_t, size_t)>(&Source::setName));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(Source::*)(const String&, size_t, size_t)>(&Source::setName));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Source::*)(const uint8_t*, size_t, const char*)>(&Source::setData, {}, {}, nullptr));
					case 6: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Source::isSource));
					case 7: return FunctionPtr(new FunctionImpl<bool(const String&)>(&Source::isSource));
					case 8: return FunctionPtr(new FunctionImpl<uint64_t(const char*)>(&Source::getMTime));
					case 9: return FunctionPtr(new FunctionImpl<size_t(const char*)>(&Source::getSize));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Source::OpenCallback*, void*)>(&Source::setCallback, {}, nullptr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(Source::OpenCallback*, Source::IsCallback*, void*)>(&Source::setCallback, {}, {}, nullptr));
					case 12: return FunctionPtr(new FunctionImpl<Source::OpenCallback*()>(&Source::getOpenCallback));
					case 13: return FunctionPtr(new FunctionImpl<Source::IsCallback*()>(&Source::getIsCallback));
					case 14: return FunctionPtr(new FunctionVoidImpl<void*()>(&Source::getCallbackData));
					case 15: return FunctionPtr(new FunctionImpl<Source(Source::*)() const>(&Source::clonePtr));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(Source::*)()>(&Source::clearPtr));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(Source::*)()>(&Source::destroyPtr));
					case 18: return FunctionPtr(new FunctionImpl<Source&(Source::*)()>(&Source::acquirePtr));
					case 19: return FunctionPtr(new FunctionImpl<Source&(Source::*)()>(&Source::unacquirePtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(Source::*)() const>(&Source::isValidPtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(Source::*)() const>(&Source::isOwnerPtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(Source::*)() const>(&Source::isConstPtr));
					case 23: return FunctionPtr(new FunctionImpl<uint32_t(Source::*)() const>(&Source::getCountPtr));
					case 24: return FunctionPtr(new FunctionImpl<const void*(Source::*)() const>(&Source::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 166, 74, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 167, 87, 23 };
			static constexpr uint16_t function_names[] = { 184, 184, 189, 172, 172, 175, 226, 226, 191, 73, 227, 227, 232, 234, 236, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 21, 6, 6, 6, 6, 21, 21, 39, 74, 6, 6, 233, 235, 6, 224, 224, 224, 224, 224, 224, 224, 224, 224, 224 };
			static constexpr uint16_t function_bases[] = { 0, 3, 6, 6, 9, 12, 15, 16, 17, 18, 19, 21, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24 };
			static constexpr uint16_t function_arg_types[] = { 22, 21, 21, 94, 21, 21, 22, 74, 74, 94, 74, 74, 166, 74, 22, 22, 94, 22, 22, 228, 85, 228, 230, 85 };
			static constexpr uint16_t function_arg_names[] = { 23, 225, 88, 23, 225, 88, 23, 78, 87, 23, 78, 87, 167, 87, 23, 23, 23, 23, 23, 229, 167, 229, 231, 167 };
	};
	constexpr uint16_t ReflectionSource::constructor_bases[];
	constexpr uint16_t ReflectionSource::constructor_arg_types[];
	constexpr uint16_t ReflectionSource::constructor_arg_names[];
	constexpr uint16_t ReflectionSource::function_names[];
	constexpr uint16_t ReflectionSource::function_types[];
	constexpr uint16_t ReflectionSource::function_bases[];
	constexpr uint16_t ReflectionSource::function_arg_types[];
	constexpr uint16_t ReflectionSource::function_arg_names[];
	static ReflectionSource reflection_source;
	
	// Tellusim::Date
	class ReflectionDate : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Date::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Date, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Date, TypeList<int64_t, bool>>({}, true));
					case 2: return ConstructorPtr(new ConstructorImpl<Date, TypeList<const char*, const char*>>({}, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Date>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(Date::*)()>(&Date::clear));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(Date::*)(int64_t, bool)>(&Date::setTime, {}, true));
					case 2: return FunctionPtr(new FunctionImpl<int64_t(Date::*)(bool) const>(&Date::getTime, true));
					case 3: return FunctionPtr(new FunctionImpl<bool(Date::*)(const char*, const char*)>(&Date::setString, {}, nullptr));
					case 4: return FunctionPtr(new FunctionImpl<String(Date::*)(const char*) const>(&Date::getString, nullptr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Date::*)(uint32_t)>(&Date::setYear));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(Date::*)(uint32_t)>(&Date::setMonth));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(Date::*)(uint32_t)>(&Date::setDate));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(Date::*)(uint32_t)>(&Date::setDay));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(Date::*)(uint32_t)>(&Date::setHours));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Date::*)(uint32_t)>(&Date::setMinutes));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(Date::*)(uint32_t)>(&Date::setSeconds));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(Date::*)() const>(&Date::getYear));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(Date::*)() const>(&Date::getMonth));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(Date::*)() const>(&Date::getDate));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(Date::*)() const>(&Date::getDay));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(Date::*)() const>(&Date::getHours));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(Date::*)() const>(&Date::getMinutes));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(Date::*)() const>(&Date::getSeconds));
					case 19: return FunctionPtr(new FunctionImpl<int32_t()>(&Date::getTimeZone));
					case 20: return FunctionPtr(new FunctionImpl<Date(Date::*)() const>(&Date::clonePtr));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(Date::*)()>(&Date::clearPtr));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(Date::*)()>(&Date::destroyPtr));
					case 23: return FunctionPtr(new FunctionImpl<Date&(Date::*)()>(&Date::acquirePtr));
					case 24: return FunctionPtr(new FunctionImpl<Date&(Date::*)()>(&Date::unacquirePtr));
					case 25: return FunctionPtr(new FunctionImpl<bool(Date::*)() const>(&Date::isValidPtr));
					case 26: return FunctionPtr(new FunctionImpl<bool(Date::*)() const>(&Date::isOwnerPtr));
					case 27: return FunctionPtr(new FunctionImpl<bool(Date::*)() const>(&Date::isConstPtr));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(Date::*)() const>(&Date::getCountPtr));
					case 29: return FunctionPtr(new FunctionImpl<const void*(Date::*)() const>(&Date::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2, 4 };
			static constexpr uint16_t constructor_arg_types[] = { 81, 21, 22, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 238, 239, 93, 96 };
			static constexpr uint16_t function_names[] = { 5, 240, 241, 242, 243, 244, 246, 248, 250, 252, 254, 256, 258, 259, 260, 261, 262, 263, 264, 265, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 81, 21, 16, 6, 6, 6, 6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 10, 1, 237, 237, 237, 237, 237, 237, 237, 237, 237, 237 };
			static constexpr uint16_t function_bases[] = { 0, 0, 2, 3, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 };
			static constexpr uint16_t function_arg_types[] = { 81, 21, 21, 22, 22, 22, 10, 10, 10, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 238, 239, 239, 93, 96, 96, 245, 247, 249, 251, 253, 255, 257 };
	};
	constexpr uint16_t ReflectionDate::constructor_bases[];
	constexpr uint16_t ReflectionDate::constructor_arg_types[];
	constexpr uint16_t ReflectionDate::constructor_arg_names[];
	constexpr uint16_t ReflectionDate::function_names[];
	constexpr uint16_t ReflectionDate::function_types[];
	constexpr uint16_t ReflectionDate::function_bases[];
	constexpr uint16_t ReflectionDate::function_arg_types[];
	constexpr uint16_t ReflectionDate::function_arg_names[];
	static ReflectionDate reflection_date;
	
	// Tellusim::Info
	class ReflectionInfo : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Info::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Info, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Info>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<size_t(Info::*)() const>(&Info::getSystemMemory));
					case 1: return FunctionPtr(new FunctionImpl<uint64_t(Info::*)() const>(&Info::getSystemUptime));
					case 2: return FunctionPtr(new FunctionImpl<String(Info::*)() const>(&Info::getSystemName));
					case 3: return FunctionPtr(new FunctionImpl<String(Info::*)() const>(&Info::getSystemVersion));
					case 4: return FunctionPtr(new FunctionImpl<String(Info::*)() const>(&Info::getKernelVersion));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)() const>(&Info::getCPUCount));
					case 6: return FunctionPtr(new FunctionImpl<String(Info::*)(uint32_t) const>(&Info::getCPUName));
					case 7: return FunctionPtr(new FunctionImpl<String(Info::*)(uint32_t) const>(&Info::getCPUVendor));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getCPUCores));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getCPUThreads));
					case 10: return FunctionPtr(new FunctionImpl<uint64_t(Info::*)(uint32_t) const>(&Info::getCPUFrequency));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getCPUTemperature));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getCPUUtilization));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getCPUFanSpeed));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getCPUPower));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)() const>(&Info::getGPUCount));
					case 16: return FunctionPtr(new FunctionImpl<String(Info::*)(uint32_t) const>(&Info::getGPUName));
					case 17: return FunctionPtr(new FunctionImpl<String(Info::*)(uint32_t) const>(&Info::getGPUVendor));
					case 18: return FunctionPtr(new FunctionImpl<String(Info::*)(uint32_t) const>(&Info::getGPUSerial));
					case 19: return FunctionPtr(new FunctionImpl<String(Info::*)(uint32_t) const>(&Info::getGPUDevice));
					case 20: return FunctionPtr(new FunctionImpl<String(Info::*)(uint32_t) const>(&Info::getGPUVersion));
					case 21: return FunctionPtr(new FunctionImpl<size_t(Info::*)(uint32_t) const>(&Info::getGPUMemory));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getGPUScreens));
					case 23: return FunctionPtr(new FunctionImpl<uint64_t(Info::*)(uint32_t) const>(&Info::getGPUFrequency));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getGPUTemperature));
					case 25: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getGPUUtilization));
					case 26: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getGPUFanSpeed));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)(uint32_t) const>(&Info::getGPUPower));
					case 28: return FunctionPtr(new FunctionImpl<bool(Info::*)(uint32_t) const>(&Info::isGPUThrottling));
					case 29: return FunctionPtr(new FunctionImpl<Info(Info::*)() const>(&Info::clonePtr));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(Info::*)()>(&Info::clearPtr));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(Info::*)()>(&Info::destroyPtr));
					case 32: return FunctionPtr(new FunctionImpl<Info&(Info::*)()>(&Info::acquirePtr));
					case 33: return FunctionPtr(new FunctionImpl<Info&(Info::*)()>(&Info::unacquirePtr));
					case 34: return FunctionPtr(new FunctionImpl<bool(Info::*)() const>(&Info::isValidPtr));
					case 35: return FunctionPtr(new FunctionImpl<bool(Info::*)() const>(&Info::isOwnerPtr));
					case 36: return FunctionPtr(new FunctionImpl<bool(Info::*)() const>(&Info::isConstPtr));
					case 37: return FunctionPtr(new FunctionImpl<uint32_t(Info::*)() const>(&Info::getCountPtr));
					case 38: return FunctionPtr(new FunctionImpl<const void*(Info::*)() const>(&Info::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 267, 268, 269, 270, 271, 272, 273, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 74, 39, 16, 16, 16, 10, 16, 16, 10, 10, 39, 10, 10, 10, 10, 10, 16, 16, 16, 16, 16, 74, 10, 39, 10, 10, 10, 10, 21, 266, 266, 266, 266, 266, 266, 266, 266, 266, 266 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274 };
	};
	constexpr uint16_t ReflectionInfo::constructor_bases[];
	constexpr uint16_t ReflectionInfo::constructor_arg_types[];
	constexpr uint16_t ReflectionInfo::constructor_arg_names[];
	constexpr uint16_t ReflectionInfo::function_names[];
	constexpr uint16_t ReflectionInfo::function_types[];
	constexpr uint16_t ReflectionInfo::function_bases[];
	constexpr uint16_t ReflectionInfo::function_arg_types[];
	constexpr uint16_t ReflectionInfo::function_arg_names[];
	static ReflectionInfo reflection_info;
	
	// Tellusim::Directory
	class ReflectionDirectory : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Directory::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Directory, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Directory>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(Directory::*)(const char*, bool)>(&Directory::open, {}, false));
					case 1: return FunctionPtr(new FunctionImpl<bool(Directory::*)(const String&, bool)>(&Directory::open, {}, false));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(Directory::*)()>(&Directory::close));
					case 3: return FunctionPtr(new FunctionImpl<bool(Directory::*)() const>(&Directory::isOpened));
					case 4: return FunctionPtr(new FunctionImpl<String(Directory::*)() const>(&Directory::getName));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(Directory::*)() const>(&Directory::getNumFiles));
					case 6: return FunctionPtr(new FunctionImpl<String(Directory::*)(uint32_t) const>(&Directory::getFileName));
					case 7: return FunctionPtr(new FunctionImpl<Directory::Attributes(Directory::*)(uint32_t) const>(&Directory::getFileAttributes));
					case 8: return FunctionPtr(new FunctionImpl<uint64_t(Directory::*)(uint32_t) const>(&Directory::getFileMTime));
					case 9: return FunctionPtr(new FunctionImpl<uint64_t(Directory::*)(uint32_t) const>(&Directory::getFileATime));
					case 10: return FunctionPtr(new FunctionImpl<uint64_t(Directory::*)(uint32_t) const>(&Directory::getFileCTime));
					case 11: return FunctionPtr(new FunctionImpl<size_t(Directory::*)(uint32_t) const>(&Directory::getFileSize));
					case 12: return FunctionPtr(new FunctionImpl<const Array<String>(Directory::*)() const>(&Directory::getFiles));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(Directory::*)() const>(&Directory::getNumDirectories));
					case 14: return FunctionPtr(new FunctionImpl<String(Directory::*)(uint32_t) const>(&Directory::getDirectoryName));
					case 15: return FunctionPtr(new FunctionImpl<Directory::Attributes(Directory::*)(uint32_t) const>(&Directory::getDirectoryAttributes));
					case 16: return FunctionPtr(new FunctionImpl<uint64_t(Directory::*)(uint32_t) const>(&Directory::getDirectoryCTime));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(Directory::*)(uint32_t) const>(&Directory::getDirectorySize));
					case 18: return FunctionPtr(new FunctionImpl<const Array<String>(Directory::*)() const>(&Directory::getDirectories));
					case 19: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Directory::isFile));
					case 20: return FunctionPtr(new FunctionImpl<bool(const String&)>(&Directory::isFile));
					case 21: return FunctionPtr(new FunctionImpl<bool(const char*, Directory::Attributes)>(&Directory::setFileAttributes));
					case 22: return FunctionPtr(new FunctionImpl<Directory::Attributes(const char*)>(&Directory::getFileAttributes));
					case 23: return FunctionPtr(new FunctionImpl<bool(const char*, uint64_t)>(&Directory::setFileMTime));
					case 24: return FunctionPtr(new FunctionImpl<uint64_t(const char*)>(&Directory::getFileMTime));
					case 25: return FunctionPtr(new FunctionImpl<uint64_t(const char*)>(&Directory::getFileATime));
					case 26: return FunctionPtr(new FunctionImpl<uint64_t(const char*)>(&Directory::getFileCTime));
					case 27: return FunctionPtr(new FunctionImpl<size_t(const char*)>(&Directory::getFileSize));
					case 28: return FunctionPtr(new FunctionImpl<size_t(const String&)>(&Directory::getFileSize));
					case 29: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Directory::removeFile));
					case 30: return FunctionPtr(new FunctionImpl<bool(const String&)>(&Directory::removeFile));
					case 31: return FunctionPtr(new FunctionImpl<bool(const char*, const char*, bool)>(&Directory::copyFile, {}, {}, false));
					case 32: return FunctionPtr(new FunctionImpl<bool(const String&, const String&, bool)>(&Directory::copyFile, {}, {}, false));
					case 33: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Directory::isDirectory));
					case 34: return FunctionPtr(new FunctionImpl<bool(const String&)>(&Directory::isDirectory));
					case 35: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Directory::changeDirectory));
					case 36: return FunctionPtr(new FunctionImpl<bool(const String&)>(&Directory::changeDirectory));
					case 37: return FunctionPtr(new FunctionImpl<bool(const char*, bool)>(&Directory::createDirectory, {}, false));
					case 38: return FunctionPtr(new FunctionImpl<bool(const String&, bool)>(&Directory::createDirectory, {}, false));
					case 39: return FunctionPtr(new FunctionImpl<bool(const char*, bool)>(&Directory::removeDirectory, {}, false));
					case 40: return FunctionPtr(new FunctionImpl<bool(const String&, bool)>(&Directory::removeDirectory, {}, false));
					case 41: return FunctionPtr(new FunctionImpl<bool(const char*, const char*, bool)>(&Directory::copyDirectory, {}, {}, false));
					case 42: return FunctionPtr(new FunctionImpl<bool(const String&, const String&, bool)>(&Directory::copyDirectory, {}, {}, false));
					case 43: return FunctionPtr(new FunctionImpl<bool(const char*, const char*)>(&Directory::rename));
					case 44: return FunctionPtr(new FunctionImpl<bool(const String&, const String&)>(&Directory::rename));
					case 45: return FunctionPtr(new FunctionImpl<String()>(&Directory::getCurrentDirectory));
					case 46: return FunctionPtr(new FunctionImpl<String()>(&Directory::getHomeDirectory));
					case 47: return FunctionPtr(new FunctionImpl<String()>(&Directory::getTempDirectory));
					case 48: return FunctionPtr(new FunctionImpl<String()>(&Directory::getConfigDirectory));
					case 49: return FunctionPtr(new FunctionImpl<String()>(&Directory::getDocumentsDirectory));
					case 50: return FunctionPtr(new FunctionImpl<const Array<String>()>(&Directory::getDriveNames));
					case 51: return FunctionPtr(new FunctionImpl<Directory(Directory::*)() const>(&Directory::clonePtr));
					case 52: return FunctionPtr(new FunctionVoidImpl<void(Directory::*)()>(&Directory::clearPtr));
					case 53: return FunctionPtr(new FunctionVoidImpl<void(Directory::*)()>(&Directory::destroyPtr));
					case 54: return FunctionPtr(new FunctionImpl<Directory&(Directory::*)()>(&Directory::acquirePtr));
					case 55: return FunctionPtr(new FunctionImpl<Directory&(Directory::*)()>(&Directory::unacquirePtr));
					case 56: return FunctionPtr(new FunctionImpl<bool(Directory::*)() const>(&Directory::isValidPtr));
					case 57: return FunctionPtr(new FunctionImpl<bool(Directory::*)() const>(&Directory::isOwnerPtr));
					case 58: return FunctionPtr(new FunctionImpl<bool(Directory::*)() const>(&Directory::isConstPtr));
					case 59: return FunctionPtr(new FunctionImpl<uint32_t(Directory::*)() const>(&Directory::getCountPtr));
					case 60: return FunctionPtr(new FunctionImpl<const void*(Directory::*)() const>(&Directory::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 184, 184, 189, 70, 75, 299, 300, 301, 303, 304, 305, 306, 307, 308, 309, 310, 311, 312, 313, 190, 190, 314, 301, 317, 303, 304, 305, 306, 306, 318, 318, 319, 319, 321, 321, 322, 322, 323, 323, 324, 324, 325, 325, 326, 326, 327, 328, 329, 330, 331, 332, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 21, 6, 21, 16, 10, 16, 302, 39, 39, 39, 74, 19, 10, 16, 302, 39, 10, 19, 21, 21, 21, 302, 21, 39, 39, 39, 74, 74, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 16, 16, 16, 16, 16, 19, 297, 297, 297, 297, 297, 297, 297, 297, 297, 297 };
			static constexpr uint16_t function_bases[] = { 0, 2, 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 10, 10, 10, 11, 12, 13, 14, 14, 15, 16, 18, 19, 21, 22, 23, 24, 25, 26, 27, 28, 31, 34, 35, 36, 37, 38, 40, 42, 44, 46, 49, 52, 54, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56, 56 };
			static constexpr uint16_t function_arg_types[] = { 22, 21, 94, 21, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 22, 94, 22, 315, 22, 22, 39, 22, 22, 22, 22, 94, 22, 94, 22, 22, 21, 94, 94, 21, 22, 94, 22, 94, 22, 21, 94, 21, 22, 21, 94, 21, 22, 22, 21, 94, 94, 21, 22, 22, 94, 94 };
			static constexpr uint16_t function_arg_names[] = { 23, 298, 23, 298, 274, 274, 274, 274, 274, 274, 274, 274, 274, 274, 23, 23, 23, 316, 23, 23, 238, 23, 23, 23, 23, 23, 23, 23, 23, 320, 316, 23, 320, 316, 23, 23, 23, 23, 23, 298, 23, 298, 23, 298, 23, 298, 23, 320, 316, 23, 320, 316, 23, 320, 23, 320 };
	};
	constexpr uint16_t ReflectionDirectory::constructor_bases[];
	constexpr uint16_t ReflectionDirectory::constructor_arg_types[];
	constexpr uint16_t ReflectionDirectory::constructor_arg_names[];
	constexpr uint16_t ReflectionDirectory::function_names[];
	constexpr uint16_t ReflectionDirectory::function_types[];
	constexpr uint16_t ReflectionDirectory::function_bases[];
	constexpr uint16_t ReflectionDirectory::function_arg_types[];
	constexpr uint16_t ReflectionDirectory::function_arg_names[];
	static ReflectionDirectory reflection_directory;
	
	// Tellusim::Archive
	class ReflectionArchive : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Archive::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Archive, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Archive>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(Archive::*)(const char*, const char*)>(&Archive::open, {}, nullptr));
					case 1: return FunctionPtr(new FunctionImpl<bool(Archive::*)(const String&, const char*)>(&Archive::open, {}, nullptr));
					case 2: return FunctionPtr(new FunctionImpl<bool(Archive::*)(Stream&, const char*)>(&Archive::open, Stream::null, nullptr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Archive::*)()>(&Archive::close));
					case 4: return FunctionPtr(new FunctionImpl<bool(Archive::*)() const>(&Archive::isOpened));
					case 5: return FunctionPtr(new FunctionImpl<String(Archive::*)() const>(&Archive::getName));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(Archive::*)() const>(&Archive::getNumFiles));
					case 7: return FunctionPtr(new FunctionImpl<String(Archive::*)(uint32_t) const>(&Archive::getFileName));
					case 8: return FunctionPtr(new FunctionImpl<uint64_t(Archive::*)(uint32_t) const>(&Archive::getFileMTime));
					case 9: return FunctionPtr(new FunctionImpl<size_t(Archive::*)(uint32_t) const>(&Archive::getFileSize));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(Archive::*)(const char*) const>(&Archive::findFile));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(Archive::*)(const String&) const>(&Archive::findFile));
					case 12: return FunctionPtr(new FunctionImpl<bool(Archive::*)(const char*) const>(&Archive::isFile));
					case 13: return FunctionPtr(new FunctionImpl<bool(Archive::*)(const String&) const>(&Archive::isFile));
					case 14: return FunctionPtr(new FunctionImpl<Stream(Archive::*)(const char*) const>(&Archive::openFile));
					case 15: return FunctionPtr(new FunctionImpl<Stream(Archive::*)(const String&) const>(&Archive::openFile));
					case 16: return FunctionPtr(new FunctionImpl<Stream(Archive::*)(uint32_t) const>(&Archive::openFile));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 184, 184, 184, 189, 70, 75, 299, 300, 303, 306, 334, 334, 190, 190, 335, 335, 335 };
			static constexpr uint16_t function_types[] = { 21, 21, 21, 6, 21, 16, 10, 16, 39, 74, 10, 10, 21, 21, 68, 68, 68 };
			static constexpr uint16_t function_bases[] = { 0, 2, 4, 6, 6, 6, 6, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
			static constexpr uint16_t function_arg_types[] = { 22, 22, 94, 22, 145, 22, 10, 10, 10, 22, 94, 22, 94, 22, 94, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 195, 23, 195, 222, 195, 274, 274, 274, 23, 23, 23, 23, 23, 23, 274 };
	};
	constexpr uint16_t ReflectionArchive::constructor_bases[];
	constexpr uint16_t ReflectionArchive::constructor_arg_types[];
	constexpr uint16_t ReflectionArchive::constructor_arg_names[];
	constexpr uint16_t ReflectionArchive::function_names[];
	constexpr uint16_t ReflectionArchive::function_types[];
	constexpr uint16_t ReflectionArchive::function_bases[];
	constexpr uint16_t ReflectionArchive::function_arg_types[];
	constexpr uint16_t ReflectionArchive::function_arg_names[];
	static ReflectionArchive reflection_archive;
	
	// Tellusim::Image
	class ReflectionImage : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Image::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Image, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Image, TypeList<const char*, Image::Flags, uint32_t>>({}, Image::FlagNone, 0));
					case 2: return ConstructorPtr(new ConstructorImpl<Image, TypeList<Stream&, Image::Flags, uint32_t>>(Stream::null, Image::FlagNone, 0));
					case 3: return ConstructorPtr(new ConstructorImpl<Image, TypeList<Image::Type, Format, const Size&, Image::Flags>>((Image::Type)0, (Format)0, {}, Image::FlagNone));
					case 4: return ConstructorPtr(new ConstructorImpl<Image, TypeList<Image::Type, Format, const Size&, uint32_t, Image::Flags>>((Image::Type)0, (Format)0, {}, {}, Image::FlagNone));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Image>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(Image::*)()>(&Image::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isLoaded));
					case 2: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isAllocated));
					case 3: return FunctionPtr(new FunctionImpl<Image::Type(Image::*)() const>(&Image::getType));
					case 4: return FunctionPtr(new FunctionImpl<const char*(Image::Type)>(&Image::getTypeName));
					case 5: return FunctionPtr(new FunctionImpl<const char*(Image::*)() const>(&Image::getTypeName));
					case 6: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::is2DType));
					case 7: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::is3DType));
					case 8: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isCubeType));
					case 9: return FunctionPtr(new FunctionImpl<Format(Image::*)() const>(&Image::getFormat));
					case 10: return FunctionPtr(new FunctionImpl<const char*(Image::*)() const>(&Image::getFormatName));
					case 11: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isColorFormat));
					case 12: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isDepthFormat));
					case 13: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isPixelFormat));
					case 14: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isPlainFormat));
					case 15: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isMixedFormat));
					case 16: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isBlockFormat));
					case 17: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isStencilFormat));
					case 18: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isNormFormat));
					case 19: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isSRGBFormat));
					case 20: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isFloatFormat));
					case 21: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isSignedFormat));
					case 22: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isUnsignedFormat));
					case 23: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isIntegerFormat));
					case 24: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isi8Format));
					case 25: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isu8Format));
					case 26: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::is8BitFormat));
					case 27: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isi16Format));
					case 28: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isu16Format));
					case 29: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isf16Format));
					case 30: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::is16BitFormat));
					case 31: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isi32Format));
					case 32: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isu32Format));
					case 33: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isf32Format));
					case 34: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::is32BitFormat));
					case 35: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isi64Format));
					case 36: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isu64Format));
					case 37: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isf64Format));
					case 38: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::is64BitFormat));
					case 39: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isBC15Format));
					case 40: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isBC67Format));
					case 41: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isETC2Format));
					case 42: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isASTCFormat));
					case 43: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getComponents));
					case 44: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getPixelSize));
					case 45: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getBlockSize));
					case 46: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getBlockWidth));
					case 47: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getBlockHeight));
					case 48: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getWidth));
					case 49: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getHeight));
					case 50: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getDepth));
					case 51: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getFaces));
					case 52: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getLayers));
					case 53: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getMipmaps));
					case 54: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)(const Size&) const>(&Image::findMipmap));
					case 55: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)(uint32_t) const>(&Image::getWidth));
					case 56: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)(uint32_t) const>(&Image::getHeight));
					case 57: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)(uint32_t) const>(&Image::getDepth));
					case 58: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::hasLayers));
					case 59: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::hasMipmaps));
					case 60: return FunctionPtr(new FunctionImpl<Size(Image::*)() const>(&Image::getSize));
					case 61: return FunctionPtr(new FunctionImpl<Region(Image::*)() const>(&Image::getRegion));
					case 62: return FunctionPtr(new FunctionImpl<Slice(Image::*)() const>(&Image::getSlice));
					case 63: return FunctionPtr(new FunctionImpl<Size(Image::*)(uint32_t) const>(&Image::getSize));
					case 64: return FunctionPtr(new FunctionImpl<Region(Image::*)(uint32_t) const>(&Image::getRegion));
					case 65: return FunctionPtr(new FunctionImpl<Slice(Image::*)(uint32_t) const>(&Image::getSlice));
					case 66: return FunctionPtr(new FunctionVoidImpl<void(Image::*)(const String&)>(&Image::setMetaInfo));
					case 67: return FunctionPtr(new FunctionImpl<String(Image::*)() const>(&Image::getMetaInfo));
					case 68: return FunctionPtr(new FunctionImpl<String(Image::*)() const>(&Image::getDescription));
					case 69: return FunctionPtr(new FunctionImpl<size_t(Image::*)(const Slice&, uint32_t) const>(&Image::getOffset, {}, 1));
					case 70: return FunctionPtr(new FunctionImpl<size_t(Image::*)(uint32_t, uint32_t) const>(&Image::getStride, 0, 1));
					case 71: return FunctionPtr(new FunctionImpl<size_t(Image::*)(uint32_t, uint32_t) const>(&Image::getMipmapSize, {}, 1));
					case 72: return FunctionPtr(new FunctionImpl<size_t(Image::*)(uint32_t) const>(&Image::getLayerSize, 1));
					case 73: return FunctionPtr(new FunctionImpl<size_t(Image::*)(uint32_t) const>(&Image::getDataSize, 1));
					case 74: return FunctionPtr(new FunctionImpl<bool(Image::*)(Image::Type, Format, const Size&, Image::Flags)>(&Image::create, (Image::Type)0, (Format)0, {}, Image::FlagNone));
					case 75: return FunctionPtr(new FunctionImpl<bool(Image::*)(Image::Type, Format, const Size&, uint32_t, Image::Flags)>(&Image::create, (Image::Type)0, (Format)0, {}, {}, Image::FlagNone));
					case 76: return FunctionPtr(new FunctionImpl<bool(Image::*)(Format, uint32_t, Image::Flags)>(&Image::create2D, (Format)0, {}, Image::FlagNone));
					case 77: return FunctionPtr(new FunctionImpl<bool(Image::*)(Format, uint32_t, Image::Flags)>(&Image::create3D, (Format)0, {}, Image::FlagNone));
					case 78: return FunctionPtr(new FunctionImpl<bool(Image::*)(Format, uint32_t, Image::Flags)>(&Image::createCube, (Format)0, {}, Image::FlagNone));
					case 79: return FunctionPtr(new FunctionImpl<bool(Image::*)(Format, uint32_t, uint32_t, Image::Flags)>(&Image::create2D, (Format)0, {}, {}, Image::FlagNone));
					case 80: return FunctionPtr(new FunctionImpl<bool(Image::*)(Format, uint32_t, uint32_t, uint32_t, Image::Flags)>(&Image::create3D, (Format)0, {}, {}, {}, Image::FlagNone));
					case 81: return FunctionPtr(new FunctionImpl<bool(Image::*)(Format, uint32_t, uint32_t, uint32_t, Image::Flags)>(&Image::create2D, (Format)0, {}, {}, {}, Image::FlagNone));
					case 82: return FunctionPtr(new FunctionImpl<bool(Image::*)(Format, uint32_t, uint32_t, Image::Flags)>(&Image::createCube, (Format)0, {}, {}, Image::FlagNone));
					case 83: return FunctionPtr(new FunctionImpl<bool(Image::*)(const char*, Image::Flags, uint32_t, Async*)>(&Image::info, {}, Image::FlagNone, 0, nullptr));
					case 84: return FunctionPtr(new FunctionImpl<bool(Image::*)(const String&, Image::Flags, uint32_t, Async*)>(&Image::info, {}, Image::FlagNone, 0, nullptr));
					case 85: return FunctionPtr(new FunctionImpl<bool(Image::*)(Stream&, Image::Flags, uint32_t, Async*)>(&Image::info, Stream::null, Image::FlagNone, 0, nullptr));
					case 86: return FunctionPtr(new FunctionImpl<bool(Image::*)(const char*, Async*)>(&Image::info));
					case 87: return FunctionPtr(new FunctionImpl<bool(Image::*)(const String&, Async*)>(&Image::info));
					case 88: return FunctionPtr(new FunctionImpl<bool(Image::*)(Stream&, Async*)>(&Image::info));
					case 89: return FunctionPtr(new FunctionImpl<bool(Image::*)(const char*, Image::Flags, uint32_t, Async*)>(&Image::load, {}, Image::FlagNone, 0, nullptr));
					case 90: return FunctionPtr(new FunctionImpl<bool(Image::*)(const String&, Image::Flags, uint32_t, Async*)>(&Image::load, {}, Image::FlagNone, 0, nullptr));
					case 91: return FunctionPtr(new FunctionImpl<bool(Image::*)(Stream&, Image::Flags, uint32_t, Async*)>(&Image::load, Stream::null, Image::FlagNone, 0, nullptr));
					case 92: return FunctionPtr(new FunctionImpl<bool(Image::*)(const char*, Async*)>(&Image::load));
					case 93: return FunctionPtr(new FunctionImpl<bool(Image::*)(const String&, Async*)>(&Image::load));
					case 94: return FunctionPtr(new FunctionImpl<bool(Image::*)(Stream&, Async*)>(&Image::load));
					case 95: return FunctionPtr(new FunctionImpl<bool(Image::*)(const char*, Image::Flags, uint32_t) const>(&Image::save, {}, Image::FlagNone, 95));
					case 96: return FunctionPtr(new FunctionImpl<bool(Image::*)(const String&, Image::Flags, uint32_t) const>(&Image::save, {}, Image::FlagNone, 95));
					case 97: return FunctionPtr(new FunctionImpl<bool(Image::*)(Stream&, Image::Flags, uint32_t) const>(&Image::save, Stream::null, Image::FlagNone, 95));
					case 98: return FunctionPtr(new FunctionImpl<bool(Image::*)(uint32_t, uint32_t)>(&Image::swap));
					case 99: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Image&, uint32_t, uint32_t)>(&Image::copy));
					case 100: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Region&, const Slice&)>(&Image::flipX));
					case 101: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Region&)>(&Image::flipX));
					case 102: return FunctionPtr(new FunctionImpl<bool(Image::*)()>(&Image::flipX));
					case 103: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Region&, const Slice&)>(&Image::flipY));
					case 104: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Region&)>(&Image::flipY));
					case 105: return FunctionPtr(new FunctionImpl<bool(Image::*)()>(&Image::flipY));
					case 106: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Image&, const Origin&, const Region&, const Slice&, const Slice&)>(&Image::copy));
					case 107: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Image&, const Origin&, const Region&)>(&Image::copy));
					case 108: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Image&, const Origin&, const Slice&)>(&Image::copy));
					case 109: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Image&, const Slice&, const Slice&)>(&Image::copy));
					case 110: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Image&, const Origin&)>(&Image::copy));
					case 111: return FunctionPtr(new FunctionImpl<bool(Image::*)(const Image&, const Slice&)>(&Image::copy));
					case 112: return FunctionPtr(new FunctionImpl<Image(Image::*)(Image::Type, Image::Flags, Async*) const>(&Image::toType, (Image::Type)0, (Image::Flags)0, nullptr));
					case 113: return FunctionPtr(new FunctionImpl<Image(Image::*)(Image::Type, Async*) const>(&Image::toType, (Image::Type)0, nullptr));
					case 114: return FunctionPtr(new FunctionImpl<Image(Image::*)(Format, Image::Flags, Async*) const>(&Image::toFormat, (Format)0, (Image::Flags)0, nullptr));
					case 115: return FunctionPtr(new FunctionImpl<Image(Image::*)(Format, Async*) const>(&Image::toFormat, (Format)0, nullptr));
					case 116: return FunctionPtr(new FunctionImpl<Image(Image::*)(const Slice&) const>(&Image::getSlice));
					case 117: return FunctionPtr(new FunctionImpl<Image(Image::*)(uint32_t) const>(&Image::getComponent));
					case 118: return FunctionPtr(new FunctionImpl<Image(Image::*)(const Region&, const Slice&) const>(&Image::getRegion));
					case 119: return FunctionPtr(new FunctionImpl<Image(Image::*)(const Region&) const>(&Image::getRegion));
					case 120: return FunctionPtr(new FunctionImpl<Image(Image::*)(int32_t, const Slice&) const>(&Image::getRotated));
					case 121: return FunctionPtr(new FunctionImpl<Image(Image::*)(int32_t) const>(&Image::getRotated));
					case 122: return FunctionPtr(new FunctionImpl<Image(Image::*)(const Size&, Image::Filter, Image::Filter, Image::Flags, Async*) const>(&Image::getResized, {}, (Image::Filter)0, (Image::Filter)0, (Image::Flags)0, nullptr));
					case 123: return FunctionPtr(new FunctionImpl<Image(Image::*)(const Size&, Image::Filter, Image::Filter, Async*) const>(&Image::getResized, {}, (Image::Filter)0, Image::FilterCubic, nullptr));
					case 124: return FunctionPtr(new FunctionImpl<Image(Image::*)(const Size&, Async*) const>(&Image::getResized, {}, nullptr));
					case 125: return FunctionPtr(new FunctionImpl<Image(Image::*)(Image::Filter, Image::Flags, Async*) const>(&Image::getMipmapped, (Image::Filter)0, (Image::Flags)0, nullptr));
					case 126: return FunctionPtr(new FunctionImpl<Image(Image::*)(Image::Filter, Async*) const>(&Image::getMipmapped, (Image::Filter)0, nullptr));
					case 127: return FunctionPtr(new FunctionImpl<Image(Image::*)(Async*) const>(&Image::getMipmapped, nullptr));
					case 128: return FunctionPtr(new FunctionImpl<int32_t(Image::*)(const Image&) const>(&Image::compare));
					case 129: return FunctionPtr(new FunctionImpl<const uint8_t*(Image::*)(const Slice&) const>(&Image::getData, Slice()));
					case 130: return FunctionPtr(new FunctionImpl<uint8_t*(Image::*)(const Slice&)>(&Image::getData, Slice()));
					case 131: return FunctionPtr(new FunctionImpl<const uint8_t*(Image::*)(const Origin&, const Slice&) const>(&Image::getData, {}, Slice()));
					case 132: return FunctionPtr(new FunctionImpl<uint8_t*(Image::*)(const Origin&, const Slice&)>(&Image::getData, {}, Slice()));
					case 133: return FunctionPtr(new FunctionImpl<bool(Image::*)(const void*, const Slice&, uint32_t, size_t)>(&Image::setData, {}, Slice(), 1, 0));
					case 134: return FunctionPtr(new FunctionImpl<bool(Image::*)(void*, const Slice&, uint32_t, size_t) const>(&Image::getData, {}, Slice(), 1, 0));
					case 135: return FunctionPtr(new FunctionImpl<size_t(Image::*)() const>(&Image::getMemory));
					case 136: return FunctionPtr(new FunctionImpl<Image(Image::*)() const>(&Image::clonePtr));
					case 137: return FunctionPtr(new FunctionVoidImpl<void(Image::*)()>(&Image::clearPtr));
					case 138: return FunctionPtr(new FunctionVoidImpl<void(Image::*)()>(&Image::destroyPtr));
					case 139: return FunctionPtr(new FunctionImpl<Image&(Image::*)()>(&Image::acquirePtr));
					case 140: return FunctionPtr(new FunctionImpl<Image&(Image::*)()>(&Image::unacquirePtr));
					case 141: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isValidPtr));
					case 142: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isOwnerPtr));
					case 143: return FunctionPtr(new FunctionImpl<bool(Image::*)() const>(&Image::isConstPtr));
					case 144: return FunctionPtr(new FunctionImpl<uint32_t(Image::*)() const>(&Image::getCountPtr));
					case 145: return FunctionPtr(new FunctionImpl<const void*(Image::*)() const>(&Image::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 3, 6, 10, 15 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 337, 10, 145, 337, 10, 339, 340, 341, 337, 339, 340, 341, 10, 337 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 338, 78, 222, 338, 78, 195, 96, 87, 338, 195, 96, 87, 342, 338 };
			static constexpr uint16_t function_names[] = { 5, 343, 344, 214, 345, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 11, 12, 388, 389, 390, 391, 392, 11, 12, 388, 394, 395, 73, 397, 399, 73, 397, 399, 401, 402, 403, 404, 408, 409, 410, 411, 24, 24, 412, 413, 414, 412, 413, 412, 414, 416, 416, 416, 416, 416, 416, 221, 221, 221, 221, 221, 221, 419, 419, 419, 421, 424, 428, 428, 428, 431, 431, 431, 424, 424, 424, 424, 424, 424, 437, 437, 438, 438, 399, 439, 397, 397, 441, 441, 443, 443, 443, 447, 447, 447, 449, 82, 82, 82, 82, 175, 82, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 215, 138, 138, 21, 21, 21, 340, 138, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21, 21, 396, 398, 400, 396, 398, 400, 6, 16, 16, 74, 74, 74, 74, 74, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 336, 336, 336, 336, 336, 336, 336, 336, 336, 336, 336, 336, 336, 336, 336, 336, 1, 83, 83, 83, 83, 21, 21, 74, 336, 336, 336, 336, 336, 336, 336, 336, 336, 336 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 4, 5, 5, 5, 5, 5, 5, 6, 7, 8, 9, 9, 9, 11, 13, 15, 16, 17, 21, 26, 29, 32, 35, 39, 44, 49, 53, 57, 61, 65, 67, 69, 71, 75, 79, 83, 85, 87, 89, 92, 95, 98, 100, 103, 105, 106, 106, 108, 109, 109, 114, 117, 120, 123, 125, 127, 130, 132, 135, 137, 138, 139, 141, 142, 144, 145, 150, 154, 156, 159, 161, 162, 163, 164, 165, 167, 169, 173, 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 177, 177 };
			static constexpr uint16_t function_arg_types[] = { 339, 341, 10, 10, 10, 10, 10, 10, 94, 405, 10, 10, 10, 10, 10, 10, 10, 339, 340, 341, 337, 339, 340, 341, 10, 337, 340, 10, 337, 340, 10, 337, 340, 10, 337, 340, 10, 10, 337, 340, 10, 10, 10, 337, 340, 10, 10, 10, 337, 340, 10, 10, 337, 22, 337, 10, 417, 94, 337, 10, 417, 145, 337, 10, 417, 22, 417, 94, 417, 145, 417, 22, 337, 10, 417, 94, 337, 10, 417, 145, 337, 10, 417, 22, 417, 94, 417, 145, 417, 22, 337, 10, 94, 337, 10, 145, 337, 10, 10, 10, 425, 10, 10, 429, 405, 429, 429, 405, 429, 425, 432, 429, 405, 405, 425, 432, 429, 425, 432, 405, 425, 405, 405, 425, 432, 425, 405, 339, 337, 417, 339, 417, 340, 337, 417, 340, 417, 405, 10, 429, 405, 429, 1, 405, 1, 341, 444, 444, 337, 417, 341, 444, 444, 417, 341, 417, 444, 337, 417, 444, 417, 417, 425, 405, 405, 432, 405, 432, 405, 89, 405, 10, 74, 85, 405, 10, 74 };
			static constexpr uint16_t function_arg_names[] = { 195, 87, 393, 393, 393, 393, 393, 393, 93, 406, 407, 393, 407, 393, 407, 407, 407, 195, 96, 87, 338, 195, 96, 87, 342, 338, 96, 87, 338, 96, 87, 338, 96, 87, 338, 96, 30, 31, 338, 96, 30, 31, 415, 338, 96, 30, 31, 342, 338, 96, 87, 342, 338, 23, 338, 78, 418, 23, 338, 78, 418, 222, 338, 78, 418, 23, 418, 23, 418, 222, 418, 23, 338, 78, 418, 23, 338, 78, 418, 222, 338, 78, 418, 23, 418, 23, 418, 222, 418, 23, 338, 420, 23, 338, 420, 222, 338, 420, 422, 423, 90, 426, 427, 430, 406, 430, 430, 406, 430, 90, 433, 434, 435, 436, 90, 433, 434, 90, 433, 435, 90, 435, 436, 90, 433, 90, 435, 195, 338, 418, 195, 418, 96, 338, 418, 96, 418, 406, 440, 430, 406, 430, 442, 406, 442, 87, 445, 446, 338, 418, 87, 445, 446, 418, 87, 418, 448, 338, 418, 448, 418, 418, 450, 406, 406, 451, 406, 451, 406, 90, 406, 407, 452, 86, 406, 407, 452 };
	};
	constexpr uint16_t ReflectionImage::constructor_bases[];
	constexpr uint16_t ReflectionImage::constructor_arg_types[];
	constexpr uint16_t ReflectionImage::constructor_arg_names[];
	constexpr uint16_t ReflectionImage::function_names[];
	constexpr uint16_t ReflectionImage::function_types[];
	constexpr uint16_t ReflectionImage::function_bases[];
	constexpr uint16_t ReflectionImage::function_arg_types[];
	constexpr uint16_t ReflectionImage::function_arg_names[];
	static ReflectionImage reflection_image;
	
	// Tellusim::MeshNode
	class ReflectionMeshNode : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshNode::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshNode, TypeList<const char*>>(nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<MeshNode, TypeList<Mesh&, const char*>>(Mesh::null, nullptr));
					case 2: return ConstructorPtr(new ConstructorImpl<MeshNode, TypeList<MeshNode*, const char*>>({}, nullptr));
					case 3: return ConstructorPtr(new ConstructorImpl<MeshNode, TypeList<Mesh&, MeshNode*, const char*>>(Mesh::null, {}, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshNode>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)()>(&MeshNode::clear));
					case 1: return FunctionPtr(new FunctionImpl<MeshNode(MeshNode::*)(Mesh&)>(&MeshNode::clone));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(const char*)>(&MeshNode::setName));
					case 3: return FunctionPtr(new FunctionImpl<String(MeshNode::*)() const>(&MeshNode::getName));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)() const>(&MeshNode::getIndex));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(Mesh&, bool)>(&MeshNode::setMesh, Mesh::null, true));
					case 6: return FunctionPtr(new FunctionImpl<const Mesh(MeshNode::*)() const>(&MeshNode::getMesh));
					case 7: return FunctionPtr(new FunctionImpl<Mesh(MeshNode::*)()>(&MeshNode::getMesh));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)(MeshNode&, bool)>(&MeshNode::setParent, MeshNode::null, true));
					case 9: return FunctionPtr(new FunctionImpl<const MeshNode(MeshNode::*)() const>(&MeshNode::getParent));
					case 10: return FunctionPtr(new FunctionImpl<MeshNode(MeshNode::*)()>(&MeshNode::getParent));
					case 11: return FunctionPtr(new FunctionImpl<bool(MeshNode::*)() const>(&MeshNode::isRoot));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(uint32_t)>(&MeshNode::reserveChildren));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)(MeshNode&, bool)>(&MeshNode::addChild, MeshNode::null, true));
					case 14: return FunctionPtr(new FunctionImpl<bool(MeshNode::*)(MeshNode&)>(&MeshNode::removeChild));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)()>(&MeshNode::releaseChildren));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)(const MeshNode&) const>(&MeshNode::findChild));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)() const>(&MeshNode::getNumChildren));
					case 18: return FunctionPtr(new FunctionImpl<const Array<MeshNode>(MeshNode::*)() const>(&MeshNode::getChildren));
					case 19: return FunctionPtr(new FunctionImpl<Array<MeshNode>(MeshNode::*)()>(&MeshNode::getChildren));
					case 20: return FunctionPtr(new FunctionImpl<const MeshNode(MeshNode::*)(uint32_t) const>(&MeshNode::getChild));
					case 21: return FunctionPtr(new FunctionImpl<MeshNode(MeshNode::*)(uint32_t)>(&MeshNode::getChild));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)()>(&MeshNode::clearGeometries));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(uint32_t)>(&MeshNode::reserveGeometries));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)(MeshGeometry&, bool)>(&MeshNode::addGeometry, MeshGeometry::null, true));
					case 25: return FunctionPtr(new FunctionImpl<bool(MeshNode::*)(MeshGeometry&)>(&MeshNode::removeGeometry));
					case 26: return FunctionPtr(new FunctionImpl<bool(MeshNode::*)(MeshGeometry&, MeshGeometry&)>(&MeshNode::replaceGeometry));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)(const MeshGeometry&) const>(&MeshNode::findGeometry));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)() const>(&MeshNode::getNumGeometries));
					case 29: return FunctionPtr(new FunctionImpl<const Array<MeshGeometry>(MeshNode::*)() const>(&MeshNode::getGeometries));
					case 30: return FunctionPtr(new FunctionImpl<Array<MeshGeometry>(MeshNode::*)()>(&MeshNode::getGeometries));
					case 31: return FunctionPtr(new FunctionImpl<const MeshGeometry(MeshNode::*)(uint32_t) const>(&MeshNode::getGeometry));
					case 32: return FunctionPtr(new FunctionImpl<MeshGeometry(MeshNode::*)(uint32_t)>(&MeshNode::getGeometry));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)()>(&MeshNode::clearAttachments));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(uint32_t)>(&MeshNode::reserveAttachments));
					case 35: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)(MeshAttachment&, bool)>(&MeshNode::addAttachment, MeshAttachment::null, true));
					case 36: return FunctionPtr(new FunctionImpl<bool(MeshNode::*)(MeshAttachment&)>(&MeshNode::removeAttachment));
					case 37: return FunctionPtr(new FunctionImpl<bool(MeshNode::*)(MeshAttachment&, MeshAttachment&)>(&MeshNode::replaceAttachment));
					case 38: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)(const MeshAttachment&) const>(&MeshNode::findAttachment));
					case 39: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)(const char*) const>(&MeshNode::findAttachment));
					case 40: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)() const>(&MeshNode::getNumAttachments));
					case 41: return FunctionPtr(new FunctionImpl<const Array<MeshAttachment>(MeshNode::*)() const>(&MeshNode::getAttachments));
					case 42: return FunctionPtr(new FunctionImpl<Array<MeshAttachment>(MeshNode::*)()>(&MeshNode::getAttachments));
					case 43: return FunctionPtr(new FunctionImpl<const MeshAttachment(MeshNode::*)(uint32_t) const>(&MeshNode::getAttachment));
					case 44: return FunctionPtr(new FunctionImpl<MeshAttachment(MeshNode::*)(uint32_t)>(&MeshNode::getAttachment));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(const Matrix4x3d&)>(&MeshNode::setLocalTransform));
					case 46: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshNode::*)() const>(&MeshNode::getLocalTransform));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(const Matrix4x3d&)>(&MeshNode::setGlobalTransform));
					case 48: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshNode::*)() const>(&MeshNode::getGlobalTransform));
					case 49: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(const Matrix4x3d&)>(&MeshNode::setPivotTransform));
					case 50: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshNode::*)() const>(&MeshNode::getPivotTransform));
					case 51: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(const Vector4f&)>(&MeshNode::setMorphTransform));
					case 52: return FunctionPtr(new FunctionImpl<const Vector4f&(MeshNode::*)() const>(&MeshNode::getMorphTransform));
					case 53: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(const Matrix4x3d&)>(&MeshNode::createLocalTransforms, Matrix4x3d::identity));
					case 54: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(const Matrix4x3d&)>(&MeshNode::createGlobalTransforms, Matrix4x3d::identity));
					case 55: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)(const Vector3d&)>(&MeshNode::setTransform));
					case 56: return FunctionPtr(new FunctionImpl<size_t(MeshNode::*)() const>(&MeshNode::getMemory));
					case 57: return FunctionPtr(new FunctionImpl<MeshNode(MeshNode::*)() const>(&MeshNode::clonePtr));
					case 58: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)()>(&MeshNode::clearPtr));
					case 59: return FunctionPtr(new FunctionVoidImpl<void(MeshNode::*)()>(&MeshNode::destroyPtr));
					case 60: return FunctionPtr(new FunctionImpl<MeshNode&(MeshNode::*)()>(&MeshNode::acquirePtr));
					case 61: return FunctionPtr(new FunctionImpl<MeshNode&(MeshNode::*)()>(&MeshNode::unacquirePtr));
					case 62: return FunctionPtr(new FunctionImpl<bool(MeshNode::*)() const>(&MeshNode::isValidPtr));
					case 63: return FunctionPtr(new FunctionImpl<bool(MeshNode::*)() const>(&MeshNode::isOwnerPtr));
					case 64: return FunctionPtr(new FunctionImpl<bool(MeshNode::*)() const>(&MeshNode::isConstPtr));
					case 65: return FunctionPtr(new FunctionImpl<uint32_t(MeshNode::*)() const>(&MeshNode::getCountPtr));
					case 66: return FunctionPtr(new FunctionImpl<const void*(MeshNode::*)() const>(&MeshNode::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 1, 3, 5, 8 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 455, 22, 457, 22, 455, 457, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 456, 23, 458, 23, 456, 458, 23 };
			static constexpr uint16_t function_names[] = { 5, 459, 172, 75, 460, 461, 462, 462, 464, 466, 466, 467, 468, 470, 472, 473, 474, 476, 477, 477, 478, 478, 479, 480, 482, 485, 486, 488, 490, 491, 491, 492, 492, 494, 495, 497, 500, 501, 503, 503, 505, 506, 506, 507, 507, 509, 512, 514, 515, 516, 517, 518, 520, 522, 524, 525, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 454, 6, 16, 10, 6, 463, 463, 10, 454, 454, 21, 6, 10, 21, 6, 10, 10, 19, 19, 454, 454, 6, 6, 10, 21, 21, 10, 10, 19, 19, 493, 493, 6, 6, 10, 21, 21, 10, 10, 10, 19, 19, 508, 508, 6, 513, 6, 513, 6, 513, 6, 521, 6, 6, 6, 74, 454, 454, 454, 454, 454, 454, 454, 454, 454, 454 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 2, 2, 2, 4, 4, 4, 6, 6, 6, 6, 7, 9, 10, 10, 11, 11, 11, 11, 12, 13, 13, 14, 16, 17, 19, 20, 20, 20, 20, 21, 22, 22, 23, 25, 26, 28, 29, 30, 30, 30, 30, 31, 32, 33, 33, 34, 34, 35, 35, 36, 36, 37, 38, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39, 39 };
			static constexpr uint16_t function_arg_types[] = { 455, 22, 455, 21, 465, 21, 10, 465, 21, 465, 475, 10, 10, 10, 483, 21, 483, 483, 483, 489, 10, 10, 10, 498, 21, 498, 498, 498, 504, 22, 10, 10, 510, 510, 510, 519, 510, 510, 526 };
			static constexpr uint16_t function_arg_names[] = { 456, 23, 456, 50, 458, 50, 469, 471, 50, 471, 471, 274, 274, 481, 484, 50, 484, 487, 484, 484, 274, 274, 496, 499, 50, 499, 502, 499, 499, 23, 274, 274, 511, 511, 511, 511, 523, 511, 527 };
	};
	constexpr uint16_t ReflectionMeshNode::constructor_bases[];
	constexpr uint16_t ReflectionMeshNode::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshNode::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshNode::function_names[];
	constexpr uint16_t ReflectionMeshNode::function_types[];
	constexpr uint16_t ReflectionMeshNode::function_bases[];
	constexpr uint16_t ReflectionMeshNode::function_arg_types[];
	constexpr uint16_t ReflectionMeshNode::function_arg_names[];
	static ReflectionMeshNode reflection_mesh_node;
	
	// Tellusim::MeshIndices
	class ReflectionMeshIndices : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshIndices::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshIndices, TypeList<const char*>>(nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<MeshIndices, TypeList<MeshIndices::Type, Format, const char*>>((MeshIndices::Type)0, (Format)0, nullptr));
					case 2: return ConstructorPtr(new ConstructorImpl<MeshIndices, TypeList<MeshIndices::Type, Format, uint32_t, const char*>>((MeshIndices::Type)0, (Format)0, {}, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshIndices>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)()>(&MeshIndices::clear));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(const char*)>(&MeshIndices::setName));
					case 2: return FunctionPtr(new FunctionImpl<String(MeshIndices::*)() const>(&MeshIndices::getName));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(MeshIndices::Type, Format, uint32_t)>(&MeshIndices::create, (MeshIndices::Type)0, (Format)0, 0));
					case 4: return FunctionPtr(new FunctionImpl<MeshIndices::Type(MeshIndices::*)() const>(&MeshIndices::getType));
					case 5: return FunctionPtr(new FunctionImpl<const char*(MeshIndices::Type)>(&MeshIndices::getTypeName));
					case 6: return FunctionPtr(new FunctionImpl<const char*(MeshIndices::*)() const>(&MeshIndices::getTypeName));
					case 7: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isUnknown));
					case 8: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isPoint));
					case 9: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isLine));
					case 10: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isTriangle));
					case 11: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isQuadrilateral));
					case 12: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isTetrahedron));
					case 13: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isPrimitive));
					case 14: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isSolid));
					case 15: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isVolume));
					case 16: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isMaterial));
					case 17: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isGroup));
					case 18: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isJoint));
					case 19: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isEdge));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(MeshIndices::*)() const>(&MeshIndices::getPrimitiveSize));
					case 21: return FunctionPtr(new FunctionImpl<Format(MeshIndices::*)() const>(&MeshIndices::getFormat));
					case 22: return FunctionPtr(new FunctionImpl<const char*(MeshIndices::*)() const>(&MeshIndices::getFormatName));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(MeshGeometry&, bool)>(&MeshIndices::setGeometry, MeshGeometry::null, true));
					case 24: return FunctionPtr(new FunctionImpl<const MeshGeometry(MeshIndices::*)() const>(&MeshIndices::getGeometry));
					case 25: return FunctionPtr(new FunctionImpl<MeshGeometry(MeshIndices::*)()>(&MeshIndices::getGeometry));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(uint32_t, bool, bool)>(&MeshIndices::setSize, {}, true, false));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(MeshIndices::*)() const>(&MeshIndices::getSize));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(MeshIndices::*)() const>(&MeshIndices::getStride));
					case 29: return FunctionPtr(new FunctionImpl<size_t(MeshIndices::*)() const>(&MeshIndices::getBytes));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(uint32_t, uint32_t, uint32_t)>(&MeshIndices::setData, {}, 0, 0));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(const void*, Format, uint32_t, uint32_t)>(&MeshIndices::setData, {}, Tellusim::FormatUnknown, 0, 1));
					case 32: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(void*, Format, uint32_t, uint32_t) const>(&MeshIndices::getData, {}, Tellusim::FormatUnknown, 0, 1));
					case 33: return FunctionPtr(new FunctionVoidImpl<const void*(MeshIndices::*)() const>(&MeshIndices::getData));
					case 34: return FunctionPtr(new FunctionVoidImpl<void*(MeshIndices::*)()>(&MeshIndices::getData));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(uint32_t, uint32_t)>(&MeshIndices::set));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(uint32_t, uint32_t, uint32_t)>(&MeshIndices::set));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(uint32_t, uint32_t, uint32_t, uint32_t)>(&MeshIndices::set));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(uint32_t, uint32_t, uint32_t, uint32_t, uint32_t)>(&MeshIndices::set));
					case 39: return FunctionPtr(new FunctionImpl<uint32_t(MeshIndices::*)(uint32_t) const>(&MeshIndices::get));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(uint32_t, uint32_t&, uint32_t&) const>(&MeshIndices::get));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(uint32_t, uint32_t&, uint32_t&, uint32_t&) const>(&MeshIndices::get));
					case 42: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(uint32_t, uint32_t&, uint32_t&, uint32_t&, uint32_t&) const>(&MeshIndices::get));
					case 43: return FunctionPtr(new FunctionVoidImpl<const void*(MeshIndices::*)(uint32_t) const>(&MeshIndices::getPtr));
					case 44: return FunctionPtr(new FunctionVoidImpl<void*(MeshIndices::*)(uint32_t)>(&MeshIndices::getPtr));
					case 45: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isDirect));
					case 46: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isUniform));
					case 47: return FunctionPtr(new FunctionImpl<uint32_t(MeshIndices::*)() const>(&MeshIndices::getMinIndex));
					case 48: return FunctionPtr(new FunctionImpl<uint32_t(MeshIndices::*)() const>(&MeshIndices::getMaxIndex));
					case 49: return FunctionPtr(new FunctionImpl<int32_t(MeshIndices::*)(const MeshIndices&) const>(&MeshIndices::compare));
					case 50: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)(const MeshIndices&, uint32_t, bool)>(&MeshIndices::addIndices, MeshIndices::null, {}, false));
					case 51: return FunctionPtr(new FunctionImpl<MeshIndices(MeshIndices::*)(Format) const>(&MeshIndices::toFormat));
					case 52: return FunctionPtr(new FunctionImpl<MeshIndices(MeshIndices::*)(MeshIndices::Type) const>(&MeshIndices::toType));
					case 53: return FunctionPtr(new FunctionImpl<MeshIndices(MeshIndices::*)(MeshIndices::Type, const MeshAttribute&) const>(&MeshIndices::toType));
					case 54: return FunctionPtr(new FunctionImpl<size_t(MeshIndices::*)() const>(&MeshIndices::getMemory));
					case 55: return FunctionPtr(new FunctionImpl<MeshIndices(MeshIndices::*)() const>(&MeshIndices::clonePtr));
					case 56: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)()>(&MeshIndices::clearPtr));
					case 57: return FunctionPtr(new FunctionVoidImpl<void(MeshIndices::*)()>(&MeshIndices::destroyPtr));
					case 58: return FunctionPtr(new FunctionImpl<MeshIndices&(MeshIndices::*)()>(&MeshIndices::acquirePtr));
					case 59: return FunctionPtr(new FunctionImpl<MeshIndices&(MeshIndices::*)()>(&MeshIndices::unacquirePtr));
					case 60: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isValidPtr));
					case 61: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isOwnerPtr));
					case 62: return FunctionPtr(new FunctionImpl<bool(MeshIndices::*)() const>(&MeshIndices::isConstPtr));
					case 63: return FunctionPtr(new FunctionImpl<uint32_t(MeshIndices::*)() const>(&MeshIndices::getCountPtr));
					case 64: return FunctionPtr(new FunctionImpl<const void*(MeshIndices::*)() const>(&MeshIndices::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 1, 4, 8 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 529, 340, 22, 529, 340, 10, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 195, 96, 23, 195, 96, 87, 23 };
			static constexpr uint16_t function_names[] = { 5, 172, 75, 24, 214, 345, 345, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 349, 350, 544, 492, 492, 29, 73, 408, 546, 175, 175, 82, 82, 82, 548, 548, 548, 548, 553, 553, 553, 553, 555, 555, 556, 557, 558, 559, 449, 562, 438, 437, 437, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 16, 6, 215, 138, 138, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 10, 340, 138, 6, 493, 493, 6, 10, 10, 74, 6, 6, 6, 6, 6, 6, 6, 6, 6, 10, 6, 6, 6, 6, 6, 21, 21, 10, 10, 1, 6, 528, 528, 528, 74, 528, 528, 528, 528, 528, 528, 528, 528, 528, 528 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 7, 7, 7, 10, 10, 10, 10, 13, 17, 21, 21, 21, 23, 26, 30, 35, 36, 39, 43, 48, 49, 50, 50, 50, 50, 50, 51, 54, 55, 56, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58, 58 };
			static constexpr uint16_t function_arg_types[] = { 22, 529, 340, 10, 529, 483, 21, 10, 21, 21, 10, 10, 10, 89, 340, 10, 10, 85, 340, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 554, 554, 10, 554, 554, 554, 10, 554, 554, 554, 554, 10, 10, 560, 560, 10, 21, 340, 529, 529, 564 };
			static constexpr uint16_t function_arg_names[] = { 23, 195, 96, 87, 195, 484, 50, 87, 545, 5, 105, 87, 78, 90, 96, 87, 547, 86, 96, 87, 547, 274, 105, 274, 549, 550, 274, 549, 550, 551, 274, 549, 550, 551, 552, 274, 274, 549, 550, 274, 549, 550, 551, 274, 549, 550, 551, 552, 274, 274, 561, 561, 78, 563, 96, 195, 195, 565 };
	};
	constexpr uint16_t ReflectionMeshIndices::constructor_bases[];
	constexpr uint16_t ReflectionMeshIndices::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshIndices::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshIndices::function_names[];
	constexpr uint16_t ReflectionMeshIndices::function_types[];
	constexpr uint16_t ReflectionMeshIndices::function_bases[];
	constexpr uint16_t ReflectionMeshIndices::function_arg_types[];
	constexpr uint16_t ReflectionMeshIndices::function_arg_names[];
	static ReflectionMeshIndices reflection_mesh_indices;
	
	// Tellusim::MeshAttribute
	class ReflectionMeshAttribute : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshAttribute::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshAttribute, TypeList<const char*, uint32_t>>(nullptr, 0));
					case 1: return ConstructorPtr(new ConstructorImpl<MeshAttribute, TypeList<MeshAttribute::Type, Format, const char*, uint32_t>>((MeshAttribute::Type)0, (Format)0, nullptr, 0));
					case 2: return ConstructorPtr(new ConstructorImpl<MeshAttribute, TypeList<MeshAttribute::Type, Format, uint32_t, const char*, uint32_t>>((MeshAttribute::Type)0, (Format)0, {}, nullptr, 0));
					case 3: return ConstructorPtr(new ConstructorImpl<MeshAttribute, TypeList<MeshAttribute::Type, Format, uint32_t, uint32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshAttribute>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)()>(&MeshAttribute::clear));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(const char*)>(&MeshAttribute::setName));
					case 2: return FunctionPtr(new FunctionImpl<String(MeshAttribute::*)() const>(&MeshAttribute::getName));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(MeshAttribute::Type, Format, uint32_t)>(&MeshAttribute::create, (MeshAttribute::Type)0, (Format)0, 0));
					case 4: return FunctionPtr(new FunctionImpl<MeshAttribute::Type(MeshAttribute::*)() const>(&MeshAttribute::getType));
					case 5: return FunctionPtr(new FunctionImpl<const char*(MeshAttribute::Type)>(&MeshAttribute::getTypeName));
					case 6: return FunctionPtr(new FunctionImpl<const char*(MeshAttribute::*)() const>(&MeshAttribute::getTypeName));
					case 7: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isUnknown));
					case 8: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isPosition));
					case 9: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isBasis));
					case 10: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isNormal));
					case 11: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isTangent));
					case 12: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isBinormal));
					case 13: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isSpatial));
					case 14: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isNormalized));
					case 15: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isTexCoord));
					case 16: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isWeights));
					case 17: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isJoints));
					case 18: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isColor));
					case 19: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isVertex));
					case 20: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isCrease));
					case 21: return FunctionPtr(new FunctionImpl<Format(MeshAttribute::*)() const>(&MeshAttribute::getFormat));
					case 22: return FunctionPtr(new FunctionImpl<const char*(MeshAttribute::*)() const>(&MeshAttribute::getFormatName));
					case 23: return FunctionPtr(new FunctionImpl<uint32_t(MeshAttribute::*)() const>(&MeshAttribute::getComponents));
					case 24: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isPacked));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(uint32_t)>(&MeshAttribute::setIndex));
					case 26: return FunctionPtr(new FunctionImpl<uint32_t(MeshAttribute::*)() const>(&MeshAttribute::getIndex));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(MeshIndices&)>(&MeshAttribute::setIndices));
					case 28: return FunctionPtr(new FunctionImpl<const MeshIndices(MeshAttribute::*)() const>(&MeshAttribute::getIndices));
					case 29: return FunctionPtr(new FunctionImpl<MeshIndices(MeshAttribute::*)()>(&MeshAttribute::getIndices));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(MeshGeometry&, bool)>(&MeshAttribute::setGeometry, MeshGeometry::null, true));
					case 31: return FunctionPtr(new FunctionImpl<const MeshGeometry(MeshAttribute::*)() const>(&MeshAttribute::getGeometry));
					case 32: return FunctionPtr(new FunctionImpl<MeshGeometry(MeshAttribute::*)()>(&MeshAttribute::getGeometry));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(uint32_t, bool, bool)>(&MeshAttribute::setSize, {}, true, false));
					case 34: return FunctionPtr(new FunctionImpl<uint32_t(MeshAttribute::*)() const>(&MeshAttribute::getSize));
					case 35: return FunctionPtr(new FunctionImpl<uint32_t(MeshAttribute::*)() const>(&MeshAttribute::getStride));
					case 36: return FunctionPtr(new FunctionImpl<size_t(MeshAttribute::*)() const>(&MeshAttribute::getBytes));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(const void*, uint32_t, uint32_t)>(&MeshAttribute::setData, {}, 0, 0));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(const void*, const Array<uint32_t>&, uint32_t)>(&MeshAttribute::setData, {}, {}, 0));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(void*, uint32_t, uint32_t) const>(&MeshAttribute::getData, {}, 0, 0));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(void*, const MeshIndices&, uint32_t) const>(&MeshAttribute::getData, {}, MeshIndices::null, 0));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(void*, const Array<uint32_t>&, uint32_t) const>(&MeshAttribute::getData, {}, {}, 0));
					case 42: return FunctionPtr(new FunctionVoidImpl<const void*(MeshAttribute::*)() const>(&MeshAttribute::getData));
					case 43: return FunctionPtr(new FunctionVoidImpl<void*(MeshAttribute::*)()>(&MeshAttribute::getData));
					case 44: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(uint32_t, const void*, size_t)>(&MeshAttribute::setValue));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(uint32_t, void*, size_t) const>(&MeshAttribute::getValue));
					case 46: return FunctionPtr(new FunctionVoidImpl<const void*(MeshAttribute::*)(uint32_t) const>(&MeshAttribute::getPtr));
					case 47: return FunctionPtr(new FunctionVoidImpl<void*(MeshAttribute::*)(uint32_t)>(&MeshAttribute::getPtr));
					case 48: return FunctionPtr(new FunctionImpl<int32_t(MeshAttribute::*)(const MeshAttribute&, const Matrix4x3f&, float32_t, bool) const>(&MeshAttribute::compare, MeshAttribute::null, Matrix4x3f::identity, 1e-6f, true));
					case 49: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)(const MeshAttribute&)>(&MeshAttribute::addAttribute));
					case 50: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)(const Matrix4x3f&)>(&MeshAttribute::setTransform));
					case 51: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)(const MeshAttribute&, float32_t)>(&MeshAttribute::morphAttribute));
					case 52: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)(const MeshAttribute&, const MeshAttribute&, Format)>(&MeshAttribute::packAttributes));
					case 53: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)(MeshAttribute&, MeshAttribute&) const>(&MeshAttribute::unpackAttributes));
					case 54: return FunctionPtr(new FunctionImpl<MeshAttribute(MeshAttribute::*)(MeshIndices&) const>(&MeshAttribute::optimizeAttribute));
					case 55: return FunctionPtr(new FunctionImpl<MeshAttribute(MeshAttribute::*)(const MeshIndices&) const>(&MeshAttribute::toDirect));
					case 56: return FunctionPtr(new FunctionImpl<MeshAttribute(MeshAttribute::*)(Format) const>(&MeshAttribute::toFormat));
					case 57: return FunctionPtr(new FunctionImpl<MeshAttribute(MeshAttribute::*)(MeshAttribute::Type) const>(&MeshAttribute::toType));
					case 58: return FunctionPtr(new FunctionImpl<Matrix4x3f(MeshAttribute::*)() const>(&MeshAttribute::getCovarianceMatrix));
					case 59: return FunctionPtr(new FunctionImpl<Matrix4x3f(MeshAttribute::*)() const>(&MeshAttribute::getMinTransform));
					case 60: return FunctionPtr(new FunctionImpl<BoundBoxf(MeshAttribute::*)() const>(&MeshAttribute::getBoundBox));
					case 61: return FunctionPtr(new FunctionImpl<BoundSpheref(MeshAttribute::*)() const>(&MeshAttribute::getBoundSphere));
					case 62: return FunctionPtr(new FunctionImpl<size_t(MeshAttribute::*)() const>(&MeshAttribute::getMemory));
					case 63: return FunctionPtr(new FunctionImpl<MeshAttribute(MeshAttribute::*)() const>(&MeshAttribute::clonePtr));
					case 64: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)()>(&MeshAttribute::clearPtr));
					case 65: return FunctionPtr(new FunctionVoidImpl<void(MeshAttribute::*)()>(&MeshAttribute::destroyPtr));
					case 66: return FunctionPtr(new FunctionImpl<MeshAttribute&(MeshAttribute::*)()>(&MeshAttribute::acquirePtr));
					case 67: return FunctionPtr(new FunctionImpl<MeshAttribute&(MeshAttribute::*)()>(&MeshAttribute::unacquirePtr));
					case 68: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isValidPtr));
					case 69: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isOwnerPtr));
					case 70: return FunctionPtr(new FunctionImpl<bool(MeshAttribute::*)() const>(&MeshAttribute::isConstPtr));
					case 71: return FunctionPtr(new FunctionImpl<uint32_t(MeshAttribute::*)() const>(&MeshAttribute::getCountPtr));
					case 72: return FunctionPtr(new FunctionImpl<const void*(MeshAttribute::*)() const>(&MeshAttribute::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 2, 6, 11, 15 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 10, 567, 340, 22, 10, 567, 340, 10, 22, 10, 567, 340, 10, 10 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 274, 195, 96, 23, 274, 195, 96, 87, 23, 274, 195, 96, 87, 274 };
			static constexpr uint16_t function_names[] = { 5, 172, 75, 24, 214, 345, 345, 530, 568, 569, 570, 571, 572, 573, 574, 575, 576, 577, 578, 579, 580, 349, 350, 383, 581, 582, 460, 583, 585, 585, 544, 492, 492, 29, 73, 408, 546, 175, 175, 82, 82, 82, 82, 82, 587, 588, 555, 555, 449, 593, 525, 594, 596, 599, 601, 602, 438, 437, 603, 605, 606, 608, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 16, 6, 215, 138, 138, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 340, 138, 10, 21, 6, 10, 6, 528, 528, 6, 493, 493, 6, 10, 10, 74, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 1, 6, 21, 21, 21, 21, 566, 566, 566, 566, 604, 604, 607, 609, 74, 566, 566, 566, 566, 566, 566, 566, 566, 566, 566 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 7, 7, 7, 9, 9, 9, 12, 12, 12, 12, 15, 18, 21, 24, 27, 27, 27, 30, 33, 34, 35, 39, 40, 41, 43, 46, 48, 49, 50, 51, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52 };
			static constexpr uint16_t function_arg_types[] = { 22, 567, 340, 10, 567, 10, 584, 483, 21, 10, 21, 21, 89, 10, 10, 89, 586, 10, 85, 10, 10, 85, 560, 10, 85, 586, 10, 10, 89, 74, 10, 85, 74, 10, 10, 564, 590, 123, 21, 564, 590, 564, 123, 564, 564, 340, 600, 600, 584, 560, 340, 567 };
			static constexpr uint16_t function_arg_names[] = { 23, 195, 96, 87, 195, 274, 561, 484, 50, 87, 545, 5, 90, 87, 452, 90, 561, 452, 86, 87, 452, 86, 561, 452, 86, 561, 452, 274, 90, 87, 274, 86, 87, 274, 274, 589, 511, 591, 592, 589, 511, 589, 595, 597, 598, 96, 597, 598, 561, 561, 96, 195 };
	};
	constexpr uint16_t ReflectionMeshAttribute::constructor_bases[];
	constexpr uint16_t ReflectionMeshAttribute::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshAttribute::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshAttribute::function_names[];
	constexpr uint16_t ReflectionMeshAttribute::function_types[];
	constexpr uint16_t ReflectionMeshAttribute::function_bases[];
	constexpr uint16_t ReflectionMeshAttribute::function_arg_types[];
	constexpr uint16_t ReflectionMeshAttribute::function_arg_names[];
	static ReflectionMeshAttribute reflection_mesh_attribute;
	
	// Tellusim::MeshJoint
	class ReflectionMeshJoint : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshJoint::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshJoint, TypeList<const char*>>(nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<MeshJoint, TypeList<MeshGeometry&, const char*>>(MeshGeometry::null, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshJoint>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)()>(&MeshJoint::clear));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)(const char*)>(&MeshJoint::setName));
					case 2: return FunctionPtr(new FunctionImpl<String(MeshJoint::*)() const>(&MeshJoint::getName));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)(MeshNode&)>(&MeshJoint::setNode));
					case 4: return FunctionPtr(new FunctionImpl<const MeshNode(MeshJoint::*)() const>(&MeshJoint::getNode));
					case 5: return FunctionPtr(new FunctionImpl<MeshNode(MeshJoint::*)()>(&MeshJoint::getNode));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(MeshJoint::*)() const>(&MeshJoint::getNodeIndex));
					case 7: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshJoint::*)() const>(&MeshJoint::getLocalTransform));
					case 8: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshJoint::*)() const>(&MeshJoint::getGlobalTransform));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)(MeshIndices&)>(&MeshJoint::setIndices));
					case 10: return FunctionPtr(new FunctionImpl<const MeshIndices(MeshJoint::*)() const>(&MeshJoint::getIndices));
					case 11: return FunctionPtr(new FunctionImpl<MeshIndices(MeshJoint::*)()>(&MeshJoint::getIndices));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)(MeshGeometry&, bool)>(&MeshJoint::setGeometry, MeshGeometry::null, true));
					case 13: return FunctionPtr(new FunctionImpl<const MeshGeometry(MeshJoint::*)() const>(&MeshJoint::getGeometry));
					case 14: return FunctionPtr(new FunctionImpl<MeshGeometry(MeshJoint::*)()>(&MeshJoint::getGeometry));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)(const BoundBoxf&)>(&MeshJoint::setBoundBox));
					case 16: return FunctionPtr(new FunctionImpl<const BoundBoxf&(MeshJoint::*)() const>(&MeshJoint::getBoundBox));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)(const BoundSpheref&)>(&MeshJoint::setBoundSphere));
					case 18: return FunctionPtr(new FunctionImpl<const BoundSpheref&(MeshJoint::*)()>(&MeshJoint::getBoundSphere));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)(const Matrix4x3f&)>(&MeshJoint::setITransform));
					case 20: return FunctionPtr(new FunctionImpl<const Matrix4x3f&(MeshJoint::*)() const>(&MeshJoint::getITransform));
					case 21: return FunctionPtr(new FunctionImpl<int32_t(MeshJoint::*)(const MeshJoint&) const>(&MeshJoint::compare));
					case 22: return FunctionPtr(new FunctionImpl<size_t(MeshJoint::*)() const>(&MeshJoint::getMemory));
					case 23: return FunctionPtr(new FunctionImpl<MeshJoint(MeshJoint::*)() const>(&MeshJoint::clonePtr));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)()>(&MeshJoint::clearPtr));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(MeshJoint::*)()>(&MeshJoint::destroyPtr));
					case 26: return FunctionPtr(new FunctionImpl<MeshJoint&(MeshJoint::*)()>(&MeshJoint::acquirePtr));
					case 27: return FunctionPtr(new FunctionImpl<MeshJoint&(MeshJoint::*)()>(&MeshJoint::unacquirePtr));
					case 28: return FunctionPtr(new FunctionImpl<bool(MeshJoint::*)() const>(&MeshJoint::isValidPtr));
					case 29: return FunctionPtr(new FunctionImpl<bool(MeshJoint::*)() const>(&MeshJoint::isOwnerPtr));
					case 30: return FunctionPtr(new FunctionImpl<bool(MeshJoint::*)() const>(&MeshJoint::isConstPtr));
					case 31: return FunctionPtr(new FunctionImpl<uint32_t(MeshJoint::*)() const>(&MeshJoint::getCountPtr));
					case 32: return FunctionPtr(new FunctionImpl<const void*(MeshJoint::*)() const>(&MeshJoint::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 1, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 483, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 484, 23 };
			static constexpr uint16_t function_names[] = { 5, 172, 75, 611, 613, 613, 614, 512, 515, 583, 585, 585, 544, 492, 492, 615, 606, 618, 608, 621, 622, 449, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 16, 6, 454, 454, 10, 513, 513, 6, 528, 528, 6, 493, 493, 6, 607, 6, 609, 6, 604, 1, 74, 610, 610, 610, 610, 610, 610, 610, 610, 610, 610 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 5, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
			static constexpr uint16_t function_arg_types[] = { 22, 465, 584, 483, 21, 616, 619, 590, 623 };
			static constexpr uint16_t function_arg_names[] = { 23, 612, 561, 484, 50, 617, 620, 523, 624 };
	};
	constexpr uint16_t ReflectionMeshJoint::constructor_bases[];
	constexpr uint16_t ReflectionMeshJoint::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshJoint::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshJoint::function_names[];
	constexpr uint16_t ReflectionMeshJoint::function_types[];
	constexpr uint16_t ReflectionMeshJoint::function_bases[];
	constexpr uint16_t ReflectionMeshJoint::function_arg_types[];
	constexpr uint16_t ReflectionMeshJoint::function_arg_names[];
	static ReflectionMeshJoint reflection_mesh_joint;
	
	// Tellusim::MeshMaterial
	class ReflectionMeshMaterial : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshMaterial::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshMaterial, TypeList<const char*>>(nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<MeshMaterial, TypeList<MeshGeometry&, const char*>>(MeshGeometry::null, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshMaterial>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)()>(&MeshMaterial::clear));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*)>(&MeshMaterial::setName));
					case 2: return FunctionPtr(new FunctionImpl<String(MeshMaterial::*)() const>(&MeshMaterial::getName));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(MeshMaterial::*)() const>(&MeshMaterial::getIndex));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(MeshIndices&)>(&MeshMaterial::setIndices));
					case 5: return FunctionPtr(new FunctionImpl<const MeshIndices(MeshMaterial::*)() const>(&MeshMaterial::getIndices));
					case 6: return FunctionPtr(new FunctionImpl<MeshIndices(MeshMaterial::*)()>(&MeshMaterial::getIndices));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(MeshGeometry&, bool)>(&MeshMaterial::setGeometry, MeshGeometry::null, true));
					case 8: return FunctionPtr(new FunctionImpl<const MeshGeometry(MeshMaterial::*)() const>(&MeshMaterial::getGeometry));
					case 9: return FunctionPtr(new FunctionImpl<MeshGeometry(MeshMaterial::*)()>(&MeshMaterial::getGeometry));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*)>(&MeshMaterial::setData));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const String&)>(&MeshMaterial::setData));
					case 12: return FunctionPtr(new FunctionImpl<String(MeshMaterial::*)() const>(&MeshMaterial::getData));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)()>(&MeshMaterial::clearParameters));
					case 14: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)(const char*)>(&MeshMaterial::removeParameter));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const MeshMaterial&)>(&MeshMaterial::copyParameters));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(MeshMaterial::*)(const char*) const>(&MeshMaterial::findParameter));
					case 17: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)(const char*) const>(&MeshMaterial::hasParameter));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(MeshMaterial::*)() const>(&MeshMaterial::getNumParameters));
					case 19: return FunctionPtr(new FunctionImpl<String(MeshMaterial::*)(uint32_t) const>(&MeshMaterial::getParameterType));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*, bool)>(&MeshMaterial::addParameter));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*, float32_t)>(&MeshMaterial::addParameter));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*, const Vector4f&)>(&MeshMaterial::addParameter));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*, const Matrix3x2f&)>(&MeshMaterial::addParameter));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*, const Color&)>(&MeshMaterial::addParameter));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*, const char*, const char*)>(&MeshMaterial::addParameter, {}, {}, nullptr));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*, const String&, const char*)>(&MeshMaterial::addParameter, {}, {}, nullptr));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*, const Image&, const char*)>(&MeshMaterial::addParameter, {}, Image::null, nullptr));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)(const char*, Blob&, const char*)>(&MeshMaterial::addParameter, {}, Blob::null, nullptr));
					case 29: return FunctionPtr(new FunctionImpl<MeshMaterial::Flags(MeshMaterial::*)(uint32_t) const>(&MeshMaterial::getParameterFlags));
					case 30: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)(uint32_t, MeshMaterial::Flags) const>(&MeshMaterial::hasParameterFlag));
					case 31: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)(uint32_t, MeshMaterial::Flags) const>(&MeshMaterial::hasParameterFlags));
					case 32: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)(uint32_t, bool) const>(&MeshMaterial::getParameterBool, {}, false));
					case 33: return FunctionPtr(new FunctionImpl<float32_t(MeshMaterial::*)(uint32_t, float32_t) const>(&MeshMaterial::getParameterScalarf32, {}, 0.0f));
					case 34: return FunctionPtr(new FunctionImpl<const Vector4f&(MeshMaterial::*)(uint32_t, const Vector4f&) const>(&MeshMaterial::getParameterVector4f, {}, Vector4f::zero));
					case 35: return FunctionPtr(new FunctionImpl<const Matrix3x2f&(MeshMaterial::*)(uint32_t, const Matrix3x2f&) const>(&MeshMaterial::getParameterMatrix3x2f, {}, Matrix3x2f::identity));
					case 36: return FunctionPtr(new FunctionImpl<const Color&(MeshMaterial::*)(uint32_t, const Color&) const>(&MeshMaterial::getParameterColor, {}, Color::white));
					case 37: return FunctionPtr(new FunctionImpl<String(MeshMaterial::*)(uint32_t, const String&) const>(&MeshMaterial::getParameterName, {}, String::null));
					case 38: return FunctionPtr(new FunctionImpl<String(MeshMaterial::*)(uint32_t, const String&) const>(&MeshMaterial::getParameterLayout, {}, String::null));
					case 39: return FunctionPtr(new FunctionImpl<const Image(MeshMaterial::*)(uint32_t) const>(&MeshMaterial::getParameterImage));
					case 40: return FunctionPtr(new FunctionImpl<Blob(MeshMaterial::*)(uint32_t) const>(&MeshMaterial::getParameterBlob));
					case 41: return FunctionPtr(new FunctionImpl<Image(MeshMaterial::*)(uint32_t)>(&MeshMaterial::getParameterImage));
					case 42: return FunctionPtr(new FunctionImpl<Blob(MeshMaterial::*)(uint32_t)>(&MeshMaterial::getParameterBlob));
					case 43: return FunctionPtr(new FunctionImpl<MeshMaterial::Flags(MeshMaterial::*)(const char*) const>(&MeshMaterial::getParameterFlags));
					case 44: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)(const char*, MeshMaterial::Flags) const>(&MeshMaterial::hasParameterFlag));
					case 45: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)(const char*, MeshMaterial::Flags) const>(&MeshMaterial::hasParameterFlags));
					case 46: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)(const char*, bool) const>(&MeshMaterial::getParameterBool, {}, false));
					case 47: return FunctionPtr(new FunctionImpl<float32_t(MeshMaterial::*)(const char*, float32_t) const>(&MeshMaterial::getParameterScalarf32, {}, 0.0f));
					case 48: return FunctionPtr(new FunctionImpl<const Vector4f&(MeshMaterial::*)(const char*, const Vector4f&) const>(&MeshMaterial::getParameterVector4f, {}, Vector4f::zero));
					case 49: return FunctionPtr(new FunctionImpl<const Matrix3x2f&(MeshMaterial::*)(const char*, const Matrix3x2f&) const>(&MeshMaterial::getParameterMatrix3x2f, {}, Matrix3x2f::identity));
					case 50: return FunctionPtr(new FunctionImpl<const Color&(MeshMaterial::*)(const char*, const Color&) const>(&MeshMaterial::getParameterColor, {}, Color::white));
					case 51: return FunctionPtr(new FunctionImpl<String(MeshMaterial::*)(const char*, const String&) const>(&MeshMaterial::getParameterName, {}, String::null));
					case 52: return FunctionPtr(new FunctionImpl<String(MeshMaterial::*)(const char*, const String&) const>(&MeshMaterial::getParameterLayout, {}, String::null));
					case 53: return FunctionPtr(new FunctionImpl<int32_t(MeshMaterial::*)(const MeshMaterial&) const>(&MeshMaterial::compare));
					case 54: return FunctionPtr(new FunctionImpl<size_t(MeshMaterial::*)() const>(&MeshMaterial::getMemory));
					case 55: return FunctionPtr(new FunctionImpl<MeshMaterial(MeshMaterial::*)() const>(&MeshMaterial::clonePtr));
					case 56: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)()>(&MeshMaterial::clearPtr));
					case 57: return FunctionPtr(new FunctionVoidImpl<void(MeshMaterial::*)()>(&MeshMaterial::destroyPtr));
					case 58: return FunctionPtr(new FunctionImpl<MeshMaterial&(MeshMaterial::*)()>(&MeshMaterial::acquirePtr));
					case 59: return FunctionPtr(new FunctionImpl<MeshMaterial&(MeshMaterial::*)()>(&MeshMaterial::unacquirePtr));
					case 60: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)() const>(&MeshMaterial::isValidPtr));
					case 61: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)() const>(&MeshMaterial::isOwnerPtr));
					case 62: return FunctionPtr(new FunctionImpl<bool(MeshMaterial::*)() const>(&MeshMaterial::isConstPtr));
					case 63: return FunctionPtr(new FunctionImpl<uint32_t(MeshMaterial::*)() const>(&MeshMaterial::getCountPtr));
					case 64: return FunctionPtr(new FunctionImpl<const void*(MeshMaterial::*)() const>(&MeshMaterial::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 1, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 483, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 484, 23 };
			static constexpr uint16_t function_names[] = { 5, 172, 75, 460, 583, 585, 585, 544, 492, 492, 175, 175, 82, 626, 627, 628, 631, 632, 633, 634, 635, 635, 635, 635, 635, 635, 635, 635, 635, 641, 643, 645, 646, 647, 648, 650, 653, 655, 656, 657, 658, 657, 658, 641, 643, 645, 646, 647, 648, 650, 653, 655, 656, 449, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 16, 10, 6, 528, 528, 6, 493, 493, 6, 6, 16, 6, 21, 6, 10, 21, 10, 16, 6, 6, 6, 6, 6, 6, 6, 6, 6, 642, 21, 21, 21, 123, 521, 651, 654, 16, 16, 336, 165, 336, 165, 642, 21, 21, 21, 123, 521, 651, 654, 16, 16, 1, 74, 625, 625, 625, 625, 625, 625, 625, 625, 625, 625 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 2, 2, 2, 4, 4, 4, 5, 6, 6, 6, 7, 8, 9, 10, 10, 11, 13, 15, 17, 19, 21, 24, 27, 30, 33, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 53, 54, 55, 56, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76, 76 };
			static constexpr uint16_t function_arg_types[] = { 22, 584, 483, 21, 22, 94, 22, 629, 22, 22, 10, 22, 21, 22, 123, 22, 519, 22, 636, 22, 637, 22, 22, 22, 22, 94, 22, 22, 425, 22, 22, 640, 22, 10, 10, 644, 10, 644, 10, 21, 10, 123, 10, 519, 10, 636, 10, 637, 10, 94, 10, 94, 10, 10, 10, 10, 22, 22, 644, 22, 644, 22, 21, 22, 123, 22, 519, 22, 636, 22, 637, 22, 94, 22, 94, 629 };
			static constexpr uint16_t function_arg_names[] = { 23, 561, 484, 50, 167, 167, 195, 630, 195, 195, 274, 195, 105, 195, 105, 195, 105, 195, 105, 195, 638, 195, 23, 639, 195, 23, 639, 195, 450, 639, 195, 169, 639, 274, 274, 338, 274, 338, 274, 105, 274, 105, 274, 649, 274, 652, 274, 638, 274, 23, 274, 639, 274, 274, 274, 274, 195, 195, 338, 195, 338, 195, 105, 195, 105, 195, 649, 195, 652, 195, 638, 195, 23, 195, 639, 630 };
	};
	constexpr uint16_t ReflectionMeshMaterial::constructor_bases[];
	constexpr uint16_t ReflectionMeshMaterial::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshMaterial::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshMaterial::function_names[];
	constexpr uint16_t ReflectionMeshMaterial::function_types[];
	constexpr uint16_t ReflectionMeshMaterial::function_bases[];
	constexpr uint16_t ReflectionMeshMaterial::function_arg_types[];
	constexpr uint16_t ReflectionMeshMaterial::function_arg_names[];
	static ReflectionMeshMaterial reflection_mesh_material;
	
	// Tellusim::MeshGeometry
	class ReflectionMeshGeometry : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshGeometry::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshGeometry, TypeList<const char*>>(nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<MeshGeometry, TypeList<Mesh&, const char*>>(Mesh::null, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshGeometry>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)()>(&MeshGeometry::clear));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(const char*)>(&MeshGeometry::setName));
					case 2: return FunctionPtr(new FunctionImpl<String(MeshGeometry::*)() const>(&MeshGeometry::getName));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)() const>(&MeshGeometry::getIndex));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(Mesh&, bool)>(&MeshGeometry::setMesh, Mesh::null, true));
					case 5: return FunctionPtr(new FunctionImpl<const Mesh(MeshGeometry::*)() const>(&MeshGeometry::getMesh));
					case 6: return FunctionPtr(new FunctionImpl<Mesh(MeshGeometry::*)()>(&MeshGeometry::getMesh));
					case 7: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshGeometry&, bool)>(&MeshGeometry::setParent0, MeshGeometry::null, true));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshGeometry&, bool)>(&MeshGeometry::setParent1, MeshGeometry::null, true));
					case 9: return FunctionPtr(new FunctionImpl<const MeshGeometry(MeshGeometry::*)() const>(&MeshGeometry::getParent0));
					case 10: return FunctionPtr(new FunctionImpl<const MeshGeometry(MeshGeometry::*)() const>(&MeshGeometry::getParent1));
					case 11: return FunctionPtr(new FunctionImpl<MeshGeometry(MeshGeometry::*)()>(&MeshGeometry::getParent0));
					case 12: return FunctionPtr(new FunctionImpl<MeshGeometry(MeshGeometry::*)()>(&MeshGeometry::getParent1));
					case 13: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)() const>(&MeshGeometry::isRoot));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(uint32_t)>(&MeshGeometry::reserveChildren));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshGeometry&, bool)>(&MeshGeometry::addChild0, MeshGeometry::null, true));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshGeometry&, bool)>(&MeshGeometry::addChild1, MeshGeometry::null, true));
					case 17: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshGeometry&)>(&MeshGeometry::removeChild));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)()>(&MeshGeometry::releaseChildren));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const MeshGeometry&) const>(&MeshGeometry::findChild));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)() const>(&MeshGeometry::getNumChildren));
					case 21: return FunctionPtr(new FunctionImpl<const Array<MeshGeometry>(MeshGeometry::*)() const>(&MeshGeometry::getChildren));
					case 22: return FunctionPtr(new FunctionImpl<Array<MeshGeometry>(MeshGeometry::*)()>(&MeshGeometry::getChildren));
					case 23: return FunctionPtr(new FunctionImpl<const MeshGeometry(MeshGeometry::*)(uint32_t) const>(&MeshGeometry::getChild));
					case 24: return FunctionPtr(new FunctionImpl<MeshGeometry(MeshGeometry::*)(uint32_t)>(&MeshGeometry::getChild));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)()>(&MeshGeometry::clearIndices));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(uint32_t)>(&MeshGeometry::reserveIndices));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshIndices&, bool)>(&MeshGeometry::addIndices, MeshIndices::null, true));
					case 28: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshIndices&)>(&MeshGeometry::removeIndices));
					case 29: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshIndices&, MeshIndices&)>(&MeshGeometry::replaceIndices));
					case 30: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const MeshIndices&) const>(&MeshGeometry::findIndices));
					case 31: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshIndices::Type) const>(&MeshGeometry::findIndices));
					case 32: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshIndices::Type) const>(&MeshGeometry::hasIndices));
					case 33: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)() const>(&MeshGeometry::hasSolidIndices));
					case 34: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshIndices::Type) const>(&MeshGeometry::getNumIndices));
					case 35: return FunctionPtr(new FunctionImpl<const MeshIndices(MeshGeometry::*)(MeshIndices::Type) const>(&MeshGeometry::getIndices));
					case 36: return FunctionPtr(new FunctionImpl<MeshIndices(MeshGeometry::*)(MeshIndices::Type)>(&MeshGeometry::getIndices));
					case 37: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)() const>(&MeshGeometry::getNumIndices));
					case 38: return FunctionPtr(new FunctionImpl<const Array<MeshIndices>(MeshGeometry::*)() const>(&MeshGeometry::getIndices));
					case 39: return FunctionPtr(new FunctionImpl<Array<MeshIndices>(MeshGeometry::*)()>(&MeshGeometry::getIndices));
					case 40: return FunctionPtr(new FunctionImpl<const MeshIndices(MeshGeometry::*)(uint32_t) const>(&MeshGeometry::getIndices));
					case 41: return FunctionPtr(new FunctionImpl<MeshIndices(MeshGeometry::*)(uint32_t)>(&MeshGeometry::getIndices));
					case 42: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)()>(&MeshGeometry::clearAttributes));
					case 43: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(uint32_t)>(&MeshGeometry::reserveAttributes));
					case 44: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshAttribute&, bool)>(&MeshGeometry::addAttribute, MeshAttribute::null, true));
					case 45: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshAttribute&, MeshIndices&, bool)>(&MeshGeometry::addAttribute, MeshAttribute::null, MeshIndices::null, true));
					case 46: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshAttribute&)>(&MeshGeometry::removeAttribute));
					case 47: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshAttribute&, MeshAttribute&)>(&MeshGeometry::replaceAttribute));
					case 48: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(const MeshIndices&, MeshIndices&)>(&MeshGeometry::replaceAttributeIndices));
					case 49: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshAttribute::Type, Format, uint32_t) const>(&MeshGeometry::findAttribute, {}, (Format)0, 0));
					case 50: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshAttribute::Type, uint32_t) const>(&MeshGeometry::findAttribute, {}, 0));
					case 51: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const char*, uint32_t) const>(&MeshGeometry::findAttribute, {}, 0));
					case 52: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const MeshAttribute&) const>(&MeshGeometry::findAttribute));
					case 53: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshAttribute::Type, Format, uint32_t) const>(&MeshGeometry::hasAttribute, {}, (Format)0, 0));
					case 54: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshAttribute::Type, uint32_t) const>(&MeshGeometry::hasAttribute, {}, 0));
					case 55: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(const char*, uint32_t) const>(&MeshGeometry::hasAttribute, {}, 0));
					case 56: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(const MeshAttribute&) const>(&MeshGeometry::hasAttribute));
					case 57: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshAttribute::Type) const>(&MeshGeometry::getNumAttributes));
					case 58: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const MeshIndices&) const>(&MeshGeometry::getNumAttributes));
					case 59: return FunctionPtr(new FunctionImpl<const MeshAttribute(MeshGeometry::*)(MeshAttribute::Type, uint32_t) const>(&MeshGeometry::getAttribute, {}, 0));
					case 60: return FunctionPtr(new FunctionImpl<MeshAttribute(MeshGeometry::*)(MeshAttribute::Type, uint32_t)>(&MeshGeometry::getAttribute, {}, 0));
					case 61: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)() const>(&MeshGeometry::getNumAttributes));
					case 62: return FunctionPtr(new FunctionImpl<const Array<MeshAttribute>(MeshGeometry::*)() const>(&MeshGeometry::getAttributes));
					case 63: return FunctionPtr(new FunctionImpl<Array<MeshAttribute>(MeshGeometry::*)()>(&MeshGeometry::getAttributes));
					case 64: return FunctionPtr(new FunctionImpl<const MeshAttribute(MeshGeometry::*)(uint32_t) const>(&MeshGeometry::getAttribute));
					case 65: return FunctionPtr(new FunctionImpl<MeshAttribute(MeshGeometry::*)(uint32_t)>(&MeshGeometry::getAttribute));
					case 66: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)()>(&MeshGeometry::clearJoints));
					case 67: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(uint32_t)>(&MeshGeometry::reserveJoints));
					case 68: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshJoint&, bool)>(&MeshGeometry::addJoint, MeshJoint::null, true));
					case 69: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshJoint&, MeshNode&, bool)>(&MeshGeometry::addJoint, MeshJoint::null, MeshNode::null, true));
					case 70: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshJoint&)>(&MeshGeometry::removeJoint));
					case 71: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshJoint&, MeshJoint&)>(&MeshGeometry::replaceJoint));
					case 72: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const MeshJoint&) const>(&MeshGeometry::findJoint));
					case 73: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const MeshNode&) const>(&MeshGeometry::findJoint));
					case 74: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const char*) const>(&MeshGeometry::findJoint));
					case 75: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)() const>(&MeshGeometry::getNumJoints));
					case 76: return FunctionPtr(new FunctionImpl<const Array<MeshJoint>(MeshGeometry::*)() const>(&MeshGeometry::getJoints));
					case 77: return FunctionPtr(new FunctionImpl<Array<MeshJoint>(MeshGeometry::*)()>(&MeshGeometry::getJoints));
					case 78: return FunctionPtr(new FunctionImpl<const MeshJoint(MeshGeometry::*)(uint32_t) const>(&MeshGeometry::getJoint));
					case 79: return FunctionPtr(new FunctionImpl<MeshJoint(MeshGeometry::*)(uint32_t)>(&MeshGeometry::getJoint));
					case 80: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)()>(&MeshGeometry::clearMaterials));
					case 81: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(uint32_t)>(&MeshGeometry::reserveMaterials));
					case 82: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshMaterial&, bool)>(&MeshGeometry::addMaterial, MeshMaterial::null, true));
					case 83: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(MeshMaterial&, MeshIndices&, bool)>(&MeshGeometry::addMaterial, MeshMaterial::null, MeshIndices::null, true));
					case 84: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshMaterial&)>(&MeshGeometry::removeMaterial));
					case 85: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(MeshMaterial&, MeshMaterial&)>(&MeshGeometry::replaceMaterial));
					case 86: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const MeshMaterial&) const>(&MeshGeometry::findMaterial));
					case 87: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(const char*) const>(&MeshGeometry::findMaterial));
					case 88: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)() const>(&MeshGeometry::getNumMaterials));
					case 89: return FunctionPtr(new FunctionImpl<const Array<MeshMaterial>(MeshGeometry::*)() const>(&MeshGeometry::getMaterials));
					case 90: return FunctionPtr(new FunctionImpl<Array<MeshMaterial>(MeshGeometry::*)()>(&MeshGeometry::getMaterials));
					case 91: return FunctionPtr(new FunctionImpl<const MeshMaterial(MeshGeometry::*)(uint32_t) const>(&MeshGeometry::getMaterial));
					case 92: return FunctionPtr(new FunctionImpl<MeshMaterial(MeshGeometry::*)(uint32_t)>(&MeshGeometry::getMaterial));
					case 93: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(const BoundBoxf&)>(&MeshGeometry::setBoundBox));
					case 94: return FunctionPtr(new FunctionImpl<const BoundBoxf&(MeshGeometry::*)() const>(&MeshGeometry::getBoundBox));
					case 95: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(const BoundSpheref&)>(&MeshGeometry::setBoundSphere));
					case 96: return FunctionPtr(new FunctionImpl<const BoundSpheref&(MeshGeometry::*)() const>(&MeshGeometry::getBoundSphere));
					case 97: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(const Vector3f&)>(&MeshGeometry::setTransform));
					case 98: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(const Matrix4x3f&, bool)>(&MeshGeometry::setTransform, {}, false));
					case 99: return FunctionPtr(new FunctionImpl<const Matrix4x3f&(MeshGeometry::*)() const>(&MeshGeometry::getTransform));
					case 100: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(const Matrix4x3f&)>(&MeshGeometry::setJointITransform));
					case 101: return FunctionPtr(new FunctionImpl<const Matrix4x3f&(MeshGeometry::*)() const>(&MeshGeometry::getJointITransform));
					case 102: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(float32_t)>(&MeshGeometry::setMinVisibility));
					case 103: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(float32_t)>(&MeshGeometry::setMaxVisibility));
					case 104: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(float32_t, float32_t)>(&MeshGeometry::setVisibilityRange));
					case 105: return FunctionPtr(new FunctionImpl<float32_t(MeshGeometry::*)() const>(&MeshGeometry::getMinVisibility));
					case 106: return FunctionPtr(new FunctionImpl<float32_t(MeshGeometry::*)() const>(&MeshGeometry::getMaxVisibility));
					case 107: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)() const>(&MeshGeometry::hasVisibilityRange));
					case 108: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)(float32_t)>(&MeshGeometry::setVisibilityError));
					case 109: return FunctionPtr(new FunctionImpl<float32_t(MeshGeometry::*)() const>(&MeshGeometry::getVisibilityError));
					case 110: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(bool, uint32_t)>(&MeshGeometry::createBounds, false, Maxu32));
					case 111: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(bool, uint32_t, uint32_t, uint32_t, bool)>(&MeshGeometry::createBasis, false, Maxu32, Maxu32, Maxu32, false));
					case 112: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(float32_t, bool, uint32_t, uint32_t, uint32_t, bool)>(&MeshGeometry::createBasis, {}, false, Maxu32, Maxu32, Maxu32, false));
					case 113: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(bool, uint32_t, bool)>(&MeshGeometry::createNormals, false, Maxu32, false));
					case 114: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(float32_t, bool, uint32_t, bool)>(&MeshGeometry::createNormals, {}, false, Maxu32, false));
					case 115: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(bool, uint32_t, uint32_t, uint32_t, bool)>(&MeshGeometry::createTangents, false, Maxu32, Maxu32, Maxu32, false));
					case 116: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)(uint32_t, uint32_t, bool, uint32_t, uint32_t, bool)>(&MeshGeometry::createIslands, {}, {}, false, Maxu32, Maxu32, false));
					case 117: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(uint32_t, bool, uint32_t, uint32_t)>(&MeshGeometry::optimizeIndices, 32, false, Maxu32, Maxu32));
					case 118: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(uint32_t)>(&MeshGeometry::optimizeAttributes, Maxu32));
					case 119: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)()>(&MeshGeometry::optimizeMaterials));
					case 120: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(bool)>(&MeshGeometry::packAttributes, true));
					case 121: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)(bool)>(&MeshGeometry::unpackAttributes, true));
					case 122: return FunctionPtr(new FunctionImpl<int32_t(MeshGeometry::*)(const MeshGeometry&, const Matrix4x3f&, float32_t, bool) const>(&MeshGeometry::compare, MeshGeometry::null, Matrix4x3f::identity, 1e-6f, true));
					case 123: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)() const>(&MeshGeometry::isOptimized));
					case 124: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)() const>(&MeshGeometry::validate));
					case 125: return FunctionPtr(new FunctionImpl<size_t(MeshGeometry::*)() const>(&MeshGeometry::getMemory));
					case 126: return FunctionPtr(new FunctionImpl<MeshGeometry(MeshGeometry::*)() const>(&MeshGeometry::clonePtr));
					case 127: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)()>(&MeshGeometry::clearPtr));
					case 128: return FunctionPtr(new FunctionVoidImpl<void(MeshGeometry::*)()>(&MeshGeometry::destroyPtr));
					case 129: return FunctionPtr(new FunctionImpl<MeshGeometry&(MeshGeometry::*)()>(&MeshGeometry::acquirePtr));
					case 130: return FunctionPtr(new FunctionImpl<MeshGeometry&(MeshGeometry::*)()>(&MeshGeometry::unacquirePtr));
					case 131: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)() const>(&MeshGeometry::isValidPtr));
					case 132: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)() const>(&MeshGeometry::isOwnerPtr));
					case 133: return FunctionPtr(new FunctionImpl<bool(MeshGeometry::*)() const>(&MeshGeometry::isConstPtr));
					case 134: return FunctionPtr(new FunctionImpl<uint32_t(MeshGeometry::*)() const>(&MeshGeometry::getCountPtr));
					case 135: return FunctionPtr(new FunctionImpl<const void*(MeshGeometry::*)() const>(&MeshGeometry::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 1, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 455, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 456, 23 };
			static constexpr uint16_t function_names[] = { 5, 172, 75, 460, 461, 462, 462, 659, 660, 661, 662, 661, 662, 467, 468, 663, 664, 472, 473, 474, 476, 477, 477, 478, 478, 665, 666, 562, 668, 669, 671, 671, 672, 673, 674, 585, 585, 674, 585, 585, 585, 585, 675, 676, 593, 593, 678, 679, 681, 682, 682, 682, 682, 683, 683, 683, 683, 684, 684, 685, 685, 684, 686, 686, 685, 685, 687, 688, 690, 690, 692, 693, 695, 695, 695, 696, 697, 697, 698, 698, 699, 700, 702, 702, 704, 705, 707, 707, 708, 709, 709, 710, 710, 615, 606, 618, 608, 525, 525, 713, 714, 715, 716, 718, 719, 721, 722, 723, 724, 726, 727, 730, 730, 733, 733, 734, 736, 739, 742, 743, 596, 599, 449, 744, 745, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 16, 10, 6, 463, 463, 10, 10, 493, 493, 493, 493, 21, 6, 10, 10, 21, 6, 10, 10, 19, 19, 493, 493, 6, 6, 10, 21, 21, 10, 10, 21, 21, 10, 528, 528, 10, 19, 19, 528, 528, 6, 6, 10, 10, 21, 21, 21, 10, 10, 10, 10, 21, 21, 21, 21, 10, 10, 566, 566, 10, 19, 19, 566, 566, 6, 6, 10, 10, 21, 21, 10, 10, 10, 10, 19, 19, 610, 610, 6, 6, 10, 10, 21, 21, 10, 10, 10, 19, 19, 625, 625, 6, 607, 6, 609, 21, 21, 604, 6, 604, 6, 6, 6, 123, 123, 21, 6, 123, 21, 10, 10, 10, 10, 10, 10, 21, 21, 6, 21, 21, 1, 21, 21, 74, 493, 493, 493, 493, 493, 493, 493, 493, 493, 493 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 3, 3, 3, 5, 7, 7, 7, 7, 7, 7, 8, 10, 12, 13, 13, 14, 14, 14, 14, 15, 16, 16, 17, 19, 20, 22, 23, 24, 25, 25, 26, 27, 28, 28, 28, 28, 29, 30, 30, 31, 33, 36, 37, 39, 41, 44, 46, 48, 49, 52, 54, 56, 57, 58, 59, 61, 63, 63, 63, 63, 64, 65, 65, 66, 68, 71, 72, 74, 75, 76, 77, 77, 77, 77, 78, 79, 79, 80, 82, 85, 86, 88, 89, 90, 90, 90, 90, 91, 92, 93, 93, 94, 94, 95, 97, 97, 98, 98, 99, 100, 102, 102, 102, 102, 103, 103, 105, 110, 116, 119, 123, 128, 134, 138, 139, 139, 140, 141, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145, 145 };
			static constexpr uint16_t function_arg_types[] = { 22, 455, 21, 483, 21, 483, 21, 10, 483, 21, 483, 21, 483, 489, 10, 10, 10, 584, 21, 584, 584, 584, 560, 529, 529, 529, 529, 529, 10, 10, 10, 600, 21, 600, 584, 21, 600, 600, 600, 560, 584, 567, 340, 10, 567, 10, 22, 10, 564, 567, 340, 10, 567, 10, 22, 10, 564, 567, 560, 567, 10, 567, 10, 10, 10, 10, 691, 21, 691, 465, 21, 691, 691, 691, 623, 475, 22, 10, 10, 10, 703, 21, 703, 584, 21, 703, 703, 703, 629, 22, 10, 10, 616, 619, 711, 590, 21, 590, 123, 123, 123, 123, 123, 21, 10, 21, 10, 10, 10, 21, 123, 21, 10, 10, 10, 21, 21, 10, 21, 123, 21, 10, 21, 21, 10, 10, 10, 21, 10, 10, 21, 10, 10, 21, 10, 21, 10, 10, 10, 21, 21, 489, 590, 123, 21 };
			static constexpr uint16_t function_arg_names[] = { 23, 456, 50, 458, 50, 458, 50, 469, 471, 50, 471, 50, 471, 471, 274, 274, 667, 561, 50, 561, 670, 561, 561, 195, 195, 195, 195, 195, 274, 274, 677, 589, 50, 589, 561, 50, 589, 680, 589, 670, 561, 195, 96, 274, 195, 274, 23, 274, 589, 195, 96, 274, 195, 274, 23, 274, 589, 195, 561, 195, 274, 195, 274, 274, 274, 689, 624, 50, 624, 612, 50, 624, 694, 624, 624, 612, 23, 274, 274, 701, 630, 50, 630, 561, 50, 630, 706, 630, 630, 23, 274, 274, 617, 620, 527, 511, 712, 523, 717, 717, 445, 720, 725, 728, 729, 728, 729, 731, 732, 46, 442, 728, 729, 731, 732, 46, 728, 729, 46, 442, 728, 729, 46, 728, 729, 731, 735, 46, 737, 738, 728, 274, 729, 46, 740, 741, 274, 729, 630, 192, 192, 484, 511, 591, 592 };
	};
	constexpr uint16_t ReflectionMeshGeometry::constructor_bases[];
	constexpr uint16_t ReflectionMeshGeometry::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshGeometry::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshGeometry::function_names[];
	constexpr uint16_t ReflectionMeshGeometry::function_types[];
	constexpr uint16_t ReflectionMeshGeometry::function_bases[];
	constexpr uint16_t ReflectionMeshGeometry::function_arg_types[];
	constexpr uint16_t ReflectionMeshGeometry::function_arg_names[];
	static ReflectionMeshGeometry reflection_mesh_geometry;
	
	// Tellusim::MeshTransform
	class ReflectionMeshTransform : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshTransform::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshTransform, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshTransform>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)()>(&MeshTransform::clear));
					case 1: return FunctionPtr(new FunctionImpl<float64_t(MeshTransform::*)() const>(&MeshTransform::getMinTime));
					case 2: return FunctionPtr(new FunctionImpl<float64_t(MeshTransform::*)() const>(&MeshTransform::getMaxTime));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(float64_t, const Matrix4x3d&, float32_t)>(&MeshTransform::setTransform, {}, {}, 1e-6f));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(float64_t, const Vector3d&, float32_t)>(&MeshTransform::setTranslate, {}, {}, 1e-6f));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(float64_t, const Quaternionf&, float32_t)>(&MeshTransform::setRotate, {}, {}, 1e-6f));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(float64_t, const Vector3f&, float32_t)>(&MeshTransform::setScale, {}, {}, 1e-6f));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(float64_t, const Vector4f&, float32_t)>(&MeshTransform::setMorph, {}, {}, 1e-6f));
					case 8: return FunctionPtr(new FunctionImpl<Matrix4x3d(MeshTransform::*)(float64_t) const>(&MeshTransform::getTransform));
					case 9: return FunctionPtr(new FunctionImpl<Vector3d(MeshTransform::*)(float64_t) const>(&MeshTransform::getTranslate));
					case 10: return FunctionPtr(new FunctionImpl<Quaternionf(MeshTransform::*)(float64_t) const>(&MeshTransform::getRotate));
					case 11: return FunctionPtr(new FunctionImpl<Vector3f(MeshTransform::*)(float64_t) const>(&MeshTransform::getScale));
					case 12: return FunctionPtr(new FunctionImpl<Vector4f(MeshTransform::*)(float64_t) const>(&MeshTransform::getMorph));
					case 13: return FunctionPtr(new FunctionImpl<bool(MeshTransform::*)() const>(&MeshTransform::hasTransformKeys));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(const MeshTransform::TranslateKeys&, float64_t)>(&MeshTransform::setTranslateKeys, {}, 1.0));
					case 15: return FunctionPtr(new FunctionImpl<MeshTransform::TranslateKeys(MeshTransform::*)() const>(&MeshTransform::getTranslateKeys));
					case 16: return FunctionPtr(new FunctionImpl<bool(MeshTransform::*)() const>(&MeshTransform::hasTranslateKeys));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(const MeshTransform::RotateKeys&)>(&MeshTransform::setRotateKeys));
					case 18: return FunctionPtr(new FunctionImpl<MeshTransform::RotateKeys(MeshTransform::*)() const>(&MeshTransform::getRotateKeys));
					case 19: return FunctionPtr(new FunctionImpl<bool(MeshTransform::*)() const>(&MeshTransform::hasRotateKeys));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(const MeshTransform::ScaleKeys&)>(&MeshTransform::setScaleKeys));
					case 21: return FunctionPtr(new FunctionImpl<MeshTransform::ScaleKeys(MeshTransform::*)() const>(&MeshTransform::getScaleKeys));
					case 22: return FunctionPtr(new FunctionImpl<bool(MeshTransform::*)() const>(&MeshTransform::hasScaleKeys));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(const MeshTransform::MorphKeys&)>(&MeshTransform::setMorphKeys));
					case 24: return FunctionPtr(new FunctionImpl<MeshTransform::MorphKeys(MeshTransform::*)() const>(&MeshTransform::getMorphKeys));
					case 25: return FunctionPtr(new FunctionImpl<bool(MeshTransform::*)() const>(&MeshTransform::hasMorphKeys));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(const Vector3d&)>(&MeshTransform::setTransform));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)(const Matrix4x3d&)>(&MeshTransform::setTransform));
					case 28: return FunctionPtr(new FunctionImpl<size_t(MeshTransform::*)() const>(&MeshTransform::getMemory));
					case 29: return FunctionPtr(new FunctionImpl<MeshTransform(MeshTransform::*)() const>(&MeshTransform::clonePtr));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)()>(&MeshTransform::clearPtr));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(MeshTransform::*)()>(&MeshTransform::destroyPtr));
					case 32: return FunctionPtr(new FunctionImpl<MeshTransform&(MeshTransform::*)()>(&MeshTransform::acquirePtr));
					case 33: return FunctionPtr(new FunctionImpl<MeshTransform&(MeshTransform::*)()>(&MeshTransform::unacquirePtr));
					case 34: return FunctionPtr(new FunctionImpl<bool(MeshTransform::*)() const>(&MeshTransform::isValidPtr));
					case 35: return FunctionPtr(new FunctionImpl<bool(MeshTransform::*)() const>(&MeshTransform::isOwnerPtr));
					case 36: return FunctionPtr(new FunctionImpl<bool(MeshTransform::*)() const>(&MeshTransform::isConstPtr));
					case 37: return FunctionPtr(new FunctionImpl<uint32_t(MeshTransform::*)() const>(&MeshTransform::getCountPtr));
					case 38: return FunctionPtr(new FunctionImpl<const void*(MeshTransform::*)() const>(&MeshTransform::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 747, 748, 525, 749, 751, 754, 755, 713, 757, 759, 761, 763, 764, 765, 768, 770, 771, 773, 775, 776, 778, 780, 781, 783, 785, 525, 525, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 126, 126, 6, 6, 6, 6, 6, 513, 758, 760, 762, 521, 21, 6, 769, 21, 6, 774, 21, 6, 779, 21, 6, 784, 21, 6, 6, 74, 746, 746, 746, 746, 746, 746, 746, 746, 746, 746 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 3, 6, 9, 12, 15, 16, 17, 18, 19, 20, 20, 22, 22, 22, 23, 23, 23, 24, 24, 24, 25, 25, 25, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27 };
			static constexpr uint16_t function_arg_types[] = { 126, 510, 123, 126, 526, 123, 126, 752, 123, 126, 711, 123, 126, 519, 123, 126, 126, 126, 126, 126, 766, 126, 772, 777, 782, 526, 510 };
			static constexpr uint16_t function_arg_names[] = { 238, 511, 591, 238, 750, 591, 238, 753, 591, 238, 527, 591, 238, 756, 591, 238, 238, 238, 238, 238, 767, 527, 767, 767, 767, 527, 511 };
	};
	constexpr uint16_t ReflectionMeshTransform::constructor_bases[];
	constexpr uint16_t ReflectionMeshTransform::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshTransform::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshTransform::function_names[];
	constexpr uint16_t ReflectionMeshTransform::function_types[];
	constexpr uint16_t ReflectionMeshTransform::function_bases[];
	constexpr uint16_t ReflectionMeshTransform::function_arg_types[];
	constexpr uint16_t ReflectionMeshTransform::function_arg_names[];
	static ReflectionMeshTransform reflection_mesh_transform;
	
	// Tellusim::MeshAnimation
	class ReflectionMeshAnimation : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshAnimation::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshAnimation, TypeList<const char*>>(nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<MeshAnimation, TypeList<Mesh&, const char*>>(Mesh::null, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshAnimation>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)()>(&MeshAnimation::clear));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(MeshAnimation::*)() const>(&MeshAnimation::getIndex));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(const char*)>(&MeshAnimation::setName));
					case 3: return FunctionPtr(new FunctionImpl<String(MeshAnimation::*)() const>(&MeshAnimation::getName));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(Mesh&, bool)>(&MeshAnimation::setMesh, Mesh::null, true));
					case 5: return FunctionPtr(new FunctionImpl<const Mesh(MeshAnimation::*)() const>(&MeshAnimation::getMesh));
					case 6: return FunctionPtr(new FunctionImpl<Mesh(MeshAnimation::*)()>(&MeshAnimation::getMesh));
					case 7: return FunctionPtr(new FunctionImpl<float64_t(MeshAnimation::*)() const>(&MeshAnimation::getMinTime));
					case 8: return FunctionPtr(new FunctionImpl<float64_t(MeshAnimation::*)() const>(&MeshAnimation::getMaxTime));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(uint32_t)>(&MeshAnimation::setNumTransforms));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(MeshAnimation::*)() const>(&MeshAnimation::getNumTransforms));
					case 11: return FunctionPtr(new FunctionImpl<const Array<MeshTransform>(MeshAnimation::*)() const>(&MeshAnimation::getTransforms));
					case 12: return FunctionPtr(new FunctionImpl<Array<MeshTransform>(MeshAnimation::*)()>(&MeshAnimation::getTransforms));
					case 13: return FunctionPtr(new FunctionImpl<const MeshTransform(MeshAnimation::*)(uint32_t) const>(&MeshAnimation::getTransform));
					case 14: return FunctionPtr(new FunctionImpl<MeshTransform(MeshAnimation::*)(uint32_t)>(&MeshAnimation::getTransform));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(float64_t, uint32_t, const Matrix4x3d&, float32_t)>(&MeshAnimation::setTransform, {}, {}, {}, 1e-6f));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(float64_t, uint32_t, const Vector3d&, float32_t)>(&MeshAnimation::setTranslate, {}, {}, {}, 1e-6f));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(float64_t, uint32_t, const Quaternionf&, float32_t)>(&MeshAnimation::setRotate, {}, {}, {}, 1e-6f));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(float64_t, uint32_t, const Vector3f&, float32_t)>(&MeshAnimation::setScale, {}, {}, {}, 1e-6f));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(float64_t, uint32_t, const Vector4f&, float32_t)>(&MeshAnimation::setMorph, {}, {}, {}, 1e-6f));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(float64_t, const Matrix4x3d&, bool, float64_t, float64_t)>(&MeshAnimation::setTime, {}, Matrix4x3d::identity, true, -Maxf32, Maxf32));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(float64_t, bool, float64_t, float64_t)>(&MeshAnimation::setTime, {}, {}, -Maxf32, Maxf32));
					case 22: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshAnimation::*)(uint32_t) const>(&MeshAnimation::getLocalTransform));
					case 23: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshAnimation::*)(const MeshNode&) const>(&MeshAnimation::getLocalTransform));
					case 24: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshAnimation::*)(const MeshJoint&) const>(&MeshAnimation::getLocalTransform));
					case 25: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshAnimation::*)(uint32_t) const>(&MeshAnimation::getGlobalTransform));
					case 26: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshAnimation::*)(const MeshNode&) const>(&MeshAnimation::getGlobalTransform));
					case 27: return FunctionPtr(new FunctionImpl<const Matrix4x3d&(MeshAnimation::*)(const MeshJoint&) const>(&MeshAnimation::getGlobalTransform));
					case 28: return FunctionPtr(new FunctionImpl<const Vector4f&(MeshAnimation::*)(uint32_t) const>(&MeshAnimation::getMorphTransform));
					case 29: return FunctionPtr(new FunctionImpl<const Vector4f&(MeshAnimation::*)(const MeshNode&) const>(&MeshAnimation::getMorphTransform));
					case 30: return FunctionPtr(new FunctionImpl<BoundBoxd(MeshAnimation::*)() const>(&MeshAnimation::getBoundBox));
					case 31: return FunctionPtr(new FunctionImpl<BoundBoxd(MeshAnimation::*)(const MeshNode&) const>(&MeshAnimation::getBoundBox));
					case 32: return FunctionPtr(new FunctionImpl<BoundBoxd(MeshAnimation::*)(const MeshGeometry&) const>(&MeshAnimation::getBoundBox));
					case 33: return FunctionPtr(new FunctionImpl<BoundBoxd(MeshAnimation::*)(const MeshGeometry&, const Vector4f&) const>(&MeshAnimation::getBoundBox));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(const Vector3d&)>(&MeshAnimation::setTransform));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(const Matrix4x3d&)>(&MeshAnimation::setTransform));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)(float32_t)>(&MeshAnimation::optimizeTransforms, 1e-6f));
					case 37: return FunctionPtr(new FunctionImpl<size_t(MeshAnimation::*)() const>(&MeshAnimation::getMemory));
					case 38: return FunctionPtr(new FunctionImpl<MeshAnimation(MeshAnimation::*)() const>(&MeshAnimation::clonePtr));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)()>(&MeshAnimation::clearPtr));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(MeshAnimation::*)()>(&MeshAnimation::destroyPtr));
					case 41: return FunctionPtr(new FunctionImpl<MeshAnimation&(MeshAnimation::*)()>(&MeshAnimation::acquirePtr));
					case 42: return FunctionPtr(new FunctionImpl<MeshAnimation&(MeshAnimation::*)()>(&MeshAnimation::unacquirePtr));
					case 43: return FunctionPtr(new FunctionImpl<bool(MeshAnimation::*)() const>(&MeshAnimation::isValidPtr));
					case 44: return FunctionPtr(new FunctionImpl<bool(MeshAnimation::*)() const>(&MeshAnimation::isOwnerPtr));
					case 45: return FunctionPtr(new FunctionImpl<bool(MeshAnimation::*)() const>(&MeshAnimation::isConstPtr));
					case 46: return FunctionPtr(new FunctionImpl<uint32_t(MeshAnimation::*)() const>(&MeshAnimation::getCountPtr));
					case 47: return FunctionPtr(new FunctionImpl<const void*(MeshAnimation::*)() const>(&MeshAnimation::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 1, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 455, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 456, 23 };
			static constexpr uint16_t function_names[] = { 5, 460, 172, 75, 461, 462, 462, 747, 748, 787, 789, 790, 790, 713, 713, 525, 749, 751, 754, 755, 240, 240, 512, 512, 512, 515, 515, 515, 520, 520, 606, 606, 606, 606, 525, 525, 795, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 6, 16, 6, 463, 463, 126, 126, 6, 10, 19, 19, 746, 746, 6, 6, 6, 6, 6, 6, 6, 513, 513, 513, 513, 513, 513, 521, 521, 794, 794, 794, 794, 6, 6, 6, 74, 786, 786, 786, 786, 786, 786, 786, 786, 786, 786 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 1, 1, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 6, 10, 14, 18, 22, 26, 31, 35, 36, 37, 38, 39, 40, 41, 42, 43, 43, 44, 45, 47, 48, 49, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50 };
			static constexpr uint16_t function_arg_types[] = { 22, 455, 21, 10, 10, 10, 126, 10, 510, 123, 126, 10, 526, 123, 126, 10, 752, 123, 126, 10, 711, 123, 126, 10, 519, 123, 126, 510, 21, 126, 126, 126, 21, 126, 126, 10, 475, 623, 10, 475, 623, 10, 475, 475, 489, 489, 519, 526, 510, 123 };
			static constexpr uint16_t function_arg_names[] = { 23, 456, 50, 788, 612, 612, 238, 612, 511, 591, 238, 612, 750, 591, 238, 612, 753, 591, 238, 612, 527, 591, 238, 612, 756, 591, 238, 511, 791, 792, 793, 238, 791, 792, 793, 612, 612, 624, 612, 612, 624, 612, 612, 612, 484, 484, 756, 527, 511, 591 };
	};
	constexpr uint16_t ReflectionMeshAnimation::constructor_bases[];
	constexpr uint16_t ReflectionMeshAnimation::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshAnimation::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshAnimation::function_names[];
	constexpr uint16_t ReflectionMeshAnimation::function_types[];
	constexpr uint16_t ReflectionMeshAnimation::function_bases[];
	constexpr uint16_t ReflectionMeshAnimation::function_arg_types[];
	constexpr uint16_t ReflectionMeshAnimation::function_arg_names[];
	static ReflectionMeshAnimation reflection_mesh_animation;
	
	// Tellusim::MeshAttachment
	class ReflectionMeshAttachment : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshAttachment::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshAttachment, TypeList<const char*>>(nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<MeshAttachment, TypeList<MeshAttachment::Type, const char*>>((MeshAttachment::Type)0, nullptr));
					case 2: return ConstructorPtr(new ConstructorImpl<MeshAttachment, TypeList<MeshNode&, const char*>>(MeshNode::null, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshAttachment>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)()>(&MeshAttachment::clear));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(MeshAttachment::Type)>(&MeshAttachment::setType));
					case 2: return FunctionPtr(new FunctionImpl<MeshAttachment::Type(MeshAttachment::*)() const>(&MeshAttachment::getType));
					case 3: return FunctionPtr(new FunctionImpl<const char*(MeshAttachment::Type)>(&MeshAttachment::getTypeName));
					case 4: return FunctionPtr(new FunctionImpl<const char*(MeshAttachment::*)() const>(&MeshAttachment::getTypeName));
					case 5: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)() const>(&MeshAttachment::isUnknown));
					case 6: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)() const>(&MeshAttachment::isLight));
					case 7: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)() const>(&MeshAttachment::isCamera));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const char*)>(&MeshAttachment::setName));
					case 9: return FunctionPtr(new FunctionImpl<String(MeshAttachment::*)() const>(&MeshAttachment::getName));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(MeshNode&, bool)>(&MeshAttachment::setNode, MeshNode::null, true));
					case 11: return FunctionPtr(new FunctionImpl<const MeshNode(MeshAttachment::*)() const>(&MeshAttachment::getNode));
					case 12: return FunctionPtr(new FunctionImpl<MeshNode(MeshAttachment::*)()>(&MeshAttachment::getNode));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const char*)>(&MeshAttachment::setData));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const String&)>(&MeshAttachment::setData));
					case 15: return FunctionPtr(new FunctionImpl<String(MeshAttachment::*)() const>(&MeshAttachment::getData));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)()>(&MeshAttachment::clearParameters));
					case 17: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)(const char*)>(&MeshAttachment::removeParameter));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const MeshAttachment&)>(&MeshAttachment::copyParameters));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(MeshAttachment::*)(const char*) const>(&MeshAttachment::findParameter));
					case 20: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)(const char*) const>(&MeshAttachment::hasParameter));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(MeshAttachment::*)() const>(&MeshAttachment::getNumParameters));
					case 22: return FunctionPtr(new FunctionImpl<String(MeshAttachment::*)(uint32_t) const>(&MeshAttachment::getParameterType));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const char*, bool)>(&MeshAttachment::addParameter));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const char*, float32_t)>(&MeshAttachment::addParameter));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const char*, const Vector4f&)>(&MeshAttachment::addParameter));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const char*, const Color&)>(&MeshAttachment::addParameter));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const char*, const char*)>(&MeshAttachment::addParameter));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const char*, const String&)>(&MeshAttachment::addParameter));
					case 29: return FunctionPtr(new FunctionImpl<MeshAttachment::Flags(MeshAttachment::*)(uint32_t) const>(&MeshAttachment::getParameterFlags));
					case 30: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)(uint32_t, MeshAttachment::Flags) const>(&MeshAttachment::hasParameterFlag));
					case 31: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)(uint32_t, MeshAttachment::Flags) const>(&MeshAttachment::hasParameterFlags));
					case 32: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)(uint32_t, bool) const>(&MeshAttachment::getParameterBool, {}, false));
					case 33: return FunctionPtr(new FunctionImpl<float32_t(MeshAttachment::*)(uint32_t, float32_t) const>(&MeshAttachment::getParameterScalarf32, {}, 0.0f));
					case 34: return FunctionPtr(new FunctionImpl<const Vector4f&(MeshAttachment::*)(uint32_t, const Vector4f&) const>(&MeshAttachment::getParameterVector4f, {}, Vector4f::zero));
					case 35: return FunctionPtr(new FunctionImpl<const Color&(MeshAttachment::*)(uint32_t, const Color&) const>(&MeshAttachment::getParameterColor, {}, Color::white));
					case 36: return FunctionPtr(new FunctionImpl<String(MeshAttachment::*)(uint32_t, const String&) const>(&MeshAttachment::getParameterName, {}, String::null));
					case 37: return FunctionPtr(new FunctionImpl<MeshAttachment::Flags(MeshAttachment::*)(const char*) const>(&MeshAttachment::getParameterFlags));
					case 38: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)(const char*, MeshAttachment::Flags) const>(&MeshAttachment::hasParameterFlag));
					case 39: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)(const char*, MeshAttachment::Flags) const>(&MeshAttachment::hasParameterFlags));
					case 40: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)(const char*, bool) const>(&MeshAttachment::getParameterBool, {}, false));
					case 41: return FunctionPtr(new FunctionImpl<float32_t(MeshAttachment::*)(const char*, float32_t) const>(&MeshAttachment::getParameterScalarf32, {}, 0.0f));
					case 42: return FunctionPtr(new FunctionImpl<const Vector4f&(MeshAttachment::*)(const char*, const Vector4f&) const>(&MeshAttachment::getParameterVector4f, {}, Vector4f::zero));
					case 43: return FunctionPtr(new FunctionImpl<const Color&(MeshAttachment::*)(const char*, const Color&) const>(&MeshAttachment::getParameterColor, {}, Color::white));
					case 44: return FunctionPtr(new FunctionImpl<String(MeshAttachment::*)(const char*, const String&) const>(&MeshAttachment::getParameterName, {}, String::null));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const Vector3f&)>(&MeshAttachment::setTransform));
					case 46: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)(const Matrix4x3f&)>(&MeshAttachment::setTransform));
					case 47: return FunctionPtr(new FunctionImpl<const Matrix4x3f&(MeshAttachment::*)() const>(&MeshAttachment::getTransform));
					case 48: return FunctionPtr(new FunctionImpl<int32_t(MeshAttachment::*)(const MeshAttachment&) const>(&MeshAttachment::compare));
					case 49: return FunctionPtr(new FunctionImpl<size_t(MeshAttachment::*)() const>(&MeshAttachment::getMemory));
					case 50: return FunctionPtr(new FunctionImpl<MeshAttachment(MeshAttachment::*)() const>(&MeshAttachment::clonePtr));
					case 51: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)()>(&MeshAttachment::clearPtr));
					case 52: return FunctionPtr(new FunctionVoidImpl<void(MeshAttachment::*)()>(&MeshAttachment::destroyPtr));
					case 53: return FunctionPtr(new FunctionImpl<MeshAttachment&(MeshAttachment::*)()>(&MeshAttachment::acquirePtr));
					case 54: return FunctionPtr(new FunctionImpl<MeshAttachment&(MeshAttachment::*)()>(&MeshAttachment::unacquirePtr));
					case 55: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)() const>(&MeshAttachment::isValidPtr));
					case 56: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)() const>(&MeshAttachment::isOwnerPtr));
					case 57: return FunctionPtr(new FunctionImpl<bool(MeshAttachment::*)() const>(&MeshAttachment::isConstPtr));
					case 58: return FunctionPtr(new FunctionImpl<uint32_t(MeshAttachment::*)() const>(&MeshAttachment::getCountPtr));
					case 59: return FunctionPtr(new FunctionImpl<const void*(MeshAttachment::*)() const>(&MeshAttachment::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 1, 3, 5 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 796, 22, 465, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 195, 23, 612, 23 };
			static constexpr uint16_t function_names[] = { 5, 797, 214, 345, 345, 530, 798, 799, 172, 75, 611, 613, 613, 175, 175, 82, 626, 627, 628, 631, 632, 633, 634, 635, 635, 635, 635, 635, 635, 641, 643, 645, 646, 647, 648, 653, 655, 641, 643, 645, 646, 647, 648, 653, 655, 525, 525, 713, 449, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 215, 138, 138, 21, 21, 21, 6, 16, 6, 454, 454, 6, 6, 16, 6, 21, 6, 10, 21, 10, 16, 6, 6, 6, 6, 6, 6, 642, 21, 21, 21, 123, 521, 654, 16, 642, 21, 21, 21, 123, 521, 654, 16, 6, 6, 604, 1, 74, 508, 508, 508, 508, 508, 508, 508, 508, 508, 508 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 2, 2, 2, 2, 2, 3, 3, 5, 5, 5, 6, 7, 7, 7, 8, 9, 10, 11, 11, 12, 14, 16, 18, 20, 22, 24, 25, 27, 29, 31, 33, 35, 37, 39, 40, 42, 44, 46, 48, 50, 52, 54, 55, 56, 56, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57, 57 };
			static constexpr uint16_t function_arg_types[] = { 796, 796, 22, 465, 21, 22, 94, 22, 504, 22, 22, 10, 22, 21, 22, 123, 22, 519, 22, 637, 22, 22, 22, 94, 10, 10, 800, 10, 800, 10, 21, 10, 123, 10, 519, 10, 637, 10, 94, 22, 22, 800, 22, 800, 22, 21, 22, 123, 22, 519, 22, 637, 22, 94, 711, 590, 504 };
			static constexpr uint16_t function_arg_names[] = { 195, 195, 23, 612, 50, 167, 167, 195, 499, 195, 195, 274, 195, 105, 195, 105, 195, 649, 195, 638, 195, 23, 195, 23, 274, 274, 338, 274, 338, 274, 105, 274, 105, 274, 649, 274, 638, 274, 23, 195, 195, 338, 195, 338, 195, 105, 195, 105, 195, 649, 195, 638, 195, 23, 527, 511, 499 };
	};
	constexpr uint16_t ReflectionMeshAttachment::constructor_bases[];
	constexpr uint16_t ReflectionMeshAttachment::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshAttachment::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshAttachment::function_names[];
	constexpr uint16_t ReflectionMeshAttachment::function_types[];
	constexpr uint16_t ReflectionMeshAttachment::function_bases[];
	constexpr uint16_t ReflectionMeshAttachment::function_arg_types[];
	constexpr uint16_t ReflectionMeshAttachment::function_arg_names[];
	static ReflectionMeshAttachment reflection_mesh_attachment;
	
	// Tellusim::Mesh
	class ReflectionMesh : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Mesh::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Mesh, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Mesh>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)()>(&Mesh::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(Mesh::*)() const>(&Mesh::isLoaded));
					case 2: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const char*, Mesh::Flags, Async*)>(&Mesh::info, {}, Mesh::FlagNone, nullptr));
					case 3: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const String&, Mesh::Flags, Async*)>(&Mesh::info, {}, Mesh::FlagNone, nullptr));
					case 4: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Stream&, Mesh::Flags, Async*)>(&Mesh::info, Stream::null, Mesh::FlagNone, nullptr));
					case 5: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const char*, Async*)>(&Mesh::info));
					case 6: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const String&, Async*)>(&Mesh::info));
					case 7: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Stream&, Async*)>(&Mesh::info));
					case 8: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const char*, Mesh::Flags, Async*)>(&Mesh::load, {}, Mesh::FlagNone, nullptr));
					case 9: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const String&, Mesh::Flags, Async*)>(&Mesh::load, {}, Mesh::FlagNone, nullptr));
					case 10: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Stream&, Mesh::Flags, Async*)>(&Mesh::load, Stream::null, Mesh::FlagNone, nullptr));
					case 11: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const char*, Async*)>(&Mesh::load));
					case 12: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const String&, Async*)>(&Mesh::load));
					case 13: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Stream&, Async*)>(&Mesh::load));
					case 14: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const char*, Mesh::Flags) const>(&Mesh::save, {}, Mesh::FlagNone));
					case 15: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const String&, Mesh::Flags) const>(&Mesh::save, {}, Mesh::FlagNone));
					case 16: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Stream&, Mesh::Flags) const>(&Mesh::save, Stream::null, Mesh::FlagNone));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)(const char*)>(&Mesh::setName));
					case 18: return FunctionPtr(new FunctionImpl<String(Mesh::*)() const>(&Mesh::getName));
					case 19: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Mesh::Axis, Mesh::Axis, Mesh::Axis)>(&Mesh::setBasis));
					case 20: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Mesh::Basis)>(&Mesh::setBasis));
					case 21: return FunctionPtr(new FunctionImpl<Mesh::Axis(Mesh::*)() const>(&Mesh::getFrontAxis));
					case 22: return FunctionPtr(new FunctionImpl<Mesh::Axis(Mesh::*)() const>(&Mesh::getRightAxis));
					case 23: return FunctionPtr(new FunctionImpl<Mesh::Axis(Mesh::*)() const>(&Mesh::getUpAxis));
					case 24: return FunctionPtr(new FunctionImpl<Mesh::Basis(Mesh::*)() const>(&Mesh::getBasis));
					case 25: return FunctionPtr(new FunctionImpl<const char*(Mesh::*)() const>(&Mesh::getFrontAxisName));
					case 26: return FunctionPtr(new FunctionImpl<const char*(Mesh::*)() const>(&Mesh::getRightAxisName));
					case 27: return FunctionPtr(new FunctionImpl<const char*(Mesh::*)() const>(&Mesh::getUpAxisName));
					case 28: return FunctionPtr(new FunctionImpl<String(Mesh::*)() const>(&Mesh::getBasisName));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)()>(&Mesh::clearNodes));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)(uint32_t)>(&Mesh::reserveNodes));
					case 31: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(MeshNode&, bool)>(&Mesh::addNode, MeshNode::null, true));
					case 32: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(MeshNode&)>(&Mesh::removeNode));
					case 33: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(const MeshNode&) const>(&Mesh::findNode));
					case 34: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(const char*) const>(&Mesh::findNode));
					case 35: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)() const>(&Mesh::getNumNodes));
					case 36: return FunctionPtr(new FunctionImpl<const Array<MeshNode>(Mesh::*)() const>(&Mesh::getNodes));
					case 37: return FunctionPtr(new FunctionImpl<Array<MeshNode>(Mesh::*)()>(&Mesh::getNodes));
					case 38: return FunctionPtr(new FunctionImpl<const MeshNode(Mesh::*)(uint32_t) const>(&Mesh::getNode));
					case 39: return FunctionPtr(new FunctionImpl<MeshNode(Mesh::*)(uint32_t)>(&Mesh::getNode));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)(const Matrix4x3d&)>(&Mesh::createLocalTransforms, Matrix4x3d::identity));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)(const Matrix4x3d&)>(&Mesh::createGlobalTransforms, Matrix4x3d::identity));
					case 42: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)()>(&Mesh::clearGeometries));
					case 43: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)(uint32_t)>(&Mesh::reserveGeometries));
					case 44: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(MeshGeometry&, bool)>(&Mesh::addGeometry, MeshGeometry::null, true));
					case 45: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(MeshGeometry&, MeshNode&, bool)>(&Mesh::addGeometry, MeshGeometry::null, MeshNode::null, true));
					case 46: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(MeshGeometry&)>(&Mesh::removeGeometry));
					case 47: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(MeshGeometry&, MeshGeometry&)>(&Mesh::replaceGeometry));
					case 48: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(const MeshGeometry&) const>(&Mesh::findGeometry));
					case 49: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(const char*) const>(&Mesh::findGeometry));
					case 50: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)() const>(&Mesh::getNumGeometries));
					case 51: return FunctionPtr(new FunctionImpl<const Array<MeshGeometry>(Mesh::*)() const>(&Mesh::getGeometries));
					case 52: return FunctionPtr(new FunctionImpl<Array<MeshGeometry>(Mesh::*)()>(&Mesh::getGeometries));
					case 53: return FunctionPtr(new FunctionImpl<const MeshGeometry(Mesh::*)(uint32_t) const>(&Mesh::getGeometry));
					case 54: return FunctionPtr(new FunctionImpl<MeshGeometry(Mesh::*)(uint32_t)>(&Mesh::getGeometry));
					case 55: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(MeshIndices::Type) const>(&Mesh::hasGeometryIndices));
					case 56: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(MeshAttribute::Type) const>(&Mesh::hasGeometryAttribute));
					case 57: return FunctionPtr(new FunctionImpl<size_t(Mesh::*)() const>(&Mesh::getNumGeometryPositions));
					case 58: return FunctionPtr(new FunctionImpl<size_t(Mesh::*)() const>(&Mesh::getNumGeometryPrimitives));
					case 59: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)()>(&Mesh::clearAnimations));
					case 60: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)(uint32_t)>(&Mesh::reserveAnimations));
					case 61: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(MeshAnimation&, bool)>(&Mesh::addAnimation, MeshAnimation::null, true));
					case 62: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(MeshAnimation&)>(&Mesh::removeAnimation));
					case 63: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(MeshAnimation&, MeshAnimation&)>(&Mesh::replaceAnimation));
					case 64: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(const MeshAnimation&) const>(&Mesh::findAnimation));
					case 65: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)(const char*) const>(&Mesh::findAnimation));
					case 66: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)() const>(&Mesh::getNumAnimations));
					case 67: return FunctionPtr(new FunctionImpl<const Array<MeshAnimation>(Mesh::*)() const>(&Mesh::getAnimations));
					case 68: return FunctionPtr(new FunctionImpl<Array<MeshAnimation>(Mesh::*)()>(&Mesh::getAnimations));
					case 69: return FunctionPtr(new FunctionImpl<const MeshAnimation(Mesh::*)(uint32_t) const>(&Mesh::getAnimation));
					case 70: return FunctionPtr(new FunctionImpl<MeshAnimation(Mesh::*)(uint32_t)>(&Mesh::getAnimation));
					case 71: return FunctionPtr(new FunctionImpl<BoundBoxd(Mesh::*)() const>(&Mesh::getBoundBox));
					case 72: return FunctionPtr(new FunctionImpl<BoundBoxd(Mesh::*)(const MeshNode&) const>(&Mesh::getBoundBox));
					case 73: return FunctionPtr(new FunctionImpl<BoundBoxd(Mesh::*)(const MeshGeometry&) const>(&Mesh::getBoundBox));
					case 74: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(bool, Async*)>(&Mesh::createBounds, {}, nullptr));
					case 75: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Async*)>(&Mesh::createBounds, nullptr));
					case 76: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(bool, Async*)>(&Mesh::createBasis, {}, nullptr));
					case 77: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(float32_t, bool, Async*)>(&Mesh::createBasis, {}, {}, nullptr));
					case 78: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Async*)>(&Mesh::createBasis, nullptr));
					case 79: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(float32_t, Async*)>(&Mesh::createBasis, {}, nullptr));
					case 80: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(bool, Async*)>(&Mesh::createNormals, {}, nullptr));
					case 81: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(float32_t, bool, Async*)>(&Mesh::createNormals, {}, {}, nullptr));
					case 82: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Async*)>(&Mesh::createNormals, nullptr));
					case 83: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(float32_t, Async*)>(&Mesh::createNormals, {}, nullptr));
					case 84: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(bool, Async*)>(&Mesh::createTangents, {}, nullptr));
					case 85: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Async*)>(&Mesh::createTangents, nullptr));
					case 86: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(uint32_t, uint32_t, bool, Async*)>(&Mesh::createIslands, {}, {}, {}, nullptr));
					case 87: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(uint32_t, uint32_t, Async*)>(&Mesh::createIslands, {}, {}, nullptr));
					case 88: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(uint32_t, bool, Async*)>(&Mesh::optimizeIndices, {}, {}, nullptr));
					case 89: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Async*)>(&Mesh::optimizeIndices, nullptr));
					case 90: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(uint32_t, Async*)>(&Mesh::optimizeIndices, {}, nullptr));
					case 91: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(Async*)>(&Mesh::optimizeAttributes, nullptr));
					case 92: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)()>(&Mesh::optimizeMaterials));
					case 93: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(bool)>(&Mesh::optimizeWinding, false));
					case 94: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)(float32_t, uint32_t)>(&Mesh::optimizeGeometries, 1e-3f, 16));
					case 95: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)(float32_t)>(&Mesh::optimizeAnimations, 1e-6f));
					case 96: return FunctionPtr(new FunctionImpl<bool(Mesh::*)()>(&Mesh::optimizeOrder));
					case 97: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)()>(&Mesh::mergeGeometries));
					case 98: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(bool)>(&Mesh::packAttributes, true));
					case 99: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(bool)>(&Mesh::unpackAttributes, true));
					case 100: return FunctionPtr(new FunctionImpl<bool(Mesh::*)(const Vector3d&)>(&Mesh::setTransform));
					case 101: return FunctionPtr(new FunctionImpl<size_t(Mesh::*)() const>(&Mesh::getMemory));
					case 102: return FunctionPtr(new FunctionImpl<Mesh(Mesh::*)() const>(&Mesh::clonePtr));
					case 103: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)()>(&Mesh::clearPtr));
					case 104: return FunctionPtr(new FunctionVoidImpl<void(Mesh::*)()>(&Mesh::destroyPtr));
					case 105: return FunctionPtr(new FunctionImpl<Mesh&(Mesh::*)()>(&Mesh::acquirePtr));
					case 106: return FunctionPtr(new FunctionImpl<Mesh&(Mesh::*)()>(&Mesh::unacquirePtr));
					case 107: return FunctionPtr(new FunctionImpl<bool(Mesh::*)() const>(&Mesh::isValidPtr));
					case 108: return FunctionPtr(new FunctionImpl<bool(Mesh::*)() const>(&Mesh::isOwnerPtr));
					case 109: return FunctionPtr(new FunctionImpl<bool(Mesh::*)() const>(&Mesh::isConstPtr));
					case 110: return FunctionPtr(new FunctionImpl<uint32_t(Mesh::*)() const>(&Mesh::getCountPtr));
					case 111: return FunctionPtr(new FunctionImpl<const void*(Mesh::*)() const>(&Mesh::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 343, 416, 416, 416, 416, 416, 416, 221, 221, 221, 221, 221, 221, 419, 419, 419, 172, 75, 802, 802, 809, 811, 812, 813, 815, 816, 817, 818, 819, 820, 822, 823, 824, 824, 825, 826, 826, 613, 613, 522, 524, 479, 480, 482, 482, 485, 486, 488, 488, 490, 491, 491, 492, 492, 827, 828, 829, 830, 831, 832, 834, 837, 838, 840, 840, 842, 843, 843, 844, 844, 606, 606, 606, 727, 727, 730, 730, 730, 730, 733, 733, 733, 733, 734, 734, 736, 736, 739, 739, 739, 742, 743, 845, 847, 848, 849, 850, 596, 599, 525, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 6, 16, 21, 21, 810, 810, 810, 814, 138, 138, 138, 16, 6, 6, 10, 21, 10, 10, 10, 19, 19, 454, 454, 6, 6, 6, 6, 10, 10, 21, 21, 10, 10, 10, 19, 19, 493, 493, 21, 21, 74, 74, 6, 6, 10, 21, 21, 10, 10, 10, 19, 19, 786, 786, 794, 794, 794, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 6, 21, 6, 6, 21, 6, 21, 21, 21, 74, 463, 463, 463, 463, 463, 463, 463, 463, 463, 463 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 3, 6, 9, 11, 13, 15, 18, 21, 24, 26, 28, 30, 32, 34, 36, 37, 37, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 42, 44, 45, 46, 47, 47, 47, 47, 48, 49, 50, 51, 51, 52, 54, 57, 58, 60, 61, 62, 62, 62, 62, 63, 64, 65, 66, 66, 66, 66, 67, 69, 70, 72, 73, 74, 74, 74, 74, 75, 76, 76, 77, 78, 80, 81, 83, 86, 87, 89, 91, 94, 95, 97, 99, 100, 104, 107, 110, 111, 113, 114, 114, 115, 117, 118, 118, 118, 119, 120, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121, 121 };
			static constexpr uint16_t function_arg_types[] = { 22, 801, 417, 94, 801, 417, 145, 801, 417, 22, 417, 94, 417, 145, 417, 22, 801, 417, 94, 801, 417, 145, 801, 417, 22, 417, 94, 417, 145, 417, 22, 801, 94, 801, 145, 801, 22, 803, 803, 803, 807, 10, 465, 21, 465, 475, 22, 10, 10, 510, 510, 10, 483, 21, 483, 465, 21, 483, 483, 483, 489, 22, 10, 10, 529, 567, 10, 835, 21, 835, 835, 835, 841, 22, 10, 10, 475, 489, 21, 417, 417, 21, 417, 123, 21, 417, 417, 123, 417, 21, 417, 123, 21, 417, 417, 123, 417, 21, 417, 417, 10, 10, 21, 417, 10, 10, 417, 10, 21, 417, 417, 10, 417, 417, 21, 123, 10, 123, 21, 21, 526 };
			static constexpr uint16_t function_arg_names[] = { 23, 338, 418, 23, 338, 418, 222, 338, 418, 23, 418, 23, 418, 222, 418, 23, 338, 418, 23, 338, 418, 222, 338, 418, 23, 418, 23, 418, 222, 418, 23, 338, 23, 338, 222, 338, 23, 804, 805, 806, 808, 821, 612, 50, 612, 612, 23, 274, 274, 523, 511, 481, 484, 50, 484, 612, 50, 484, 487, 484, 484, 23, 274, 274, 195, 195, 833, 836, 50, 836, 839, 836, 836, 23, 274, 274, 612, 484, 728, 418, 418, 728, 418, 442, 728, 418, 418, 442, 418, 728, 418, 442, 728, 418, 418, 442, 418, 728, 418, 418, 737, 738, 728, 418, 737, 738, 418, 740, 741, 418, 418, 740, 418, 418, 846, 591, 415, 591, 192, 192, 527 };
	};
	constexpr uint16_t ReflectionMesh::constructor_bases[];
	constexpr uint16_t ReflectionMesh::constructor_arg_types[];
	constexpr uint16_t ReflectionMesh::constructor_arg_names[];
	constexpr uint16_t ReflectionMesh::function_names[];
	constexpr uint16_t ReflectionMesh::function_types[];
	constexpr uint16_t ReflectionMesh::function_bases[];
	constexpr uint16_t ReflectionMesh::function_arg_types[];
	constexpr uint16_t ReflectionMesh::function_arg_names[];
	static ReflectionMesh reflection_mesh;
	
	// Tellusim::Json
	class ReflectionJson : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Json::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Json, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Json, TypeList<Json::Type>>());
					case 2: return ConstructorPtr(new ConstructorImpl<Json, TypeList<const char*, Json::Type>>({}, Json::TypeUnknown));
					case 3: return ConstructorPtr(new ConstructorImpl<Json, TypeList<const String&, Json::Type>>({}, Json::TypeUnknown));
					case 4: return ConstructorPtr(new ConstructorImpl<Json, TypeList<Json*, const char*, Json::Type>>({}, {}, Json::TypeUnknown));
					case 5: return ConstructorPtr(new ConstructorImpl<Json, TypeList<Json*, const String&, Json::Type>>({}, {}, Json::TypeUnknown));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Json>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(Json::*)()>(&Json::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(Json::*)(const char*, size_t, bool)>(&Json::create, {}, 0, false));
					case 2: return FunctionPtr(new FunctionImpl<bool(Json::*)(const String&, size_t, bool)>(&Json::create, {}, 0, false));
					case 3: return FunctionPtr(new FunctionImpl<bool(Json::*)(const char*)>(&Json::load));
					case 4: return FunctionPtr(new FunctionImpl<bool(Json::*)(const String&)>(&Json::load));
					case 5: return FunctionPtr(new FunctionImpl<bool(Json::*)(Stream&)>(&Json::load));
					case 6: return FunctionPtr(new FunctionImpl<bool(Json::*)(const char*, bool) const>(&Json::save, {}, false));
					case 7: return FunctionPtr(new FunctionImpl<bool(Json::*)(const String&, bool) const>(&Json::save, {}, false));
					case 8: return FunctionPtr(new FunctionImpl<bool(Json::*)(Stream&, bool) const>(&Json::save, Stream::null, false));
					case 9: return FunctionPtr(new FunctionImpl<const Json(Json::*)() const>(&Json::getRoot));
					case 10: return FunctionPtr(new FunctionImpl<Json(Json::*)()>(&Json::getRoot));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(Json&, bool)>(&Json::setParent, Json::null, true));
					case 12: return FunctionPtr(new FunctionImpl<const Json(Json::*)() const>(&Json::getParent));
					case 13: return FunctionPtr(new FunctionImpl<Json(Json::*)()>(&Json::getParent));
					case 14: return FunctionPtr(new FunctionImpl<Json(Json::*)(const char*, Json::Type, bool)>(&Json::addChild, {}, Json::TypeUnknown, true));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(Json&, bool)>(&Json::addChild, Json::null, true));
					case 16: return FunctionPtr(new FunctionImpl<bool(Json::*)(Json&)>(&Json::removeChild));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(Json::*)()>(&Json::releaseChildren));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(const char*) const>(&Json::findChild));
					case 19: return FunctionPtr(new FunctionImpl<bool(Json::*)(const char*) const>(&Json::isChild));
					case 20: return FunctionPtr(new FunctionImpl<const Json(Json::*)(const char*) const>(&Json::getChild));
					case 21: return FunctionPtr(new FunctionImpl<Json(Json::*)(const char*)>(&Json::getChild));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)() const>(&Json::getNumChildren));
					case 23: return FunctionPtr(new FunctionImpl<const Array<Json>(Json::*)() const>(&Json::getChildren));
					case 24: return FunctionPtr(new FunctionImpl<Array<Json>(Json::*)()>(&Json::getChildren));
					case 25: return FunctionPtr(new FunctionImpl<const Json(Json::*)(uint32_t) const>(&Json::getChild));
					case 26: return FunctionPtr(new FunctionImpl<Json(Json::*)(uint32_t)>(&Json::getChild));
					case 27: return FunctionPtr(new FunctionImpl<String(Json::*)() const>(&Json::getPathName));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const char*)>(&Json::setName));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const String&)>(&Json::setName));
					case 30: return FunctionPtr(new FunctionImpl<String(Json::*)() const>(&Json::getName));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(Json::Type)>(&Json::setType));
					case 32: return FunctionPtr(new FunctionImpl<Json::Type(Json::*)() const>(&Json::getType));
					case 33: return FunctionPtr(new FunctionImpl<const char*(Json::Type)>(&Json::getTypeName));
					case 34: return FunctionPtr(new FunctionImpl<const char*(Json::*)() const>(&Json::getTypeName));
					case 35: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isUnknown));
					case 36: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isNull));
					case 37: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isBool));
					case 38: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isNumber));
					case 39: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isString));
					case 40: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isObject));
					case 41: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isArray));
					case 42: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(bool)>(&Json::setData));
					case 43: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(int32_t, uint32_t)>(&Json::setData, {}, 10));
					case 44: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(uint32_t, uint32_t)>(&Json::setData, {}, 10));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(uint64_t, uint32_t)>(&Json::setData, {}, 10));
					case 46: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(float32_t, uint32_t, bool, bool)>(&Json::setData, {}, 6, true, true));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(float64_t, uint32_t, bool, bool)>(&Json::setData, {}, 12, true, true));
					case 48: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const char*)>(&Json::setData));
					case 49: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const String&)>(&Json::setData));
					case 50: return FunctionPtr(new FunctionImpl<String(Json::*)() const>(&Json::getData));
					case 51: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::getDataBool));
					case 52: return FunctionPtr(new FunctionImpl<int32_t(Json::*)(uint32_t) const>(&Json::getDatai32, 10));
					case 53: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(uint32_t) const>(&Json::getDatau32, 10));
					case 54: return FunctionPtr(new FunctionImpl<uint64_t(Json::*)(uint32_t) const>(&Json::getDatau64, 10));
					case 55: return FunctionPtr(new FunctionImpl<float32_t(Json::*)() const>(&Json::getDataf32));
					case 56: return FunctionPtr(new FunctionImpl<float64_t(Json::*)() const>(&Json::getDataf64));
					case 57: return FunctionPtr(new FunctionImpl<String(Json::*)() const>(&Json::getNumber));
					case 58: return FunctionPtr(new FunctionImpl<String(Json::*)() const>(&Json::getString));
					case 59: return FunctionPtr(new FunctionImpl<bool(Json::*)(const char*, bool) const>(&Json::getData));
					case 60: return FunctionPtr(new FunctionImpl<int32_t(Json::*)(const char*, int32_t, uint32_t) const>(&Json::getData, {}, {}, 10));
					case 61: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(const char*, uint32_t, uint32_t) const>(&Json::getData, {}, {}, 10));
					case 62: return FunctionPtr(new FunctionImpl<uint64_t(Json::*)(const char*, uint64_t, uint32_t) const>(&Json::getData, {}, {}, 10));
					case 63: return FunctionPtr(new FunctionImpl<float32_t(Json::*)(const char*, float32_t) const>(&Json::getData));
					case 64: return FunctionPtr(new FunctionImpl<float64_t(Json::*)(const char*, float64_t) const>(&Json::getData));
					case 65: return FunctionPtr(new FunctionImpl<String(Json::*)(const char*, const String&) const>(&Json::getData, {}, String::null));
					case 66: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const char**, uint32_t)>(&Json::setData));
					case 67: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const String*, uint32_t)>(&Json::setData));
					case 68: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const int32_t*, uint32_t, uint32_t)>(&Json::setData, {}, {}, 10));
					case 69: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const uint32_t*, uint32_t, uint32_t)>(&Json::setData, {}, {}, 10));
					case 70: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const float32_t*, uint32_t, uint32_t, bool, bool)>(&Json::setData, {}, {}, 6, true, true));
					case 71: return FunctionPtr(new FunctionVoidImpl<void(Json::*)(const float64_t*, uint32_t, uint32_t, bool, bool)>(&Json::setData, {}, {}, 12, true, true));
					case 72: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(String*, uint32_t) const>(&Json::getData));
					case 73: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(int32_t*, uint32_t, uint32_t) const>(&Json::getData, {}, {}, 10));
					case 74: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(uint32_t*, uint32_t, uint32_t) const>(&Json::getData, {}, {}, 10));
					case 75: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(float32_t*, uint32_t) const>(&Json::getData));
					case 76: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)(float64_t*, uint32_t) const>(&Json::getData));
					case 77: return FunctionPtr(new FunctionImpl<Json(Json::*)() const>(&Json::clonePtr));
					case 78: return FunctionPtr(new FunctionVoidImpl<void(Json::*)()>(&Json::clearPtr));
					case 79: return FunctionPtr(new FunctionVoidImpl<void(Json::*)()>(&Json::destroyPtr));
					case 80: return FunctionPtr(new FunctionImpl<Json&(Json::*)()>(&Json::acquirePtr));
					case 81: return FunctionPtr(new FunctionImpl<Json&(Json::*)()>(&Json::unacquirePtr));
					case 82: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isValidPtr));
					case 83: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isOwnerPtr));
					case 84: return FunctionPtr(new FunctionImpl<bool(Json::*)() const>(&Json::isConstPtr));
					case 85: return FunctionPtr(new FunctionImpl<uint32_t(Json::*)() const>(&Json::getCountPtr));
					case 86: return FunctionPtr(new FunctionImpl<const void*(Json::*)() const>(&Json::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 5, 8, 11 };
			static constexpr uint16_t constructor_arg_types[] = { 852, 22, 852, 94, 852, 853, 22, 852, 853, 94, 852 };
			static constexpr uint16_t constructor_arg_names[] = { 195, 23, 195, 23, 195, 458, 23, 195, 458, 23, 195 };
			static constexpr uint16_t function_names[] = { 5, 24, 24, 221, 221, 221, 419, 419, 419, 856, 856, 464, 466, 466, 470, 470, 472, 473, 474, 858, 478, 478, 476, 477, 477, 478, 478, 859, 172, 172, 75, 797, 214, 345, 345, 530, 860, 861, 862, 863, 864, 865, 175, 175, 175, 175, 175, 175, 175, 175, 82, 869, 870, 871, 872, 873, 874, 875, 243, 82, 82, 82, 82, 82, 82, 82, 175, 175, 175, 175, 175, 175, 82, 82, 82, 82, 82, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 21, 21, 21, 21, 21, 21, 851, 851, 10, 851, 851, 851, 10, 21, 6, 10, 21, 851, 851, 10, 19, 19, 851, 851, 16, 6, 6, 16, 6, 215, 138, 138, 21, 21, 21, 21, 21, 21, 21, 6, 6, 6, 6, 6, 6, 6, 6, 16, 21, 1, 10, 39, 123, 126, 16, 16, 21, 1, 10, 39, 123, 126, 16, 6, 6, 6, 6, 6, 6, 10, 10, 10, 10, 10, 851, 851, 851, 851, 851, 851, 851, 851, 851, 851 };
			static constexpr uint16_t function_bases[] = { 0, 0, 3, 6, 7, 8, 9, 11, 13, 15, 15, 15, 17, 17, 17, 20, 22, 23, 23, 24, 25, 26, 27, 27, 27, 27, 28, 29, 29, 30, 31, 31, 32, 32, 33, 33, 33, 33, 33, 33, 33, 33, 33, 34, 36, 38, 40, 44, 48, 49, 50, 50, 50, 51, 52, 53, 53, 53, 53, 53, 55, 58, 61, 64, 66, 68, 70, 72, 74, 77, 80, 85, 90, 92, 95, 98, 100, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102, 102 };
			static constexpr uint16_t function_arg_types[] = { 22, 74, 21, 94, 74, 21, 22, 94, 145, 22, 21, 94, 21, 145, 21, 857, 21, 22, 852, 21, 857, 21, 857, 22, 22, 22, 22, 10, 10, 22, 94, 852, 852, 21, 1, 10, 10, 10, 39, 10, 123, 10, 21, 21, 126, 10, 21, 21, 22, 94, 10, 10, 10, 22, 21, 22, 1, 10, 22, 10, 10, 22, 39, 10, 22, 123, 22, 126, 22, 94, 876, 10, 878, 10, 879, 10, 10, 880, 10, 10, 881, 10, 10, 21, 21, 882, 10, 10, 21, 21, 883, 10, 884, 10, 10, 885, 10, 10, 886, 10, 887, 10 };
			static constexpr uint16_t function_arg_names[] = { 93, 87, 854, 93, 87, 854, 23, 23, 222, 23, 855, 23, 855, 222, 855, 458, 50, 23, 195, 50, 471, 50, 471, 23, 23, 23, 23, 274, 274, 23, 23, 195, 195, 105, 105, 866, 105, 866, 105, 866, 105, 867, 855, 868, 105, 867, 855, 868, 105, 105, 866, 866, 866, 23, 105, 23, 105, 866, 23, 105, 866, 23, 105, 866, 23, 105, 23, 105, 23, 105, 877, 87, 877, 87, 877, 87, 866, 877, 87, 866, 877, 87, 867, 855, 868, 877, 87, 867, 855, 868, 877, 87, 877, 87, 866, 877, 87, 866, 877, 87, 877, 87 };
	};
	constexpr uint16_t ReflectionJson::constructor_bases[];
	constexpr uint16_t ReflectionJson::constructor_arg_types[];
	constexpr uint16_t ReflectionJson::constructor_arg_names[];
	constexpr uint16_t ReflectionJson::function_names[];
	constexpr uint16_t ReflectionJson::function_types[];
	constexpr uint16_t ReflectionJson::function_bases[];
	constexpr uint16_t ReflectionJson::function_arg_types[];
	constexpr uint16_t ReflectionJson::function_arg_names[];
	static ReflectionJson reflection_json;
	
	// Tellusim::Xml
	class ReflectionXml : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Xml::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Xml, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Xml, TypeList<const char*, const char*>>({}, nullptr));
					case 2: return ConstructorPtr(new ConstructorImpl<Xml, TypeList<const String&, const char*>>({}, nullptr));
					case 3: return ConstructorPtr(new ConstructorImpl<Xml, TypeList<Xml*, const char*, const char*>>({}, {}, nullptr));
					case 4: return ConstructorPtr(new ConstructorImpl<Xml, TypeList<Xml*, const String&, const char*>>({}, {}, nullptr));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Xml>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)()>(&Xml::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const char*, size_t, bool)>(&Xml::create, {}, 0, false));
					case 2: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const String&, size_t, bool)>(&Xml::create, {}, 0, false));
					case 3: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const char*)>(&Xml::load));
					case 4: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const String&)>(&Xml::load));
					case 5: return FunctionPtr(new FunctionImpl<bool(Xml::*)(Stream&)>(&Xml::load));
					case 6: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const char*, bool) const>(&Xml::save, {}, false));
					case 7: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const String&, bool) const>(&Xml::save, {}, false));
					case 8: return FunctionPtr(new FunctionImpl<bool(Xml::*)(Stream&, bool) const>(&Xml::save, Stream::null, false));
					case 9: return FunctionPtr(new FunctionImpl<const Xml(Xml::*)() const>(&Xml::getRoot));
					case 10: return FunctionPtr(new FunctionImpl<Xml(Xml::*)()>(&Xml::getRoot));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(Xml&, bool)>(&Xml::setParent, Xml::null, true));
					case 12: return FunctionPtr(new FunctionImpl<const Xml(Xml::*)() const>(&Xml::getParent));
					case 13: return FunctionPtr(new FunctionImpl<Xml(Xml::*)()>(&Xml::getParent));
					case 14: return FunctionPtr(new FunctionImpl<Xml(Xml::*)(const char*, bool)>(&Xml::addChild, {}, true));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(Xml&, bool)>(&Xml::addChild, Xml::null, true));
					case 16: return FunctionPtr(new FunctionImpl<bool(Xml::*)(Xml&)>(&Xml::removeChild));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)()>(&Xml::releaseChildren));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(const char*) const>(&Xml::findChild));
					case 19: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const char*) const>(&Xml::isChild));
					case 20: return FunctionPtr(new FunctionImpl<const Xml(Xml::*)(const char*) const>(&Xml::getChild));
					case 21: return FunctionPtr(new FunctionImpl<Xml(Xml::*)(const char*)>(&Xml::getChild));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)() const>(&Xml::getNumChildren));
					case 23: return FunctionPtr(new FunctionImpl<const Array<Xml>(Xml::*)() const>(&Xml::getChildren));
					case 24: return FunctionPtr(new FunctionImpl<Array<Xml>(Xml::*)()>(&Xml::getChildren));
					case 25: return FunctionPtr(new FunctionImpl<const Xml(Xml::*)(uint32_t) const>(&Xml::getChild));
					case 26: return FunctionPtr(new FunctionImpl<Xml(Xml::*)(uint32_t)>(&Xml::getChild));
					case 27: return FunctionPtr(new FunctionImpl<String(Xml::*)() const>(&Xml::getPathName));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const char*)>(&Xml::setName));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const String&)>(&Xml::setName));
					case 30: return FunctionPtr(new FunctionImpl<String(Xml::*)() const>(&Xml::getName));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(bool)>(&Xml::setData));
					case 32: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const char*)>(&Xml::setData));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const String&)>(&Xml::setData));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(int32_t, uint32_t)>(&Xml::setData, {}, 10));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, uint32_t)>(&Xml::setData, {}, 10));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint64_t, uint32_t)>(&Xml::setData, {}, 10));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(float32_t, uint32_t, bool, bool)>(&Xml::setData, {}, 6, true, true));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(float64_t, uint32_t, bool, bool)>(&Xml::setData, {}, 12, true, true));
					case 39: return FunctionPtr(new FunctionImpl<String(Xml::*)() const>(&Xml::getData));
					case 40: return FunctionPtr(new FunctionImpl<bool(Xml::*)() const>(&Xml::getDataBool));
					case 41: return FunctionPtr(new FunctionImpl<int32_t(Xml::*)(uint32_t) const>(&Xml::getDatai32, 10));
					case 42: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(uint32_t) const>(&Xml::getDatau32, 10));
					case 43: return FunctionPtr(new FunctionImpl<uint64_t(Xml::*)(uint32_t) const>(&Xml::getDatau64, 10));
					case 44: return FunctionPtr(new FunctionImpl<float32_t(Xml::*)() const>(&Xml::getDataf32));
					case 45: return FunctionPtr(new FunctionImpl<float64_t(Xml::*)() const>(&Xml::getDataf64));
					case 46: return FunctionPtr(new FunctionImpl<String(Xml::*)(const char*, const String&) const>(&Xml::getData, {}, String::null));
					case 47: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const char*, bool) const>(&Xml::getData));
					case 48: return FunctionPtr(new FunctionImpl<int32_t(Xml::*)(const char*, int32_t, uint32_t) const>(&Xml::getData, {}, {}, 10));
					case 49: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(const char*, uint32_t, uint32_t) const>(&Xml::getData, {}, {}, 10));
					case 50: return FunctionPtr(new FunctionImpl<uint64_t(Xml::*)(const char*, uint64_t, uint32_t) const>(&Xml::getData, {}, {}, 10));
					case 51: return FunctionPtr(new FunctionImpl<float32_t(Xml::*)(const char*, float32_t) const>(&Xml::getData));
					case 52: return FunctionPtr(new FunctionImpl<float64_t(Xml::*)(const char*, float64_t) const>(&Xml::getData));
					case 53: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const char**, uint32_t, uint32_t)>(&Xml::setData, {}, {}, Maxu32));
					case 54: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const String*, uint32_t, uint32_t)>(&Xml::setData, {}, {}, Maxu32));
					case 55: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const int32_t*, uint32_t, uint32_t, uint32_t)>(&Xml::setData, {}, {}, 10, Maxu32));
					case 56: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const uint32_t*, uint32_t, uint32_t, uint32_t)>(&Xml::setData, {}, {}, 10, Maxu32));
					case 57: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const float32_t*, uint32_t, uint32_t, bool, bool, uint32_t)>(&Xml::setData, {}, {}, 6, true, true, Maxu32));
					case 58: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(const float64_t*, uint32_t, uint32_t, bool, bool, uint32_t)>(&Xml::setData, {}, {}, 12, true, true, Maxu32));
					case 59: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(String*, uint32_t) const>(&Xml::getData));
					case 60: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(int32_t*, uint32_t, uint32_t) const>(&Xml::getData, {}, {}, 10));
					case 61: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(uint32_t*, uint32_t, uint32_t) const>(&Xml::getData, {}, {}, 10));
					case 62: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(float32_t*, uint32_t) const>(&Xml::getData));
					case 63: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(float64_t*, uint32_t) const>(&Xml::getData));
					case 64: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(const char*)>(&Xml::addAttribute));
					case 65: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const char*)>(&Xml::removeAttribute));
					case 66: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(const char*) const>(&Xml::findAttribute));
					case 67: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const char*) const>(&Xml::isAttribute));
					case 68: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)()>(&Xml::removeAttributes));
					case 69: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)() const>(&Xml::getNumAttributes));
					case 70: return FunctionPtr(new FunctionImpl<String(Xml::*)(uint32_t) const>(&Xml::getAttributeName));
					case 71: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const char*)>(&Xml::setAttributes));
					case 72: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, bool)>(&Xml::setAttribute));
					case 73: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, const char*)>(&Xml::setAttribute));
					case 74: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, const String&)>(&Xml::setAttribute));
					case 75: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, int32_t, uint32_t)>(&Xml::setAttribute, {}, {}, 10));
					case 76: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, uint32_t, uint32_t)>(&Xml::setAttribute, {}, {}, 10));
					case 77: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, uint64_t, uint32_t)>(&Xml::setAttribute, {}, {}, 10));
					case 78: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, float32_t, uint32_t, bool, bool)>(&Xml::setAttribute, {}, {}, 6, true, true));
					case 79: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, float64_t, uint32_t, bool, bool)>(&Xml::setAttribute, {}, {}, 12, true, true));
					case 80: return FunctionPtr(new FunctionImpl<String(Xml::*)(uint32_t) const>(&Xml::getAttribute));
					case 81: return FunctionPtr(new FunctionImpl<int32_t(Xml::*)(uint32_t, uint32_t) const>(&Xml::getAttributei32, {}, 10));
					case 82: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(uint32_t, uint32_t) const>(&Xml::getAttributeu32, {}, 10));
					case 83: return FunctionPtr(new FunctionImpl<uint64_t(Xml::*)(uint32_t, uint32_t) const>(&Xml::getAttributeu64, {}, 10));
					case 84: return FunctionPtr(new FunctionImpl<float32_t(Xml::*)(uint32_t) const>(&Xml::getAttributef32));
					case 85: return FunctionPtr(new FunctionImpl<float64_t(Xml::*)(uint32_t) const>(&Xml::getAttributef64));
					case 86: return FunctionPtr(new FunctionImpl<String(Xml::*)(const char*, const String&) const>(&Xml::getAttribute, {}, String::null));
					case 87: return FunctionPtr(new FunctionImpl<bool(Xml::*)(const char*, bool) const>(&Xml::getAttribute));
					case 88: return FunctionPtr(new FunctionImpl<int32_t(Xml::*)(const char*, int32_t, uint32_t) const>(&Xml::getAttribute, {}, {}, 10));
					case 89: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(const char*, uint32_t, uint32_t) const>(&Xml::getAttribute, {}, {}, 10));
					case 90: return FunctionPtr(new FunctionImpl<uint64_t(Xml::*)(const char*, uint64_t, uint32_t) const>(&Xml::getAttribute, {}, {}, 10));
					case 91: return FunctionPtr(new FunctionImpl<float32_t(Xml::*)(const char*, float32_t) const>(&Xml::getAttribute));
					case 92: return FunctionPtr(new FunctionImpl<float64_t(Xml::*)(const char*, float64_t) const>(&Xml::getAttribute));
					case 93: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, const char**, uint32_t, const char*)>(&Xml::setAttribute, {}, {}, {}, nullptr));
					case 94: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, const String*, uint32_t, const char*)>(&Xml::setAttribute, {}, {}, {}, nullptr));
					case 95: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, const int32_t*, uint32_t, uint32_t)>(&Xml::setAttribute, {}, {}, {}, 10));
					case 96: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, const uint32_t*, uint32_t, uint32_t)>(&Xml::setAttribute, {}, {}, {}, 10));
					case 97: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, const float32_t*, uint32_t, uint32_t, bool, bool)>(&Xml::setAttribute, {}, {}, {}, 6, true, true));
					case 98: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)(uint32_t, const float64_t*, uint32_t, uint32_t, bool, bool)>(&Xml::setAttribute, {}, {}, {}, 12, true, true));
					case 99: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(uint32_t, String*, uint32_t, const char*) const>(&Xml::getAttribute, {}, {}, {}, nullptr));
					case 100: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(uint32_t, int32_t*, uint32_t, uint32_t) const>(&Xml::getAttribute, {}, {}, {}, 10));
					case 101: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(uint32_t, uint32_t*, uint32_t, uint32_t) const>(&Xml::getAttribute, {}, {}, {}, 10));
					case 102: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(uint32_t, float32_t*, uint32_t) const>(&Xml::getAttribute));
					case 103: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)(uint32_t, float64_t*, uint32_t) const>(&Xml::getAttribute));
					case 104: return FunctionPtr(new FunctionImpl<Xml(Xml::*)() const>(&Xml::clonePtr));
					case 105: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)()>(&Xml::clearPtr));
					case 106: return FunctionPtr(new FunctionVoidImpl<void(Xml::*)()>(&Xml::destroyPtr));
					case 107: return FunctionPtr(new FunctionImpl<Xml&(Xml::*)()>(&Xml::acquirePtr));
					case 108: return FunctionPtr(new FunctionImpl<Xml&(Xml::*)()>(&Xml::unacquirePtr));
					case 109: return FunctionPtr(new FunctionImpl<bool(Xml::*)() const>(&Xml::isValidPtr));
					case 110: return FunctionPtr(new FunctionImpl<bool(Xml::*)() const>(&Xml::isOwnerPtr));
					case 111: return FunctionPtr(new FunctionImpl<bool(Xml::*)() const>(&Xml::isConstPtr));
					case 112: return FunctionPtr(new FunctionImpl<uint32_t(Xml::*)() const>(&Xml::getCountPtr));
					case 113: return FunctionPtr(new FunctionImpl<const void*(Xml::*)() const>(&Xml::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2, 4, 7, 10 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 22, 94, 22, 889, 22, 22, 889, 94, 22 };
			static constexpr uint16_t constructor_arg_names[] = { 23, 316, 23, 316, 458, 23, 316, 458, 23, 316 };
			static constexpr uint16_t function_names[] = { 5, 24, 24, 221, 221, 221, 419, 419, 419, 856, 856, 464, 466, 466, 470, 470, 472, 473, 474, 858, 478, 478, 476, 477, 477, 478, 478, 859, 172, 172, 75, 175, 175, 175, 175, 175, 175, 175, 175, 82, 869, 870, 871, 872, 873, 874, 82, 82, 82, 82, 82, 82, 82, 175, 175, 175, 175, 175, 175, 82, 82, 82, 82, 82, 593, 678, 682, 892, 893, 684, 894, 895, 896, 896, 896, 896, 896, 896, 896, 896, 685, 897, 898, 899, 900, 901, 685, 685, 685, 685, 685, 685, 685, 896, 896, 896, 896, 896, 896, 685, 685, 685, 685, 685, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 21, 21, 21, 21, 21, 21, 888, 888, 10, 888, 888, 888, 10, 21, 6, 10, 21, 888, 888, 10, 19, 19, 888, 888, 16, 6, 6, 16, 6, 6, 6, 6, 6, 6, 6, 6, 16, 21, 1, 10, 39, 123, 126, 16, 21, 1, 10, 39, 123, 126, 6, 6, 6, 6, 6, 6, 10, 10, 10, 10, 10, 10, 21, 10, 21, 6, 10, 16, 21, 6, 6, 6, 6, 6, 6, 6, 6, 16, 1, 10, 39, 123, 126, 16, 21, 1, 10, 39, 123, 126, 6, 6, 6, 6, 6, 6, 10, 10, 10, 10, 10, 888, 888, 888, 888, 888, 888, 888, 888, 888, 888 };
			static constexpr uint16_t function_bases[] = { 0, 0, 3, 6, 7, 8, 9, 11, 13, 15, 15, 15, 17, 17, 17, 19, 21, 22, 22, 23, 24, 25, 26, 26, 26, 26, 27, 28, 28, 29, 30, 30, 31, 32, 33, 35, 37, 39, 43, 47, 47, 47, 48, 49, 50, 50, 50, 52, 54, 57, 60, 63, 65, 67, 70, 73, 77, 81, 87, 93, 95, 98, 101, 103, 105, 106, 107, 108, 109, 109, 109, 110, 111, 113, 115, 117, 120, 123, 126, 131, 136, 137, 139, 141, 143, 144, 145, 147, 149, 152, 155, 158, 160, 162, 166, 170, 174, 178, 184, 190, 194, 198, 202, 205, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208, 208 };
			static constexpr uint16_t function_arg_types[] = { 22, 74, 21, 94, 74, 21, 22, 94, 145, 22, 21, 94, 21, 145, 21, 890, 21, 22, 21, 890, 21, 890, 22, 22, 22, 22, 10, 10, 22, 94, 21, 22, 94, 1, 10, 10, 10, 39, 10, 123, 10, 21, 21, 126, 10, 21, 21, 10, 10, 10, 22, 94, 22, 21, 22, 1, 10, 22, 10, 10, 22, 39, 10, 22, 123, 22, 126, 876, 10, 10, 878, 10, 10, 879, 10, 10, 10, 880, 10, 10, 10, 881, 10, 10, 21, 21, 10, 882, 10, 10, 21, 21, 10, 883, 10, 884, 10, 10, 885, 10, 10, 886, 10, 887, 10, 22, 22, 22, 22, 10, 22, 10, 21, 10, 22, 10, 94, 10, 1, 10, 10, 10, 10, 10, 39, 10, 10, 123, 10, 21, 21, 10, 126, 10, 21, 21, 10, 10, 10, 10, 10, 10, 10, 10, 10, 22, 94, 22, 21, 22, 1, 10, 22, 10, 10, 22, 39, 10, 22, 123, 22, 126, 10, 876, 10, 22, 10, 878, 10, 22, 10, 879, 10, 10, 10, 880, 10, 10, 10, 881, 10, 10, 21, 21, 10, 882, 10, 10, 21, 21, 10, 883, 10, 22, 10, 884, 10, 10, 10, 885, 10, 10, 10, 886, 10, 10, 887, 10 };
			static constexpr uint16_t function_arg_names[] = { 93, 87, 854, 93, 87, 854, 23, 23, 222, 23, 855, 23, 855, 222, 855, 458, 50, 23, 50, 471, 50, 471, 23, 23, 23, 23, 274, 274, 23, 23, 105, 105, 105, 105, 866, 105, 866, 105, 866, 105, 867, 855, 868, 105, 867, 855, 868, 866, 866, 866, 23, 105, 23, 105, 23, 105, 866, 23, 105, 866, 23, 105, 866, 23, 105, 23, 105, 877, 87, 891, 877, 87, 891, 877, 87, 866, 891, 877, 87, 866, 891, 877, 87, 867, 855, 868, 891, 877, 87, 867, 855, 868, 891, 877, 87, 877, 87, 866, 877, 87, 866, 877, 87, 877, 87, 23, 23, 23, 23, 274, 93, 274, 105, 274, 105, 274, 105, 274, 105, 866, 274, 105, 866, 274, 105, 866, 274, 105, 867, 855, 868, 274, 105, 867, 855, 868, 274, 274, 866, 274, 866, 274, 866, 274, 274, 23, 105, 23, 105, 23, 105, 866, 23, 105, 866, 23, 105, 866, 23, 105, 23, 105, 274, 877, 87, 217, 274, 877, 87, 217, 274, 877, 87, 866, 274, 877, 87, 866, 274, 877, 87, 867, 855, 868, 274, 877, 87, 867, 855, 868, 274, 877, 87, 217, 274, 877, 87, 866, 274, 877, 87, 866, 274, 877, 87, 274, 877, 87 };
	};
	constexpr uint16_t ReflectionXml::constructor_bases[];
	constexpr uint16_t ReflectionXml::constructor_arg_types[];
	constexpr uint16_t ReflectionXml::constructor_arg_names[];
	constexpr uint16_t ReflectionXml::function_names[];
	constexpr uint16_t ReflectionXml::function_types[];
	constexpr uint16_t ReflectionXml::function_bases[];
	constexpr uint16_t ReflectionXml::function_arg_types[];
	constexpr uint16_t ReflectionXml::function_arg_names[];
	static ReflectionXml reflection_xml;
	
	// Tellusim::Buffer
	class ReflectionBuffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Buffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Buffer, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Buffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Buffer::*)() const>(&Buffer::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Buffer::*)() const>(&Buffer::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Buffer::*)() const>(&Buffer::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Buffer::*)()>(&Buffer::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Buffer::*)() const>(&Buffer::isCreated));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Buffer::*)(const char*)>(&Buffer::setName));
					case 6: return FunctionPtr(new FunctionImpl<String(Buffer::*)() const>(&Buffer::getName));
					case 7: return FunctionPtr(new FunctionImpl<bool(Buffer::*)(Buffer::Flags, size_t, Format)>(&Buffer::create, (Buffer::Flags)0, {}, Tellusim::FormatUnknown));
					case 8: return FunctionPtr(new FunctionImpl<bool(Buffer::*)() const>(&Buffer::isMapped));
					case 9: return FunctionPtr(new FunctionImpl<Buffer::Flags(Buffer::*)() const>(&Buffer::getFlags));
					case 10: return FunctionPtr(new FunctionImpl<bool(Buffer::*)(Buffer::Flags) const>(&Buffer::hasFlag));
					case 11: return FunctionPtr(new FunctionImpl<bool(Buffer::*)(Buffer::Flags) const>(&Buffer::hasFlags));
					case 12: return FunctionPtr(new FunctionImpl<String(Buffer::*)() const>(&Buffer::getFlagsName));
					case 13: return FunctionPtr(new FunctionImpl<Format(Buffer::*)() const>(&Buffer::getFormat));
					case 14: return FunctionPtr(new FunctionImpl<const char*(Buffer::*)() const>(&Buffer::getFormatName));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(Buffer::*)() const>(&Buffer::getComponents));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(Buffer::*)() const>(&Buffer::getPixelSize));
					case 17: return FunctionPtr(new FunctionImpl<size_t(Buffer::*)()>(&Buffer::getSize));
					case 18: return FunctionPtr(new FunctionImpl<size_t(Buffer::*)()>(&Buffer::getPageSize));
					case 19: return FunctionPtr(new FunctionImpl<String(Buffer::*)() const>(&Buffer::getDescription));
					case 20: return FunctionPtr(new FunctionImpl<Buffer(Buffer::*)() const>(&Buffer::clonePtr));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(Buffer::*)()>(&Buffer::clearPtr));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(Buffer::*)()>(&Buffer::destroyPtr));
					case 23: return FunctionPtr(new FunctionImpl<Buffer&(Buffer::*)()>(&Buffer::acquirePtr));
					case 24: return FunctionPtr(new FunctionImpl<Buffer&(Buffer::*)()>(&Buffer::unacquirePtr));
					case 25: return FunctionPtr(new FunctionImpl<bool(Buffer::*)() const>(&Buffer::isValidPtr));
					case 26: return FunctionPtr(new FunctionImpl<bool(Buffer::*)() const>(&Buffer::isOwnerPtr));
					case 27: return FunctionPtr(new FunctionImpl<bool(Buffer::*)() const>(&Buffer::isConstPtr));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(Buffer::*)() const>(&Buffer::getCountPtr));
					case 29: return FunctionPtr(new FunctionImpl<const void*(Buffer::*)() const>(&Buffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 172, 75, 24, 71, 906, 907, 908, 909, 349, 350, 383, 384, 73, 910, 403, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 6, 16, 21, 21, 642, 21, 21, 16, 340, 138, 10, 10, 74, 74, 16, 902, 902, 902, 902, 902, 902, 902, 902, 902, 902 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 1, 1, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 };
			static constexpr uint16_t function_arg_types[] = { 22, 905, 74, 340, 905, 905 };
			static constexpr uint16_t function_arg_names[] = { 23, 338, 87, 96, 338, 338 };
	};
	constexpr uint16_t ReflectionBuffer::constructor_bases[];
	constexpr uint16_t ReflectionBuffer::constructor_arg_types[];
	constexpr uint16_t ReflectionBuffer::constructor_arg_names[];
	constexpr uint16_t ReflectionBuffer::function_names[];
	constexpr uint16_t ReflectionBuffer::function_types[];
	constexpr uint16_t ReflectionBuffer::function_bases[];
	constexpr uint16_t ReflectionBuffer::function_arg_types[];
	constexpr uint16_t ReflectionBuffer::function_arg_names[];
	static ReflectionBuffer reflection_buffer;
	
	// Tellusim::BufferTable
	class ReflectionBufferTable : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return BufferTable::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<BufferTable, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<BufferTable>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(BufferTable::*)() const>(&BufferTable::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(BufferTable::*)() const>(&BufferTable::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(BufferTable::*)() const>(&BufferTable::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(BufferTable::*)()>(&BufferTable::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(BufferTable::*)() const>(&BufferTable::isCreated));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(BufferTable::*)(const char*)>(&BufferTable::setName));
					case 6: return FunctionPtr(new FunctionImpl<String(BufferTable::*)() const>(&BufferTable::getName));
					case 7: return FunctionPtr(new FunctionImpl<bool(BufferTable::*)(uint32_t)>(&BufferTable::create));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(BufferTable::*)() const>(&BufferTable::getSize));
					case 9: return FunctionPtr(new FunctionImpl<Buffer(BufferTable::*)(uint32_t) const>(&BufferTable::get));
					case 10: return FunctionPtr(new FunctionImpl<bool(BufferTable::*)(uint32_t) const>(&BufferTable::isOwner));
					case 11: return FunctionPtr(new FunctionImpl<size_t(BufferTable::*)() const>(&BufferTable::getMemory));
					case 12: return FunctionPtr(new FunctionImpl<BufferTable(BufferTable::*)() const>(&BufferTable::clonePtr));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(BufferTable::*)()>(&BufferTable::clearPtr));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(BufferTable::*)()>(&BufferTable::destroyPtr));
					case 15: return FunctionPtr(new FunctionImpl<BufferTable&(BufferTable::*)()>(&BufferTable::acquirePtr));
					case 16: return FunctionPtr(new FunctionImpl<BufferTable&(BufferTable::*)()>(&BufferTable::unacquirePtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(BufferTable::*)() const>(&BufferTable::isValidPtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(BufferTable::*)() const>(&BufferTable::isOwnerPtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(BufferTable::*)() const>(&BufferTable::isConstPtr));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(BufferTable::*)() const>(&BufferTable::getCountPtr));
					case 21: return FunctionPtr(new FunctionImpl<const void*(BufferTable::*)() const>(&BufferTable::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 172, 75, 24, 73, 553, 912, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 6, 16, 21, 10, 902, 21, 74, 911, 911, 911, 911, 911, 911, 911, 911, 911, 911 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 22, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 87, 274, 274 };
	};
	constexpr uint16_t ReflectionBufferTable::constructor_bases[];
	constexpr uint16_t ReflectionBufferTable::constructor_arg_types[];
	constexpr uint16_t ReflectionBufferTable::constructor_arg_names[];
	constexpr uint16_t ReflectionBufferTable::function_names[];
	constexpr uint16_t ReflectionBufferTable::function_types[];
	constexpr uint16_t ReflectionBufferTable::function_bases[];
	constexpr uint16_t ReflectionBufferTable::function_arg_types[];
	constexpr uint16_t ReflectionBufferTable::function_arg_names[];
	static ReflectionBufferTable reflection_buffer_table;
	
	// Tellusim::D3D12Buffer
	class ReflectionD3D12Buffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Buffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_buffer;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Buffer, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Buffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(D3D12Buffer::*)(Buffer::Flags, ID3D12Resource*, uint32_t)>(&D3D12Buffer::create));
					case 1: return FunctionPtr(new FunctionImpl<ID3D12Resource*(D3D12Buffer::*)() const>(&D3D12Buffer::getD3D12Buffer));
					case 2: return FunctionPtr(new FunctionImpl<size_t(D3D12Buffer::*)() const>(&D3D12Buffer::getUnorderedAccessView));
					case 3: return FunctionPtr(new FunctionImpl<size_t(D3D12Buffer::*)() const>(&D3D12Buffer::getShaderResourceView));
					case 4: return FunctionPtr(new FunctionImpl<uint64_t(D3D12Buffer::*)() const>(&D3D12Buffer::getBufferAddress));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(D3D12Buffer::*)(uint32_t)>(&D3D12Buffer::setBufferState));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Buffer::*)() const>(&D3D12Buffer::getBufferState));
					case 7: return FunctionPtr(new FunctionVoidImpl<void*(D3D12Buffer::*)() const>(&D3D12Buffer::getSharedHandle));
					case 8: return FunctionPtr(new FunctionVoidImpl<void*(D3D12Buffer::*)() const>(&D3D12Buffer::getInteropHandle));
					case 9: return FunctionPtr(new FunctionImpl<D3D12Buffer(D3D12Buffer::*)() const>(&D3D12Buffer::clonePtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(D3D12Buffer::*)()>(&D3D12Buffer::clearPtr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(D3D12Buffer::*)()>(&D3D12Buffer::destroyPtr));
					case 12: return FunctionPtr(new FunctionImpl<D3D12Buffer&(D3D12Buffer::*)()>(&D3D12Buffer::acquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<D3D12Buffer&(D3D12Buffer::*)()>(&D3D12Buffer::unacquirePtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(D3D12Buffer::*)() const>(&D3D12Buffer::isValidPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(D3D12Buffer::*)() const>(&D3D12Buffer::isOwnerPtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(D3D12Buffer::*)() const>(&D3D12Buffer::isConstPtr));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Buffer::*)() const>(&D3D12Buffer::getCountPtr));
					case 18: return FunctionPtr(new FunctionImpl<const void*(D3D12Buffer::*)() const>(&D3D12Buffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 917, 919, 920, 921, 922, 923, 924, 925, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 918, 74, 74, 39, 6, 10, 6, 6, 913, 913, 913, 913, 913, 913, 913, 913, 913, 913 };
			static constexpr uint16_t function_bases[] = { 0, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 905, 914, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 338, 915, 916, 916 };
	};
	constexpr uint16_t ReflectionD3D12Buffer::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Buffer::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Buffer::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Buffer::function_names[];
	constexpr uint16_t ReflectionD3D12Buffer::function_types[];
	constexpr uint16_t ReflectionD3D12Buffer::function_bases[];
	constexpr uint16_t ReflectionD3D12Buffer::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Buffer::function_arg_names[];
	static ReflectionD3D12Buffer reflection_d3d12_buffer;
	
	// Tellusim::D3D11Buffer
	class ReflectionD3D11Buffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D11Buffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_buffer;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D11Buffer, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D11Buffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(D3D11Buffer::*)(Buffer::Flags, ID3D11Buffer*)>(&D3D11Buffer::create));
					case 1: return FunctionPtr(new FunctionImpl<ID3D11Buffer*(D3D11Buffer::*)() const>(&D3D11Buffer::getD3D11Buffer));
					case 2: return FunctionPtr(new FunctionImpl<ID3D11UnorderedAccessView*(D3D11Buffer::*)() const>(&D3D11Buffer::getUnorderedAccessView));
					case 3: return FunctionPtr(new FunctionImpl<ID3D11ShaderResourceView*(D3D11Buffer::*)() const>(&D3D11Buffer::getShaderResourceView));
					case 4: return FunctionPtr(new FunctionVoidImpl<void*(D3D11Buffer::*)() const>(&D3D11Buffer::getInteropHandle));
					case 5: return FunctionPtr(new FunctionImpl<D3D11Buffer(D3D11Buffer::*)() const>(&D3D11Buffer::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(D3D11Buffer::*)()>(&D3D11Buffer::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(D3D11Buffer::*)()>(&D3D11Buffer::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<D3D11Buffer&(D3D11Buffer::*)()>(&D3D11Buffer::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<D3D11Buffer&(D3D11Buffer::*)()>(&D3D11Buffer::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(D3D11Buffer::*)() const>(&D3D11Buffer::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(D3D11Buffer::*)() const>(&D3D11Buffer::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(D3D11Buffer::*)() const>(&D3D11Buffer::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Buffer::*)() const>(&D3D11Buffer::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(D3D11Buffer::*)() const>(&D3D11Buffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 928, 919, 920, 925, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 929, 930, 931, 6, 926, 926, 926, 926, 926, 926, 926, 926, 926, 926 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 };
			static constexpr uint16_t function_arg_types[] = { 905, 927 };
			static constexpr uint16_t function_arg_names[] = { 338, 915 };
	};
	constexpr uint16_t ReflectionD3D11Buffer::constructor_bases[];
	constexpr uint16_t ReflectionD3D11Buffer::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D11Buffer::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D11Buffer::function_names[];
	constexpr uint16_t ReflectionD3D11Buffer::function_types[];
	constexpr uint16_t ReflectionD3D11Buffer::function_bases[];
	constexpr uint16_t ReflectionD3D11Buffer::function_arg_types[];
	constexpr uint16_t ReflectionD3D11Buffer::function_arg_names[];
	static ReflectionD3D11Buffer reflection_d3d11_buffer;
	
	// Tellusim::MTLBuffer
	class ReflectionMTLBuffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLBuffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_buffer;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLBuffer, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLBuffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(MTLBuffer::*)(Buffer::Flags, void*)>(&MTLBuffer::create));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(MTLBuffer::*)() const>(&MTLBuffer::getMTLBuffer));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(MTLBuffer::*)() const>(&MTLBuffer::getSharedPtr));
					case 3: return FunctionPtr(new FunctionImpl<MTLBuffer(MTLBuffer::*)() const>(&MTLBuffer::clonePtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(MTLBuffer::*)()>(&MTLBuffer::clearPtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(MTLBuffer::*)()>(&MTLBuffer::destroyPtr));
					case 6: return FunctionPtr(new FunctionImpl<MTLBuffer&(MTLBuffer::*)()>(&MTLBuffer::acquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<MTLBuffer&(MTLBuffer::*)()>(&MTLBuffer::unacquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(MTLBuffer::*)() const>(&MTLBuffer::isValidPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(MTLBuffer::*)() const>(&MTLBuffer::isOwnerPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(MTLBuffer::*)() const>(&MTLBuffer::isConstPtr));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(MTLBuffer::*)() const>(&MTLBuffer::getCountPtr));
					case 12: return FunctionPtr(new FunctionImpl<const void*(MTLBuffer::*)() const>(&MTLBuffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 933, 934, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 6, 6, 932, 932, 932, 932, 932, 932, 932, 932, 932, 932 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 };
			static constexpr uint16_t function_arg_types[] = { 905, 85 };
			static constexpr uint16_t function_arg_names[] = { 338, 915 };
	};
	constexpr uint16_t ReflectionMTLBuffer::constructor_bases[];
	constexpr uint16_t ReflectionMTLBuffer::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLBuffer::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLBuffer::function_names[];
	constexpr uint16_t ReflectionMTLBuffer::function_types[];
	constexpr uint16_t ReflectionMTLBuffer::function_bases[];
	constexpr uint16_t ReflectionMTLBuffer::function_arg_types[];
	constexpr uint16_t ReflectionMTLBuffer::function_arg_names[];
	static ReflectionMTLBuffer reflection_mtl_buffer;
	
	// Tellusim::VKBuffer
	class ReflectionVKBuffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKBuffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_buffer;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKBuffer, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKBuffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(VKBuffer::*)(Buffer::Flags, size_t, VkBuffer, uint32_t)>(&VKBuffer::create));
					case 1: return FunctionPtr(new FunctionImpl<VkBuffer(VKBuffer::*)() const>(&VKBuffer::getVKBuffer));
					case 2: return FunctionPtr(new FunctionImpl<VkBufferView(VKBuffer::*)() const>(&VKBuffer::getBufferView));
					case 3: return FunctionPtr(new FunctionImpl<uint64_t(VKBuffer::*)() const>(&VKBuffer::getBufferAddress));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(VKBuffer::*)(uint32_t)>(&VKBuffer::setBufferAccess));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(VKBuffer::*)() const>(&VKBuffer::getBufferAccess));
					case 6: return FunctionPtr(new FunctionVoidImpl<void*(VKBuffer::*)() const>(&VKBuffer::getSharedPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void*(VKBuffer::*)() const>(&VKBuffer::getInteropHandle));
					case 8: return FunctionPtr(new FunctionImpl<VKBuffer(VKBuffer::*)() const>(&VKBuffer::clonePtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(VKBuffer::*)()>(&VKBuffer::clearPtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(VKBuffer::*)()>(&VKBuffer::destroyPtr));
					case 11: return FunctionPtr(new FunctionImpl<VKBuffer&(VKBuffer::*)()>(&VKBuffer::acquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<VKBuffer&(VKBuffer::*)()>(&VKBuffer::unacquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(VKBuffer::*)() const>(&VKBuffer::isValidPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(VKBuffer::*)() const>(&VKBuffer::isOwnerPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(VKBuffer::*)() const>(&VKBuffer::isConstPtr));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(VKBuffer::*)() const>(&VKBuffer::getCountPtr));
					case 17: return FunctionPtr(new FunctionImpl<const void*(VKBuffer::*)() const>(&VKBuffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 938, 939, 921, 941, 942, 934, 925, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 936, 940, 39, 6, 10, 6, 6, 935, 935, 935, 935, 935, 935, 935, 935, 935, 935 };
			static constexpr uint16_t function_bases[] = { 0, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };
			static constexpr uint16_t function_arg_types[] = { 905, 74, 936, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 338, 87, 915, 937, 937 };
	};
	constexpr uint16_t ReflectionVKBuffer::constructor_bases[];
	constexpr uint16_t ReflectionVKBuffer::constructor_arg_types[];
	constexpr uint16_t ReflectionVKBuffer::constructor_arg_names[];
	constexpr uint16_t ReflectionVKBuffer::function_names[];
	constexpr uint16_t ReflectionVKBuffer::function_types[];
	constexpr uint16_t ReflectionVKBuffer::function_bases[];
	constexpr uint16_t ReflectionVKBuffer::function_arg_types[];
	constexpr uint16_t ReflectionVKBuffer::function_arg_names[];
	static ReflectionVKBuffer reflection_vk_buffer;
	
	// Tellusim::GLBuffer
	class ReflectionGLBuffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLBuffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_buffer;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLBuffer, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLBuffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(GLBuffer::*)(Buffer::Flags, uint32_t, uint32_t)>(&GLBuffer::create));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(GLBuffer::*)() const>(&GLBuffer::getTarget));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(GLBuffer::*)() const>(&GLBuffer::getBufferID));
					case 3: return FunctionPtr(new FunctionImpl<GLBuffer(GLBuffer::*)() const>(&GLBuffer::clonePtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(GLBuffer::*)()>(&GLBuffer::clearPtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(GLBuffer::*)()>(&GLBuffer::destroyPtr));
					case 6: return FunctionPtr(new FunctionImpl<GLBuffer&(GLBuffer::*)()>(&GLBuffer::acquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<GLBuffer&(GLBuffer::*)()>(&GLBuffer::unacquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(GLBuffer::*)() const>(&GLBuffer::isValidPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(GLBuffer::*)() const>(&GLBuffer::isOwnerPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(GLBuffer::*)() const>(&GLBuffer::isConstPtr));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(GLBuffer::*)() const>(&GLBuffer::getCountPtr));
					case 12: return FunctionPtr(new FunctionImpl<const void*(GLBuffer::*)() const>(&GLBuffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 946, 947, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 10, 943, 943, 943, 943, 943, 943, 943, 943, 943, 943 };
			static constexpr uint16_t function_bases[] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 905, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 338, 944, 945 };
	};
	constexpr uint16_t ReflectionGLBuffer::constructor_bases[];
	constexpr uint16_t ReflectionGLBuffer::constructor_arg_types[];
	constexpr uint16_t ReflectionGLBuffer::constructor_arg_names[];
	constexpr uint16_t ReflectionGLBuffer::function_names[];
	constexpr uint16_t ReflectionGLBuffer::function_types[];
	constexpr uint16_t ReflectionGLBuffer::function_bases[];
	constexpr uint16_t ReflectionGLBuffer::function_arg_types[];
	constexpr uint16_t ReflectionGLBuffer::function_arg_names[];
	static ReflectionGLBuffer reflection_gl_buffer;
	
	// Tellusim::GLESBuffer
	class ReflectionGLESBuffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLESBuffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_buffer;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLESBuffer, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLESBuffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(GLESBuffer::*)(Buffer::Flags, uint32_t, uint32_t)>(&GLESBuffer::create));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(GLESBuffer::*)() const>(&GLESBuffer::getTarget));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(GLESBuffer::*)() const>(&GLESBuffer::getBufferID));
					case 3: return FunctionPtr(new FunctionImpl<GLESBuffer(GLESBuffer::*)() const>(&GLESBuffer::clonePtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(GLESBuffer::*)()>(&GLESBuffer::clearPtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(GLESBuffer::*)()>(&GLESBuffer::destroyPtr));
					case 6: return FunctionPtr(new FunctionImpl<GLESBuffer&(GLESBuffer::*)()>(&GLESBuffer::acquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<GLESBuffer&(GLESBuffer::*)()>(&GLESBuffer::unacquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(GLESBuffer::*)() const>(&GLESBuffer::isValidPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(GLESBuffer::*)() const>(&GLESBuffer::isOwnerPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(GLESBuffer::*)() const>(&GLESBuffer::isConstPtr));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(GLESBuffer::*)() const>(&GLESBuffer::getCountPtr));
					case 12: return FunctionPtr(new FunctionImpl<const void*(GLESBuffer::*)() const>(&GLESBuffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 946, 947, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 10, 948, 948, 948, 948, 948, 948, 948, 948, 948, 948 };
			static constexpr uint16_t function_bases[] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 905, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 338, 944, 945 };
	};
	constexpr uint16_t ReflectionGLESBuffer::constructor_bases[];
	constexpr uint16_t ReflectionGLESBuffer::constructor_arg_types[];
	constexpr uint16_t ReflectionGLESBuffer::constructor_arg_names[];
	constexpr uint16_t ReflectionGLESBuffer::function_names[];
	constexpr uint16_t ReflectionGLESBuffer::function_types[];
	constexpr uint16_t ReflectionGLESBuffer::function_bases[];
	constexpr uint16_t ReflectionGLESBuffer::function_arg_types[];
	constexpr uint16_t ReflectionGLESBuffer::function_arg_names[];
	static ReflectionGLESBuffer reflection_gles_buffer;
	
	// Tellusim::CUBuffer
	class ReflectionCUBuffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CUBuffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_buffer;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CUBuffer, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CUBuffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<size_t(CUBuffer::*)() const>(&CUBuffer::getBufferPtr));
					case 1: return FunctionPtr(new FunctionImpl<uint8_t*(CUBuffer::*)() const>(&CUBuffer::getBufferData));
					case 2: return FunctionPtr(new FunctionImpl<CUevent(CUBuffer::*)() const>(&CUBuffer::getBufferEvent));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(CUBuffer::*)() const>(&CUBuffer::getArrayFormat));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(CUBuffer::*)() const>(&CUBuffer::getArrayChannels));
					case 5: return FunctionPtr(new FunctionImpl<CUexternalMemory(CUBuffer::*)() const>(&CUBuffer::getSharedMemory));
					case 6: return FunctionPtr(new FunctionImpl<CUBuffer(CUBuffer::*)() const>(&CUBuffer::clonePtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(CUBuffer::*)()>(&CUBuffer::clearPtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(CUBuffer::*)()>(&CUBuffer::destroyPtr));
					case 9: return FunctionPtr(new FunctionImpl<CUBuffer&(CUBuffer::*)()>(&CUBuffer::acquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<CUBuffer&(CUBuffer::*)()>(&CUBuffer::unacquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(CUBuffer::*)() const>(&CUBuffer::isValidPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(CUBuffer::*)() const>(&CUBuffer::isOwnerPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(CUBuffer::*)() const>(&CUBuffer::isConstPtr));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(CUBuffer::*)() const>(&CUBuffer::getCountPtr));
					case 15: return FunctionPtr(new FunctionImpl<const void*(CUBuffer::*)() const>(&CUBuffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 950, 951, 952, 954, 955, 956, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 74, 83, 953, 10, 10, 957, 949, 949, 949, 949, 949, 949, 949, 949, 949, 949 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionCUBuffer::constructor_bases[];
	constexpr uint16_t ReflectionCUBuffer::constructor_arg_types[];
	constexpr uint16_t ReflectionCUBuffer::constructor_arg_names[];
	constexpr uint16_t ReflectionCUBuffer::function_names[];
	constexpr uint16_t ReflectionCUBuffer::function_types[];
	constexpr uint16_t ReflectionCUBuffer::function_bases[];
	constexpr uint16_t ReflectionCUBuffer::function_arg_types[];
	constexpr uint16_t ReflectionCUBuffer::function_arg_names[];
	static ReflectionCUBuffer reflection_cu_buffer;
	
	// Tellusim::HIPBuffer
	class ReflectionHIPBuffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return HIPBuffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_buffer;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<HIPBuffer, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<HIPBuffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(HIPBuffer::*)() const>(&HIPBuffer::getBufferPtr));
					case 1: return FunctionPtr(new FunctionImpl<uint8_t*(HIPBuffer::*)() const>(&HIPBuffer::getBufferData));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(HIPBuffer::*)() const>(&HIPBuffer::getBufferEvent));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(HIPBuffer::*)() const>(&HIPBuffer::getArrayFormat));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(HIPBuffer::*)() const>(&HIPBuffer::getArrayChannels));
					case 5: return FunctionPtr(new FunctionVoidImpl<void*(HIPBuffer::*)() const>(&HIPBuffer::getSharedMemory));
					case 6: return FunctionPtr(new FunctionImpl<HIPBuffer(HIPBuffer::*)() const>(&HIPBuffer::clonePtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(HIPBuffer::*)()>(&HIPBuffer::clearPtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(HIPBuffer::*)()>(&HIPBuffer::destroyPtr));
					case 9: return FunctionPtr(new FunctionImpl<HIPBuffer&(HIPBuffer::*)()>(&HIPBuffer::acquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<HIPBuffer&(HIPBuffer::*)()>(&HIPBuffer::unacquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(HIPBuffer::*)() const>(&HIPBuffer::isValidPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(HIPBuffer::*)() const>(&HIPBuffer::isOwnerPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(HIPBuffer::*)() const>(&HIPBuffer::isConstPtr));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(HIPBuffer::*)() const>(&HIPBuffer::getCountPtr));
					case 15: return FunctionPtr(new FunctionImpl<const void*(HIPBuffer::*)() const>(&HIPBuffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 950, 951, 952, 954, 955, 956, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 83, 6, 10, 10, 6, 958, 958, 958, 958, 958, 958, 958, 958, 958, 958 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionHIPBuffer::constructor_bases[];
	constexpr uint16_t ReflectionHIPBuffer::constructor_arg_types[];
	constexpr uint16_t ReflectionHIPBuffer::constructor_arg_names[];
	constexpr uint16_t ReflectionHIPBuffer::function_names[];
	constexpr uint16_t ReflectionHIPBuffer::function_types[];
	constexpr uint16_t ReflectionHIPBuffer::function_bases[];
	constexpr uint16_t ReflectionHIPBuffer::function_arg_types[];
	constexpr uint16_t ReflectionHIPBuffer::function_arg_names[];
	static ReflectionHIPBuffer reflection_hip_buffer;
	
	// Tellusim::FUBuffer
	class ReflectionFUBuffer : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUBuffer::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_buffer;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUBuffer, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUBuffer, TypeList<const Array<Buffer>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUBuffer>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUBuffer::*)(uint32_t)>(&FUBuffer::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUBuffer::*)() const>(&FUBuffer::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUBuffer::*)() const>(&FUBuffer::getNumBuffers));
					case 3: return FunctionPtr(new FunctionImpl<const Buffer(FUBuffer::*)(uint32_t) const>(&FUBuffer::getBuffer));
					case 4: return FunctionPtr(new FunctionImpl<Buffer(FUBuffer::*)(uint32_t)>(&FUBuffer::getBuffer));
					case 5: return FunctionPtr(new FunctionImpl<FUBuffer(FUBuffer::*)() const>(&FUBuffer::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUBuffer::*)()>(&FUBuffer::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUBuffer::*)()>(&FUBuffer::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUBuffer&(FUBuffer::*)()>(&FUBuffer::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUBuffer&(FUBuffer::*)()>(&FUBuffer::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUBuffer::*)() const>(&FUBuffer::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUBuffer::*)() const>(&FUBuffer::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUBuffer::*)() const>(&FUBuffer::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUBuffer::*)() const>(&FUBuffer::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUBuffer::*)() const>(&FUBuffer::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 960, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 961, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 964, 965, 965, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 902, 902, 959, 959, 959, 959, 959, 959, 959, 959, 959, 959 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUBuffer::constructor_bases[];
	constexpr uint16_t ReflectionFUBuffer::constructor_arg_types[];
	constexpr uint16_t ReflectionFUBuffer::constructor_arg_names[];
	constexpr uint16_t ReflectionFUBuffer::function_names[];
	constexpr uint16_t ReflectionFUBuffer::function_types[];
	constexpr uint16_t ReflectionFUBuffer::function_bases[];
	constexpr uint16_t ReflectionFUBuffer::function_arg_types[];
	constexpr uint16_t ReflectionFUBuffer::function_arg_names[];
	static ReflectionFUBuffer reflection_fu_buffer;
	
	// Tellusim::Command
	class ReflectionCommand : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Command::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Command, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Command>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Command::*)() const>(&Command::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Command::*)() const>(&Command::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Command::*)() const>(&Command::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(Pipeline&)>(&Command::setPipeline));
					case 4: return FunctionPtr(new FunctionImpl<Pipeline(Command::*)() const>(&Command::getPipeline));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Viewport&)>(&Command::setViewport));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(const Viewport*, uint32_t)>(&Command::setViewports));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Scissor&)>(&Command::setScissor));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(const Scissor*, uint32_t)>(&Command::setScissors));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Sampler&)>(&Command::setSampler));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Sampler>&)>(&Command::setSamplers));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Sampler>&)>(&Command::setSamplers));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Texture&)>(&Command::setTexture));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Texture&, const Slice&)>(&Command::setTexture));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Texture>&)>(&Command::setTextures));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Texture>&)>(&Command::setTextures));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Texture&)>(&Command::setSurfaceTexture));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Texture&, const Slice&, Format)>(&Command::setSurfaceTexture, {}, Texture::null, {}, Tellusim::FormatUnknown));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Texture>&)>(&Command::setSurfaceTextures));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Texture>&)>(&Command::setSurfaceTextures));
					case 20: return FunctionPtr(new FunctionVoidImpl<void*(Command::*)(uint32_t, size_t)>(&Command::getUniformData));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const void*, size_t)>(&Command::setUniformData));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Buffer&, size_t, size_t)>(&Command::setUniformBuffer, {}, Buffer::null, 0, 0));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, size_t, bool)>(&Command::setUniformOffset, {}, {}, false));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Buffer>&)>(&Command::setUniformBuffers));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Buffer>&, const Array<size_t>&)>(&Command::setUniformBuffers));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Buffer>&)>(&Command::setUniformBuffers));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Buffer>&, const InitializerList<size_t>&)>(&Command::setUniformBuffers));
					case 28: return FunctionPtr(new FunctionVoidImpl<void*(Command::*)(uint32_t, size_t)>(&Command::getStorageData));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const void*, size_t)>(&Command::setStorageData));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Buffer&, size_t, size_t)>(&Command::setStorageBuffer, {}, Buffer::null, 0, 0));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, size_t, bool)>(&Command::setStorageOffset, {}, {}, false));
					case 32: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Buffer>&)>(&Command::setStorageBuffers));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Buffer>&, const Array<size_t>&)>(&Command::setStorageBuffers));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Buffer>&)>(&Command::setStorageBuffers));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Buffer>&, const InitializerList<size_t>&)>(&Command::setStorageBuffers));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Tracing&)>(&Command::setTracing));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Tracing>&)>(&Command::setTracings));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Tracing>&)>(&Command::setTracings));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Buffer&)>(&Command::setTexelBuffer));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Buffer>&)>(&Command::setTexelBuffers));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Buffer>&)>(&Command::setTexelBuffers));
					case 42: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, TextureTable&)>(&Command::setTextureTable));
					case 43: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<TextureTable>&)>(&Command::setTextureTables));
					case 44: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<TextureTable>&)>(&Command::setTextureTables));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, BufferTable&)>(&Command::setStorageTable));
					case 46: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<BufferTable>&)>(&Command::setStorageTables));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<BufferTable>&)>(&Command::setStorageTables));
					case 48: return FunctionPtr(new FunctionVoidImpl<void*(Command::*)(uint32_t, size_t)>(&Command::getVertexData));
					case 49: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const void*, size_t)>(&Command::setVertexData));
					case 50: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, Buffer&, size_t)>(&Command::setVertexBuffer, {}, Buffer::null, 0));
					case 51: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, size_t, bool)>(&Command::setVertexOffset, {}, {}, false));
					case 52: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Buffer>&)>(&Command::setVertexBuffers));
					case 53: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const Array<Buffer>&, const Array<size_t>&)>(&Command::setVertexBuffers));
					case 54: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Buffer>&)>(&Command::setVertexBuffers));
					case 55: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, const InitializerList<Buffer>&, const InitializerList<size_t>&)>(&Command::setVertexBuffers));
					case 56: return FunctionPtr(new FunctionVoidImpl<void*(Command::*)(Format, size_t)>(&Command::getIndexData));
					case 57: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(Format, const void*, size_t)>(&Command::setIndexData));
					case 58: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(Format, Buffer&, size_t)>(&Command::setIndexBuffer, (Format)0, Buffer::null, 0));
					case 59: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(size_t, bool)>(&Command::setIndexOffset, {}, false));
					case 60: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(const InitializerList<uint16_t>&)>(&Command::setIndices));
					case 61: return FunctionPtr(new FunctionVoidImpl<void*(Command::*)(size_t)>(&Command::getIndirectData));
					case 62: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(const void*, size_t)>(&Command::setIndirectData));
					case 63: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(Buffer&, size_t)>(&Command::setIndirectBuffer, Buffer::null, 0));
					case 64: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(size_t, bool)>(&Command::setIndirectOffset, {}, false));
					case 65: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(const Color&)>(&Command::setBlendColor));
					case 66: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(float32_t, float32_t, float32_t, float32_t)>(&Command::setBlendColor));
					case 67: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t)>(&Command::setStencilRef));
					case 68: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, uint32_t)>(&Command::drawArrays, {}, 0));
					case 69: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, uint32_t, uint32_t, uint32_t)>(&Command::drawArraysInstanced, {}, {}, {}, 0));
					case 70: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, size_t)>(&Command::drawArraysIndirect, {}, sizeof(Command::DrawArraysIndirect)));
					case 71: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(Buffer&, size_t, uint32_t, size_t)>(&Command::drawArraysIndirect, Buffer::null, {}, {}, sizeof(Command::DrawArraysIndirect)));
					case 72: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, uint32_t, int32_t)>(&Command::drawElements, {}, 0, 0));
					case 73: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, uint32_t, uint32_t)>(&Command::drawElementsInstanced));
					case 74: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, uint32_t, int32_t, uint32_t, uint32_t)>(&Command::drawElementsInstanced, {}, {}, {}, {}, 0));
					case 75: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, size_t)>(&Command::drawElementsIndirect, {}, sizeof(Command::DrawElementsIndirect)));
					case 76: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(Buffer&, size_t, uint32_t, size_t)>(&Command::drawElementsIndirect, Buffer::null, {}, {}, sizeof(Command::DrawElementsIndirect)));
					case 77: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, uint32_t, uint32_t)>(&Command::drawMesh, {}, 1, 1));
					case 78: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(uint32_t, size_t)>(&Command::drawMeshIndirect, {}, sizeof(Command::DrawMeshIndirect)));
					case 79: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(Buffer&, size_t, uint32_t, size_t)>(&Command::drawMeshIndirect, Buffer::null, {}, {}, sizeof(Command::DrawMeshIndirect)));
					case 80: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(Buffer&, size_t)>(&Command::beginConditional));
					case 81: return FunctionPtr(new FunctionVoidImpl<void(Command::*)()>(&Command::endConditional));
					case 82: return FunctionPtr(new FunctionImpl<bool(Command::*)(Query&)>(&Command::beginQuery));
					case 83: return FunctionPtr(new FunctionVoidImpl<void(Command::*)(Query&)>(&Command::endQuery));
					case 84: return FunctionPtr(new FunctionImpl<Command(Command::*)() const>(&Command::clonePtr));
					case 85: return FunctionPtr(new FunctionVoidImpl<void(Command::*)()>(&Command::clearPtr));
					case 86: return FunctionPtr(new FunctionVoidImpl<void(Command::*)()>(&Command::destroyPtr));
					case 87: return FunctionPtr(new FunctionImpl<Command&(Command::*)()>(&Command::acquirePtr));
					case 88: return FunctionPtr(new FunctionImpl<Command&(Command::*)()>(&Command::unacquirePtr));
					case 89: return FunctionPtr(new FunctionImpl<bool(Command::*)() const>(&Command::isValidPtr));
					case 90: return FunctionPtr(new FunctionImpl<bool(Command::*)() const>(&Command::isOwnerPtr));
					case 91: return FunctionPtr(new FunctionImpl<bool(Command::*)() const>(&Command::isConstPtr));
					case 92: return FunctionPtr(new FunctionImpl<uint32_t(Command::*)() const>(&Command::getCountPtr));
					case 93: return FunctionPtr(new FunctionImpl<const void*(Command::*)() const>(&Command::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 967, 970, 972, 975, 979, 982, 986, 989, 989, 993, 993, 996, 996, 1000, 1000, 1001, 1001, 1002, 1003, 1004, 1006, 1008, 1008, 1008, 1008, 1013, 1014, 1015, 1016, 1017, 1017, 1017, 1017, 1018, 1021, 1021, 1025, 1026, 1026, 1027, 1030, 1030, 1034, 1036, 1036, 1039, 1040, 1041, 1042, 1043, 1043, 1043, 1043, 1044, 1045, 1046, 1047, 583, 1049, 1050, 1051, 1052, 1053, 1053, 1058, 1060, 1063, 1066, 1066, 1068, 1070, 1070, 1071, 1071, 1072, 1073, 1073, 1074, 1075, 1076, 1079, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 971, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 21, 6, 966, 966, 966, 966, 966, 966, 966, 966, 966, 966 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 1, 1, 3, 5, 7, 9, 11, 13, 15, 17, 20, 22, 24, 26, 30, 32, 34, 36, 39, 43, 46, 48, 51, 53, 56, 58, 61, 65, 68, 70, 73, 75, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 107, 110, 113, 115, 118, 120, 123, 125, 128, 131, 133, 134, 135, 137, 139, 141, 142, 146, 147, 149, 153, 155, 159, 162, 165, 170, 172, 176, 179, 181, 185, 187, 187, 188, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189, 189 };
			static constexpr uint16_t function_arg_types[] = { 968, 10, 973, 976, 10, 10, 980, 983, 10, 10, 987, 10, 990, 10, 992, 10, 994, 10, 994, 405, 10, 997, 10, 999, 10, 994, 10, 994, 405, 340, 10, 997, 10, 999, 10, 74, 10, 89, 74, 10, 1005, 74, 74, 10, 74, 21, 10, 960, 10, 960, 1009, 10, 1011, 10, 1011, 1012, 10, 74, 10, 89, 74, 10, 1005, 74, 74, 10, 74, 21, 10, 960, 10, 960, 1009, 10, 1011, 10, 1011, 1012, 10, 1019, 10, 1022, 10, 1024, 10, 1005, 10, 960, 10, 1011, 10, 1028, 10, 1031, 10, 1033, 10, 1035, 10, 1037, 10, 1038, 10, 74, 10, 89, 74, 10, 1005, 74, 10, 74, 21, 10, 960, 10, 960, 1009, 10, 1011, 10, 1011, 1012, 340, 74, 340, 89, 74, 340, 1005, 74, 74, 21, 1048, 74, 89, 74, 1005, 74, 74, 21, 637, 123, 123, 123, 123, 10, 10, 10, 10, 10, 10, 10, 10, 74, 1005, 74, 10, 74, 10, 10, 1, 10, 10, 10, 10, 10, 1, 10, 10, 10, 74, 1005, 74, 10, 74, 10, 10, 10, 10, 74, 1005, 74, 10, 74, 1005, 74, 1077, 1077 };
			static constexpr uint16_t function_arg_names[] = { 969, 274, 974, 977, 978, 274, 981, 984, 985, 274, 988, 274, 991, 274, 991, 274, 995, 274, 995, 406, 274, 998, 274, 998, 274, 995, 274, 995, 406, 96, 274, 998, 274, 998, 274, 87, 274, 90, 87, 274, 915, 78, 87, 274, 78, 1007, 274, 961, 274, 961, 1010, 274, 961, 274, 961, 1010, 274, 87, 274, 90, 87, 274, 915, 78, 87, 274, 78, 1007, 274, 961, 274, 961, 1010, 274, 961, 274, 961, 1010, 274, 1020, 274, 1023, 274, 1023, 274, 915, 274, 961, 274, 961, 274, 1029, 274, 1032, 274, 1032, 274, 1029, 274, 1032, 274, 1032, 274, 87, 274, 90, 87, 274, 915, 78, 274, 78, 1007, 274, 961, 274, 961, 1010, 274, 961, 274, 961, 1010, 96, 87, 96, 90, 87, 96, 915, 78, 78, 1007, 561, 87, 90, 87, 915, 78, 78, 1007, 638, 1054, 1055, 1056, 1057, 1059, 1061, 1062, 1061, 1062, 1064, 1065, 1067, 452, 915, 78, 1067, 452, 667, 1069, 1062, 667, 1069, 1064, 667, 1069, 1062, 1064, 1065, 1067, 452, 915, 78, 1067, 452, 30, 31, 415, 1067, 452, 915, 78, 1067, 452, 915, 78, 1078, 1078 };
	};
	constexpr uint16_t ReflectionCommand::constructor_bases[];
	constexpr uint16_t ReflectionCommand::constructor_arg_types[];
	constexpr uint16_t ReflectionCommand::constructor_arg_names[];
	constexpr uint16_t ReflectionCommand::function_names[];
	constexpr uint16_t ReflectionCommand::function_types[];
	constexpr uint16_t ReflectionCommand::function_bases[];
	constexpr uint16_t ReflectionCommand::function_arg_types[];
	constexpr uint16_t ReflectionCommand::function_arg_names[];
	static ReflectionCommand reflection_command;
	
	// Tellusim::D3D12Command
	class ReflectionD3D12Command : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Command::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_command;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Command, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Command>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<ID3D12GraphicsCommandList*(D3D12Command::*)() const>(&D3D12Command::getD3D12Command));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(D3D12Command::*)()>(&D3D12Command::update));
					case 2: return FunctionPtr(new FunctionImpl<D3D12Command(D3D12Command::*)() const>(&D3D12Command::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D12Command::*)()>(&D3D12Command::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(D3D12Command::*)()>(&D3D12Command::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D12Command&(D3D12Command::*)()>(&D3D12Command::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<D3D12Command&(D3D12Command::*)()>(&D3D12Command::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D12Command::*)() const>(&D3D12Command::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D12Command::*)() const>(&D3D12Command::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(D3D12Command::*)() const>(&D3D12Command::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Command::*)() const>(&D3D12Command::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(D3D12Command::*)() const>(&D3D12Command::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1081, 1083, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1082, 6, 1080, 1080, 1080, 1080, 1080, 1080, 1080, 1080, 1080, 1080 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D12Command::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Command::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Command::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Command::function_names[];
	constexpr uint16_t ReflectionD3D12Command::function_types[];
	constexpr uint16_t ReflectionD3D12Command::function_bases[];
	constexpr uint16_t ReflectionD3D12Command::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Command::function_arg_names[];
	static ReflectionD3D12Command reflection_d3d12_command;
	
	// Tellusim::MTLCommand
	class ReflectionMTLCommand : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLCommand::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_command;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLCommand, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLCommand>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(MTLCommand::*)() const>(&MTLCommand::getEncoder));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(MTLCommand::*)(void*, bool)>(&MTLCommand::flush, {}, false));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(MTLCommand::*)(bool, bool)>(&MTLCommand::flush, false, false));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(MTLCommand::*)()>(&MTLCommand::update));
					case 4: return FunctionPtr(new FunctionImpl<MTLCommand(MTLCommand::*)() const>(&MTLCommand::clonePtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(MTLCommand::*)()>(&MTLCommand::clearPtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(MTLCommand::*)()>(&MTLCommand::destroyPtr));
					case 7: return FunctionPtr(new FunctionImpl<MTLCommand&(MTLCommand::*)()>(&MTLCommand::acquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<MTLCommand&(MTLCommand::*)()>(&MTLCommand::unacquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(MTLCommand::*)() const>(&MTLCommand::isValidPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(MTLCommand::*)() const>(&MTLCommand::isOwnerPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(MTLCommand::*)() const>(&MTLCommand::isConstPtr));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(MTLCommand::*)() const>(&MTLCommand::getCountPtr));
					case 13: return FunctionPtr(new FunctionImpl<const void*(MTLCommand::*)() const>(&MTLCommand::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1085, 91, 91, 1083, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 6, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084, 1084 };
			static constexpr uint16_t function_bases[] = { 0, 0, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 85, 21, 21, 21 };
			static constexpr uint16_t function_arg_names[] = { 1086, 1087, 24, 1087 };
	};
	constexpr uint16_t ReflectionMTLCommand::constructor_bases[];
	constexpr uint16_t ReflectionMTLCommand::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLCommand::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLCommand::function_names[];
	constexpr uint16_t ReflectionMTLCommand::function_types[];
	constexpr uint16_t ReflectionMTLCommand::function_bases[];
	constexpr uint16_t ReflectionMTLCommand::function_arg_types[];
	constexpr uint16_t ReflectionMTLCommand::function_arg_names[];
	static ReflectionMTLCommand reflection_mtl_command;
	
	// Tellusim::VKCommand
	class ReflectionVKCommand : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKCommand::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_command;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKCommand, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKCommand>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<VkCommandBuffer(VKCommand::*)() const>(&VKCommand::getVKCommand));
					case 1: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCommand::*)() const>(&VKCommand::getSamplerDescriptor));
					case 2: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCommand::*)() const>(&VKCommand::getImageDescriptor));
					case 3: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCommand::*)() const>(&VKCommand::getBufferDescriptor));
					case 4: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCommand::*)() const>(&VKCommand::getTracingDescriptor));
					case 5: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCommand::*)() const>(&VKCommand::getTexelDescriptor));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(VKCommand::*)()>(&VKCommand::update));
					case 7: return FunctionPtr(new FunctionImpl<VKCommand(VKCommand::*)() const>(&VKCommand::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(VKCommand::*)()>(&VKCommand::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(VKCommand::*)()>(&VKCommand::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<VKCommand&(VKCommand::*)()>(&VKCommand::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<VKCommand&(VKCommand::*)()>(&VKCommand::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(VKCommand::*)() const>(&VKCommand::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(VKCommand::*)() const>(&VKCommand::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(VKCommand::*)() const>(&VKCommand::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(VKCommand::*)() const>(&VKCommand::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(VKCommand::*)() const>(&VKCommand::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1089, 1091, 1093, 1094, 1095, 1096, 1083, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1090, 1092, 1092, 1092, 1092, 1092, 6, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088, 1088 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionVKCommand::constructor_bases[];
	constexpr uint16_t ReflectionVKCommand::constructor_arg_types[];
	constexpr uint16_t ReflectionVKCommand::constructor_arg_names[];
	constexpr uint16_t ReflectionVKCommand::function_names[];
	constexpr uint16_t ReflectionVKCommand::function_types[];
	constexpr uint16_t ReflectionVKCommand::function_bases[];
	constexpr uint16_t ReflectionVKCommand::function_arg_types[];
	constexpr uint16_t ReflectionVKCommand::function_arg_names[];
	static ReflectionVKCommand reflection_vk_command;
	
	// Tellusim::FUCommand
	class ReflectionFUCommand : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUCommand::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_command;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUCommand, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUCommand, TypeList<const Array<Command>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUCommand>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUCommand::*)(uint32_t)>(&FUCommand::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUCommand::*)() const>(&FUCommand::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUCommand::*)() const>(&FUCommand::getNumCommands));
					case 3: return FunctionPtr(new FunctionImpl<const Command(FUCommand::*)(uint32_t) const>(&FUCommand::getCommand));
					case 4: return FunctionPtr(new FunctionImpl<Command(FUCommand::*)(uint32_t)>(&FUCommand::getCommand));
					case 5: return FunctionPtr(new FunctionImpl<FUCommand(FUCommand::*)() const>(&FUCommand::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUCommand::*)()>(&FUCommand::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUCommand::*)()>(&FUCommand::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUCommand&(FUCommand::*)()>(&FUCommand::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUCommand&(FUCommand::*)()>(&FUCommand::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUCommand::*)() const>(&FUCommand::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUCommand::*)() const>(&FUCommand::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUCommand::*)() const>(&FUCommand::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUCommand::*)() const>(&FUCommand::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUCommand::*)() const>(&FUCommand::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1098, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1099, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1100, 1101, 1101, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 966, 966, 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097, 1097 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUCommand::constructor_bases[];
	constexpr uint16_t ReflectionFUCommand::constructor_arg_types[];
	constexpr uint16_t ReflectionFUCommand::constructor_arg_names[];
	constexpr uint16_t ReflectionFUCommand::function_names[];
	constexpr uint16_t ReflectionFUCommand::function_types[];
	constexpr uint16_t ReflectionFUCommand::function_bases[];
	constexpr uint16_t ReflectionFUCommand::function_arg_types[];
	constexpr uint16_t ReflectionFUCommand::function_arg_names[];
	static ReflectionFUCommand reflection_fu_command;
	
	// Tellusim::Compute
	class ReflectionCompute : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Compute::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Compute, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Compute>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Compute::*)() const>(&Compute::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Compute::*)() const>(&Compute::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Compute::*)() const>(&Compute::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(Kernel&)>(&Compute::setKernel));
					case 4: return FunctionPtr(new FunctionImpl<Kernel(Compute::*)() const>(&Compute::getKernel));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(Traversal&)>(&Compute::setTraversal));
					case 6: return FunctionPtr(new FunctionImpl<Traversal(Compute::*)() const>(&Compute::getTraversal));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, Sampler&)>(&Compute::setSampler));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<Sampler>&)>(&Compute::setSamplers));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<Sampler>&)>(&Compute::setSamplers));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, Texture&)>(&Compute::setTexture));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, Texture&, const Slice&)>(&Compute::setTexture));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<Texture>&)>(&Compute::setTextures));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<Texture>&)>(&Compute::setTextures));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, Texture&)>(&Compute::setSurfaceTexture));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, Texture&, const Slice&, Format)>(&Compute::setSurfaceTexture, {}, Texture::null, {}, Tellusim::FormatUnknown));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<Texture>&)>(&Compute::setSurfaceTextures));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<Texture>&)>(&Compute::setSurfaceTextures));
					case 18: return FunctionPtr(new FunctionVoidImpl<void*(Compute::*)(uint32_t, size_t)>(&Compute::getUniformData));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const void*, size_t)>(&Compute::setUniformData));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, Buffer&, size_t, size_t)>(&Compute::setUniformBuffer, {}, Buffer::null, 0, 0));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, size_t, bool)>(&Compute::setUniformOffset, {}, {}, false));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<Buffer>&)>(&Compute::setUniformBuffers));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<Buffer>&, const Array<size_t>&)>(&Compute::setUniformBuffers));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<Buffer>&)>(&Compute::setUniformBuffers));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<Buffer>&, const InitializerList<size_t>&)>(&Compute::setUniformBuffers));
					case 26: return FunctionPtr(new FunctionVoidImpl<void*(Compute::*)(uint32_t, size_t)>(&Compute::getStorageData));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const void*, size_t)>(&Compute::setStorageData));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, Buffer&, size_t, size_t)>(&Compute::setStorageBuffer, {}, Buffer::null, 0, 0));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, size_t, bool)>(&Compute::setStorageOffset, {}, {}, false));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<Buffer>&)>(&Compute::setStorageBuffers));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<Buffer>&, const InitializerList<size_t>&)>(&Compute::setStorageBuffers));
					case 32: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<Buffer>&)>(&Compute::setStorageBuffers));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<Buffer>&, const Array<size_t>&)>(&Compute::setStorageBuffers));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, Tracing&)>(&Compute::setTracing));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<Tracing>&)>(&Compute::setTracings));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<Tracing>&)>(&Compute::setTracings));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, Buffer&)>(&Compute::setTexelBuffer));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<Buffer>&)>(&Compute::setTexelBuffers));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<Buffer>&)>(&Compute::setTexelBuffers));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, TextureTable&)>(&Compute::setTextureTable));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<TextureTable>&)>(&Compute::setTextureTables));
					case 42: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<TextureTable>&)>(&Compute::setTextureTables));
					case 43: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, BufferTable&)>(&Compute::setStorageTable));
					case 44: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const Array<BufferTable>&)>(&Compute::setStorageTables));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, const InitializerList<BufferTable>&)>(&Compute::setStorageTables));
					case 46: return FunctionPtr(new FunctionVoidImpl<void*(Compute::*)(size_t)>(&Compute::getIndirectData));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(const void*, size_t)>(&Compute::setIndirectData));
					case 48: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(Buffer&, size_t)>(&Compute::setIndirectBuffer, Buffer::null, 0));
					case 49: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(size_t, bool)>(&Compute::setIndirectOffset, {}, false));
					case 50: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(uint32_t, uint32_t, uint32_t)>(&Compute::dispatch, {}, 1, 1));
					case 51: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(const Texture&)>(&Compute::dispatch));
					case 52: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(const Size&)>(&Compute::dispatch));
					case 53: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)()>(&Compute::dispatchIndirect));
					case 54: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, size_t, const void*, size_t)>(&Compute::setBuffer));
					case 55: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, const void*, size_t)>(&Compute::setBuffer));
					case 56: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, const void*)>(&Compute::setBuffer));
					case 57: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, size_t, Buffer&, size_t, size_t)>(&Compute::copyBuffer));
					case 58: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, size_t, Buffer&, size_t)>(&Compute::copyBuffer));
					case 59: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, Buffer&, size_t)>(&Compute::copyBuffer));
					case 60: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, Buffer&)>(&Compute::copyBuffer));
					case 61: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, Format, size_t, const void*, size_t)>(&Compute::clearBuffer));
					case 62: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, Format, const void*, size_t)>(&Compute::clearBuffer));
					case 63: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&, Format, const void*)>(&Compute::clearBuffer));
					case 64: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Buffer&)>(&Compute::clearBuffer));
					case 65: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Origin&, const Slice&, const Image&, const Slice&)>(&Compute::setTexture));
					case 66: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Origin&, const Image&)>(&Compute::setTexture));
					case 67: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Slice&, const Image&)>(&Compute::setTexture));
					case 68: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Image&)>(&Compute::setTexture));
					case 69: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Origin&, const Slice&, Texture&, const Region&, const Slice&)>(&Compute::copyTexture));
					case 70: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Origin&, Texture&, const Region&)>(&Compute::copyTexture));
					case 71: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Slice&, Texture&, const Slice&)>(&Compute::copyTexture));
					case 72: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, Texture&)>(&Compute::copyTexture));
					case 73: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Region&, const Slice&, const void*)>(&Compute::clearTexture));
					case 74: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Region&, const void*)>(&Compute::clearTexture));
					case 75: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const Slice&, const void*)>(&Compute::clearTexture));
					case 76: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Texture&, const void*)>(&Compute::clearTexture));
					case 77: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(Texture&)>(&Compute::barrier));
					case 78: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(Buffer&)>(&Compute::barrier));
					case 79: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(const Array<Texture>&)>(&Compute::barrier));
					case 80: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(const Array<Buffer>&)>(&Compute::barrier));
					case 81: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(const InitializerList<Texture>&)>(&Compute::barrier));
					case 82: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(const InitializerList<Buffer>&)>(&Compute::barrier));
					case 83: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(Buffer&, size_t)>(&Compute::beginConditional));
					case 84: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)()>(&Compute::endConditional));
					case 85: return FunctionPtr(new FunctionImpl<bool(Compute::*)(Query&)>(&Compute::beginQuery));
					case 86: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)(Query&)>(&Compute::endQuery));
					case 87: return FunctionPtr(new FunctionImpl<Compute(Compute::*)() const>(&Compute::clonePtr));
					case 88: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)()>(&Compute::clearPtr));
					case 89: return FunctionPtr(new FunctionVoidImpl<void(Compute::*)()>(&Compute::destroyPtr));
					case 90: return FunctionPtr(new FunctionImpl<Compute&(Compute::*)()>(&Compute::acquirePtr));
					case 91: return FunctionPtr(new FunctionImpl<Compute&(Compute::*)()>(&Compute::unacquirePtr));
					case 92: return FunctionPtr(new FunctionImpl<bool(Compute::*)() const>(&Compute::isValidPtr));
					case 93: return FunctionPtr(new FunctionImpl<bool(Compute::*)() const>(&Compute::isOwnerPtr));
					case 94: return FunctionPtr(new FunctionImpl<bool(Compute::*)() const>(&Compute::isConstPtr));
					case 95: return FunctionPtr(new FunctionImpl<uint32_t(Compute::*)() const>(&Compute::getCountPtr));
					case 96: return FunctionPtr(new FunctionImpl<const void*(Compute::*)() const>(&Compute::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 1103, 1106, 1108, 1111, 986, 989, 989, 993, 993, 996, 996, 1000, 1000, 1001, 1001, 1002, 1003, 1004, 1006, 1008, 1008, 1008, 1008, 1013, 1014, 1015, 1016, 1017, 1017, 1017, 1017, 1018, 1021, 1021, 1025, 1026, 1026, 1027, 1030, 1030, 1034, 1036, 1036, 1049, 1050, 1051, 1052, 1113, 1113, 1113, 1115, 1116, 1116, 1116, 1117, 1117, 1117, 1117, 1120, 1120, 1120, 1120, 993, 993, 993, 993, 1121, 1121, 1121, 1121, 1122, 1122, 1122, 1122, 1123, 1123, 1123, 1123, 1123, 1123, 1074, 1075, 1076, 1079, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 1107, 6, 1112, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 6, 6, 6, 6, 6, 6, 6, 6, 21, 6, 1102, 1102, 1102, 1102, 1102, 1102, 1102, 1102, 1102, 1102 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 1, 1, 2, 2, 4, 6, 8, 10, 13, 15, 17, 19, 23, 25, 27, 29, 32, 36, 39, 41, 44, 46, 49, 51, 54, 58, 61, 63, 66, 68, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 96, 98, 100, 102, 105, 106, 107, 107, 111, 114, 116, 121, 125, 128, 130, 135, 139, 142, 143, 148, 151, 154, 156, 162, 166, 170, 172, 176, 179, 182, 184, 185, 186, 187, 188, 189, 190, 192, 192, 193, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194, 194 };
			static constexpr uint16_t function_arg_types[] = { 1104, 1109, 10, 987, 10, 990, 10, 992, 10, 994, 10, 994, 405, 10, 997, 10, 999, 10, 994, 10, 994, 405, 340, 10, 997, 10, 999, 10, 74, 10, 89, 74, 10, 1005, 74, 74, 10, 74, 21, 10, 960, 10, 960, 1009, 10, 1011, 10, 1011, 1012, 10, 74, 10, 89, 74, 10, 1005, 74, 74, 10, 74, 21, 10, 1011, 10, 1011, 1012, 10, 960, 10, 960, 1009, 10, 1019, 10, 1022, 10, 1024, 10, 1005, 10, 960, 10, 1011, 10, 1028, 10, 1031, 10, 1033, 10, 1035, 10, 1037, 10, 1038, 74, 89, 74, 1005, 74, 74, 21, 10, 10, 10, 1114, 341, 1005, 74, 89, 74, 1005, 89, 74, 1005, 89, 1005, 74, 1005, 74, 74, 1005, 74, 1005, 74, 1005, 1005, 74, 1005, 1005, 1005, 340, 74, 89, 74, 1005, 340, 89, 74, 1005, 340, 89, 1005, 994, 432, 405, 425, 405, 994, 432, 425, 994, 405, 425, 994, 425, 994, 432, 405, 994, 429, 405, 994, 432, 994, 429, 994, 405, 994, 405, 994, 994, 994, 429, 405, 89, 994, 429, 89, 994, 405, 89, 994, 89, 994, 1005, 997, 960, 999, 1011, 1005, 74, 1077, 1077 };
			static constexpr uint16_t function_arg_names[] = { 1105, 1110, 274, 988, 274, 991, 274, 991, 274, 995, 274, 995, 406, 274, 998, 274, 998, 274, 995, 274, 995, 406, 96, 274, 998, 274, 998, 274, 87, 274, 90, 87, 274, 915, 78, 87, 274, 78, 1007, 274, 961, 274, 961, 1010, 274, 961, 274, 961, 1010, 274, 87, 274, 90, 87, 274, 915, 78, 87, 274, 78, 1007, 274, 961, 274, 961, 1010, 274, 961, 274, 961, 1010, 274, 1020, 274, 1023, 274, 1023, 274, 915, 274, 961, 274, 961, 274, 1029, 274, 1032, 274, 1032, 274, 1029, 274, 1032, 274, 1032, 87, 90, 87, 915, 78, 78, 1007, 30, 31, 415, 995, 87, 915, 78, 90, 87, 915, 90, 87, 915, 90, 915, 1118, 90, 1119, 87, 915, 1118, 90, 87, 915, 90, 87, 915, 90, 915, 96, 78, 90, 87, 915, 96, 90, 87, 915, 96, 90, 915, 995, 433, 435, 450, 436, 995, 433, 450, 995, 435, 450, 995, 450, 995, 433, 435, 90, 434, 436, 995, 433, 90, 434, 995, 435, 90, 436, 995, 90, 995, 430, 406, 90, 995, 430, 90, 995, 406, 90, 995, 90, 995, 915, 998, 961, 998, 961, 915, 78, 1078, 1078 };
	};
	constexpr uint16_t ReflectionCompute::constructor_bases[];
	constexpr uint16_t ReflectionCompute::constructor_arg_types[];
	constexpr uint16_t ReflectionCompute::constructor_arg_names[];
	constexpr uint16_t ReflectionCompute::function_names[];
	constexpr uint16_t ReflectionCompute::function_types[];
	constexpr uint16_t ReflectionCompute::function_bases[];
	constexpr uint16_t ReflectionCompute::function_arg_types[];
	constexpr uint16_t ReflectionCompute::function_arg_names[];
	static ReflectionCompute reflection_compute;
	
	// Tellusim::D3D12Compute
	class ReflectionD3D12Compute : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Compute::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_compute;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Compute, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Compute>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<ID3D12GraphicsCommandList*(D3D12Compute::*)() const>(&D3D12Compute::getCommand));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(D3D12Compute::*)()>(&D3D12Compute::update));
					case 2: return FunctionPtr(new FunctionImpl<D3D12Compute(D3D12Compute::*)() const>(&D3D12Compute::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D12Compute::*)()>(&D3D12Compute::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(D3D12Compute::*)()>(&D3D12Compute::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D12Compute&(D3D12Compute::*)()>(&D3D12Compute::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<D3D12Compute&(D3D12Compute::*)()>(&D3D12Compute::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D12Compute::*)() const>(&D3D12Compute::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D12Compute::*)() const>(&D3D12Compute::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(D3D12Compute::*)() const>(&D3D12Compute::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Compute::*)() const>(&D3D12Compute::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(D3D12Compute::*)() const>(&D3D12Compute::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1101, 1083, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1082, 6, 1124, 1124, 1124, 1124, 1124, 1124, 1124, 1124, 1124, 1124 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D12Compute::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Compute::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Compute::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Compute::function_names[];
	constexpr uint16_t ReflectionD3D12Compute::function_types[];
	constexpr uint16_t ReflectionD3D12Compute::function_bases[];
	constexpr uint16_t ReflectionD3D12Compute::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Compute::function_arg_names[];
	static ReflectionD3D12Compute reflection_d3d12_compute;
	
	// Tellusim::MTLCompute
	class ReflectionMTLCompute : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLCompute::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_compute;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLCompute, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLCompute>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(MTLCompute::*)() const>(&MTLCompute::getEncoder));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(MTLCompute::*)(void*, bool)>(&MTLCompute::flush, {}, false));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(MTLCompute::*)(bool, bool)>(&MTLCompute::flush, false, false));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(MTLCompute::*)()>(&MTLCompute::update));
					case 4: return FunctionPtr(new FunctionImpl<MTLCompute(MTLCompute::*)() const>(&MTLCompute::clonePtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(MTLCompute::*)()>(&MTLCompute::clearPtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(MTLCompute::*)()>(&MTLCompute::destroyPtr));
					case 7: return FunctionPtr(new FunctionImpl<MTLCompute&(MTLCompute::*)()>(&MTLCompute::acquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<MTLCompute&(MTLCompute::*)()>(&MTLCompute::unacquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(MTLCompute::*)() const>(&MTLCompute::isValidPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(MTLCompute::*)() const>(&MTLCompute::isOwnerPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(MTLCompute::*)() const>(&MTLCompute::isConstPtr));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(MTLCompute::*)() const>(&MTLCompute::getCountPtr));
					case 13: return FunctionPtr(new FunctionImpl<const void*(MTLCompute::*)() const>(&MTLCompute::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1085, 91, 91, 1083, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 6, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125, 1125 };
			static constexpr uint16_t function_bases[] = { 0, 0, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 85, 21, 21, 21 };
			static constexpr uint16_t function_arg_names[] = { 1086, 1087, 24, 1087 };
	};
	constexpr uint16_t ReflectionMTLCompute::constructor_bases[];
	constexpr uint16_t ReflectionMTLCompute::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLCompute::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLCompute::function_names[];
	constexpr uint16_t ReflectionMTLCompute::function_types[];
	constexpr uint16_t ReflectionMTLCompute::function_bases[];
	constexpr uint16_t ReflectionMTLCompute::function_arg_types[];
	constexpr uint16_t ReflectionMTLCompute::function_arg_names[];
	static ReflectionMTLCompute reflection_mtl_compute;
	
	// Tellusim::VKCompute
	class ReflectionVKCompute : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKCompute::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_compute;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKCompute, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKCompute>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<VkCommandBuffer(VKCompute::*)() const>(&VKCompute::getCommand));
					case 1: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCompute::*)() const>(&VKCompute::getSamplerDescriptor));
					case 2: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCompute::*)() const>(&VKCompute::getImageDescriptor));
					case 3: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCompute::*)() const>(&VKCompute::getBufferDescriptor));
					case 4: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCompute::*)() const>(&VKCompute::getTracingDescriptor));
					case 5: return FunctionPtr(new FunctionImpl<VkDescriptorSet(VKCompute::*)() const>(&VKCompute::getTexelDescriptor));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(VKCompute::*)()>(&VKCompute::update));
					case 7: return FunctionPtr(new FunctionImpl<VKCompute(VKCompute::*)() const>(&VKCompute::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(VKCompute::*)()>(&VKCompute::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(VKCompute::*)()>(&VKCompute::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<VKCompute&(VKCompute::*)()>(&VKCompute::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<VKCompute&(VKCompute::*)()>(&VKCompute::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(VKCompute::*)() const>(&VKCompute::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(VKCompute::*)() const>(&VKCompute::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(VKCompute::*)() const>(&VKCompute::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(VKCompute::*)() const>(&VKCompute::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(VKCompute::*)() const>(&VKCompute::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1101, 1091, 1093, 1094, 1095, 1096, 1083, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1090, 1092, 1092, 1092, 1092, 1092, 6, 1126, 1126, 1126, 1126, 1126, 1126, 1126, 1126, 1126, 1126 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionVKCompute::constructor_bases[];
	constexpr uint16_t ReflectionVKCompute::constructor_arg_types[];
	constexpr uint16_t ReflectionVKCompute::constructor_arg_names[];
	constexpr uint16_t ReflectionVKCompute::function_names[];
	constexpr uint16_t ReflectionVKCompute::function_types[];
	constexpr uint16_t ReflectionVKCompute::function_bases[];
	constexpr uint16_t ReflectionVKCompute::function_arg_types[];
	constexpr uint16_t ReflectionVKCompute::function_arg_names[];
	static ReflectionVKCompute reflection_vk_compute;
	
	// Tellusim::FUCompute
	class ReflectionFUCompute : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUCompute::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_compute;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUCompute, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUCompute, TypeList<const Array<Compute>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUCompute>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUCompute::*)(uint32_t)>(&FUCompute::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUCompute::*)() const>(&FUCompute::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUCompute::*)() const>(&FUCompute::getNumComputes));
					case 3: return FunctionPtr(new FunctionImpl<const Compute(FUCompute::*)(uint32_t) const>(&FUCompute::getCompute));
					case 4: return FunctionPtr(new FunctionImpl<Compute(FUCompute::*)(uint32_t)>(&FUCompute::getCompute));
					case 5: return FunctionPtr(new FunctionImpl<FUCompute(FUCompute::*)() const>(&FUCompute::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUCompute::*)()>(&FUCompute::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUCompute::*)()>(&FUCompute::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUCompute&(FUCompute::*)()>(&FUCompute::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUCompute&(FUCompute::*)()>(&FUCompute::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUCompute::*)() const>(&FUCompute::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUCompute::*)() const>(&FUCompute::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUCompute::*)() const>(&FUCompute::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUCompute::*)() const>(&FUCompute::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUCompute::*)() const>(&FUCompute::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1128, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1129, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1130, 1131, 1131, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1102, 1102, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127, 1127 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUCompute::constructor_bases[];
	constexpr uint16_t ReflectionFUCompute::constructor_arg_types[];
	constexpr uint16_t ReflectionFUCompute::constructor_arg_names[];
	constexpr uint16_t ReflectionFUCompute::function_names[];
	constexpr uint16_t ReflectionFUCompute::function_types[];
	constexpr uint16_t ReflectionFUCompute::function_bases[];
	constexpr uint16_t ReflectionFUCompute::function_arg_types[];
	constexpr uint16_t ReflectionFUCompute::function_arg_names[];
	static ReflectionFUCompute reflection_fu_compute;
	
	// Tellusim::Context
	class ReflectionContext : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Context::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Context, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Context, TypeList<Platform, uint32_t>>((Platform)0, Maxu32));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Context>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Context::*)() const>(&Context::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Context::*)() const>(&Context::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Context::*)() const>(&Context::getIndex));
					case 3: return FunctionPtr(new FunctionImpl<bool(Context::*)() const>(&Context::isCreated));
					case 4: return FunctionPtr(new FunctionImpl<bool(Context::*)()>(&Context::create));
					case 5: return FunctionPtr(new FunctionImpl<bool(Context::*)()>(&Context::flush));
					case 6: return FunctionPtr(new FunctionImpl<bool(Context::*)()>(&Context::finish));
					case 7: return FunctionPtr(new FunctionImpl<Context(Context::*)() const>(&Context::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(Context::*)()>(&Context::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(Context::*)()>(&Context::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<Context&(Context::*)()>(&Context::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<Context&(Context::*)()>(&Context::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(Context::*)() const>(&Context::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(Context::*)() const>(&Context::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(Context::*)() const>(&Context::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(Context::*)() const>(&Context::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(Context::*)() const>(&Context::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 8, 10 };
			static constexpr uint16_t constructor_arg_names[] = { 25, 274 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 904, 24, 91, 1133, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 21, 21, 21, 21, 1132, 1132, 1132, 1132, 1132, 1132, 1132, 1132, 1132, 1132 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionContext::constructor_bases[];
	constexpr uint16_t ReflectionContext::constructor_arg_types[];
	constexpr uint16_t ReflectionContext::constructor_arg_names[];
	constexpr uint16_t ReflectionContext::function_names[];
	constexpr uint16_t ReflectionContext::function_types[];
	constexpr uint16_t ReflectionContext::function_bases[];
	constexpr uint16_t ReflectionContext::function_arg_types[];
	constexpr uint16_t ReflectionContext::function_arg_names[];
	static ReflectionContext reflection_context;
	
	// Tellusim::D3D12Context
	class ReflectionD3D12Context : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Context::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_context;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Context, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Context>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(D3D12Context::*)(ID3D12Device*, ID3D12CommandQueue*)>(&D3D12Context::create));
					case 1: return FunctionPtr(new FunctionImpl<IDXGIFactory4*(D3D12Context::*)() const>(&D3D12Context::getFactory));
					case 2: return FunctionPtr(new FunctionImpl<ID3D12Device*(D3D12Context::*)() const>(&D3D12Context::getDevice));
					case 3: return FunctionPtr(new FunctionImpl<ID3D12CommandQueue*(D3D12Context::*)() const>(&D3D12Context::getQueue));
					case 4: return FunctionPtr(new FunctionImpl<ID3D12GraphicsCommandList*(D3D12Context::*)() const>(&D3D12Context::getCommand));
					case 5: return FunctionPtr(new FunctionVoidImpl<void*(const char*)>(&D3D12Context::getProcAddress));
					case 6: return FunctionPtr(new FunctionImpl<bool(uint32_t)>(&D3D12Context::error));
					case 7: return FunctionPtr(new FunctionImpl<D3D12Context(D3D12Context::*)() const>(&D3D12Context::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(D3D12Context::*)()>(&D3D12Context::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(D3D12Context::*)()>(&D3D12Context::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<D3D12Context&(D3D12Context::*)()>(&D3D12Context::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<D3D12Context&(D3D12Context::*)()>(&D3D12Context::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(D3D12Context::*)() const>(&D3D12Context::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(D3D12Context::*)() const>(&D3D12Context::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(D3D12Context::*)() const>(&D3D12Context::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Context::*)() const>(&D3D12Context::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(D3D12Context::*)() const>(&D3D12Context::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 1138, 9, 1141, 1101, 1143, 725, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 1139, 1140, 1142, 1082, 6, 21, 1134, 1134, 1134, 1134, 1134, 1134, 1134, 1134, 1134, 1134 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 2, 2, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 1135, 1136, 22, 10 };
			static constexpr uint16_t function_arg_names[] = { 28, 1137, 23, 1144 };
	};
	constexpr uint16_t ReflectionD3D12Context::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Context::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Context::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Context::function_names[];
	constexpr uint16_t ReflectionD3D12Context::function_types[];
	constexpr uint16_t ReflectionD3D12Context::function_bases[];
	constexpr uint16_t ReflectionD3D12Context::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Context::function_arg_names[];
	static ReflectionD3D12Context reflection_d3d12_context;
	
	// Tellusim::D3D11Context
	class ReflectionD3D11Context : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D11Context::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_context;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D11Context, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D11Context>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(D3D11Context::*)(ID3D11Device*)>(&D3D11Context::create));
					case 1: return FunctionPtr(new FunctionImpl<IDXGIFactory*(D3D11Context::*)() const>(&D3D11Context::getFactory));
					case 2: return FunctionPtr(new FunctionImpl<ID3D11Device*(D3D11Context::*)() const>(&D3D11Context::getDevice));
					case 3: return FunctionPtr(new FunctionImpl<ID3D11DeviceContext*(D3D11Context::*)() const>(&D3D11Context::getD3D11Context));
					case 4: return FunctionPtr(new FunctionVoidImpl<void*(const char*)>(&D3D11Context::getProcAddress));
					case 5: return FunctionPtr(new FunctionImpl<bool(uint32_t)>(&D3D11Context::error));
					case 6: return FunctionPtr(new FunctionImpl<D3D11Context(D3D11Context::*)() const>(&D3D11Context::clonePtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(D3D11Context::*)()>(&D3D11Context::clearPtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(D3D11Context::*)()>(&D3D11Context::destroyPtr));
					case 9: return FunctionPtr(new FunctionImpl<D3D11Context&(D3D11Context::*)()>(&D3D11Context::acquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<D3D11Context&(D3D11Context::*)()>(&D3D11Context::unacquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(D3D11Context::*)() const>(&D3D11Context::isValidPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(D3D11Context::*)() const>(&D3D11Context::isOwnerPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(D3D11Context::*)() const>(&D3D11Context::isConstPtr));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Context::*)() const>(&D3D11Context::getCountPtr));
					case 15: return FunctionPtr(new FunctionImpl<const void*(D3D11Context::*)() const>(&D3D11Context::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 1138, 9, 1149, 1143, 725, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 1147, 1148, 1150, 6, 21, 1145, 1145, 1145, 1145, 1145, 1145, 1145, 1145, 1145, 1145 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 1146, 22, 10 };
			static constexpr uint16_t function_arg_names[] = { 28, 23, 1144 };
	};
	constexpr uint16_t ReflectionD3D11Context::constructor_bases[];
	constexpr uint16_t ReflectionD3D11Context::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D11Context::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D11Context::function_names[];
	constexpr uint16_t ReflectionD3D11Context::function_types[];
	constexpr uint16_t ReflectionD3D11Context::function_bases[];
	constexpr uint16_t ReflectionD3D11Context::function_arg_types[];
	constexpr uint16_t ReflectionD3D11Context::function_arg_names[];
	static ReflectionD3D11Context reflection_d3d11_context;
	
	// Tellusim::MTLContext
	class ReflectionMTLContext : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLContext::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_context;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLContext, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLContext>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(MTLContext::*)(void*, void*)>(&MTLContext::create));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(MTLContext::*)() const>(&MTLContext::getDevice));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(MTLContext::*)() const>(&MTLContext::getQueue));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(MTLContext::*)() const>(&MTLContext::getCommand));
					case 4: return FunctionPtr(new FunctionVoidImpl<void*(MTLContext::*)() const>(&MTLContext::getEncoder));
					case 5: return FunctionPtr(new FunctionVoidImpl<void*(MTLContext::*)(void*) const>(&MTLContext::getRenderEncoder));
					case 6: return FunctionPtr(new FunctionVoidImpl<void*(MTLContext::*)() const>(&MTLContext::getComputeEncoder));
					case 7: return FunctionPtr(new FunctionVoidImpl<void*(MTLContext::*)() const>(&MTLContext::getTracingEncoder));
					case 8: return FunctionPtr(new FunctionVoidImpl<void*(MTLContext::*)() const>(&MTLContext::getBlitEncoder));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(MTLContext::*)() const>(&MTLContext::endEncoder));
					case 10: return FunctionPtr(new FunctionImpl<MTLContext(MTLContext::*)() const>(&MTLContext::clonePtr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(MTLContext::*)()>(&MTLContext::clearPtr));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(MTLContext::*)()>(&MTLContext::destroyPtr));
					case 13: return FunctionPtr(new FunctionImpl<MTLContext&(MTLContext::*)()>(&MTLContext::acquirePtr));
					case 14: return FunctionPtr(new FunctionImpl<MTLContext&(MTLContext::*)()>(&MTLContext::unacquirePtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(MTLContext::*)() const>(&MTLContext::isValidPtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(MTLContext::*)() const>(&MTLContext::isOwnerPtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(MTLContext::*)() const>(&MTLContext::isConstPtr));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(MTLContext::*)() const>(&MTLContext::getCountPtr));
					case 19: return FunctionPtr(new FunctionImpl<const void*(MTLContext::*)() const>(&MTLContext::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 9, 1141, 1101, 1085, 1152, 1154, 1155, 1156, 1157, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 6, 6, 6, 6, 6, 6, 6, 6, 6, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151, 1151 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 85, 85, 85 };
			static constexpr uint16_t function_arg_names[] = { 28, 1137, 1153 };
	};
	constexpr uint16_t ReflectionMTLContext::constructor_bases[];
	constexpr uint16_t ReflectionMTLContext::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLContext::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLContext::function_names[];
	constexpr uint16_t ReflectionMTLContext::function_types[];
	constexpr uint16_t ReflectionMTLContext::function_bases[];
	constexpr uint16_t ReflectionMTLContext::function_arg_types[];
	constexpr uint16_t ReflectionMTLContext::function_arg_names[];
	static ReflectionMTLContext reflection_mtl_context;
	
	// Tellusim::VKContext
	class ReflectionVKContext : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKContext::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_context;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKContext, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKContext>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(VKContext::*)(VkInstance, PFN_vkGetInstanceProcAddr, VkPhysicalDevice, VkDevice, uint32_t, uint32_t)>(&VKContext::create));
					case 1: return FunctionPtr(new FunctionImpl<VkInstance(VKContext::*)() const>(&VKContext::getInstance));
					case 2: return FunctionPtr(new FunctionImpl<VkPhysicalDevice(VKContext::*)() const>(&VKContext::getAdapter));
					case 3: return FunctionPtr(new FunctionImpl<VkDevice(VKContext::*)() const>(&VKContext::getDevice));
					case 4: return FunctionPtr(new FunctionImpl<VkQueue(VKContext::*)() const>(&VKContext::getQueue));
					case 5: return FunctionPtr(new FunctionImpl<VkCommandBuffer(VKContext::*)() const>(&VKContext::getCommand));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(VKContext::*)() const>(&VKContext::getFamily));
					case 7: return FunctionPtr(new FunctionImpl<uint32_t(VKContext::*)()>(&VKContext::getNumQueues));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(VKContext::*)(uint32_t)>(&VKContext::getQueueFlags));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(VKContext::*)(uint32_t)>(&VKContext::getQueueFamily));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(const char*)>(&VKContext::addContextExtension));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(const char*)>(&VKContext::addAdapterExtension));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(void*)>(&VKContext::addAdapterFeatures));
					case 13: return FunctionPtr(new FunctionImpl<PFN_vkGetInstanceProcAddr()>(&VKContext::getInstanceProcAddress));
					case 14: return FunctionPtr(new FunctionImpl<PFN_vkGetDeviceProcAddr()>(&VKContext::getDeviceProcAddress));
					case 15: return FunctionPtr(new FunctionVoidImpl<void*(const char*)>(&VKContext::getProcAddress));
					case 16: return FunctionPtr(new FunctionImpl<bool(uint32_t)>(&VKContext::error));
					case 17: return FunctionPtr(new FunctionImpl<VKContext(VKContext::*)() const>(&VKContext::clonePtr));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(VKContext::*)()>(&VKContext::clearPtr));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(VKContext::*)()>(&VKContext::destroyPtr));
					case 20: return FunctionPtr(new FunctionImpl<VKContext&(VKContext::*)()>(&VKContext::acquirePtr));
					case 21: return FunctionPtr(new FunctionImpl<VKContext&(VKContext::*)()>(&VKContext::unacquirePtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(VKContext::*)() const>(&VKContext::isValidPtr));
					case 23: return FunctionPtr(new FunctionImpl<bool(VKContext::*)() const>(&VKContext::isOwnerPtr));
					case 24: return FunctionPtr(new FunctionImpl<bool(VKContext::*)() const>(&VKContext::isConstPtr));
					case 25: return FunctionPtr(new FunctionImpl<uint32_t(VKContext::*)() const>(&VKContext::getCountPtr));
					case 26: return FunctionPtr(new FunctionImpl<const void*(VKContext::*)() const>(&VKContext::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 1167, 1168, 9, 1141, 1101, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1178, 1179, 1143, 725, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 1159, 1163, 1165, 1169, 1090, 10, 10, 10, 10, 6, 6, 6, 1161, 1180, 6, 21, 1158, 1158, 1158, 1158, 1158, 1158, 1158, 1158, 1158, 1158 };
			static constexpr uint16_t function_bases[] = { 0, 6, 6, 6, 6, 6, 6, 6, 6, 7, 8, 9, 10, 11, 11, 11, 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 };
			static constexpr uint16_t function_arg_types[] = { 1159, 1161, 1163, 1165, 10, 10, 10, 10, 22, 22, 85, 22, 10 };
			static constexpr uint16_t function_arg_names[] = { 1160, 1162, 1164, 28, 1166, 274, 274, 274, 23, 23, 1177, 23, 1144 };
	};
	constexpr uint16_t ReflectionVKContext::constructor_bases[];
	constexpr uint16_t ReflectionVKContext::constructor_arg_types[];
	constexpr uint16_t ReflectionVKContext::constructor_arg_names[];
	constexpr uint16_t ReflectionVKContext::function_names[];
	constexpr uint16_t ReflectionVKContext::function_types[];
	constexpr uint16_t ReflectionVKContext::function_bases[];
	constexpr uint16_t ReflectionVKContext::function_arg_types[];
	constexpr uint16_t ReflectionVKContext::function_arg_names[];
	static ReflectionVKContext reflection_vk_context;
	
	// Tellusim::GLContext
	class ReflectionGLContext : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLContext::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_context;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLContext, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLContext>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(GLContext::*)(void*)>(&GLContext::create));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(GLContext::*)() const>(&GLContext::getGLDisplay));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(GLContext::*)() const>(&GLContext::getGLVisual));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(GLContext::*)() const>(&GLContext::getGLConfig));
					case 4: return FunctionPtr(new FunctionVoidImpl<void*(GLContext::*)() const>(&GLContext::getGLSurface));
					case 5: return FunctionPtr(new FunctionVoidImpl<void*(GLContext::*)() const>(&GLContext::getGLContext));
					case 6: return FunctionPtr(new FunctionVoidImpl<void*(const char*)>(&GLContext::getProcAddress));
					case 7: return FunctionPtr(new FunctionImpl<bool(uint32_t)>(&GLContext::error));
					case 8: return FunctionPtr(new FunctionImpl<bool()>(&GLContext::check));
					case 9: return FunctionPtr(new FunctionImpl<GLContext(GLContext::*)() const>(&GLContext::clonePtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(GLContext::*)()>(&GLContext::clearPtr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(GLContext::*)()>(&GLContext::destroyPtr));
					case 12: return FunctionPtr(new FunctionImpl<GLContext&(GLContext::*)()>(&GLContext::acquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<GLContext&(GLContext::*)()>(&GLContext::unacquirePtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(GLContext::*)() const>(&GLContext::isValidPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(GLContext::*)() const>(&GLContext::isOwnerPtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(GLContext::*)() const>(&GLContext::isConstPtr));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(GLContext::*)() const>(&GLContext::getCountPtr));
					case 18: return FunctionPtr(new FunctionImpl<const void*(GLContext::*)() const>(&GLContext::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 1183, 1184, 1185, 1186, 1187, 1143, 725, 50, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 6, 6, 6, 6, 6, 6, 21, 21, 1181, 1181, 1181, 1181, 1181, 1181, 1181, 1181, 1181, 1181 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 85, 22, 10 };
			static constexpr uint16_t function_arg_names[] = { 1182, 23, 1144 };
	};
	constexpr uint16_t ReflectionGLContext::constructor_bases[];
	constexpr uint16_t ReflectionGLContext::constructor_arg_types[];
	constexpr uint16_t ReflectionGLContext::constructor_arg_names[];
	constexpr uint16_t ReflectionGLContext::function_names[];
	constexpr uint16_t ReflectionGLContext::function_types[];
	constexpr uint16_t ReflectionGLContext::function_bases[];
	constexpr uint16_t ReflectionGLContext::function_arg_types[];
	constexpr uint16_t ReflectionGLContext::function_arg_names[];
	static ReflectionGLContext reflection_gl_context;
	
	// Tellusim::GLESContext
	class ReflectionGLESContext : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLESContext::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_context;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLESContext, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLESContext>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(GLESContext::*)(void*)>(&GLESContext::create));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(GLESContext::*)() const>(&GLESContext::getGLESDisplay));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(GLESContext::*)() const>(&GLESContext::getGLESConfig));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(GLESContext::*)() const>(&GLESContext::getGLESContext));
					case 4: return FunctionPtr(new FunctionVoidImpl<void*(const char*)>(&GLESContext::getProcAddress));
					case 5: return FunctionPtr(new FunctionImpl<bool(uint32_t)>(&GLESContext::error));
					case 6: return FunctionPtr(new FunctionImpl<bool()>(&GLESContext::check));
					case 7: return FunctionPtr(new FunctionImpl<GLESContext(GLESContext::*)() const>(&GLESContext::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(GLESContext::*)()>(&GLESContext::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(GLESContext::*)()>(&GLESContext::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<GLESContext&(GLESContext::*)()>(&GLESContext::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<GLESContext&(GLESContext::*)()>(&GLESContext::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(GLESContext::*)() const>(&GLESContext::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(GLESContext::*)() const>(&GLESContext::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(GLESContext::*)() const>(&GLESContext::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(GLESContext::*)() const>(&GLESContext::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(GLESContext::*)() const>(&GLESContext::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 1189, 1190, 1191, 1143, 725, 50, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 6, 6, 6, 6, 21, 21, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188, 1188 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 85, 22, 10 };
			static constexpr uint16_t function_arg_names[] = { 1182, 23, 1144 };
	};
	constexpr uint16_t ReflectionGLESContext::constructor_bases[];
	constexpr uint16_t ReflectionGLESContext::constructor_arg_types[];
	constexpr uint16_t ReflectionGLESContext::constructor_arg_names[];
	constexpr uint16_t ReflectionGLESContext::function_names[];
	constexpr uint16_t ReflectionGLESContext::function_types[];
	constexpr uint16_t ReflectionGLESContext::function_bases[];
	constexpr uint16_t ReflectionGLESContext::function_arg_types[];
	constexpr uint16_t ReflectionGLESContext::function_arg_names[];
	static ReflectionGLESContext reflection_gles_context;
	
	// Tellusim::WGContext
	class ReflectionWGContext : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return WGContext::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_context;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<WGContext, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<WGContext>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(WGPUInstance, WGPUAdapter, WGPUDevice)>(&WGContext::open));
					case 1: return FunctionPtr(new FunctionImpl<bool(WGContext::*)(WGPUInstance, WGPUAdapter, WGPUDevice)>(&WGContext::create));
					case 2: return FunctionPtr(new FunctionImpl<WGPUInstance(WGContext::*)() const>(&WGContext::getInstance));
					case 3: return FunctionPtr(new FunctionImpl<WGPUAdapter(WGContext::*)() const>(&WGContext::getAdapter));
					case 4: return FunctionPtr(new FunctionImpl<WGPUDevice(WGContext::*)() const>(&WGContext::getDevice));
					case 5: return FunctionPtr(new FunctionImpl<WGContext(WGContext::*)() const>(&WGContext::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(WGContext::*)()>(&WGContext::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(WGContext::*)()>(&WGContext::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<WGContext&(WGContext::*)()>(&WGContext::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<WGContext&(WGContext::*)()>(&WGContext::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(WGContext::*)() const>(&WGContext::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(WGContext::*)() const>(&WGContext::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(WGContext::*)() const>(&WGContext::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(WGContext::*)() const>(&WGContext::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(WGContext::*)() const>(&WGContext::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 184, 24, 1167, 1168, 9, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 21, 1193, 1194, 1195, 1192, 1192, 1192, 1192, 1192, 1192, 1192, 1192, 1192, 1192 };
			static constexpr uint16_t function_bases[] = { 0, 3, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 };
			static constexpr uint16_t function_arg_types[] = { 1193, 1194, 1195, 1193, 1194, 1195 };
			static constexpr uint16_t function_arg_names[] = { 1160, 1164, 28, 1160, 1164, 28 };
	};
	constexpr uint16_t ReflectionWGContext::constructor_bases[];
	constexpr uint16_t ReflectionWGContext::constructor_arg_types[];
	constexpr uint16_t ReflectionWGContext::constructor_arg_names[];
	constexpr uint16_t ReflectionWGContext::function_names[];
	constexpr uint16_t ReflectionWGContext::function_types[];
	constexpr uint16_t ReflectionWGContext::function_bases[];
	constexpr uint16_t ReflectionWGContext::function_arg_types[];
	constexpr uint16_t ReflectionWGContext::function_arg_names[];
	static ReflectionWGContext reflection_wg_context;
	
	// Tellusim::CUContext
	class ReflectionCUContext : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CUContext::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_context;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CUContext, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CUContext>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<int32_t(CUContext::*)() const>(&CUContext::getDevice));
					case 1: return FunctionPtr(new FunctionImpl<CUcontext(CUContext::*)() const>(&CUContext::getCUContext));
					case 2: return FunctionPtr(new FunctionImpl<CUstream(CUContext::*)() const>(&CUContext::getStream));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(const char*)>(&CUContext::getProcAddress));
					case 4: return FunctionPtr(new FunctionImpl<bool(uint32_t)>(&CUContext::error));
					case 5: return FunctionPtr(new FunctionImpl<CUContext(CUContext::*)() const>(&CUContext::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(CUContext::*)()>(&CUContext::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(CUContext::*)()>(&CUContext::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<CUContext&(CUContext::*)()>(&CUContext::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<CUContext&(CUContext::*)()>(&CUContext::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(CUContext::*)() const>(&CUContext::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(CUContext::*)() const>(&CUContext::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(CUContext::*)() const>(&CUContext::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(CUContext::*)() const>(&CUContext::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(CUContext::*)() const>(&CUContext::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 9, 1197, 1199, 1143, 725, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1, 1198, 1200, 6, 21, 1196, 1196, 1196, 1196, 1196, 1196, 1196, 1196, 1196, 1196 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 };
			static constexpr uint16_t function_arg_types[] = { 22, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 1144 };
	};
	constexpr uint16_t ReflectionCUContext::constructor_bases[];
	constexpr uint16_t ReflectionCUContext::constructor_arg_types[];
	constexpr uint16_t ReflectionCUContext::constructor_arg_names[];
	constexpr uint16_t ReflectionCUContext::function_names[];
	constexpr uint16_t ReflectionCUContext::function_types[];
	constexpr uint16_t ReflectionCUContext::function_bases[];
	constexpr uint16_t ReflectionCUContext::function_arg_types[];
	constexpr uint16_t ReflectionCUContext::function_arg_names[];
	static ReflectionCUContext reflection_cu_context;
	
	// Tellusim::HIPContext
	class ReflectionHIPContext : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return HIPContext::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_context;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<HIPContext, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<HIPContext>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<int32_t(HIPContext::*)() const>(&HIPContext::getDevice));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(HIPContext::*)() const>(&HIPContext::getHIPContext));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(HIPContext::*)() const>(&HIPContext::getStream));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(const char*)>(&HIPContext::getProcAddress));
					case 4: return FunctionPtr(new FunctionImpl<bool(uint32_t)>(&HIPContext::error));
					case 5: return FunctionPtr(new FunctionImpl<HIPContext(HIPContext::*)() const>(&HIPContext::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(HIPContext::*)()>(&HIPContext::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(HIPContext::*)()>(&HIPContext::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<HIPContext&(HIPContext::*)()>(&HIPContext::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<HIPContext&(HIPContext::*)()>(&HIPContext::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(HIPContext::*)() const>(&HIPContext::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(HIPContext::*)() const>(&HIPContext::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(HIPContext::*)() const>(&HIPContext::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(HIPContext::*)() const>(&HIPContext::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(HIPContext::*)() const>(&HIPContext::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 9, 1202, 1199, 1143, 725, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1, 6, 6, 6, 21, 1201, 1201, 1201, 1201, 1201, 1201, 1201, 1201, 1201, 1201 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 };
			static constexpr uint16_t function_arg_types[] = { 22, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 1144 };
	};
	constexpr uint16_t ReflectionHIPContext::constructor_bases[];
	constexpr uint16_t ReflectionHIPContext::constructor_arg_types[];
	constexpr uint16_t ReflectionHIPContext::constructor_arg_names[];
	constexpr uint16_t ReflectionHIPContext::function_names[];
	constexpr uint16_t ReflectionHIPContext::function_types[];
	constexpr uint16_t ReflectionHIPContext::function_bases[];
	constexpr uint16_t ReflectionHIPContext::function_arg_types[];
	constexpr uint16_t ReflectionHIPContext::function_arg_names[];
	static ReflectionHIPContext reflection_hip_context;
	
	// Tellusim::Query
	class ReflectionQuery : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Query::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Query, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Query>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Query::*)() const>(&Query::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Query::*)() const>(&Query::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Query::*)() const>(&Query::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Query::*)()>(&Query::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isCreated));
					case 5: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isAvailable));
					case 6: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isBegan));
					case 7: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isEnded));
					case 8: return FunctionPtr(new FunctionImpl<bool(Query::*)(Query::Type)>(&Query::create));
					case 9: return FunctionPtr(new FunctionImpl<Query::Type(Query::*)() const>(&Query::getType));
					case 10: return FunctionPtr(new FunctionImpl<const char*(Query::Type)>(&Query::getTypeName));
					case 11: return FunctionPtr(new FunctionImpl<const char*(Query::*)() const>(&Query::getTypeName));
					case 12: return FunctionPtr(new FunctionImpl<size_t(Query::*)() const>(&Query::getTypeSize));
					case 13: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isTime));
					case 14: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isClock));
					case 15: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isSamples));
					case 16: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isSamples1));
					case 17: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isStatistics));
					case 18: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isTimeType));
					case 19: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isSamplesType));
					case 20: return FunctionPtr(new FunctionImpl<bool(Query::*)(void*, size_t, bool) const>(&Query::get, {}, {}, true));
					case 21: return FunctionPtr(new FunctionImpl<uint64_t(Query::*)(bool, bool*) const>(&Query::getTime, true, nullptr));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(Query::*)(bool, bool*) const>(&Query::getSamples, true, nullptr));
					case 23: return FunctionPtr(new FunctionImpl<Query::Statistics(Query::*)(bool, bool*) const>(&Query::getStatistics, true, nullptr));
					case 24: return FunctionPtr(new FunctionImpl<Query(Query::*)() const>(&Query::clonePtr));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(Query::*)()>(&Query::clearPtr));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(Query::*)()>(&Query::destroyPtr));
					case 27: return FunctionPtr(new FunctionImpl<Query&(Query::*)()>(&Query::acquirePtr));
					case 28: return FunctionPtr(new FunctionImpl<Query&(Query::*)()>(&Query::unacquirePtr));
					case 29: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isValidPtr));
					case 30: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isOwnerPtr));
					case 31: return FunctionPtr(new FunctionImpl<bool(Query::*)() const>(&Query::isConstPtr));
					case 32: return FunctionPtr(new FunctionImpl<uint32_t(Query::*)() const>(&Query::getCountPtr));
					case 33: return FunctionPtr(new FunctionImpl<const void*(Query::*)() const>(&Query::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 72, 1204, 1205, 24, 214, 345, 345, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 1214, 553, 241, 1215, 1216, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 21, 21, 21, 21, 215, 138, 138, 74, 21, 21, 21, 21, 21, 21, 21, 21, 39, 10, 1217, 1203, 1203, 1203, 1203, 1203, 1203, 1203, 1203, 1203, 1203 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 5, 7, 9, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11 };
			static constexpr uint16_t function_arg_types[] = { 1206, 1206, 85, 74, 21, 21, 100, 21, 100, 21, 100 };
			static constexpr uint16_t function_arg_names[] = { 195, 195, 86, 87, 57, 57, 101, 57, 101, 57, 101 };
	};
	constexpr uint16_t ReflectionQuery::constructor_bases[];
	constexpr uint16_t ReflectionQuery::constructor_arg_types[];
	constexpr uint16_t ReflectionQuery::constructor_arg_names[];
	constexpr uint16_t ReflectionQuery::function_names[];
	constexpr uint16_t ReflectionQuery::function_types[];
	constexpr uint16_t ReflectionQuery::function_bases[];
	constexpr uint16_t ReflectionQuery::function_arg_types[];
	constexpr uint16_t ReflectionQuery::function_arg_names[];
	static ReflectionQuery reflection_query;
	
	// Tellusim::FUQuery
	class ReflectionFUQuery : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUQuery::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_query;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUQuery, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUQuery, TypeList<const Array<Query>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUQuery>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUQuery::*)(uint32_t)>(&FUQuery::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUQuery::*)() const>(&FUQuery::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUQuery::*)() const>(&FUQuery::getNumQueries));
					case 3: return FunctionPtr(new FunctionImpl<const Query(FUQuery::*)(uint32_t) const>(&FUQuery::getQuery));
					case 4: return FunctionPtr(new FunctionImpl<Query(FUQuery::*)(uint32_t)>(&FUQuery::getQuery));
					case 5: return FunctionPtr(new FunctionImpl<FUQuery(FUQuery::*)() const>(&FUQuery::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUQuery::*)()>(&FUQuery::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUQuery::*)()>(&FUQuery::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUQuery&(FUQuery::*)()>(&FUQuery::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUQuery&(FUQuery::*)()>(&FUQuery::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUQuery::*)() const>(&FUQuery::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUQuery::*)() const>(&FUQuery::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUQuery::*)() const>(&FUQuery::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUQuery::*)() const>(&FUQuery::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUQuery::*)() const>(&FUQuery::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1219, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1220, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1221, 1222, 1222, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1203, 1203, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218, 1218 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUQuery::constructor_bases[];
	constexpr uint16_t ReflectionFUQuery::constructor_arg_types[];
	constexpr uint16_t ReflectionFUQuery::constructor_arg_names[];
	constexpr uint16_t ReflectionFUQuery::function_names[];
	constexpr uint16_t ReflectionFUQuery::function_types[];
	constexpr uint16_t ReflectionFUQuery::function_bases[];
	constexpr uint16_t ReflectionFUQuery::function_arg_types[];
	constexpr uint16_t ReflectionFUQuery::function_arg_names[];
	static ReflectionFUQuery reflection_fu_query;
	
	// Tellusim::Fence
	class ReflectionFence : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Fence::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Fence, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Fence>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Fence::*)() const>(&Fence::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Fence::*)() const>(&Fence::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Fence::*)() const>(&Fence::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Fence::*)()>(&Fence::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Fence::*)() const>(&Fence::isCreated));
					case 5: return FunctionPtr(new FunctionImpl<bool(Fence::*)(Fence::Flags)>(&Fence::create, Fence::DefaultFlags));
					case 6: return FunctionPtr(new FunctionImpl<Fence::Flags(Fence::*)() const>(&Fence::getFlags));
					case 7: return FunctionPtr(new FunctionImpl<bool(Fence::*)(Fence::Flags) const>(&Fence::hasFlag));
					case 8: return FunctionPtr(new FunctionImpl<bool(Fence::*)(Fence::Flags) const>(&Fence::hasFlags));
					case 9: return FunctionPtr(new FunctionImpl<String(Fence::*)() const>(&Fence::getFlagsName));
					case 10: return FunctionPtr(new FunctionImpl<String(Fence::*)() const>(&Fence::getDescription));
					case 11: return FunctionPtr(new FunctionImpl<Fence(Fence::*)() const>(&Fence::clonePtr));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(Fence::*)()>(&Fence::clearPtr));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(Fence::*)()>(&Fence::destroyPtr));
					case 14: return FunctionPtr(new FunctionImpl<Fence&(Fence::*)()>(&Fence::acquirePtr));
					case 15: return FunctionPtr(new FunctionImpl<Fence&(Fence::*)()>(&Fence::unacquirePtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(Fence::*)() const>(&Fence::isValidPtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(Fence::*)() const>(&Fence::isOwnerPtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(Fence::*)() const>(&Fence::isConstPtr));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(Fence::*)() const>(&Fence::getCountPtr));
					case 20: return FunctionPtr(new FunctionImpl<const void*(Fence::*)() const>(&Fence::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 24, 906, 907, 908, 909, 403, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 21, 642, 21, 21, 16, 16, 1223, 1223, 1223, 1223, 1223, 1223, 1223, 1223, 1223, 1223 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 1224, 1224, 1224 };
			static constexpr uint16_t function_arg_names[] = { 338, 338, 338 };
	};
	constexpr uint16_t ReflectionFence::constructor_bases[];
	constexpr uint16_t ReflectionFence::constructor_arg_types[];
	constexpr uint16_t ReflectionFence::constructor_arg_names[];
	constexpr uint16_t ReflectionFence::function_names[];
	constexpr uint16_t ReflectionFence::function_types[];
	constexpr uint16_t ReflectionFence::function_bases[];
	constexpr uint16_t ReflectionFence::function_arg_types[];
	constexpr uint16_t ReflectionFence::function_arg_names[];
	static ReflectionFence reflection_fence;
	
	// Tellusim::VKFence
	class ReflectionVKFence : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKFence::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_fence;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKFence, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKFence>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<VkFence(VKFence::*)() const>(&VKFence::getVKFence));
					case 1: return FunctionPtr(new FunctionImpl<VkSemaphore(VKFence::*)() const>(&VKFence::getSemaphore));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(VKFence::*)() const>(&VKFence::getSharedHandle));
					case 3: return FunctionPtr(new FunctionImpl<VKFence(VKFence::*)() const>(&VKFence::clonePtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(VKFence::*)()>(&VKFence::clearPtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(VKFence::*)()>(&VKFence::destroyPtr));
					case 6: return FunctionPtr(new FunctionImpl<VKFence&(VKFence::*)()>(&VKFence::acquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<VKFence&(VKFence::*)()>(&VKFence::unacquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(VKFence::*)() const>(&VKFence::isValidPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(VKFence::*)() const>(&VKFence::isOwnerPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(VKFence::*)() const>(&VKFence::isConstPtr));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(VKFence::*)() const>(&VKFence::getCountPtr));
					case 12: return FunctionPtr(new FunctionImpl<const void*(VKFence::*)() const>(&VKFence::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1226, 1228, 924, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1227, 1229, 6, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225, 1225 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionVKFence::constructor_bases[];
	constexpr uint16_t ReflectionVKFence::constructor_arg_types[];
	constexpr uint16_t ReflectionVKFence::constructor_arg_names[];
	constexpr uint16_t ReflectionVKFence::function_names[];
	constexpr uint16_t ReflectionVKFence::function_types[];
	constexpr uint16_t ReflectionVKFence::function_bases[];
	constexpr uint16_t ReflectionVKFence::function_arg_types[];
	constexpr uint16_t ReflectionVKFence::function_arg_names[];
	static ReflectionVKFence reflection_vk_fence;
	
	// Tellusim::FUFence
	class ReflectionFUFence : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUFence::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_fence;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUFence, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUFence, TypeList<const Array<Fence>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUFence>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUFence::*)(uint32_t)>(&FUFence::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUFence::*)() const>(&FUFence::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUFence::*)() const>(&FUFence::getNumFences));
					case 3: return FunctionPtr(new FunctionImpl<const Fence(FUFence::*)(uint32_t) const>(&FUFence::getFence));
					case 4: return FunctionPtr(new FunctionImpl<Fence(FUFence::*)(uint32_t)>(&FUFence::getFence));
					case 5: return FunctionPtr(new FunctionImpl<FUFence(FUFence::*)() const>(&FUFence::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUFence::*)()>(&FUFence::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUFence::*)()>(&FUFence::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUFence&(FUFence::*)()>(&FUFence::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUFence&(FUFence::*)()>(&FUFence::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUFence::*)() const>(&FUFence::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUFence::*)() const>(&FUFence::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUFence::*)() const>(&FUFence::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUFence::*)() const>(&FUFence::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUFence::*)() const>(&FUFence::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1231, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1232, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1233, 1234, 1234, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1223, 1223, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230, 1230 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUFence::constructor_bases[];
	constexpr uint16_t ReflectionFUFence::constructor_arg_types[];
	constexpr uint16_t ReflectionFUFence::constructor_arg_names[];
	constexpr uint16_t ReflectionFUFence::function_names[];
	constexpr uint16_t ReflectionFUFence::function_types[];
	constexpr uint16_t ReflectionFUFence::function_bases[];
	constexpr uint16_t ReflectionFUFence::function_arg_types[];
	constexpr uint16_t ReflectionFUFence::function_arg_names[];
	static ReflectionFUFence reflection_fu_fence;
	
	// Tellusim::Shader
	class ReflectionShader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Shader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Shader, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Shader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Shader::*)() const>(&Shader::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Shader::*)() const>(&Shader::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Shader::*)() const>(&Shader::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)()>(&Shader::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isCreated));
					case 5: return FunctionPtr(new FunctionImpl<bool(Shader::*)(Stream&) const>(&Shader::saveState));
					case 6: return FunctionPtr(new FunctionImpl<Shader::Type(Shader::*)() const>(&Shader::getType));
					case 7: return FunctionPtr(new FunctionImpl<const char*(Shader::Type)>(&Shader::getTypeName));
					case 8: return FunctionPtr(new FunctionImpl<const char*(Shader::*)() const>(&Shader::getTypeName));
					case 9: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isVertex));
					case 10: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isControl));
					case 11: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isEvaluate));
					case 12: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isGeometry));
					case 13: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isFragment));
					case 14: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isCompute));
					case 15: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isTask));
					case 16: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isMesh));
					case 17: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isRayGen));
					case 18: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isRayMiss));
					case 19: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isClosest));
					case 20: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isFirstHit));
					case 21: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isIntersection));
					case 22: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isCallable));
					case 23: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isGraphicsType));
					case 24: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isTessellationType));
					case 25: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isTracingType));
					case 26: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isMeshType));
					case 27: return FunctionPtr(new FunctionImpl<String(Shader::*)() const>(&Shader::getName));
					case 28: return FunctionPtr(new FunctionImpl<String(Shader::*)() const>(&Shader::getMacros));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(int32_t)>(&Shader::setSamplerOffset));
					case 30: return FunctionPtr(new FunctionImpl<int32_t(Shader::*)() const>(&Shader::getSamplerOffset));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(int32_t)>(&Shader::setTextureOffset));
					case 32: return FunctionPtr(new FunctionImpl<int32_t(Shader::*)() const>(&Shader::getTextureOffset));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(int32_t)>(&Shader::setSurfaceOffset));
					case 34: return FunctionPtr(new FunctionImpl<int32_t(Shader::*)() const>(&Shader::getSurfaceOffset));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(int32_t)>(&Shader::setUniformOffset));
					case 36: return FunctionPtr(new FunctionImpl<int32_t(Shader::*)() const>(&Shader::getUniformOffset));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(int32_t)>(&Shader::setStorageOffset));
					case 38: return FunctionPtr(new FunctionImpl<int32_t(Shader::*)() const>(&Shader::getStorageOffset));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(int32_t)>(&Shader::setTracingOffset));
					case 40: return FunctionPtr(new FunctionImpl<int32_t(Shader::*)() const>(&Shader::getTracingOffset));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(int32_t)>(&Shader::setTexelOffset));
					case 42: return FunctionPtr(new FunctionImpl<int32_t(Shader::*)() const>(&Shader::getTexelOffset));
					case 43: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(int32_t)>(&Shader::setTableOffset));
					case 44: return FunctionPtr(new FunctionImpl<int32_t(Shader::*)() const>(&Shader::getTableOffset));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(uint32_t)>(&Shader::setPatchSize));
					case 46: return FunctionPtr(new FunctionImpl<uint32_t(Shader::*)() const>(&Shader::getPatchSize));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(uint32_t)>(&Shader::setInputSize));
					case 48: return FunctionPtr(new FunctionImpl<uint32_t(Shader::*)() const>(&Shader::getInputSize));
					case 49: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)(uint32_t)>(&Shader::setOutputSize));
					case 50: return FunctionPtr(new FunctionImpl<uint32_t(Shader::*)() const>(&Shader::getOutputSize));
					case 51: return FunctionPtr(new FunctionImpl<bool(Shader::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Shader::load, (Shader::Type)0, {}, String::null, nullptr, 0));
					case 52: return FunctionPtr(new FunctionImpl<bool(Shader::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Shader::create, (Shader::Type)0, {}, String::null, nullptr, 0));
					case 53: return FunctionPtr(new FunctionImpl<bool(Shader::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Shader::loadGLSL, (Shader::Type)0, {}, String::null, nullptr, 0));
					case 54: return FunctionPtr(new FunctionImpl<bool(Shader::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Shader::createGLSL, (Shader::Type)0, {}, String::null, nullptr, 0));
					case 55: return FunctionPtr(new FunctionImpl<bool(Shader::*)(Shader::Type, const char*)>(&Shader::loadSPIRV));
					case 56: return FunctionPtr(new FunctionImpl<bool(Shader::*)(Shader::Type, const Array<uint32_t>&)>(&Shader::createSPIRV));
					case 57: return FunctionPtr(new FunctionImpl<bool()>(&Shader::hasCache));
					case 58: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Shader::setCache));
					case 59: return FunctionPtr(new FunctionImpl<bool(const String&, Stream&)>(&Shader::loadCache));
					case 60: return FunctionPtr(new FunctionImpl<bool(const String&, Stream&)>(&Shader::saveCache));
					case 61: return FunctionPtr(new FunctionVoidImpl<void()>(&Shader::clearCache));
					case 62: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Shader::isMacro));
					case 63: return FunctionPtr(new FunctionImpl<bool(const char*, int32_t)>(&Shader::setMacro));
					case 64: return FunctionPtr(new FunctionImpl<bool(const char*, uint32_t)>(&Shader::setMacro));
					case 65: return FunctionPtr(new FunctionImpl<bool(const char*, const char*)>(&Shader::setMacro, {}, nullptr));
					case 66: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Shader::setMacros));
					case 67: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Shader::removeMacro));
					case 68: return FunctionPtr(new FunctionVoidImpl<void()>(&Shader::clearMacros));
					case 69: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Shader::isInclude));
					case 70: return FunctionPtr(new FunctionImpl<bool(const char*, const String&)>(&Shader::setInclude));
					case 71: return FunctionPtr(new FunctionImpl<bool(const char*)>(&Shader::removeInclude));
					case 72: return FunctionPtr(new FunctionVoidImpl<void()>(&Shader::clearIncludes));
					case 73: return FunctionPtr(new FunctionImpl<String(const char*, const String&, const char**, uint32_t)>(&Shader::preprocessor, {}, String::null, nullptr, 0));
					case 74: return FunctionPtr(new FunctionImpl<Shader(Shader::*)() const>(&Shader::clonePtr));
					case 75: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)()>(&Shader::clearPtr));
					case 76: return FunctionPtr(new FunctionVoidImpl<void(Shader::*)()>(&Shader::destroyPtr));
					case 77: return FunctionPtr(new FunctionImpl<Shader&(Shader::*)()>(&Shader::acquirePtr));
					case 78: return FunctionPtr(new FunctionImpl<Shader&(Shader::*)()>(&Shader::unacquirePtr));
					case 79: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isValidPtr));
					case 80: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isOwnerPtr));
					case 81: return FunctionPtr(new FunctionImpl<bool(Shader::*)() const>(&Shader::isConstPtr));
					case 82: return FunctionPtr(new FunctionImpl<uint32_t(Shader::*)() const>(&Shader::getCountPtr));
					case 83: return FunctionPtr(new FunctionImpl<const void*(Shader::*)() const>(&Shader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 1236, 214, 345, 345, 579, 1238, 1239, 1240, 1241, 1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 75, 1255, 1256, 1257, 1258, 1259, 1260, 1261, 1006, 1262, 1016, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273, 1274, 1275, 221, 24, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1288, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 1295, 1296, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 21, 215, 138, 138, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 16, 16, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 10, 6, 10, 6, 10, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 6, 21, 21, 21, 21, 21, 21, 6, 21, 21, 21, 6, 16, 1235, 1235, 1235, 1235, 1235, 1235, 1235, 1235, 1235, 1235 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, 18, 23, 28, 33, 35, 37, 37, 38, 40, 42, 42, 43, 45, 47, 49, 50, 51, 51, 52, 54, 55, 55, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59, 59 };
			static constexpr uint16_t function_arg_types[] = { 145, 1237, 1, 1, 1, 1, 1, 1, 1, 1, 10, 10, 10, 1237, 22, 94, 876, 10, 1237, 22, 94, 876, 10, 1237, 22, 94, 876, 10, 1237, 22, 94, 876, 10, 1237, 22, 1237, 586, 22, 94, 145, 94, 145, 22, 22, 1, 22, 10, 22, 22, 22, 22, 22, 22, 94, 22, 22, 94, 876, 10 };
			static constexpr uint16_t function_arg_names[] = { 222, 195, 78, 78, 78, 78, 78, 78, 78, 78, 87, 87, 87, 195, 23, 1276, 1277, 87, 195, 90, 1276, 1277, 87, 195, 23, 1276, 1277, 87, 195, 90, 1276, 1277, 87, 195, 23, 195, 167, 23, 180, 222, 180, 222, 23, 23, 105, 23, 105, 23, 105, 1276, 23, 23, 23, 90, 23, 90, 1276, 1277, 87 };
	};
	constexpr uint16_t ReflectionShader::constructor_bases[];
	constexpr uint16_t ReflectionShader::constructor_arg_types[];
	constexpr uint16_t ReflectionShader::constructor_arg_names[];
	constexpr uint16_t ReflectionShader::function_names[];
	constexpr uint16_t ReflectionShader::function_types[];
	constexpr uint16_t ReflectionShader::function_bases[];
	constexpr uint16_t ReflectionShader::function_arg_types[];
	constexpr uint16_t ReflectionShader::function_arg_names[];
	static ReflectionShader reflection_shader;
	
	// Tellusim::ShaderCompiler
	class ReflectionShaderCompiler : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ShaderCompiler::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ShaderCompiler, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ShaderCompiler>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ShaderCompiler::*)(ShaderCompiler::Flags)>(&ShaderCompiler::setFlags));
					case 1: return FunctionPtr(new FunctionImpl<ShaderCompiler::Flags(ShaderCompiler::*)() const>(&ShaderCompiler::getFlags));
					case 2: return FunctionPtr(new FunctionImpl<bool(ShaderCompiler::*)(Stream&, Platform) const>(&ShaderCompiler::getBinary, Stream::null, Tellusim::PlatformUnknown));
					case 3: return FunctionPtr(new FunctionImpl<String(ShaderCompiler::*)(Platform) const>(&ShaderCompiler::getSource, Tellusim::PlatformUnknown));
					case 4: return FunctionPtr(new FunctionImpl<ShaderCompiler(ShaderCompiler::*)() const>(&ShaderCompiler::clonePtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ShaderCompiler::*)()>(&ShaderCompiler::clearPtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(ShaderCompiler::*)()>(&ShaderCompiler::destroyPtr));
					case 7: return FunctionPtr(new FunctionImpl<ShaderCompiler&(ShaderCompiler::*)()>(&ShaderCompiler::acquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<ShaderCompiler&(ShaderCompiler::*)()>(&ShaderCompiler::unacquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(ShaderCompiler::*)() const>(&ShaderCompiler::isValidPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(ShaderCompiler::*)() const>(&ShaderCompiler::isOwnerPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(ShaderCompiler::*)() const>(&ShaderCompiler::isConstPtr));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(ShaderCompiler::*)() const>(&ShaderCompiler::getCountPtr));
					case 13: return FunctionPtr(new FunctionImpl<const void*(ShaderCompiler::*)() const>(&ShaderCompiler::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1298, 906, 1300, 1301, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 642, 21, 16, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297, 1297 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 1299, 145, 8, 8 };
			static constexpr uint16_t function_arg_names[] = { 338, 222, 25, 25 };
	};
	constexpr uint16_t ReflectionShaderCompiler::constructor_bases[];
	constexpr uint16_t ReflectionShaderCompiler::constructor_arg_types[];
	constexpr uint16_t ReflectionShaderCompiler::constructor_arg_names[];
	constexpr uint16_t ReflectionShaderCompiler::function_names[];
	constexpr uint16_t ReflectionShaderCompiler::function_types[];
	constexpr uint16_t ReflectionShaderCompiler::function_bases[];
	constexpr uint16_t ReflectionShaderCompiler::function_arg_types[];
	constexpr uint16_t ReflectionShaderCompiler::function_arg_names[];
	static ReflectionShaderCompiler reflection_shader_compiler;
	
	// Tellusim::D3D12Shader
	class ReflectionD3D12Shader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Shader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Shader, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Shader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<ID3DBlob*(D3D12Shader::*)() const>(&D3D12Shader::getShaderBlob));
					case 1: return FunctionPtr(new FunctionImpl<D3D12Shader(D3D12Shader::*)() const>(&D3D12Shader::clonePtr));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(D3D12Shader::*)()>(&D3D12Shader::clearPtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D12Shader::*)()>(&D3D12Shader::destroyPtr));
					case 4: return FunctionPtr(new FunctionImpl<D3D12Shader&(D3D12Shader::*)()>(&D3D12Shader::acquirePtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D12Shader&(D3D12Shader::*)()>(&D3D12Shader::unacquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<bool(D3D12Shader::*)() const>(&D3D12Shader::isValidPtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D12Shader::*)() const>(&D3D12Shader::isOwnerPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D12Shader::*)() const>(&D3D12Shader::isConstPtr));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Shader::*)() const>(&D3D12Shader::getCountPtr));
					case 10: return FunctionPtr(new FunctionImpl<const void*(D3D12Shader::*)() const>(&D3D12Shader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1303, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1304, 1302, 1302, 1302, 1302, 1302, 1302, 1302, 1302, 1302, 1302 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D12Shader::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Shader::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Shader::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Shader::function_names[];
	constexpr uint16_t ReflectionD3D12Shader::function_types[];
	constexpr uint16_t ReflectionD3D12Shader::function_bases[];
	constexpr uint16_t ReflectionD3D12Shader::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Shader::function_arg_names[];
	static ReflectionD3D12Shader reflection_d3d12_shader;
	
	// Tellusim::D3D11Shader
	class ReflectionD3D11Shader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D11Shader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D11Shader, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D11Shader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(D3D11Shader::*)() const>(&D3D11Shader::getD3D11Shader));
					case 1: return FunctionPtr(new FunctionImpl<ID3DBlob*(D3D11Shader::*)() const>(&D3D11Shader::getShaderBlob));
					case 2: return FunctionPtr(new FunctionImpl<D3D11Shader(D3D11Shader::*)() const>(&D3D11Shader::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D11Shader::*)()>(&D3D11Shader::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(D3D11Shader::*)()>(&D3D11Shader::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D11Shader&(D3D11Shader::*)()>(&D3D11Shader::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<D3D11Shader&(D3D11Shader::*)()>(&D3D11Shader::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D11Shader::*)() const>(&D3D11Shader::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D11Shader::*)() const>(&D3D11Shader::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(D3D11Shader::*)() const>(&D3D11Shader::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Shader::*)() const>(&D3D11Shader::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(D3D11Shader::*)() const>(&D3D11Shader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1306, 1303, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 1304, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305, 1305 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D11Shader::constructor_bases[];
	constexpr uint16_t ReflectionD3D11Shader::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D11Shader::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D11Shader::function_names[];
	constexpr uint16_t ReflectionD3D11Shader::function_types[];
	constexpr uint16_t ReflectionD3D11Shader::function_bases[];
	constexpr uint16_t ReflectionD3D11Shader::function_arg_types[];
	constexpr uint16_t ReflectionD3D11Shader::function_arg_names[];
	static ReflectionD3D11Shader reflection_d3d11_shader;
	
	// Tellusim::MTLShader
	class ReflectionMTLShader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLShader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLShader, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLShader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MTLShader::*)(bool)>(&MTLShader::setIndirect));
					case 1: return FunctionPtr(new FunctionImpl<bool(MTLShader::*)() const>(&MTLShader::isIndirect));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(MTLShader::*)() const>(&MTLShader::getLibrary));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(MTLShader::*)() const>(&MTLShader::getFunction));
					case 4: return FunctionPtr(new FunctionImpl<MTLShader(MTLShader::*)() const>(&MTLShader::clonePtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(MTLShader::*)()>(&MTLShader::clearPtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(MTLShader::*)()>(&MTLShader::destroyPtr));
					case 7: return FunctionPtr(new FunctionImpl<MTLShader&(MTLShader::*)()>(&MTLShader::acquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<MTLShader&(MTLShader::*)()>(&MTLShader::unacquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(MTLShader::*)() const>(&MTLShader::isValidPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(MTLShader::*)() const>(&MTLShader::isOwnerPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(MTLShader::*)() const>(&MTLShader::isConstPtr));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(MTLShader::*)() const>(&MTLShader::getCountPtr));
					case 13: return FunctionPtr(new FunctionImpl<const void*(MTLShader::*)() const>(&MTLShader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1308, 1310, 1311, 1312, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 6, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307, 1307 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 21 };
			static constexpr uint16_t function_arg_names[] = { 1309 };
	};
	constexpr uint16_t ReflectionMTLShader::constructor_bases[];
	constexpr uint16_t ReflectionMTLShader::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLShader::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLShader::function_names[];
	constexpr uint16_t ReflectionMTLShader::function_types[];
	constexpr uint16_t ReflectionMTLShader::function_bases[];
	constexpr uint16_t ReflectionMTLShader::function_arg_types[];
	constexpr uint16_t ReflectionMTLShader::function_arg_names[];
	static ReflectionMTLShader reflection_mtl_shader;
	
	// Tellusim::VKShader
	class ReflectionVKShader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKShader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKShader, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKShader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<VkShaderModule(VKShader::*)() const>(&VKShader::getModule));
					case 1: return FunctionPtr(new FunctionImpl<VKShader(VKShader::*)() const>(&VKShader::clonePtr));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(VKShader::*)()>(&VKShader::clearPtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(VKShader::*)()>(&VKShader::destroyPtr));
					case 4: return FunctionPtr(new FunctionImpl<VKShader&(VKShader::*)()>(&VKShader::acquirePtr));
					case 5: return FunctionPtr(new FunctionImpl<VKShader&(VKShader::*)()>(&VKShader::unacquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<bool(VKShader::*)() const>(&VKShader::isValidPtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(VKShader::*)() const>(&VKShader::isOwnerPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(VKShader::*)() const>(&VKShader::isConstPtr));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(VKShader::*)() const>(&VKShader::getCountPtr));
					case 10: return FunctionPtr(new FunctionImpl<const void*(VKShader::*)() const>(&VKShader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1314, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1315, 1313, 1313, 1313, 1313, 1313, 1313, 1313, 1313, 1313, 1313 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionVKShader::constructor_bases[];
	constexpr uint16_t ReflectionVKShader::constructor_arg_types[];
	constexpr uint16_t ReflectionVKShader::constructor_arg_names[];
	constexpr uint16_t ReflectionVKShader::function_names[];
	constexpr uint16_t ReflectionVKShader::function_types[];
	constexpr uint16_t ReflectionVKShader::function_bases[];
	constexpr uint16_t ReflectionVKShader::function_arg_types[];
	constexpr uint16_t ReflectionVKShader::function_arg_names[];
	static ReflectionVKShader reflection_vk_shader;
	
	// Tellusim::GLShader
	class ReflectionGLShader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLShader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLShader, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLShader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(GLShader::*)(uint32_t)>(&GLShader::attachShader));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(GLShader::*)() const>(&GLShader::getShaderType));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(GLShader::*)() const>(&GLShader::getShaderID));
					case 3: return FunctionPtr(new FunctionImpl<GLShader(GLShader::*)() const>(&GLShader::clonePtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(GLShader::*)()>(&GLShader::clearPtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(GLShader::*)()>(&GLShader::destroyPtr));
					case 6: return FunctionPtr(new FunctionImpl<GLShader&(GLShader::*)()>(&GLShader::acquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<GLShader&(GLShader::*)()>(&GLShader::unacquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(GLShader::*)() const>(&GLShader::isValidPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(GLShader::*)() const>(&GLShader::isOwnerPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(GLShader::*)() const>(&GLShader::isConstPtr));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(GLShader::*)() const>(&GLShader::getCountPtr));
					case 12: return FunctionPtr(new FunctionImpl<const void*(GLShader::*)() const>(&GLShader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1317, 1319, 1320, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 10, 1316, 1316, 1316, 1316, 1316, 1316, 1316, 1316, 1316, 1316 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 10 };
			static constexpr uint16_t function_arg_names[] = { 1318 };
	};
	constexpr uint16_t ReflectionGLShader::constructor_bases[];
	constexpr uint16_t ReflectionGLShader::constructor_arg_types[];
	constexpr uint16_t ReflectionGLShader::constructor_arg_names[];
	constexpr uint16_t ReflectionGLShader::function_names[];
	constexpr uint16_t ReflectionGLShader::function_types[];
	constexpr uint16_t ReflectionGLShader::function_bases[];
	constexpr uint16_t ReflectionGLShader::function_arg_types[];
	constexpr uint16_t ReflectionGLShader::function_arg_names[];
	static ReflectionGLShader reflection_gl_shader;
	
	// Tellusim::GLESShader
	class ReflectionGLESShader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLESShader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLESShader, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLESShader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(GLESShader::*)(uint32_t)>(&GLESShader::attachShader));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(GLESShader::*)() const>(&GLESShader::getShaderType));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(GLESShader::*)() const>(&GLESShader::getShaderID));
					case 3: return FunctionPtr(new FunctionImpl<GLESShader(GLESShader::*)() const>(&GLESShader::clonePtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(GLESShader::*)()>(&GLESShader::clearPtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(GLESShader::*)()>(&GLESShader::destroyPtr));
					case 6: return FunctionPtr(new FunctionImpl<GLESShader&(GLESShader::*)()>(&GLESShader::acquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<GLESShader&(GLESShader::*)()>(&GLESShader::unacquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(GLESShader::*)() const>(&GLESShader::isValidPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(GLESShader::*)() const>(&GLESShader::isOwnerPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(GLESShader::*)() const>(&GLESShader::isConstPtr));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(GLESShader::*)() const>(&GLESShader::getCountPtr));
					case 12: return FunctionPtr(new FunctionImpl<const void*(GLESShader::*)() const>(&GLESShader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1317, 1319, 1320, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 10, 1321, 1321, 1321, 1321, 1321, 1321, 1321, 1321, 1321, 1321 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 10 };
			static constexpr uint16_t function_arg_names[] = { 1318 };
	};
	constexpr uint16_t ReflectionGLESShader::constructor_bases[];
	constexpr uint16_t ReflectionGLESShader::constructor_arg_types[];
	constexpr uint16_t ReflectionGLESShader::constructor_arg_names[];
	constexpr uint16_t ReflectionGLESShader::function_names[];
	constexpr uint16_t ReflectionGLESShader::function_types[];
	constexpr uint16_t ReflectionGLESShader::function_bases[];
	constexpr uint16_t ReflectionGLESShader::function_arg_types[];
	constexpr uint16_t ReflectionGLESShader::function_arg_names[];
	static ReflectionGLESShader reflection_gles_shader;
	
	// Tellusim::CUShader
	class ReflectionCUShader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CUShader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CUShader, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CUShader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<CUmodule(CUShader::*)() const>(&CUShader::getModule));
					case 1: return FunctionPtr(new FunctionImpl<CUfunction(CUShader::*)() const>(&CUShader::getFunction));
					case 2: return FunctionPtr(new FunctionImpl<CUShader(CUShader::*)() const>(&CUShader::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(CUShader::*)()>(&CUShader::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(CUShader::*)()>(&CUShader::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<CUShader&(CUShader::*)()>(&CUShader::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<CUShader&(CUShader::*)()>(&CUShader::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(CUShader::*)() const>(&CUShader::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(CUShader::*)() const>(&CUShader::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(CUShader::*)() const>(&CUShader::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(CUShader::*)() const>(&CUShader::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(CUShader::*)() const>(&CUShader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1314, 1312, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1323, 1324, 1322, 1322, 1322, 1322, 1322, 1322, 1322, 1322, 1322, 1322 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionCUShader::constructor_bases[];
	constexpr uint16_t ReflectionCUShader::constructor_arg_types[];
	constexpr uint16_t ReflectionCUShader::constructor_arg_names[];
	constexpr uint16_t ReflectionCUShader::function_names[];
	constexpr uint16_t ReflectionCUShader::function_types[];
	constexpr uint16_t ReflectionCUShader::function_bases[];
	constexpr uint16_t ReflectionCUShader::function_arg_types[];
	constexpr uint16_t ReflectionCUShader::function_arg_names[];
	static ReflectionCUShader reflection_cu_shader;
	
	// Tellusim::HIPShader
	class ReflectionHIPShader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return HIPShader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<HIPShader, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<HIPShader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(HIPShader::*)() const>(&HIPShader::getModule));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(HIPShader::*)() const>(&HIPShader::getFunction));
					case 2: return FunctionPtr(new FunctionImpl<HIPShader(HIPShader::*)() const>(&HIPShader::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(HIPShader::*)()>(&HIPShader::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(HIPShader::*)()>(&HIPShader::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<HIPShader&(HIPShader::*)()>(&HIPShader::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<HIPShader&(HIPShader::*)()>(&HIPShader::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(HIPShader::*)() const>(&HIPShader::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(HIPShader::*)() const>(&HIPShader::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(HIPShader::*)() const>(&HIPShader::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(HIPShader::*)() const>(&HIPShader::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(HIPShader::*)() const>(&HIPShader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1314, 1312, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 1325, 1325, 1325, 1325, 1325, 1325, 1325, 1325, 1325, 1325 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionHIPShader::constructor_bases[];
	constexpr uint16_t ReflectionHIPShader::constructor_arg_types[];
	constexpr uint16_t ReflectionHIPShader::constructor_arg_names[];
	constexpr uint16_t ReflectionHIPShader::function_names[];
	constexpr uint16_t ReflectionHIPShader::function_types[];
	constexpr uint16_t ReflectionHIPShader::function_bases[];
	constexpr uint16_t ReflectionHIPShader::function_arg_types[];
	constexpr uint16_t ReflectionHIPShader::function_arg_names[];
	static ReflectionHIPShader reflection_hip_shader;
	
	// Tellusim::FUShader
	class ReflectionFUShader : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUShader::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_shader;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUShader, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUShader, TypeList<const Array<Shader>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUShader>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUShader::*)(uint32_t)>(&FUShader::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUShader::*)() const>(&FUShader::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUShader::*)() const>(&FUShader::getNumShaders));
					case 3: return FunctionPtr(new FunctionImpl<const Shader(FUShader::*)(uint32_t) const>(&FUShader::getShader));
					case 4: return FunctionPtr(new FunctionImpl<Shader(FUShader::*)(uint32_t)>(&FUShader::getShader));
					case 5: return FunctionPtr(new FunctionImpl<FUShader(FUShader::*)() const>(&FUShader::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUShader::*)()>(&FUShader::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUShader::*)()>(&FUShader::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUShader&(FUShader::*)()>(&FUShader::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUShader&(FUShader::*)()>(&FUShader::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUShader::*)() const>(&FUShader::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUShader::*)() const>(&FUShader::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUShader::*)() const>(&FUShader::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUShader::*)() const>(&FUShader::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUShader::*)() const>(&FUShader::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1327, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1328, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1329, 1330, 1330, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1235, 1235, 1326, 1326, 1326, 1326, 1326, 1326, 1326, 1326, 1326, 1326 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUShader::constructor_bases[];
	constexpr uint16_t ReflectionFUShader::constructor_arg_types[];
	constexpr uint16_t ReflectionFUShader::constructor_arg_names[];
	constexpr uint16_t ReflectionFUShader::function_names[];
	constexpr uint16_t ReflectionFUShader::function_types[];
	constexpr uint16_t ReflectionFUShader::function_bases[];
	constexpr uint16_t ReflectionFUShader::function_arg_types[];
	constexpr uint16_t ReflectionFUShader::function_arg_names[];
	static ReflectionFUShader reflection_fu_shader;
	
	// Tellusim::Sampler
	class ReflectionSampler : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Sampler::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Sampler, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Sampler>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Sampler::*)() const>(&Sampler::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Sampler::*)() const>(&Sampler::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Sampler::*)() const>(&Sampler::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)()>(&Sampler::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Sampler::*)() const>(&Sampler::isCreated));
					case 5: return FunctionPtr(new FunctionImpl<bool(Sampler::*)()>(&Sampler::create));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(const Sampler&)>(&Sampler::setParameters));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(Sampler::Filter)>(&Sampler::setFilter));
					case 8: return FunctionPtr(new FunctionImpl<Sampler::Filter(Sampler::*)() const>(&Sampler::getFilter));
					case 9: return FunctionPtr(new FunctionImpl<bool(Sampler::*)() const>(&Sampler::isPointFilter));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(uint32_t)>(&Sampler::setAnisotropy));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(Sampler::*)() const>(&Sampler::getAnisotropy));
					case 12: return FunctionPtr(new FunctionImpl<bool(Sampler::*)() const>(&Sampler::hasAnisotropy));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(Sampler::WrapMode)>(&Sampler::setWrapMode));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(Sampler::WrapMode, Sampler::WrapMode, Sampler::WrapMode)>(&Sampler::setWrapMode));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(Sampler::WrapMode)>(&Sampler::setWrapModeS));
					case 16: return FunctionPtr(new FunctionImpl<Sampler::WrapMode(Sampler::*)() const>(&Sampler::getWrapModeS));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(Sampler::WrapMode)>(&Sampler::setWrapModeT));
					case 18: return FunctionPtr(new FunctionImpl<Sampler::WrapMode(Sampler::*)() const>(&Sampler::getWrapModeT));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(Sampler::WrapMode)>(&Sampler::setWrapModeR));
					case 20: return FunctionPtr(new FunctionImpl<Sampler::WrapMode(Sampler::*)() const>(&Sampler::getWrapModeR));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(float32_t, float32_t, float32_t)>(&Sampler::setLod));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(float32_t)>(&Sampler::setLodMin));
					case 23: return FunctionPtr(new FunctionImpl<float32_t(Sampler::*)() const>(&Sampler::getLodMin));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(float32_t)>(&Sampler::setLodMax));
					case 25: return FunctionPtr(new FunctionImpl<float32_t(Sampler::*)() const>(&Sampler::getLodMax));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(float32_t)>(&Sampler::setLodBias));
					case 27: return FunctionPtr(new FunctionImpl<float32_t(Sampler::*)() const>(&Sampler::getLodBias));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(const Color&)>(&Sampler::setBorderColor));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(float32_t, float32_t, float32_t, float32_t)>(&Sampler::setBorderColor));
					case 30: return FunctionPtr(new FunctionImpl<const Color&(Sampler::*)() const>(&Sampler::getBorderColor));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(Sampler::CompareFunc)>(&Sampler::setCompareFunc));
					case 32: return FunctionPtr(new FunctionImpl<Sampler::CompareFunc(Sampler::*)() const>(&Sampler::getCompareFunc));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)(Sampler::ReductionMode)>(&Sampler::setReductionMode));
					case 34: return FunctionPtr(new FunctionImpl<Sampler::ReductionMode(Sampler::*)() const>(&Sampler::getReductionMode));
					case 35: return FunctionPtr(new FunctionImpl<Sampler(Sampler::*)() const>(&Sampler::clonePtr));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)()>(&Sampler::clearPtr));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(Sampler::*)()>(&Sampler::destroyPtr));
					case 38: return FunctionPtr(new FunctionImpl<Sampler&(Sampler::*)()>(&Sampler::acquirePtr));
					case 39: return FunctionPtr(new FunctionImpl<Sampler&(Sampler::*)()>(&Sampler::unacquirePtr));
					case 40: return FunctionPtr(new FunctionImpl<bool(Sampler::*)() const>(&Sampler::isValidPtr));
					case 41: return FunctionPtr(new FunctionImpl<bool(Sampler::*)() const>(&Sampler::isOwnerPtr));
					case 42: return FunctionPtr(new FunctionImpl<bool(Sampler::*)() const>(&Sampler::isConstPtr));
					case 43: return FunctionPtr(new FunctionImpl<uint32_t(Sampler::*)() const>(&Sampler::getCountPtr));
					case 44: return FunctionPtr(new FunctionImpl<const void*(Sampler::*)() const>(&Sampler::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 24, 1332, 1334, 1336, 1338, 1339, 1341, 1342, 1343, 1343, 1348, 1349, 1351, 1352, 1353, 1354, 1355, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1363, 1364, 1365, 1367, 1369, 1371, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 21, 6, 6, 1337, 21, 6, 10, 21, 6, 6, 6, 1350, 6, 1350, 6, 1350, 6, 6, 123, 6, 123, 6, 123, 6, 6, 654, 6, 1368, 6, 1372, 1331, 1331, 1331, 1331, 1331, 1331, 1331, 1331, 1331, 1331 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 3, 3, 3, 4, 7, 8, 8, 9, 9, 10, 10, 13, 14, 14, 15, 15, 16, 16, 17, 21, 21, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23 };
			static constexpr uint16_t function_arg_types[] = { 1333, 1335, 10, 1344, 1344, 1344, 1344, 1344, 1344, 1344, 123, 123, 123, 123, 123, 123, 637, 123, 123, 123, 123, 1366, 1370 };
			static constexpr uint16_t function_arg_names[] = { 988, 448, 1340, 185, 1345, 1346, 1347, 185, 185, 185, 445, 720, 1356, 445, 720, 1356, 638, 1054, 1055, 1056, 1057, 1162, 185 };
	};
	constexpr uint16_t ReflectionSampler::constructor_bases[];
	constexpr uint16_t ReflectionSampler::constructor_arg_types[];
	constexpr uint16_t ReflectionSampler::constructor_arg_names[];
	constexpr uint16_t ReflectionSampler::function_names[];
	constexpr uint16_t ReflectionSampler::function_types[];
	constexpr uint16_t ReflectionSampler::function_bases[];
	constexpr uint16_t ReflectionSampler::function_arg_types[];
	constexpr uint16_t ReflectionSampler::function_arg_names[];
	static ReflectionSampler reflection_sampler;
	
	// Tellusim::MTLSampler
	class ReflectionMTLSampler : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLSampler::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_sampler;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLSampler, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLSampler>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MTLSampler::*)(bool)>(&MTLSampler::setIndirect));
					case 1: return FunctionPtr(new FunctionImpl<bool(MTLSampler::*)() const>(&MTLSampler::isIndirect));
					case 2: return FunctionPtr(new FunctionImpl<MTLSampler(MTLSampler::*)() const>(&MTLSampler::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(MTLSampler::*)()>(&MTLSampler::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(MTLSampler::*)()>(&MTLSampler::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<MTLSampler&(MTLSampler::*)()>(&MTLSampler::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<MTLSampler&(MTLSampler::*)()>(&MTLSampler::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(MTLSampler::*)() const>(&MTLSampler::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(MTLSampler::*)() const>(&MTLSampler::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(MTLSampler::*)() const>(&MTLSampler::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(MTLSampler::*)() const>(&MTLSampler::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(MTLSampler::*)() const>(&MTLSampler::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1308, 1310, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 1373, 1373, 1373, 1373, 1373, 1373, 1373, 1373, 1373, 1373 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 21 };
			static constexpr uint16_t function_arg_names[] = { 1309 };
	};
	constexpr uint16_t ReflectionMTLSampler::constructor_bases[];
	constexpr uint16_t ReflectionMTLSampler::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLSampler::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLSampler::function_names[];
	constexpr uint16_t ReflectionMTLSampler::function_types[];
	constexpr uint16_t ReflectionMTLSampler::function_bases[];
	constexpr uint16_t ReflectionMTLSampler::function_arg_types[];
	constexpr uint16_t ReflectionMTLSampler::function_arg_names[];
	static ReflectionMTLSampler reflection_mtl_sampler;
	
	// Tellusim::FUSampler
	class ReflectionFUSampler : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUSampler::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_sampler;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUSampler, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUSampler, TypeList<const Array<Sampler>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUSampler>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUSampler::*)(uint32_t)>(&FUSampler::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUSampler::*)() const>(&FUSampler::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUSampler::*)() const>(&FUSampler::getNumSamplers));
					case 3: return FunctionPtr(new FunctionImpl<const Sampler(FUSampler::*)(uint32_t) const>(&FUSampler::getSampler));
					case 4: return FunctionPtr(new FunctionImpl<Sampler(FUSampler::*)(uint32_t)>(&FUSampler::getSampler));
					case 5: return FunctionPtr(new FunctionImpl<FUSampler(FUSampler::*)() const>(&FUSampler::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUSampler::*)()>(&FUSampler::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUSampler::*)()>(&FUSampler::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUSampler&(FUSampler::*)()>(&FUSampler::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUSampler&(FUSampler::*)()>(&FUSampler::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUSampler::*)() const>(&FUSampler::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUSampler::*)() const>(&FUSampler::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUSampler::*)() const>(&FUSampler::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUSampler::*)() const>(&FUSampler::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUSampler::*)() const>(&FUSampler::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 990, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 991, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1375, 1376, 1376, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1331, 1331, 1374, 1374, 1374, 1374, 1374, 1374, 1374, 1374, 1374, 1374 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUSampler::constructor_bases[];
	constexpr uint16_t ReflectionFUSampler::constructor_arg_types[];
	constexpr uint16_t ReflectionFUSampler::constructor_arg_names[];
	constexpr uint16_t ReflectionFUSampler::function_names[];
	constexpr uint16_t ReflectionFUSampler::function_types[];
	constexpr uint16_t ReflectionFUSampler::function_bases[];
	constexpr uint16_t ReflectionFUSampler::function_arg_types[];
	constexpr uint16_t ReflectionFUSampler::function_arg_names[];
	static ReflectionFUSampler reflection_fu_sampler;
	
	// Tellusim::Texture
	class ReflectionTexture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Texture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Texture, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Texture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Texture::*)() const>(&Texture::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Texture::*)() const>(&Texture::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Texture::*)()>(&Texture::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isCreated));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Texture::*)(const char*)>(&Texture::setName));
					case 6: return FunctionPtr(new FunctionImpl<String(Texture::*)() const>(&Texture::getName));
					case 7: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Texture::Type, Format, const Size&, uint32_t, Texture::Flags)>(&Texture::create, (Texture::Type)0, (Format)0, {}, {}, Texture::DefaultFlags));
					case 8: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Format, uint32_t, Texture::Flags)>(&Texture::create2D, (Format)0, {}, Texture::DefaultFlags));
					case 9: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Format, uint32_t, Texture::Flags)>(&Texture::create3D, (Format)0, {}, Texture::DefaultFlags));
					case 10: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Format, uint32_t, Texture::Flags)>(&Texture::createCube, (Format)0, {}, Texture::DefaultFlags));
					case 11: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Format, uint32_t, uint32_t, Texture::Flags)>(&Texture::create2D, (Format)0, {}, {}, Texture::DefaultFlags));
					case 12: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Format, uint32_t, uint32_t, uint32_t, Texture::Flags)>(&Texture::create3D, (Format)0, {}, {}, {}, Texture::DefaultFlags));
					case 13: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Format, uint32_t, uint32_t, uint32_t, Texture::Flags)>(&Texture::create2D, (Format)0, {}, {}, {}, Texture::DefaultFlags));
					case 14: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Format, uint32_t, uint32_t, Texture::Flags)>(&Texture::createCube, (Format)0, {}, {}, Texture::DefaultFlags));
					case 15: return FunctionPtr(new FunctionImpl<Texture::Type(Texture::*)() const>(&Texture::getType));
					case 16: return FunctionPtr(new FunctionImpl<const char*(Texture::Type)>(&Texture::getTypeName));
					case 17: return FunctionPtr(new FunctionImpl<const char*(Texture::*)() const>(&Texture::getTypeName));
					case 18: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::is2DType));
					case 19: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::is3DType));
					case 20: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isCubeType));
					case 21: return FunctionPtr(new FunctionImpl<Format(Texture::*)() const>(&Texture::getFormat));
					case 22: return FunctionPtr(new FunctionImpl<const char*(Texture::*)() const>(&Texture::getFormatName));
					case 23: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isColorFormat));
					case 24: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isDepthFormat));
					case 25: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isPixelFormat));
					case 26: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isPlainFormat));
					case 27: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isMixedFormat));
					case 28: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isBlockFormat));
					case 29: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isStencilFormat));
					case 30: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isNormFormat));
					case 31: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isSRGBFormat));
					case 32: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isFloatFormat));
					case 33: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isSignedFormat));
					case 34: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isUnsignedFormat));
					case 35: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isIntegerFormat));
					case 36: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isi8Format));
					case 37: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isu8Format));
					case 38: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::is8BitFormat));
					case 39: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isi16Format));
					case 40: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isu16Format));
					case 41: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isf16Format));
					case 42: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::is16BitFormat));
					case 43: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isi32Format));
					case 44: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isu32Format));
					case 45: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isf32Format));
					case 46: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::is32BitFormat));
					case 47: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isi64Format));
					case 48: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isu64Format));
					case 49: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isf64Format));
					case 50: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::is64BitFormat));
					case 51: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isBC15Format));
					case 52: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isBC67Format));
					case 53: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isETC2Format));
					case 54: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isASTCFormat));
					case 55: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getComponents));
					case 56: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getPixelSize));
					case 57: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getBlockSize));
					case 58: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getBlockWidth));
					case 59: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getBlockHeight));
					case 60: return FunctionPtr(new FunctionImpl<Texture::Flags(Texture::*)() const>(&Texture::getFlags));
					case 61: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Texture::Flags) const>(&Texture::hasFlag));
					case 62: return FunctionPtr(new FunctionImpl<bool(Texture::*)(Texture::Flags) const>(&Texture::hasFlags));
					case 63: return FunctionPtr(new FunctionImpl<String(Texture::*)() const>(&Texture::getFlagsName));
					case 64: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getMultisample));
					case 65: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::hasMultisample));
					case 66: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getWidth));
					case 67: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getHeight));
					case 68: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getDepth));
					case 69: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getFaces));
					case 70: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getLayers));
					case 71: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getMipmaps));
					case 72: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)(const Size&) const>(&Texture::findMipmap));
					case 73: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)(uint32_t) const>(&Texture::getWidth));
					case 74: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)(uint32_t) const>(&Texture::getHeight));
					case 75: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)(uint32_t) const>(&Texture::getDepth));
					case 76: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::hasFaces));
					case 77: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::hasLayers));
					case 78: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::hasMipmaps));
					case 79: return FunctionPtr(new FunctionImpl<Size(Texture::*)() const>(&Texture::getSize));
					case 80: return FunctionPtr(new FunctionImpl<Region(Texture::*)() const>(&Texture::getRegion));
					case 81: return FunctionPtr(new FunctionImpl<Slice(Texture::*)() const>(&Texture::getSlice));
					case 82: return FunctionPtr(new FunctionImpl<Size(Texture::*)(uint32_t) const>(&Texture::getSize));
					case 83: return FunctionPtr(new FunctionImpl<Region(Texture::*)(uint32_t) const>(&Texture::getRegion));
					case 84: return FunctionPtr(new FunctionImpl<Slice(Texture::*)(uint32_t) const>(&Texture::getSlice));
					case 85: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getTileWidth));
					case 86: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getTileHeight));
					case 87: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getTileDepth));
					case 88: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getTileMipmaps));
					case 89: return FunctionPtr(new FunctionImpl<Size(Texture::*)() const>(&Texture::getTileSize));
					case 90: return FunctionPtr(new FunctionImpl<String(Texture::*)() const>(&Texture::getDescription));
					case 91: return FunctionPtr(new FunctionImpl<size_t(Texture::*)() const>(&Texture::getMemory));
					case 92: return FunctionPtr(new FunctionImpl<Texture(Texture::*)() const>(&Texture::clonePtr));
					case 93: return FunctionPtr(new FunctionVoidImpl<void(Texture::*)()>(&Texture::clearPtr));
					case 94: return FunctionPtr(new FunctionVoidImpl<void(Texture::*)()>(&Texture::destroyPtr));
					case 95: return FunctionPtr(new FunctionImpl<Texture&(Texture::*)()>(&Texture::acquirePtr));
					case 96: return FunctionPtr(new FunctionImpl<Texture&(Texture::*)()>(&Texture::unacquirePtr));
					case 97: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isValidPtr));
					case 98: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isOwnerPtr));
					case 99: return FunctionPtr(new FunctionImpl<bool(Texture::*)() const>(&Texture::isConstPtr));
					case 100: return FunctionPtr(new FunctionImpl<uint32_t(Texture::*)() const>(&Texture::getCountPtr));
					case 101: return FunctionPtr(new FunctionImpl<const void*(Texture::*)() const>(&Texture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 172, 75, 24, 412, 413, 414, 412, 413, 412, 414, 214, 345, 345, 346, 347, 348, 349, 350, 351, 352, 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368, 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384, 385, 386, 387, 906, 907, 908, 909, 13, 1380, 11, 12, 388, 389, 390, 391, 392, 11, 12, 388, 1381, 394, 395, 73, 397, 399, 73, 397, 399, 1382, 1383, 1384, 1385, 1386, 403, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 6, 16, 21, 21, 21, 21, 21, 21, 21, 21, 215, 138, 138, 21, 21, 21, 340, 138, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 10, 10, 10, 10, 10, 642, 21, 21, 16, 10, 21, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 21, 21, 21, 396, 398, 400, 396, 398, 400, 10, 10, 10, 10, 396, 16, 74, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 1, 1, 6, 9, 12, 15, 19, 24, 29, 33, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 35, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 37, 38, 39, 40, 40, 40, 40, 40, 40, 40, 41, 42, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43, 43 };
			static constexpr uint16_t function_arg_types[] = { 22, 1378, 340, 341, 10, 1379, 340, 10, 1379, 340, 10, 1379, 340, 10, 1379, 340, 10, 10, 1379, 340, 10, 10, 10, 1379, 340, 10, 10, 10, 1379, 340, 10, 10, 1379, 1378, 1379, 1379, 341, 10, 10, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 195, 96, 87, 342, 338, 96, 87, 338, 96, 87, 338, 96, 87, 338, 96, 30, 31, 338, 96, 30, 31, 415, 338, 96, 30, 31, 342, 338, 96, 87, 342, 338, 195, 338, 338, 87, 393, 393, 393, 393, 393, 393 };
	};
	constexpr uint16_t ReflectionTexture::constructor_bases[];
	constexpr uint16_t ReflectionTexture::constructor_arg_types[];
	constexpr uint16_t ReflectionTexture::constructor_arg_names[];
	constexpr uint16_t ReflectionTexture::function_names[];
	constexpr uint16_t ReflectionTexture::function_types[];
	constexpr uint16_t ReflectionTexture::function_bases[];
	constexpr uint16_t ReflectionTexture::function_arg_types[];
	constexpr uint16_t ReflectionTexture::function_arg_names[];
	static ReflectionTexture reflection_texture;
	
	// Tellusim::TextureTable
	class ReflectionTextureTable : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return TextureTable::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<TextureTable, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<TextureTable>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(TextureTable::*)() const>(&TextureTable::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(TextureTable::*)() const>(&TextureTable::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(TextureTable::*)() const>(&TextureTable::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(TextureTable::*)()>(&TextureTable::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(TextureTable::*)() const>(&TextureTable::isCreated));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(TextureTable::*)(const char*)>(&TextureTable::setName));
					case 6: return FunctionPtr(new FunctionImpl<String(TextureTable::*)() const>(&TextureTable::getName));
					case 7: return FunctionPtr(new FunctionImpl<bool(TextureTable::*)(Texture::Type, uint32_t)>(&TextureTable::create));
					case 8: return FunctionPtr(new FunctionImpl<Texture::Type(TextureTable::*)() const>(&TextureTable::getType));
					case 9: return FunctionPtr(new FunctionImpl<const char*(TextureTable::*)() const>(&TextureTable::getTypeName));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(TextureTable::*)() const>(&TextureTable::getSize));
					case 11: return FunctionPtr(new FunctionImpl<Texture(TextureTable::*)(uint32_t) const>(&TextureTable::get));
					case 12: return FunctionPtr(new FunctionImpl<bool(TextureTable::*)(uint32_t) const>(&TextureTable::isOwner));
					case 13: return FunctionPtr(new FunctionImpl<size_t(TextureTable::*)() const>(&TextureTable::getMemory));
					case 14: return FunctionPtr(new FunctionImpl<TextureTable(TextureTable::*)() const>(&TextureTable::clonePtr));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(TextureTable::*)()>(&TextureTable::clearPtr));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(TextureTable::*)()>(&TextureTable::destroyPtr));
					case 17: return FunctionPtr(new FunctionImpl<TextureTable&(TextureTable::*)()>(&TextureTable::acquirePtr));
					case 18: return FunctionPtr(new FunctionImpl<TextureTable&(TextureTable::*)()>(&TextureTable::unacquirePtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(TextureTable::*)() const>(&TextureTable::isValidPtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(TextureTable::*)() const>(&TextureTable::isOwnerPtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(TextureTable::*)() const>(&TextureTable::isConstPtr));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(TextureTable::*)() const>(&TextureTable::getCountPtr));
					case 23: return FunctionPtr(new FunctionImpl<const void*(TextureTable::*)() const>(&TextureTable::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 172, 75, 24, 214, 345, 73, 553, 912, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 6, 16, 21, 215, 138, 10, 1377, 21, 74, 1387, 1387, 1387, 1387, 1387, 1387, 1387, 1387, 1387, 1387 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 1, 1, 3, 3, 3, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };
			static constexpr uint16_t function_arg_types[] = { 22, 1378, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 195, 87, 274, 274 };
	};
	constexpr uint16_t ReflectionTextureTable::constructor_bases[];
	constexpr uint16_t ReflectionTextureTable::constructor_arg_types[];
	constexpr uint16_t ReflectionTextureTable::constructor_arg_names[];
	constexpr uint16_t ReflectionTextureTable::function_names[];
	constexpr uint16_t ReflectionTextureTable::function_types[];
	constexpr uint16_t ReflectionTextureTable::function_bases[];
	constexpr uint16_t ReflectionTextureTable::function_arg_types[];
	constexpr uint16_t ReflectionTextureTable::function_arg_names[];
	static ReflectionTextureTable reflection_texture_table;
	
	// Tellusim::D3D12Texture
	class ReflectionD3D12Texture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Texture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_texture;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Texture, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Texture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(D3D12Texture::*)(Texture::Type, ID3D12Resource*, uint32_t, Texture::Flags, Format)>(&D3D12Texture::create, (Texture::Type)0, {}, {}, Texture::DefaultFlags, Tellusim::FormatUnknown));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Texture::*)() const>(&D3D12Texture::getDXGIFormat));
					case 2: return FunctionPtr(new FunctionImpl<ID3D12Resource*(D3D12Texture::*)() const>(&D3D12Texture::getD3D12Texture));
					case 3: return FunctionPtr(new FunctionImpl<size_t(D3D12Texture::*)() const>(&D3D12Texture::getShaderResourceView));
					case 4: return FunctionPtr(new FunctionImpl<size_t(D3D12Texture::*)() const>(&D3D12Texture::getRenderTargetView));
					case 5: return FunctionPtr(new FunctionImpl<size_t(D3D12Texture::*)() const>(&D3D12Texture::getDepthStencilView));
					case 6: return FunctionPtr(new FunctionImpl<size_t(D3D12Texture::*)() const>(&D3D12Texture::getUnorderedAccessView));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(D3D12Texture::*)(uint32_t)>(&D3D12Texture::setTextureState));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Texture::*)() const>(&D3D12Texture::getTextureState));
					case 9: return FunctionPtr(new FunctionVoidImpl<void*(D3D12Texture::*)() const>(&D3D12Texture::getSharedHandle));
					case 10: return FunctionPtr(new FunctionVoidImpl<void*(D3D12Texture::*)() const>(&D3D12Texture::getInteropHandle));
					case 11: return FunctionPtr(new FunctionImpl<D3D12Texture(D3D12Texture::*)() const>(&D3D12Texture::clonePtr));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(D3D12Texture::*)()>(&D3D12Texture::clearPtr));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(D3D12Texture::*)()>(&D3D12Texture::destroyPtr));
					case 14: return FunctionPtr(new FunctionImpl<D3D12Texture&(D3D12Texture::*)()>(&D3D12Texture::acquirePtr));
					case 15: return FunctionPtr(new FunctionImpl<D3D12Texture&(D3D12Texture::*)()>(&D3D12Texture::unacquirePtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(D3D12Texture::*)() const>(&D3D12Texture::isValidPtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(D3D12Texture::*)() const>(&D3D12Texture::isOwnerPtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(D3D12Texture::*)() const>(&D3D12Texture::isConstPtr));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Texture::*)() const>(&D3D12Texture::getCountPtr));
					case 20: return FunctionPtr(new FunctionImpl<const void*(D3D12Texture::*)() const>(&D3D12Texture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 1389, 1390, 920, 1391, 1392, 919, 1393, 1394, 924, 925, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 918, 74, 74, 74, 74, 6, 10, 6, 6, 1388, 1388, 1388, 1388, 1388, 1388, 1388, 1388, 1388, 1388 };
			static constexpr uint16_t function_bases[] = { 0, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 };
			static constexpr uint16_t function_arg_types[] = { 1378, 914, 10, 1379, 340, 10 };
			static constexpr uint16_t function_arg_names[] = { 195, 995, 916, 338, 96, 916 };
	};
	constexpr uint16_t ReflectionD3D12Texture::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Texture::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Texture::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Texture::function_names[];
	constexpr uint16_t ReflectionD3D12Texture::function_types[];
	constexpr uint16_t ReflectionD3D12Texture::function_bases[];
	constexpr uint16_t ReflectionD3D12Texture::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Texture::function_arg_names[];
	static ReflectionD3D12Texture reflection_d3d12_texture;
	
	// Tellusim::D3D11Texture
	class ReflectionD3D11Texture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D11Texture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_texture;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D11Texture, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D11Texture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(D3D11Texture::*)(Texture::Type, ID3D11Texture2D*, Texture::Flags, Format)>(&D3D11Texture::create, (Texture::Type)0, {}, Texture::DefaultFlags, Tellusim::FormatUnknown));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Texture::*)() const>(&D3D11Texture::getDXGIFormat));
					case 2: return FunctionPtr(new FunctionImpl<ID3D11Texture2D*(D3D11Texture::*)() const>(&D3D11Texture::getD3D11Texture));
					case 3: return FunctionPtr(new FunctionImpl<ID3D11ShaderResourceView*(D3D11Texture::*)() const>(&D3D11Texture::getShaderResourceView));
					case 4: return FunctionPtr(new FunctionImpl<ID3D11RenderTargetView*(D3D11Texture::*)() const>(&D3D11Texture::getRenderTargetView));
					case 5: return FunctionPtr(new FunctionImpl<ID3D11DepthStencilView*(D3D11Texture::*)() const>(&D3D11Texture::getDepthStencilView));
					case 6: return FunctionPtr(new FunctionImpl<ID3D11UnorderedAccessView*(D3D11Texture::*)() const>(&D3D11Texture::getUnorderedAccessView));
					case 7: return FunctionPtr(new FunctionVoidImpl<void*(D3D11Texture::*)() const>(&D3D11Texture::getInteropHandle));
					case 8: return FunctionPtr(new FunctionImpl<D3D11Texture(D3D11Texture::*)() const>(&D3D11Texture::clonePtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(D3D11Texture::*)()>(&D3D11Texture::clearPtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(D3D11Texture::*)()>(&D3D11Texture::destroyPtr));
					case 11: return FunctionPtr(new FunctionImpl<D3D11Texture&(D3D11Texture::*)()>(&D3D11Texture::acquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<D3D11Texture&(D3D11Texture::*)()>(&D3D11Texture::unacquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(D3D11Texture::*)() const>(&D3D11Texture::isValidPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(D3D11Texture::*)() const>(&D3D11Texture::isOwnerPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(D3D11Texture::*)() const>(&D3D11Texture::isConstPtr));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Texture::*)() const>(&D3D11Texture::getCountPtr));
					case 17: return FunctionPtr(new FunctionImpl<const void*(D3D11Texture::*)() const>(&D3D11Texture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 1389, 1397, 920, 1391, 1392, 919, 925, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 1398, 931, 1399, 1400, 930, 6, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395, 1395 };
			static constexpr uint16_t function_bases[] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 1378, 1396, 1379, 340 };
			static constexpr uint16_t function_arg_names[] = { 195, 995, 338, 96 };
	};
	constexpr uint16_t ReflectionD3D11Texture::constructor_bases[];
	constexpr uint16_t ReflectionD3D11Texture::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D11Texture::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D11Texture::function_names[];
	constexpr uint16_t ReflectionD3D11Texture::function_types[];
	constexpr uint16_t ReflectionD3D11Texture::function_bases[];
	constexpr uint16_t ReflectionD3D11Texture::function_arg_types[];
	constexpr uint16_t ReflectionD3D11Texture::function_arg_names[];
	static ReflectionD3D11Texture reflection_d3d11_texture;
	
	// Tellusim::MTLTexture
	class ReflectionMTLTexture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLTexture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_texture;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLTexture, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLTexture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(MTLTexture::*)(void*, Texture::Flags, Format)>(&MTLTexture::create, {}, Texture::DefaultFlags, Tellusim::FormatUnknown));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(MTLTexture::*)() const>(&MTLTexture::getPixelFormat));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(MTLTexture::*)() const>(&MTLTexture::getTextureType));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(MTLTexture::*)() const>(&MTLTexture::getMTLTexture));
					case 4: return FunctionPtr(new FunctionVoidImpl<void*(MTLTexture::*)() const>(&MTLTexture::getMTLBuffer));
					case 5: return FunctionPtr(new FunctionVoidImpl<void*(MTLTexture::*)() const>(&MTLTexture::getSharedPtr));
					case 6: return FunctionPtr(new FunctionImpl<MTLTexture(MTLTexture::*)() const>(&MTLTexture::clonePtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(MTLTexture::*)()>(&MTLTexture::clearPtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(MTLTexture::*)()>(&MTLTexture::destroyPtr));
					case 9: return FunctionPtr(new FunctionImpl<MTLTexture&(MTLTexture::*)()>(&MTLTexture::acquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<MTLTexture&(MTLTexture::*)()>(&MTLTexture::unacquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(MTLTexture::*)() const>(&MTLTexture::isValidPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(MTLTexture::*)() const>(&MTLTexture::isOwnerPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(MTLTexture::*)() const>(&MTLTexture::isConstPtr));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(MTLTexture::*)() const>(&MTLTexture::getCountPtr));
					case 15: return FunctionPtr(new FunctionImpl<const void*(MTLTexture::*)() const>(&MTLTexture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 1402, 1403, 1404, 933, 934, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 10, 6, 6, 6, 1401, 1401, 1401, 1401, 1401, 1401, 1401, 1401, 1401, 1401 };
			static constexpr uint16_t function_bases[] = { 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 85, 1379, 340 };
			static constexpr uint16_t function_arg_names[] = { 995, 338, 96 };
	};
	constexpr uint16_t ReflectionMTLTexture::constructor_bases[];
	constexpr uint16_t ReflectionMTLTexture::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLTexture::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLTexture::function_names[];
	constexpr uint16_t ReflectionMTLTexture::function_types[];
	constexpr uint16_t ReflectionMTLTexture::function_bases[];
	constexpr uint16_t ReflectionMTLTexture::function_arg_types[];
	constexpr uint16_t ReflectionMTLTexture::function_arg_names[];
	static ReflectionMTLTexture reflection_mtl_texture;
	
	// Tellusim::VKTexture
	class ReflectionVKTexture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKTexture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_texture;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKTexture, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKTexture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(VKTexture::*)(Texture::Type, uint32_t, VkImage, uint32_t, Texture::Flags, Format)>(&VKTexture::create, (Texture::Type)0, {}, {}, {}, Texture::DefaultFlags, Tellusim::FormatUnknown));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(VKTexture::*)() const>(&VKTexture::getPixelFormat));
					case 2: return FunctionPtr(new FunctionImpl<VkImage(VKTexture::*)() const>(&VKTexture::getVKTexture));
					case 3: return FunctionPtr(new FunctionImpl<VkImageView(VKTexture::*)() const>(&VKTexture::getTextureView));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(VKTexture::*)(uint32_t)>(&VKTexture::setTextureLayout));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(VKTexture::*)() const>(&VKTexture::getTextureLayout));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(VKTexture::*)(void*, const Slice&) const>(&VKTexture::getTextureRange));
					case 7: return FunctionPtr(new FunctionVoidImpl<void*(VKTexture::*)() const>(&VKTexture::getSharedPtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void*(VKTexture::*)() const>(&VKTexture::getInteropHandle));
					case 9: return FunctionPtr(new FunctionImpl<VKTexture(VKTexture::*)() const>(&VKTexture::clonePtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(VKTexture::*)()>(&VKTexture::clearPtr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(VKTexture::*)()>(&VKTexture::destroyPtr));
					case 12: return FunctionPtr(new FunctionImpl<VKTexture&(VKTexture::*)()>(&VKTexture::acquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<VKTexture&(VKTexture::*)()>(&VKTexture::unacquirePtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(VKTexture::*)() const>(&VKTexture::isValidPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(VKTexture::*)() const>(&VKTexture::isOwnerPtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(VKTexture::*)() const>(&VKTexture::isConstPtr));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(VKTexture::*)() const>(&VKTexture::getCountPtr));
					case 18: return FunctionPtr(new FunctionImpl<const void*(VKTexture::*)() const>(&VKTexture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 1402, 1408, 1409, 1411, 1412, 1413, 934, 925, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 1406, 1410, 6, 10, 6, 6, 6, 1405, 1405, 1405, 1405, 1405, 1405, 1405, 1405, 1405, 1405 };
			static constexpr uint16_t function_bases[] = { 0, 6, 6, 6, 6, 7, 7, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
			static constexpr uint16_t function_arg_types[] = { 1378, 10, 1406, 10, 1379, 340, 10, 85, 405 };
			static constexpr uint16_t function_arg_names[] = { 195, 96, 995, 639, 338, 1407, 639, 1414, 406 };
	};
	constexpr uint16_t ReflectionVKTexture::constructor_bases[];
	constexpr uint16_t ReflectionVKTexture::constructor_arg_types[];
	constexpr uint16_t ReflectionVKTexture::constructor_arg_names[];
	constexpr uint16_t ReflectionVKTexture::function_names[];
	constexpr uint16_t ReflectionVKTexture::function_types[];
	constexpr uint16_t ReflectionVKTexture::function_bases[];
	constexpr uint16_t ReflectionVKTexture::function_arg_types[];
	constexpr uint16_t ReflectionVKTexture::function_arg_names[];
	static ReflectionVKTexture reflection_vk_texture;
	
	// Tellusim::GLTexture
	class ReflectionGLTexture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLTexture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_texture;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLTexture, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLTexture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(GLTexture::*)(uint32_t, uint32_t, Texture::Flags, Format)>(&GLTexture::create, {}, {}, Texture::DefaultFlags, Tellusim::FormatUnknown));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(GLTexture::*)() const>(&GLTexture::getTarget));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(GLTexture::*)() const>(&GLTexture::getInternalFormat));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(GLTexture::*)() const>(&GLTexture::getTextureID));
					case 4: return FunctionPtr(new FunctionImpl<GLTexture(GLTexture::*)() const>(&GLTexture::clonePtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(GLTexture::*)()>(&GLTexture::clearPtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(GLTexture::*)()>(&GLTexture::destroyPtr));
					case 7: return FunctionPtr(new FunctionImpl<GLTexture&(GLTexture::*)()>(&GLTexture::acquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<GLTexture&(GLTexture::*)()>(&GLTexture::unacquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(GLTexture::*)() const>(&GLTexture::isValidPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(GLTexture::*)() const>(&GLTexture::isOwnerPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(GLTexture::*)() const>(&GLTexture::isConstPtr));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(GLTexture::*)() const>(&GLTexture::getCountPtr));
					case 13: return FunctionPtr(new FunctionImpl<const void*(GLTexture::*)() const>(&GLTexture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 946, 1417, 1418, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 10, 10, 1415, 1415, 1415, 1415, 1415, 1415, 1415, 1415, 1415, 1415 };
			static constexpr uint16_t function_bases[] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 1379, 340 };
			static constexpr uint16_t function_arg_names[] = { 944, 1416, 338, 96 };
	};
	constexpr uint16_t ReflectionGLTexture::constructor_bases[];
	constexpr uint16_t ReflectionGLTexture::constructor_arg_types[];
	constexpr uint16_t ReflectionGLTexture::constructor_arg_names[];
	constexpr uint16_t ReflectionGLTexture::function_names[];
	constexpr uint16_t ReflectionGLTexture::function_types[];
	constexpr uint16_t ReflectionGLTexture::function_bases[];
	constexpr uint16_t ReflectionGLTexture::function_arg_types[];
	constexpr uint16_t ReflectionGLTexture::function_arg_names[];
	static ReflectionGLTexture reflection_gl_texture;
	
	// Tellusim::GLESTexture
	class ReflectionGLESTexture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLESTexture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_texture;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLESTexture, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLESTexture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(GLESTexture::*)(uint32_t, uint32_t, Texture::Flags, Format)>(&GLESTexture::create, {}, {}, Texture::DefaultFlags, Tellusim::FormatUnknown));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(GLESTexture::*)() const>(&GLESTexture::getTarget));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(GLESTexture::*)() const>(&GLESTexture::getInternalFormat));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(GLESTexture::*)() const>(&GLESTexture::getTextureID));
					case 4: return FunctionPtr(new FunctionImpl<GLESTexture(GLESTexture::*)() const>(&GLESTexture::clonePtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(GLESTexture::*)()>(&GLESTexture::clearPtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(GLESTexture::*)()>(&GLESTexture::destroyPtr));
					case 7: return FunctionPtr(new FunctionImpl<GLESTexture&(GLESTexture::*)()>(&GLESTexture::acquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<GLESTexture&(GLESTexture::*)()>(&GLESTexture::unacquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(GLESTexture::*)() const>(&GLESTexture::isValidPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(GLESTexture::*)() const>(&GLESTexture::isOwnerPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(GLESTexture::*)() const>(&GLESTexture::isConstPtr));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(GLESTexture::*)() const>(&GLESTexture::getCountPtr));
					case 13: return FunctionPtr(new FunctionImpl<const void*(GLESTexture::*)() const>(&GLESTexture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 24, 946, 1417, 1418, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 10, 10, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419, 1419 };
			static constexpr uint16_t function_bases[] = { 0, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 1379, 340 };
			static constexpr uint16_t function_arg_names[] = { 944, 1416, 338, 96 };
	};
	constexpr uint16_t ReflectionGLESTexture::constructor_bases[];
	constexpr uint16_t ReflectionGLESTexture::constructor_arg_types[];
	constexpr uint16_t ReflectionGLESTexture::constructor_arg_names[];
	constexpr uint16_t ReflectionGLESTexture::function_names[];
	constexpr uint16_t ReflectionGLESTexture::function_types[];
	constexpr uint16_t ReflectionGLESTexture::function_bases[];
	constexpr uint16_t ReflectionGLESTexture::function_arg_types[];
	constexpr uint16_t ReflectionGLESTexture::function_arg_names[];
	static ReflectionGLESTexture reflection_gles_texture;
	
	// Tellusim::CUTexture
	class ReflectionCUTexture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CUTexture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_texture;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CUTexture, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CUTexture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<CUmipmappedArray(CUTexture::*)() const>(&CUTexture::getTextureArray));
					case 1: return FunctionPtr(new FunctionImpl<CUarray(CUTexture::*)(uint32_t) const>(&CUTexture::getTextureLevel));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(CUTexture::*)() const>(&CUTexture::getArrayFormat));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(CUTexture::*)() const>(&CUTexture::getArrayChannels));
					case 4: return FunctionPtr(new FunctionImpl<CUexternalMemory(CUTexture::*)() const>(&CUTexture::getSharedMemory));
					case 5: return FunctionPtr(new FunctionImpl<CUTexture(CUTexture::*)() const>(&CUTexture::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(CUTexture::*)()>(&CUTexture::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(CUTexture::*)()>(&CUTexture::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<CUTexture&(CUTexture::*)()>(&CUTexture::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<CUTexture&(CUTexture::*)()>(&CUTexture::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(CUTexture::*)() const>(&CUTexture::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(CUTexture::*)() const>(&CUTexture::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(CUTexture::*)() const>(&CUTexture::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(CUTexture::*)() const>(&CUTexture::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(CUTexture::*)() const>(&CUTexture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1421, 1423, 954, 955, 956, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1422, 1424, 10, 10, 957, 1420, 1420, 1420, 1420, 1420, 1420, 1420, 1420, 1420, 1420 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 10 };
			static constexpr uint16_t function_arg_names[] = { 274 };
	};
	constexpr uint16_t ReflectionCUTexture::constructor_bases[];
	constexpr uint16_t ReflectionCUTexture::constructor_arg_types[];
	constexpr uint16_t ReflectionCUTexture::constructor_arg_names[];
	constexpr uint16_t ReflectionCUTexture::function_names[];
	constexpr uint16_t ReflectionCUTexture::function_types[];
	constexpr uint16_t ReflectionCUTexture::function_bases[];
	constexpr uint16_t ReflectionCUTexture::function_arg_types[];
	constexpr uint16_t ReflectionCUTexture::function_arg_names[];
	static ReflectionCUTexture reflection_cu_texture;
	
	// Tellusim::HIPTexture
	class ReflectionHIPTexture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return HIPTexture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_texture;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<HIPTexture, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<HIPTexture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(HIPTexture::*)() const>(&HIPTexture::getTextureArray));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(HIPTexture::*)(uint32_t) const>(&HIPTexture::getTextureLevel));
					case 2: return FunctionPtr(new FunctionVoidImpl<const void*(HIPTexture::*)() const>(&HIPTexture::getChannelFormat));
					case 3: return FunctionPtr(new FunctionImpl<HIPTexture(HIPTexture::*)() const>(&HIPTexture::clonePtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(HIPTexture::*)()>(&HIPTexture::clearPtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(HIPTexture::*)()>(&HIPTexture::destroyPtr));
					case 6: return FunctionPtr(new FunctionImpl<HIPTexture&(HIPTexture::*)()>(&HIPTexture::acquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<HIPTexture&(HIPTexture::*)()>(&HIPTexture::unacquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(HIPTexture::*)() const>(&HIPTexture::isValidPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(HIPTexture::*)() const>(&HIPTexture::isOwnerPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(HIPTexture::*)() const>(&HIPTexture::isConstPtr));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(HIPTexture::*)() const>(&HIPTexture::getCountPtr));
					case 12: return FunctionPtr(new FunctionImpl<const void*(HIPTexture::*)() const>(&HIPTexture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1421, 1423, 1426, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425, 1425 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 10 };
			static constexpr uint16_t function_arg_names[] = { 274 };
	};
	constexpr uint16_t ReflectionHIPTexture::constructor_bases[];
	constexpr uint16_t ReflectionHIPTexture::constructor_arg_types[];
	constexpr uint16_t ReflectionHIPTexture::constructor_arg_names[];
	constexpr uint16_t ReflectionHIPTexture::function_names[];
	constexpr uint16_t ReflectionHIPTexture::function_types[];
	constexpr uint16_t ReflectionHIPTexture::function_bases[];
	constexpr uint16_t ReflectionHIPTexture::function_arg_types[];
	constexpr uint16_t ReflectionHIPTexture::function_arg_names[];
	static ReflectionHIPTexture reflection_hip_texture;
	
	// Tellusim::FUTexture
	class ReflectionFUTexture : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUTexture::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_texture;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUTexture, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUTexture, TypeList<const Array<Texture>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUTexture>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUTexture::*)(uint32_t)>(&FUTexture::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUTexture::*)() const>(&FUTexture::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUTexture::*)() const>(&FUTexture::getNumTextures));
					case 3: return FunctionPtr(new FunctionImpl<const Texture(FUTexture::*)(uint32_t) const>(&FUTexture::getTexture));
					case 4: return FunctionPtr(new FunctionImpl<Texture(FUTexture::*)(uint32_t)>(&FUTexture::getTexture));
					case 5: return FunctionPtr(new FunctionImpl<FUTexture(FUTexture::*)() const>(&FUTexture::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUTexture::*)()>(&FUTexture::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUTexture::*)()>(&FUTexture::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUTexture&(FUTexture::*)()>(&FUTexture::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUTexture&(FUTexture::*)()>(&FUTexture::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUTexture::*)() const>(&FUTexture::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUTexture::*)() const>(&FUTexture::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUTexture::*)() const>(&FUTexture::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUTexture::*)() const>(&FUTexture::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUTexture::*)() const>(&FUTexture::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 997, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 998, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1428, 1429, 1429, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1377, 1377, 1427, 1427, 1427, 1427, 1427, 1427, 1427, 1427, 1427, 1427 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUTexture::constructor_bases[];
	constexpr uint16_t ReflectionFUTexture::constructor_arg_types[];
	constexpr uint16_t ReflectionFUTexture::constructor_arg_names[];
	constexpr uint16_t ReflectionFUTexture::function_names[];
	constexpr uint16_t ReflectionFUTexture::function_types[];
	constexpr uint16_t ReflectionFUTexture::function_bases[];
	constexpr uint16_t ReflectionFUTexture::function_arg_types[];
	constexpr uint16_t ReflectionFUTexture::function_arg_names[];
	static ReflectionFUTexture reflection_fu_texture;
	
	// Tellusim::Tracing
	class ReflectionTracing : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Tracing::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Tracing, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Tracing>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Tracing::*)() const>(&Tracing::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Tracing::*)() const>(&Tracing::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)() const>(&Tracing::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)()>(&Tracing::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Tracing::*)() const>(&Tracing::isCreated));
					case 5: return FunctionPtr(new FunctionImpl<bool(Tracing::*)() const>(&Tracing::isBuilt));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(const char*)>(&Tracing::setName));
					case 7: return FunctionPtr(new FunctionImpl<String(Tracing::*)() const>(&Tracing::getName));
					case 8: return FunctionPtr(new FunctionImpl<bool(Tracing::*)(Tracing::Type, Tracing::Flags)>(&Tracing::create, (Tracing::Type)0, Tracing::DefaultFlags));
					case 9: return FunctionPtr(new FunctionImpl<Tracing::Type(Tracing::*)() const>(&Tracing::getType));
					case 10: return FunctionPtr(new FunctionImpl<const char*(Tracing::Type)>(&Tracing::getTypeName));
					case 11: return FunctionPtr(new FunctionImpl<const char*(Tracing::*)() const>(&Tracing::getTypeName));
					case 12: return FunctionPtr(new FunctionImpl<bool(Tracing::*)() const>(&Tracing::isInstanceType));
					case 13: return FunctionPtr(new FunctionImpl<bool(Tracing::*)() const>(&Tracing::isTriangleType));
					case 14: return FunctionPtr(new FunctionImpl<bool(Tracing::*)() const>(&Tracing::isBoundType));
					case 15: return FunctionPtr(new FunctionImpl<bool(Tracing::*)() const>(&Tracing::isGeometryType));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(const Tracing&)>(&Tracing::setParameters));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)() const>(&Tracing::getNumGeometries));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, Buffer&, size_t)>(&Tracing::setInstanceBuffer, {}, Buffer::null, 0));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(Buffer&, size_t)>(&Tracing::setInstanceBuffer, Buffer::null, 0));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t)>(&Tracing::setNumInstances));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)() const>(&Tracing::getNumInstances));
					case 22: return FunctionPtr(new FunctionImpl<Buffer(Tracing::*)() const>(&Tracing::getInstanceBuffer));
					case 23: return FunctionPtr(new FunctionImpl<size_t(Tracing::*)() const>(&Tracing::getInstanceOffset));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(Buffer&, size_t)>(&Tracing::setIndirectBuffer, Buffer::null, 0));
					case 25: return FunctionPtr(new FunctionImpl<Buffer(Tracing::*)() const>(&Tracing::getIndirectBuffer));
					case 26: return FunctionPtr(new FunctionImpl<size_t(Tracing::*)() const>(&Tracing::getIndirectOffset));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)(uint32_t, Format, size_t, Buffer, size_t)>(&Tracing::addVertexBuffer, {}, (Format)0, {}, Buffer::null, 0));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, uint32_t, Buffer&, size_t)>(&Tracing::setVertexBuffer, {}, {}, Buffer::null, 0));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, Buffer&, size_t)>(&Tracing::setVertexBuffer, {}, Buffer::null, 0));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, uint32_t)>(&Tracing::setNumVertices));
					case 31: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)(uint32_t) const>(&Tracing::getNumVertices));
					case 32: return FunctionPtr(new FunctionImpl<Format(Tracing::*)(uint32_t) const>(&Tracing::getVertexFormat));
					case 33: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)(uint32_t) const>(&Tracing::getVertexStride));
					case 34: return FunctionPtr(new FunctionImpl<Buffer(Tracing::*)(uint32_t) const>(&Tracing::getVertexBuffer));
					case 35: return FunctionPtr(new FunctionImpl<size_t(Tracing::*)(uint32_t) const>(&Tracing::getVertexOffset));
					case 36: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)(uint32_t, Format, Buffer, size_t)>(&Tracing::addIndexBuffer, {}, (Format)0, Buffer::null, 0));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, uint32_t, Buffer&, size_t)>(&Tracing::setIndexBuffer, {}, {}, Buffer::null, 0));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, Buffer&, size_t)>(&Tracing::setIndexBuffer, {}, Buffer::null, 0));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, uint32_t)>(&Tracing::setNumIndices));
					case 40: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)(uint32_t) const>(&Tracing::getNumIndices));
					case 41: return FunctionPtr(new FunctionImpl<Format(Tracing::*)(uint32_t) const>(&Tracing::getIndexFormat));
					case 42: return FunctionPtr(new FunctionImpl<Buffer(Tracing::*)(uint32_t) const>(&Tracing::getIndexBuffer));
					case 43: return FunctionPtr(new FunctionImpl<size_t(Tracing::*)(uint32_t) const>(&Tracing::getIndexOffset));
					case 44: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)(uint32_t, size_t, Buffer, size_t)>(&Tracing::addBoundBuffer, {}, {}, Buffer::null, 0));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, uint32_t, Buffer&, size_t)>(&Tracing::setBoundBuffer, {}, {}, Buffer::null, 0));
					case 46: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, Buffer&, size_t)>(&Tracing::setBoundBuffer, {}, Buffer::null, 0));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)(uint32_t, uint32_t)>(&Tracing::setNumBounds));
					case 48: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)(uint32_t) const>(&Tracing::getNumBounds));
					case 49: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)(uint32_t) const>(&Tracing::getBoundStride));
					case 50: return FunctionPtr(new FunctionImpl<Buffer(Tracing::*)(uint32_t) const>(&Tracing::getBoundBuffer));
					case 51: return FunctionPtr(new FunctionImpl<size_t(Tracing::*)(uint32_t) const>(&Tracing::getBoundOffset));
					case 52: return FunctionPtr(new FunctionImpl<String(Tracing::*)() const>(&Tracing::getDescription));
					case 53: return FunctionPtr(new FunctionImpl<uint64_t(Tracing::*)() const>(&Tracing::getTracingAddress));
					case 54: return FunctionPtr(new FunctionImpl<size_t(Tracing::*)() const>(&Tracing::getBuildSize));
					case 55: return FunctionPtr(new FunctionImpl<size_t(Tracing::*)() const>(&Tracing::getUpdateSize));
					case 56: return FunctionPtr(new FunctionImpl<size_t(Tracing::*)() const>(&Tracing::getMemory));
					case 57: return FunctionPtr(new FunctionImpl<Tracing(Tracing::*)() const>(&Tracing::clonePtr));
					case 58: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)()>(&Tracing::clearPtr));
					case 59: return FunctionPtr(new FunctionVoidImpl<void(Tracing::*)()>(&Tracing::destroyPtr));
					case 60: return FunctionPtr(new FunctionImpl<Tracing&(Tracing::*)()>(&Tracing::acquirePtr));
					case 61: return FunctionPtr(new FunctionImpl<Tracing&(Tracing::*)()>(&Tracing::unacquirePtr));
					case 62: return FunctionPtr(new FunctionImpl<bool(Tracing::*)() const>(&Tracing::isValidPtr));
					case 63: return FunctionPtr(new FunctionImpl<bool(Tracing::*)() const>(&Tracing::isOwnerPtr));
					case 64: return FunctionPtr(new FunctionImpl<bool(Tracing::*)() const>(&Tracing::isConstPtr));
					case 65: return FunctionPtr(new FunctionImpl<uint32_t(Tracing::*)() const>(&Tracing::getCountPtr));
					case 66: return FunctionPtr(new FunctionImpl<const void*(Tracing::*)() const>(&Tracing::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 1431, 172, 75, 24, 214, 345, 345, 1434, 1435, 1436, 1437, 1332, 490, 1439, 1439, 1440, 1441, 1442, 1443, 1051, 1444, 1445, 1446, 1041, 1041, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 1046, 1046, 1454, 674, 1455, 1456, 1457, 1458, 1460, 1460, 1461, 1462, 1463, 1464, 1465, 403, 1466, 1467, 1468, 453, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 21, 6, 16, 21, 215, 138, 138, 21, 21, 21, 21, 6, 10, 6, 6, 6, 10, 902, 74, 6, 902, 74, 10, 6, 6, 6, 10, 340, 10, 902, 74, 10, 6, 6, 6, 10, 340, 902, 74, 10, 6, 6, 6, 10, 10, 902, 74, 16, 39, 74, 74, 74, 1430, 1430, 1430, 1430, 1430, 1430, 1430, 1430, 1430, 1430 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 1, 1, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 8, 10, 11, 11, 11, 11, 13, 13, 13, 18, 22, 25, 27, 28, 29, 30, 31, 32, 36, 40, 43, 45, 46, 47, 48, 49, 53, 57, 60, 62, 63, 64, 65, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66, 66 };
			static constexpr uint16_t function_arg_types[] = { 22, 1432, 1433, 1432, 1438, 10, 1005, 74, 1005, 74, 10, 1005, 74, 10, 340, 74, 902, 74, 10, 10, 1005, 74, 10, 1005, 74, 10, 10, 10, 10, 10, 10, 10, 10, 340, 902, 74, 10, 10, 1005, 74, 10, 1005, 74, 10, 10, 10, 10, 10, 10, 10, 74, 902, 74, 10, 10, 1005, 74, 10, 1005, 74, 10, 10, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 195, 338, 195, 1020, 1064, 915, 78, 915, 78, 1064, 915, 78, 1061, 96, 452, 915, 78, 274, 1061, 915, 78, 274, 915, 78, 274, 1061, 274, 274, 274, 274, 274, 667, 96, 915, 78, 274, 667, 915, 78, 274, 915, 78, 274, 667, 274, 274, 274, 274, 1459, 452, 915, 78, 274, 1459, 915, 78, 274, 915, 78, 274, 1459, 274, 274, 274, 274 };
	};
	constexpr uint16_t ReflectionTracing::constructor_bases[];
	constexpr uint16_t ReflectionTracing::constructor_arg_types[];
	constexpr uint16_t ReflectionTracing::constructor_arg_names[];
	constexpr uint16_t ReflectionTracing::function_names[];
	constexpr uint16_t ReflectionTracing::function_types[];
	constexpr uint16_t ReflectionTracing::function_bases[];
	constexpr uint16_t ReflectionTracing::function_arg_types[];
	constexpr uint16_t ReflectionTracing::function_arg_names[];
	static ReflectionTracing reflection_tracing;
	
	// Tellusim::D3D12Tracing
	class ReflectionD3D12Tracing : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Tracing::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_tracing;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Tracing, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Tracing>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(D3D12Tracing::*)(uint32_t) const>(&D3D12Tracing::getGeometryDesc));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(D3D12Tracing::*)() const>(&D3D12Tracing::getBuildInputs));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(D3D12Tracing::*)() const>(&D3D12Tracing::getPrebuildInfo));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(D3D12Tracing::*)() const>(&D3D12Tracing::getBuildDesc));
					case 4: return FunctionPtr(new FunctionImpl<Buffer(D3D12Tracing::*)() const>(&D3D12Tracing::getTracingBuffer));
					case 5: return FunctionPtr(new FunctionImpl<size_t(D3D12Tracing::*)() const>(&D3D12Tracing::getShaderResourceView));
					case 6: return FunctionPtr(new FunctionImpl<D3D12Tracing(D3D12Tracing::*)() const>(&D3D12Tracing::clonePtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(D3D12Tracing::*)()>(&D3D12Tracing::clearPtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(D3D12Tracing::*)()>(&D3D12Tracing::destroyPtr));
					case 9: return FunctionPtr(new FunctionImpl<D3D12Tracing&(D3D12Tracing::*)()>(&D3D12Tracing::acquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<D3D12Tracing&(D3D12Tracing::*)()>(&D3D12Tracing::unacquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(D3D12Tracing::*)() const>(&D3D12Tracing::isValidPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(D3D12Tracing::*)() const>(&D3D12Tracing::isOwnerPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(D3D12Tracing::*)() const>(&D3D12Tracing::isConstPtr));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Tracing::*)() const>(&D3D12Tracing::getCountPtr));
					case 15: return FunctionPtr(new FunctionImpl<const void*(D3D12Tracing::*)() const>(&D3D12Tracing::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1470, 1471, 1472, 1473, 1474, 920, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 6, 902, 74, 1469, 1469, 1469, 1469, 1469, 1469, 1469, 1469, 1469, 1469 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 10 };
			static constexpr uint16_t function_arg_names[] = { 274 };
	};
	constexpr uint16_t ReflectionD3D12Tracing::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Tracing::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Tracing::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Tracing::function_names[];
	constexpr uint16_t ReflectionD3D12Tracing::function_types[];
	constexpr uint16_t ReflectionD3D12Tracing::function_bases[];
	constexpr uint16_t ReflectionD3D12Tracing::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Tracing::function_arg_names[];
	static ReflectionD3D12Tracing reflection_d3d12_tracing;
	
	// Tellusim::MTLTracing
	class ReflectionMTLTracing : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLTracing::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_tracing;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLTracing, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLTracing>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(MTLTracing::*)(uint32_t) const>(&MTLTracing::getGeometryDesc));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(MTLTracing::*)() const>(&MTLTracing::getPrimitiveDesc));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(MTLTracing::*)() const>(&MTLTracing::getInstanceDesc));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(MTLTracing::*)() const>(&MTLTracing::getAccelerationStructure));
					case 4: return FunctionPtr(new FunctionImpl<MTLTracing(MTLTracing::*)() const>(&MTLTracing::clonePtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(MTLTracing::*)()>(&MTLTracing::clearPtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(MTLTracing::*)()>(&MTLTracing::destroyPtr));
					case 7: return FunctionPtr(new FunctionImpl<MTLTracing&(MTLTracing::*)()>(&MTLTracing::acquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<MTLTracing&(MTLTracing::*)()>(&MTLTracing::unacquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(MTLTracing::*)() const>(&MTLTracing::isValidPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(MTLTracing::*)() const>(&MTLTracing::isOwnerPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(MTLTracing::*)() const>(&MTLTracing::isConstPtr));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(MTLTracing::*)() const>(&MTLTracing::getCountPtr));
					case 13: return FunctionPtr(new FunctionImpl<const void*(MTLTracing::*)() const>(&MTLTracing::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1470, 1476, 1477, 1478, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 6, 1475, 1475, 1475, 1475, 1475, 1475, 1475, 1475, 1475, 1475 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 10 };
			static constexpr uint16_t function_arg_names[] = { 274 };
	};
	constexpr uint16_t ReflectionMTLTracing::constructor_bases[];
	constexpr uint16_t ReflectionMTLTracing::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLTracing::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLTracing::function_names[];
	constexpr uint16_t ReflectionMTLTracing::function_types[];
	constexpr uint16_t ReflectionMTLTracing::function_bases[];
	constexpr uint16_t ReflectionMTLTracing::function_arg_types[];
	constexpr uint16_t ReflectionMTLTracing::function_arg_names[];
	static ReflectionMTLTracing reflection_mtl_tracing;
	
	// Tellusim::VKTracing
	class ReflectionVKTracing : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKTracing::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_tracing;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKTracing, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKTracing>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(VKTracing::*)() const>(&VKTracing::getBuildGeometryInfo));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(VKTracing::*)() const>(&VKTracing::getBuildSizeInfo));
					case 2: return FunctionPtr(new FunctionImpl<Buffer(VKTracing::*)() const>(&VKTracing::getTracingBuffer));
					case 3: return FunctionPtr(new FunctionImpl<VkAccelerationStructureKHR(VKTracing::*)() const>(&VKTracing::getAccelerationStructure));
					case 4: return FunctionPtr(new FunctionImpl<VKTracing(VKTracing::*)() const>(&VKTracing::clonePtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(VKTracing::*)()>(&VKTracing::clearPtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(VKTracing::*)()>(&VKTracing::destroyPtr));
					case 7: return FunctionPtr(new FunctionImpl<VKTracing&(VKTracing::*)()>(&VKTracing::acquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<VKTracing&(VKTracing::*)()>(&VKTracing::unacquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(VKTracing::*)() const>(&VKTracing::isValidPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(VKTracing::*)() const>(&VKTracing::isOwnerPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(VKTracing::*)() const>(&VKTracing::isConstPtr));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(VKTracing::*)() const>(&VKTracing::getCountPtr));
					case 13: return FunctionPtr(new FunctionImpl<const void*(VKTracing::*)() const>(&VKTracing::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1480, 1481, 1474, 1478, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 902, 1482, 1479, 1479, 1479, 1479, 1479, 1479, 1479, 1479, 1479, 1479 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionVKTracing::constructor_bases[];
	constexpr uint16_t ReflectionVKTracing::constructor_arg_types[];
	constexpr uint16_t ReflectionVKTracing::constructor_arg_names[];
	constexpr uint16_t ReflectionVKTracing::function_names[];
	constexpr uint16_t ReflectionVKTracing::function_types[];
	constexpr uint16_t ReflectionVKTracing::function_bases[];
	constexpr uint16_t ReflectionVKTracing::function_arg_types[];
	constexpr uint16_t ReflectionVKTracing::function_arg_names[];
	static ReflectionVKTracing reflection_vk_tracing;
	
	// Tellusim::FUTracing
	class ReflectionFUTracing : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUTracing::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_tracing;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUTracing, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUTracing, TypeList<const Array<Tracing>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUTracing>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUTracing::*)(uint32_t)>(&FUTracing::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUTracing::*)() const>(&FUTracing::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUTracing::*)() const>(&FUTracing::getNumTracings));
					case 3: return FunctionPtr(new FunctionImpl<const Tracing(FUTracing::*)(uint32_t) const>(&FUTracing::getTracing));
					case 4: return FunctionPtr(new FunctionImpl<Tracing(FUTracing::*)(uint32_t)>(&FUTracing::getTracing));
					case 5: return FunctionPtr(new FunctionImpl<FUTracing(FUTracing::*)() const>(&FUTracing::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUTracing::*)()>(&FUTracing::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUTracing::*)()>(&FUTracing::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUTracing&(FUTracing::*)()>(&FUTracing::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUTracing&(FUTracing::*)()>(&FUTracing::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUTracing::*)() const>(&FUTracing::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUTracing::*)() const>(&FUTracing::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUTracing::*)() const>(&FUTracing::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUTracing::*)() const>(&FUTracing::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUTracing::*)() const>(&FUTracing::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1022, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1023, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1484, 1485, 1485, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1430, 1430, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483, 1483 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUTracing::constructor_bases[];
	constexpr uint16_t ReflectionFUTracing::constructor_arg_types[];
	constexpr uint16_t ReflectionFUTracing::constructor_arg_names[];
	constexpr uint16_t ReflectionFUTracing::function_names[];
	constexpr uint16_t ReflectionFUTracing::function_types[];
	constexpr uint16_t ReflectionFUTracing::function_bases[];
	constexpr uint16_t ReflectionFUTracing::function_arg_types[];
	constexpr uint16_t ReflectionFUTracing::function_arg_names[];
	static ReflectionFUTracing reflection_fu_tracing;
	
	// Tellusim::Target
	class ReflectionTarget : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Target::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Target, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Target>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Target::*)() const>(&Target::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Target::*)() const>(&Target::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getIndex));
					case 3: return FunctionPtr(new FunctionImpl<bool(Target::*)(Fence&)>(&Target::begin));
					case 4: return FunctionPtr(new FunctionImpl<bool(Target::*)()>(&Target::begin));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(Fence&)>(&Target::end));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(Target::*)()>(&Target::end));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(Surface&)>(&Target::swap));
					case 8: return FunctionPtr(new FunctionImpl<bool(Target::*)() const>(&Target::isEnabled));
					case 9: return FunctionPtr(new FunctionImpl<Format(Target::*)(uint32_t) const>(&Target::getColorFormat, 0));
					case 10: return FunctionPtr(new FunctionImpl<Format(Target::*)() const>(&Target::getDepthFormat));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getMultisample));
					case 12: return FunctionPtr(new FunctionImpl<bool(Target::*)() const>(&Target::hasMultisample));
					case 13: return FunctionPtr(new FunctionImpl<bool(Target::*)() const>(&Target::isFlipped));
					case 14: return FunctionPtr(new FunctionImpl<bool(Target::*)() const>(&Target::isAtomic));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getWidth));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getHeight));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getDepth));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getFaces));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getLayers));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getMipmaps));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(const Color&)>(&Target::setClearColor));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(uint32_t, const Color&)>(&Target::setClearColor));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(float32_t, float32_t, float32_t, float32_t)>(&Target::setClearColor));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(uint32_t, float32_t, float32_t, float32_t, float32_t)>(&Target::setClearColor));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(Texture&, Target::Operation, const Slice&)>(&Target::setColorTexture, Texture::null, Target::OpDefault, Slice()));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(uint32_t, Texture&, Target::Operation, const Slice&)>(&Target::setColorTexture, {}, Texture::null, Target::OpDefault, Slice()));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(Texture&, const Slice&)>(&Target::setColorResolve, Texture::null, Slice()));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(uint32_t, Texture&, const Slice&)>(&Target::setColorResolve, {}, Texture::null, Slice()));
					case 29: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getNumTargets));
					case 30: return FunctionPtr(new FunctionImpl<const Color&(Target::*)(uint32_t) const>(&Target::getClearColor, 0));
					case 31: return FunctionPtr(new FunctionImpl<Target::Operation(Target::*)(uint32_t) const>(&Target::getColorOp, 0));
					case 32: return FunctionPtr(new FunctionImpl<Texture(Target::*)(uint32_t) const>(&Target::getColorTexture));
					case 33: return FunctionPtr(new FunctionImpl<Texture(Target::*)(uint32_t) const>(&Target::getColorResolve));
					case 34: return FunctionPtr(new FunctionImpl<const Slice&(Target::*)(uint32_t) const>(&Target::getColorTextureSlice));
					case 35: return FunctionPtr(new FunctionImpl<const Slice&(Target::*)(uint32_t) const>(&Target::getColorResolveSlice));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(float32_t, uint32_t)>(&Target::setClearDepth, {}, 0));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(Texture&, Target::Operation, const Slice&)>(&Target::setDepthTexture, Texture::null, Target::OpDefault, Slice()));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(Target::*)(Texture&, const Slice&)>(&Target::setDepthResolve, Texture::null, Slice()));
					case 39: return FunctionPtr(new FunctionImpl<float32_t(Target::*)() const>(&Target::getClearDepth));
					case 40: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getClearStencil));
					case 41: return FunctionPtr(new FunctionImpl<Target::Operation(Target::*)() const>(&Target::getDepthOp));
					case 42: return FunctionPtr(new FunctionImpl<Texture(Target::*)() const>(&Target::getDepthTexture));
					case 43: return FunctionPtr(new FunctionImpl<Texture(Target::*)() const>(&Target::getDepthResolve));
					case 44: return FunctionPtr(new FunctionImpl<const Slice&(Target::*)() const>(&Target::getDepthTextureSlice));
					case 45: return FunctionPtr(new FunctionImpl<const Slice&(Target::*)() const>(&Target::getDepthResolveSlice));
					case 46: return FunctionPtr(new FunctionImpl<Target(Target::*)() const>(&Target::clonePtr));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(Target::*)()>(&Target::clearPtr));
					case 48: return FunctionPtr(new FunctionVoidImpl<void(Target::*)()>(&Target::destroyPtr));
					case 49: return FunctionPtr(new FunctionImpl<Target&(Target::*)()>(&Target::acquirePtr));
					case 50: return FunctionPtr(new FunctionImpl<Target&(Target::*)()>(&Target::unacquirePtr));
					case 51: return FunctionPtr(new FunctionImpl<bool(Target::*)() const>(&Target::isValidPtr));
					case 52: return FunctionPtr(new FunctionImpl<bool(Target::*)() const>(&Target::isOwnerPtr));
					case 53: return FunctionPtr(new FunctionImpl<bool(Target::*)() const>(&Target::isConstPtr));
					case 54: return FunctionPtr(new FunctionImpl<uint32_t(Target::*)() const>(&Target::getCountPtr));
					case 55: return FunctionPtr(new FunctionImpl<const void*(Target::*)() const>(&Target::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 1487, 1487, 1490, 1490, 421, 1493, 1494, 1495, 13, 1380, 1496, 1497, 11, 12, 388, 389, 390, 391, 1498, 1498, 1498, 1498, 1499, 1499, 1502, 1502, 1503, 1504, 1505, 1507, 1508, 1509, 1510, 1511, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 21, 21, 6, 6, 6, 21, 340, 340, 10, 21, 21, 21, 10, 10, 10, 10, 10, 10, 6, 6, 6, 6, 6, 6, 6, 6, 10, 654, 1506, 1377, 1377, 400, 400, 6, 6, 6, 123, 10, 1506, 1377, 1377, 400, 400, 1486, 1486, 1486, 1486, 1486, 1486, 1486, 1486, 1486, 1486 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 7, 11, 16, 19, 23, 25, 28, 28, 29, 30, 31, 32, 33, 34, 36, 39, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41 };
			static constexpr uint16_t function_arg_types[] = { 1488, 1488, 1491, 10, 637, 10, 637, 123, 123, 123, 123, 10, 123, 123, 123, 123, 994, 1500, 405, 10, 994, 1500, 405, 994, 405, 10, 994, 405, 10, 10, 10, 10, 10, 10, 123, 10, 994, 1500, 405, 994, 405 };
			static constexpr uint16_t function_arg_names[] = { 1489, 1489, 1492, 274, 638, 274, 638, 1054, 1055, 1056, 1057, 274, 1054, 1055, 1056, 1057, 995, 1501, 406, 274, 995, 1501, 406, 995, 406, 274, 995, 406, 274, 274, 274, 274, 274, 274, 415, 1512, 995, 1501, 406, 995, 406 };
	};
	constexpr uint16_t ReflectionTarget::constructor_bases[];
	constexpr uint16_t ReflectionTarget::constructor_arg_types[];
	constexpr uint16_t ReflectionTarget::constructor_arg_names[];
	constexpr uint16_t ReflectionTarget::function_names[];
	constexpr uint16_t ReflectionTarget::function_types[];
	constexpr uint16_t ReflectionTarget::function_bases[];
	constexpr uint16_t ReflectionTarget::function_arg_types[];
	constexpr uint16_t ReflectionTarget::function_arg_names[];
	static ReflectionTarget reflection_target;
	
	// Tellusim::D3D12Target
	class ReflectionD3D12Target : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Target::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_target;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Target, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Target>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<size_t*(D3D12Target::*)() const>(&D3D12Target::getRenderTargetViews));
					case 1: return FunctionPtr(new FunctionImpl<size_t(D3D12Target::*)() const>(&D3D12Target::getDepthStencilView));
					case 2: return FunctionPtr(new FunctionImpl<D3D12Target(D3D12Target::*)() const>(&D3D12Target::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D12Target::*)()>(&D3D12Target::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(D3D12Target::*)()>(&D3D12Target::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D12Target&(D3D12Target::*)()>(&D3D12Target::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<D3D12Target&(D3D12Target::*)()>(&D3D12Target::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D12Target::*)() const>(&D3D12Target::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D12Target::*)() const>(&D3D12Target::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(D3D12Target::*)() const>(&D3D12Target::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Target::*)() const>(&D3D12Target::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(D3D12Target::*)() const>(&D3D12Target::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1523, 1392, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 74, 74, 1522, 1522, 1522, 1522, 1522, 1522, 1522, 1522, 1522, 1522 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D12Target::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Target::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Target::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Target::function_names[];
	constexpr uint16_t ReflectionD3D12Target::function_types[];
	constexpr uint16_t ReflectionD3D12Target::function_bases[];
	constexpr uint16_t ReflectionD3D12Target::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Target::function_arg_names[];
	static ReflectionD3D12Target reflection_d3d12_target;
	
	// Tellusim::D3D11Target
	class ReflectionD3D11Target : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D11Target::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_target;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D11Target, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D11Target>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<ID3D11RenderTargetView**(D3D11Target::*)() const>(&D3D11Target::getRenderTargetViews));
					case 1: return FunctionPtr(new FunctionImpl<ID3D11DepthStencilView*(D3D11Target::*)() const>(&D3D11Target::getDepthStencilView));
					case 2: return FunctionPtr(new FunctionImpl<D3D11Target(D3D11Target::*)() const>(&D3D11Target::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D11Target::*)()>(&D3D11Target::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(D3D11Target::*)()>(&D3D11Target::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D11Target&(D3D11Target::*)()>(&D3D11Target::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<D3D11Target&(D3D11Target::*)()>(&D3D11Target::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D11Target::*)() const>(&D3D11Target::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D11Target::*)() const>(&D3D11Target::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(D3D11Target::*)() const>(&D3D11Target::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Target::*)() const>(&D3D11Target::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(D3D11Target::*)() const>(&D3D11Target::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1523, 1392, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1399, 1400, 1524, 1524, 1524, 1524, 1524, 1524, 1524, 1524, 1524, 1524 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D11Target::constructor_bases[];
	constexpr uint16_t ReflectionD3D11Target::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D11Target::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D11Target::function_names[];
	constexpr uint16_t ReflectionD3D11Target::function_types[];
	constexpr uint16_t ReflectionD3D11Target::function_bases[];
	constexpr uint16_t ReflectionD3D11Target::function_arg_types[];
	constexpr uint16_t ReflectionD3D11Target::function_arg_names[];
	static ReflectionD3D11Target reflection_d3d11_target;
	
	// Tellusim::MTLTarget
	class ReflectionMTLTarget : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLTarget::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_target;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLTarget, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLTarget>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(MTLTarget::*)() const>(&MTLTarget::getDescriptor));
					case 1: return FunctionPtr(new FunctionImpl<MTLTarget(MTLTarget::*)() const>(&MTLTarget::clonePtr));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(MTLTarget::*)()>(&MTLTarget::clearPtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(MTLTarget::*)()>(&MTLTarget::destroyPtr));
					case 4: return FunctionPtr(new FunctionImpl<MTLTarget&(MTLTarget::*)()>(&MTLTarget::acquirePtr));
					case 5: return FunctionPtr(new FunctionImpl<MTLTarget&(MTLTarget::*)()>(&MTLTarget::unacquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<bool(MTLTarget::*)() const>(&MTLTarget::isValidPtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(MTLTarget::*)() const>(&MTLTarget::isOwnerPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(MTLTarget::*)() const>(&MTLTarget::isConstPtr));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(MTLTarget::*)() const>(&MTLTarget::getCountPtr));
					case 10: return FunctionPtr(new FunctionImpl<const void*(MTLTarget::*)() const>(&MTLTarget::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1526, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 1525, 1525, 1525, 1525, 1525, 1525, 1525, 1525, 1525, 1525 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionMTLTarget::constructor_bases[];
	constexpr uint16_t ReflectionMTLTarget::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLTarget::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLTarget::function_names[];
	constexpr uint16_t ReflectionMTLTarget::function_types[];
	constexpr uint16_t ReflectionMTLTarget::function_bases[];
	constexpr uint16_t ReflectionMTLTarget::function_arg_types[];
	constexpr uint16_t ReflectionMTLTarget::function_arg_names[];
	static ReflectionMTLTarget reflection_mtl_target;
	
	// Tellusim::VKTarget
	class ReflectionVKTarget : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKTarget::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_target;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKTarget, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKTarget>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<VkRenderPass(VKTarget::*)() const>(&VKTarget::getRenderPass));
					case 1: return FunctionPtr(new FunctionImpl<VkFramebuffer(VKTarget::*)() const>(&VKTarget::getFramebuffer));
					case 2: return FunctionPtr(new FunctionImpl<VKTarget(VKTarget::*)() const>(&VKTarget::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(VKTarget::*)()>(&VKTarget::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(VKTarget::*)()>(&VKTarget::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<VKTarget&(VKTarget::*)()>(&VKTarget::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<VKTarget&(VKTarget::*)()>(&VKTarget::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(VKTarget::*)() const>(&VKTarget::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(VKTarget::*)() const>(&VKTarget::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(VKTarget::*)() const>(&VKTarget::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(VKTarget::*)() const>(&VKTarget::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(VKTarget::*)() const>(&VKTarget::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1528, 1530, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1529, 1531, 1527, 1527, 1527, 1527, 1527, 1527, 1527, 1527, 1527, 1527 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionVKTarget::constructor_bases[];
	constexpr uint16_t ReflectionVKTarget::constructor_arg_types[];
	constexpr uint16_t ReflectionVKTarget::constructor_arg_names[];
	constexpr uint16_t ReflectionVKTarget::function_names[];
	constexpr uint16_t ReflectionVKTarget::function_types[];
	constexpr uint16_t ReflectionVKTarget::function_bases[];
	constexpr uint16_t ReflectionVKTarget::function_arg_types[];
	constexpr uint16_t ReflectionVKTarget::function_arg_names[];
	static ReflectionVKTarget reflection_vk_target;
	
	// Tellusim::GLTarget
	class ReflectionGLTarget : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLTarget::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_target;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLTarget, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLTarget>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<uint32_t(GLTarget::*)() const>(&GLTarget::getFramebufferID));
					case 1: return FunctionPtr(new FunctionImpl<GLTarget(GLTarget::*)() const>(&GLTarget::clonePtr));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(GLTarget::*)()>(&GLTarget::clearPtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(GLTarget::*)()>(&GLTarget::destroyPtr));
					case 4: return FunctionPtr(new FunctionImpl<GLTarget&(GLTarget::*)()>(&GLTarget::acquirePtr));
					case 5: return FunctionPtr(new FunctionImpl<GLTarget&(GLTarget::*)()>(&GLTarget::unacquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<bool(GLTarget::*)() const>(&GLTarget::isValidPtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(GLTarget::*)() const>(&GLTarget::isOwnerPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(GLTarget::*)() const>(&GLTarget::isConstPtr));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(GLTarget::*)() const>(&GLTarget::getCountPtr));
					case 10: return FunctionPtr(new FunctionImpl<const void*(GLTarget::*)() const>(&GLTarget::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1533, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 10, 1532, 1532, 1532, 1532, 1532, 1532, 1532, 1532, 1532, 1532 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionGLTarget::constructor_bases[];
	constexpr uint16_t ReflectionGLTarget::constructor_arg_types[];
	constexpr uint16_t ReflectionGLTarget::constructor_arg_names[];
	constexpr uint16_t ReflectionGLTarget::function_names[];
	constexpr uint16_t ReflectionGLTarget::function_types[];
	constexpr uint16_t ReflectionGLTarget::function_bases[];
	constexpr uint16_t ReflectionGLTarget::function_arg_types[];
	constexpr uint16_t ReflectionGLTarget::function_arg_names[];
	static ReflectionGLTarget reflection_gl_target;
	
	// Tellusim::GLESTarget
	class ReflectionGLESTarget : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLESTarget::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_target;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLESTarget, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLESTarget>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<uint32_t(GLESTarget::*)() const>(&GLESTarget::getFramebufferID));
					case 1: return FunctionPtr(new FunctionImpl<GLESTarget(GLESTarget::*)() const>(&GLESTarget::clonePtr));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(GLESTarget::*)()>(&GLESTarget::clearPtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(GLESTarget::*)()>(&GLESTarget::destroyPtr));
					case 4: return FunctionPtr(new FunctionImpl<GLESTarget&(GLESTarget::*)()>(&GLESTarget::acquirePtr));
					case 5: return FunctionPtr(new FunctionImpl<GLESTarget&(GLESTarget::*)()>(&GLESTarget::unacquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<bool(GLESTarget::*)() const>(&GLESTarget::isValidPtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(GLESTarget::*)() const>(&GLESTarget::isOwnerPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(GLESTarget::*)() const>(&GLESTarget::isConstPtr));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(GLESTarget::*)() const>(&GLESTarget::getCountPtr));
					case 10: return FunctionPtr(new FunctionImpl<const void*(GLESTarget::*)() const>(&GLESTarget::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1533, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 10, 1534, 1534, 1534, 1534, 1534, 1534, 1534, 1534, 1534, 1534 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionGLESTarget::constructor_bases[];
	constexpr uint16_t ReflectionGLESTarget::constructor_arg_types[];
	constexpr uint16_t ReflectionGLESTarget::constructor_arg_names[];
	constexpr uint16_t ReflectionGLESTarget::function_names[];
	constexpr uint16_t ReflectionGLESTarget::function_types[];
	constexpr uint16_t ReflectionGLESTarget::function_bases[];
	constexpr uint16_t ReflectionGLESTarget::function_arg_types[];
	constexpr uint16_t ReflectionGLESTarget::function_arg_names[];
	static ReflectionGLESTarget reflection_gles_target;
	
	// Tellusim::FUTarget
	class ReflectionFUTarget : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUTarget::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_target;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUTarget, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUTarget, TypeList<const Array<Target>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUTarget>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUTarget::*)(uint32_t)>(&FUTarget::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUTarget::*)() const>(&FUTarget::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUTarget::*)() const>(&FUTarget::getNumTargets));
					case 3: return FunctionPtr(new FunctionImpl<const Target(FUTarget::*)(uint32_t) const>(&FUTarget::getTarget));
					case 4: return FunctionPtr(new FunctionImpl<Target(FUTarget::*)(uint32_t)>(&FUTarget::getTarget));
					case 5: return FunctionPtr(new FunctionImpl<FUTarget(FUTarget::*)() const>(&FUTarget::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUTarget::*)()>(&FUTarget::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUTarget::*)()>(&FUTarget::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUTarget&(FUTarget::*)()>(&FUTarget::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUTarget&(FUTarget::*)()>(&FUTarget::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUTarget::*)() const>(&FUTarget::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUTarget::*)() const>(&FUTarget::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUTarget::*)() const>(&FUTarget::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUTarget::*)() const>(&FUTarget::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUTarget::*)() const>(&FUTarget::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1536, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1537, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1503, 946, 946, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1486, 1486, 1535, 1535, 1535, 1535, 1535, 1535, 1535, 1535, 1535, 1535 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUTarget::constructor_bases[];
	constexpr uint16_t ReflectionFUTarget::constructor_arg_types[];
	constexpr uint16_t ReflectionFUTarget::constructor_arg_names[];
	constexpr uint16_t ReflectionFUTarget::function_names[];
	constexpr uint16_t ReflectionFUTarget::function_types[];
	constexpr uint16_t ReflectionFUTarget::function_bases[];
	constexpr uint16_t ReflectionFUTarget::function_arg_types[];
	constexpr uint16_t ReflectionFUTarget::function_arg_names[];
	static ReflectionFUTarget reflection_fu_target;
	
	// Tellusim::Device
	class ReflectionDevice : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Device::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Device, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Device, TypeList<Context&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<Device, TypeList<Surface&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<Device, TypeList<Window&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Device>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Device::*)() const>(&Device::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Device::*)() const>(&Device::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Device::*)() const>(&Device::getIndex));
					case 3: return FunctionPtr(new FunctionImpl<String(Device::*)() const>(&Device::getName));
					case 4: return FunctionPtr(new FunctionImpl<String(Device::*)() const>(&Device::getVendor));
					case 5: return FunctionPtr(new FunctionImpl<String(Device::*)() const>(&Device::getVersion));
					case 6: return FunctionPtr(new FunctionImpl<const Device::Features&(Device::*)() const>(&Device::getFeatures));
					case 7: return FunctionPtr(new FunctionImpl<bool(Device::*)(Query::Type) const>(&Device::hasQuery));
					case 8: return FunctionPtr(new FunctionImpl<bool(Device::*)(Shader::Type) const>(&Device::hasShader));
					case 9: return FunctionPtr(new FunctionImpl<bool(Device::*)(Format) const>(&Device::hasTarget));
					case 10: return FunctionPtr(new FunctionImpl<bool(Device::*)(Format) const>(&Device::hasTexture));
					case 11: return FunctionPtr(new FunctionImpl<bool(Device::*)(Format) const>(&Device::hasSurface));
					case 12: return FunctionPtr(new FunctionImpl<Device(Device::*)(uint32_t, uint32_t) const>(&Device::createDevice, {}, 3));
					case 13: return FunctionPtr(new FunctionImpl<Device(Device::*)(uint32_t) const>(&Device::createCommandDevice, 3));
					case 14: return FunctionPtr(new FunctionImpl<Device(Device::*)(uint32_t) const>(&Device::createComputeDevice, 3));
					case 15: return FunctionPtr(new FunctionImpl<Device(Device::*)(uint32_t) const>(&Device::createCopyDevice, 3));
					case 16: return FunctionPtr(new FunctionImpl<Query(Device::*)() const>(&Device::createQuery));
					case 17: return FunctionPtr(new FunctionImpl<Query(Device::*)(Query::Type) const>(&Device::createQuery));
					case 18: return FunctionPtr(new FunctionImpl<Fence(Device::*)() const>(&Device::createFence));
					case 19: return FunctionPtr(new FunctionImpl<Fence(Device::*)(Fence&) const>(&Device::createFence));
					case 20: return FunctionPtr(new FunctionImpl<Fence(Device::*)(Fence::Flags) const>(&Device::createFence));
					case 21: return FunctionPtr(new FunctionImpl<Buffer(Device::*)() const>(&Device::createBuffer));
					case 22: return FunctionPtr(new FunctionImpl<Buffer(Device::*)(Buffer&) const>(&Device::createBuffer));
					case 23: return FunctionPtr(new FunctionImpl<Buffer(Device::*)(Buffer::Flags, size_t, Format) const>(&Device::createBuffer, {}, {}, Tellusim::FormatUnknown));
					case 24: return FunctionPtr(new FunctionImpl<Buffer(Device::*)(Buffer::Flags, const void*, size_t, Format) const>(&Device::createBuffer, {}, {}, {}, Tellusim::FormatUnknown));
					case 25: return FunctionPtr(new FunctionImpl<Sampler(Device::*)() const>(&Device::createSampler));
					case 26: return FunctionPtr(new FunctionImpl<Sampler(Device::*)(const Sampler&) const>(&Device::createSampler));
					case 27: return FunctionPtr(new FunctionImpl<Sampler(Device::*)(Sampler::Filter, Sampler::WrapMode, uint32_t) const>(&Device::createSampler, {}, Sampler::WrapModeRepeat, Sampler::MaxAnisotropy));
					case 28: return FunctionPtr(new FunctionImpl<Texture(Device::*)() const>(&Device::createTexture));
					case 29: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Texture&) const>(&Device::createTexture));
					case 30: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Texture::Type, Format, const Size&, uint32_t, Texture::Flags) const>(&Device::createTexture, {}, (Format)0, {}, {}, Texture::DefaultFlags));
					case 31: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Texture::Type, Format, const Size&, Texture::Flags) const>(&Device::createTexture, {}, (Format)0, {}, Texture::DefaultFlags));
					case 32: return FunctionPtr(new FunctionImpl<Texture(Device::*)(const Image&, Texture::Flags, Async*) const>(&Device::createTexture, Image::null, Texture::DefaultFlags, nullptr));
					case 33: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Format, uint32_t, Texture::Flags) const>(&Device::createTexture2D, (Format)0, {}, Texture::DefaultFlags));
					case 34: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Format, uint32_t, Texture::Flags) const>(&Device::createTexture3D, (Format)0, {}, Texture::DefaultFlags));
					case 35: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Format, uint32_t, Texture::Flags) const>(&Device::createTextureCube, (Format)0, {}, Texture::DefaultFlags));
					case 36: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Format, uint32_t, uint32_t, Texture::Flags) const>(&Device::createTexture2D, (Format)0, {}, {}, Texture::DefaultFlags));
					case 37: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Format, uint32_t, uint32_t, uint32_t, Texture::Flags) const>(&Device::createTexture3D, (Format)0, {}, {}, {}, Texture::DefaultFlags));
					case 38: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Format, uint32_t, uint32_t, uint32_t, Texture::Flags) const>(&Device::createTexture2D, (Format)0, {}, {}, {}, Texture::DefaultFlags));
					case 39: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Format, uint32_t, uint32_t, Texture::Flags) const>(&Device::createTextureCube, (Format)0, {}, {}, Texture::DefaultFlags));
					case 40: return FunctionPtr(new FunctionImpl<Texture(Device::*)(const char*, Texture::Flags, Image::Flags, uint32_t, Async*) const>(&Device::loadTexture, {}, Texture::DefaultFlags, Image::FlagNone, 0, nullptr));
					case 41: return FunctionPtr(new FunctionImpl<Texture(Device::*)(const String&, Texture::Flags, Image::Flags, uint32_t, Async*) const>(&Device::loadTexture, {}, Texture::DefaultFlags, Image::FlagNone, 0, nullptr));
					case 42: return FunctionPtr(new FunctionImpl<Texture(Device::*)(Stream&, Texture::Flags, Image::Flags, uint32_t, Async*) const>(&Device::loadTexture, Stream::null, Texture::DefaultFlags, Image::FlagNone, 0, nullptr));
					case 43: return FunctionPtr(new FunctionImpl<Tracing(Device::*)() const>(&Device::createTracing));
					case 44: return FunctionPtr(new FunctionImpl<Tracing(Device::*)(const Tracing&) const>(&Device::createTracing));
					case 45: return FunctionPtr(new FunctionImpl<Tracing(Device::*)(uint32_t, Buffer, size_t, Tracing::Flags) const>(&Device::createTracing, {}, Buffer::null, 0, Tracing::DefaultFlags));
					case 46: return FunctionPtr(new FunctionImpl<Tracing(Device::*)(uint32_t, Format, size_t, uint32_t, Format, Tracing::Flags) const>(&Device::createTracing, {}, (Format)0, {}, {}, (Format)0, Tracing::DefaultFlags));
					case 47: return FunctionPtr(new FunctionImpl<Tracing(Device::*)(uint32_t, size_t, Buffer, size_t, Tracing::Flags) const>(&Device::createTracing, {}, {}, Buffer::null, 0, Tracing::DefaultFlags));
					case 48: return FunctionPtr(new FunctionImpl<BufferTable(Device::*)() const>(&Device::createBufferTable));
					case 49: return FunctionPtr(new FunctionImpl<BufferTable(Device::*)(uint32_t) const>(&Device::createBufferTable));
					case 50: return FunctionPtr(new FunctionImpl<BufferTable(Device::*)(const Array<Buffer>&, bool) const>(&Device::createBufferTable, {}, false));
					case 51: return FunctionPtr(new FunctionImpl<TextureTable(Device::*)() const>(&Device::createTextureTable));
					case 52: return FunctionPtr(new FunctionImpl<TextureTable(Device::*)(Texture::Type, uint32_t) const>(&Device::createTextureTable));
					case 53: return FunctionPtr(new FunctionImpl<TextureTable(Device::*)(const Array<Texture>&, bool) const>(&Device::createTextureTable, {}, false));
					case 54: return FunctionPtr(new FunctionImpl<Shader(Device::*)() const>(&Device::createShader));
					case 55: return FunctionPtr(new FunctionImpl<Shader(Device::*)(Shader::Type, const char*, const String&) const>(&Device::loadShader, {}, {}, String::null));
					case 56: return FunctionPtr(new FunctionImpl<Shader(Device::*)(Shader::Type, const char*, const String&) const>(&Device::loadShaderGLSL, {}, {}, String::null));
					case 57: return FunctionPtr(new FunctionImpl<Shader(Device::*)(Shader::Type, const char*) const>(&Device::loadShaderSPIRV));
					case 58: return FunctionPtr(new FunctionImpl<Shader(Device::*)(Shader::Type, const char*, const String&) const>(&Device::createShader, {}, {}, String::null));
					case 59: return FunctionPtr(new FunctionImpl<Shader(Device::*)(Shader::Type, const char*, const String&) const>(&Device::createShaderGLSL, {}, {}, String::null));
					case 60: return FunctionPtr(new FunctionImpl<Shader(Device::*)(Shader::Type, const Array<uint32_t>&) const>(&Device::createShaderSPIRV));
					case 61: return FunctionPtr(new FunctionImpl<Kernel(Device::*)() const>(&Device::createKernel));
					case 62: return FunctionPtr(new FunctionImpl<Kernel(Device::*)(const Kernel&) const>(&Device::createKernel));
					case 63: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(Kernel&) const>(&Device::releaseKernel));
					case 64: return FunctionPtr(new FunctionImpl<Pipeline(Device::*)() const>(&Device::createPipeline));
					case 65: return FunctionPtr(new FunctionImpl<Pipeline(Device::*)(const Pipeline&) const>(&Device::createPipeline));
					case 66: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(Pipeline&) const>(&Device::releasePipeline));
					case 67: return FunctionPtr(new FunctionImpl<Traversal(Device::*)() const>(&Device::createTraversal));
					case 68: return FunctionPtr(new FunctionImpl<Traversal(Device::*)(const Traversal&) const>(&Device::createTraversal));
					case 69: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(Traversal&) const>(&Device::releaseTraversal));
					case 70: return FunctionPtr(new FunctionImpl<Target(Device::*)() const>(&Device::createTarget));
					case 71: return FunctionPtr(new FunctionImpl<Target(Device::*)(Surface&) const>(&Device::createTarget));
					case 72: return FunctionPtr(new FunctionImpl<Target(Device::*)(Window&) const>(&Device::createTarget));
					case 73: return FunctionPtr(new FunctionImpl<Target(Device::*)(const InitializerList<Texture>&, Target::Operation) const>(&Device::createTarget, {}, Target::OpDefault));
					case 74: return FunctionPtr(new FunctionImpl<Compute(Device::*)() const>(&Device::createCompute));
					case 75: return FunctionPtr(new FunctionImpl<Command(Device::*)() const>(&Device::createCommand));
					case 76: return FunctionPtr(new FunctionImpl<Command(Device::*)(Target&) const>(&Device::createCommand));
					case 77: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, size_t, const void*, size_t) const>(&Device::setBuffer));
					case 78: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, const void*, size_t) const>(&Device::setBuffer));
					case 79: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, const void*) const>(&Device::setBuffer));
					case 80: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, size_t, void*, size_t) const>(&Device::getBuffer));
					case 81: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, void*, size_t) const>(&Device::getBuffer));
					case 82: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, void*) const>(&Device::getBuffer));
					case 83: return FunctionPtr(new FunctionVoidImpl<void*(Device::*)(Buffer&, size_t, size_t) const>(&Device::mapBuffer));
					case 84: return FunctionPtr(new FunctionVoidImpl<void*(Device::*)(Buffer&, size_t) const>(&Device::mapBuffer));
					case 85: return FunctionPtr(new FunctionVoidImpl<void*(Device::*)(Buffer&) const>(&Device::mapBuffer));
					case 86: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&) const>(&Device::unmapBuffer));
					case 87: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, size_t, Buffer&, size_t, size_t) const>(&Device::copyBuffer));
					case 88: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, size_t, Buffer&, size_t) const>(&Device::copyBuffer));
					case 89: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, Buffer&, size_t) const>(&Device::copyBuffer));
					case 90: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, Buffer&) const>(&Device::copyBuffer));
					case 91: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, Format, size_t, const void*, size_t) const>(&Device::clearBuffer));
					case 92: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, Format, const void*, size_t) const>(&Device::clearBuffer));
					case 93: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, Format, const void*) const>(&Device::clearBuffer));
					case 94: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&) const>(&Device::clearBuffer));
					case 95: return FunctionPtr(new FunctionImpl<bool(Device::*)(Buffer&, Buffer::Flags) const>(&Device::flushBuffer, Buffer::null, Buffer::FlagNone));
					case 96: return FunctionPtr(new FunctionImpl<bool(Device::*)(const Array<Buffer>&, Buffer::Flags) const>(&Device::flushBuffers, {}, Buffer::FlagNone));
					case 97: return FunctionPtr(new FunctionImpl<bool(Device::*)(const InitializerList<Buffer>&, Buffer::Flags) const>(&Device::flushBuffers, {}, Buffer::FlagNone));
					case 98: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(Buffer&) const>(&Device::releaseBuffer));
					case 99: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(Sampler&) const>(&Device::releaseSampler));
					case 100: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Origin&, const Slice&, const Image&, const Slice&) const>(&Device::setTexture));
					case 101: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Origin&, const Image&) const>(&Device::setTexture));
					case 102: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Slice&, const Image&) const>(&Device::setTexture));
					case 103: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Image&) const>(&Device::setTexture));
					case 104: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Slice&, Image&, const Slice&) const>(&Device::getTexture));
					case 105: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, Image&, const Slice&) const>(&Device::getTexture));
					case 106: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, Image&) const>(&Device::getTexture));
					case 107: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Origin&, const Slice&, Texture&, const Region&, const Slice&) const>(&Device::copyTexture));
					case 108: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Origin&, Texture&, const Region&) const>(&Device::copyTexture));
					case 109: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Slice&, Texture&, const Slice&) const>(&Device::copyTexture));
					case 110: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, Texture&) const>(&Device::copyTexture));
					case 111: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Region&, const Slice&, const void*) const>(&Device::clearTexture));
					case 112: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Region&, const void*) const>(&Device::clearTexture));
					case 113: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Slice&, const void*) const>(&Device::clearTexture));
					case 114: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const void*) const>(&Device::clearTexture));
					case 115: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Region*, uint32_t, const Slice*, uint32_t, bool, Fence&) const>(&Device::bindTexture));
					case 116: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Region*, uint32_t, const Slice*, uint32_t, bool) const>(&Device::bindTexture));
					case 117: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Region&, const Slice&, bool, Fence&) const>(&Device::bindTexture));
					case 118: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Region&, const Slice&, bool) const>(&Device::bindTexture));
					case 119: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Slice&) const>(&Device::createMipmaps));
					case 120: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&) const>(&Device::createMipmaps));
					case 121: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, Texture::Flags) const>(&Device::flushTexture, Texture::null, Texture::FlagNone));
					case 122: return FunctionPtr(new FunctionImpl<bool(Device::*)(Texture&, const Slice&, Texture::Flags) const>(&Device::flushTexture, Texture::null, {}, Texture::FlagNone));
					case 123: return FunctionPtr(new FunctionImpl<bool(Device::*)(const Array<Texture>&, Texture::Flags) const>(&Device::flushTextures, {}, Texture::FlagNone));
					case 124: return FunctionPtr(new FunctionImpl<bool(Device::*)(const InitializerList<Texture>&, Texture::Flags) const>(&Device::flushTextures, {}, Texture::FlagNone));
					case 125: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(Texture&) const>(&Device::releaseTexture));
					case 126: return FunctionPtr(new FunctionImpl<bool(Device::*)(Tracing&, const Tracing::Instance*, uint32_t) const>(&Device::setTracing));
					case 127: return FunctionPtr(new FunctionImpl<bool(Device::*)(Tracing&, Buffer&, Tracing::Flags) const>(&Device::buildTracing, Tracing::null, Buffer::null, Tracing::FlagNone));
					case 128: return FunctionPtr(new FunctionImpl<bool(Device::*)(Tracing&, Buffer&, size_t, Tracing::Flags) const>(&Device::buildTracing, Tracing::null, Buffer::null, {}, Tracing::FlagNone));
					case 129: return FunctionPtr(new FunctionImpl<bool(Device::*)(const Array<Tracing>&, Buffer&, Tracing::Flags) const>(&Device::buildTracings, {}, Buffer::null, Tracing::FlagNone));
					case 130: return FunctionPtr(new FunctionImpl<bool(Device::*)(const Array<Tracing>&, Buffer&, size_t, Tracing::Flags) const>(&Device::buildTracings, {}, Buffer::null, {}, Tracing::FlagNone));
					case 131: return FunctionPtr(new FunctionImpl<bool(Device::*)(Tracing&, Buffer&, size_t) const>(&Device::copyTracing, Tracing::null, Buffer::null, 0));
					case 132: return FunctionPtr(new FunctionImpl<bool(Device::*)(const Array<Tracing>&, Buffer&, size_t, size_t) const>(&Device::copyTracings, {}, Buffer::null, {}, 0));
					case 133: return FunctionPtr(new FunctionImpl<bool(Device::*)(Tracing&) const>(&Device::flushTracing));
					case 134: return FunctionPtr(new FunctionImpl<bool(Device::*)(const Array<Tracing>&) const>(&Device::flushTracings));
					case 135: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(Tracing&) const>(&Device::releaseTracing));
					case 136: return FunctionPtr(new FunctionImpl<bool(Device::*)(BufferTable&, uint32_t, Buffer&, bool) const>(&Device::setBufferTable, BufferTable::null, {}, Buffer::null, false));
					case 137: return FunctionPtr(new FunctionImpl<bool(Device::*)(BufferTable&, uint32_t, const Array<Buffer>&, bool) const>(&Device::setBufferTable, BufferTable::null, {}, {}, false));
					case 138: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(BufferTable&) const>(&Device::releaseBufferTable));
					case 139: return FunctionPtr(new FunctionImpl<bool(Device::*)(TextureTable&, uint32_t, Texture&, bool) const>(&Device::setTextureTable, TextureTable::null, {}, Texture::null, false));
					case 140: return FunctionPtr(new FunctionImpl<bool(Device::*)(TextureTable&, uint32_t, const Array<Texture>&, bool) const>(&Device::setTextureTable, TextureTable::null, {}, {}, false));
					case 141: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(TextureTable&) const>(&Device::releaseTextureTable));
					case 142: return FunctionPtr(new FunctionImpl<bool(Device::*)(Query&) const>(&Device::beginQuery));
					case 143: return FunctionPtr(new FunctionVoidImpl<void(Device::*)(Query&) const>(&Device::endQuery));
					case 144: return FunctionPtr(new FunctionImpl<bool(Device::*)(Query&, Buffer&, size_t) const>(&Device::copyQuery, Query::null, Buffer::null, 0));
					case 145: return FunctionPtr(new FunctionImpl<bool(Device::*)(const Array<Query>&, Buffer&, size_t, size_t) const>(&Device::copyQueries, {}, Buffer::null, 0, 0));
					case 146: return FunctionPtr(new FunctionImpl<bool(Device::*)(const InitializerList<Query>&, Buffer&, size_t, size_t) const>(&Device::copyQueries, {}, Buffer::null, 0, 0));
					case 147: return FunctionPtr(new FunctionImpl<bool(Device::*)(Fence&) const>(&Device::waitFence));
					case 148: return FunctionPtr(new FunctionImpl<bool(Device::*)(Fence&) const>(&Device::signalFence));
					case 149: return FunctionPtr(new FunctionImpl<bool(Device::*)(Device&) const>(&Device::execute));
					case 150: return FunctionPtr(new FunctionImpl<bool(Device::*)(Fence&) const>(&Device::flip));
					case 151: return FunctionPtr(new FunctionImpl<bool(Device::*)() const>(&Device::flip));
					case 152: return FunctionPtr(new FunctionImpl<bool(Device::*)() const>(&Device::flush));
					case 153: return FunctionPtr(new FunctionImpl<bool(Device::*)() const>(&Device::finish));
					case 154: return FunctionPtr(new FunctionImpl<bool(Device::*)() const>(&Device::check));
					case 155: return FunctionPtr(new FunctionImpl<Device(Device::*)() const>(&Device::clonePtr));
					case 156: return FunctionPtr(new FunctionVoidImpl<void(Device::*)()>(&Device::clearPtr));
					case 157: return FunctionPtr(new FunctionVoidImpl<void(Device::*)()>(&Device::destroyPtr));
					case 158: return FunctionPtr(new FunctionImpl<Device&(Device::*)()>(&Device::acquirePtr));
					case 159: return FunctionPtr(new FunctionImpl<Device&(Device::*)()>(&Device::unacquirePtr));
					case 160: return FunctionPtr(new FunctionImpl<bool(Device::*)() const>(&Device::isValidPtr));
					case 161: return FunctionPtr(new FunctionImpl<bool(Device::*)() const>(&Device::isOwnerPtr));
					case 162: return FunctionPtr(new FunctionImpl<bool(Device::*)() const>(&Device::isConstPtr));
					case 163: return FunctionPtr(new FunctionImpl<uint32_t(Device::*)() const>(&Device::getCountPtr));
					case 164: return FunctionPtr(new FunctionImpl<const void*(Device::*)() const>(&Device::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 2, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 1539, 1491, 1540 };
			static constexpr uint16_t constructor_arg_names[] = { 1182, 1492, 157 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 75, 1541, 37, 1542, 1544, 1545, 1546, 1547, 1548, 1549, 1551, 1552, 1553, 1554, 1554, 1555, 1555, 1555, 1557, 1557, 1557, 1557, 1558, 1558, 1558, 1559, 1559, 1559, 1559, 1559, 1560, 1561, 1562, 1560, 1561, 1560, 1562, 1563, 1563, 1563, 1565, 1565, 1565, 1565, 1565, 1574, 1574, 1574, 1575, 1575, 1575, 1576, 1577, 1578, 1579, 1576, 1580, 1581, 1582, 1582, 1584, 1585, 1585, 1587, 1588, 1588, 1590, 1591, 1591, 1591, 1591, 1592, 1593, 1593, 1116, 1116, 1116, 965, 965, 965, 1595, 1595, 1595, 1596, 1117, 1117, 1117, 1117, 1120, 1120, 1120, 1120, 1597, 1598, 1598, 1599, 1600, 993, 993, 993, 993, 1429, 1429, 1429, 1121, 1121, 1121, 1121, 1122, 1122, 1122, 1122, 1602, 1602, 1602, 1602, 1610, 1610, 1611, 1611, 1612, 1612, 1613, 1018, 1616, 1616, 1617, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1623, 1624, 1027, 1027, 1625, 1076, 1079, 1626, 1627, 1627, 1629, 1630, 1631, 1633, 1633, 91, 1133, 50, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 16, 16, 16, 1543, 21, 21, 21, 21, 21, 1538, 1538, 1538, 1538, 1203, 1203, 1223, 1223, 1223, 902, 902, 902, 902, 1331, 1331, 1331, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1377, 1430, 1430, 1430, 1430, 1430, 911, 911, 911, 1387, 1387, 1387, 1235, 1235, 1235, 1235, 1235, 1235, 1235, 1107, 1107, 6, 971, 971, 6, 1112, 1112, 6, 1486, 1486, 1486, 1486, 1102, 966, 966, 21, 21, 21, 21, 21, 21, 6, 6, 6, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 6, 6, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 6, 21, 21, 21, 21, 21, 21, 21, 21, 21, 6, 21, 21, 6, 21, 21, 6, 21, 6, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 1538, 1538, 1538, 1538, 1538, 1538, 1538, 1538, 1538, 1538 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 7, 8, 9, 10, 10, 11, 11, 12, 13, 13, 14, 17, 21, 21, 22, 25, 25, 26, 31, 35, 38, 41, 44, 47, 51, 56, 61, 65, 70, 75, 80, 80, 81, 85, 91, 96, 96, 97, 99, 99, 101, 103, 103, 106, 109, 111, 114, 117, 119, 119, 120, 121, 121, 122, 123, 123, 124, 125, 125, 126, 127, 129, 129, 129, 130, 134, 137, 139, 143, 146, 148, 151, 153, 154, 155, 160, 164, 167, 169, 174, 178, 181, 182, 184, 186, 188, 189, 190, 195, 198, 201, 203, 207, 210, 212, 218, 222, 226, 228, 232, 235, 238, 240, 247, 253, 258, 262, 264, 265, 267, 270, 272, 274, 275, 278, 281, 285, 288, 292, 295, 299, 300, 301, 302, 306, 310, 311, 315, 319, 320, 321, 322, 325, 329, 333, 334, 335, 336, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337, 337 };
			static constexpr uint16_t function_arg_types[] = { 1206, 1237, 340, 340, 340, 10, 10, 10, 10, 10, 1206, 1488, 1224, 1005, 905, 74, 340, 905, 89, 74, 340, 1333, 1335, 1344, 10, 994, 1378, 340, 341, 10, 1379, 1378, 340, 341, 1379, 425, 1379, 417, 340, 10, 1379, 340, 10, 1379, 340, 10, 1379, 340, 10, 10, 1379, 340, 10, 10, 10, 1379, 340, 10, 10, 10, 1379, 340, 10, 10, 1379, 22, 1379, 337, 10, 417, 94, 1379, 337, 10, 417, 145, 1379, 337, 10, 417, 1438, 10, 902, 74, 1433, 10, 340, 74, 10, 340, 1433, 10, 74, 902, 74, 1433, 10, 960, 21, 1378, 10, 997, 21, 1237, 22, 94, 1237, 22, 94, 1237, 22, 1237, 22, 94, 1237, 22, 94, 1237, 586, 1583, 1104, 1586, 968, 1589, 1109, 1491, 1540, 999, 1500, 1594, 1005, 74, 89, 74, 1005, 89, 74, 1005, 89, 1005, 74, 85, 74, 1005, 85, 74, 1005, 85, 1005, 74, 74, 1005, 74, 1005, 1005, 1005, 74, 1005, 74, 74, 1005, 74, 1005, 74, 1005, 1005, 74, 1005, 1005, 1005, 340, 74, 89, 74, 1005, 340, 89, 74, 1005, 340, 89, 1005, 1005, 905, 960, 905, 1011, 905, 1005, 987, 994, 432, 405, 425, 405, 994, 432, 425, 994, 405, 425, 994, 425, 994, 405, 1601, 405, 994, 1601, 405, 994, 1601, 994, 432, 405, 994, 429, 405, 994, 432, 994, 429, 994, 405, 994, 405, 994, 994, 994, 429, 405, 89, 994, 429, 89, 994, 405, 89, 994, 89, 994, 1603, 10, 1606, 10, 21, 1488, 994, 1603, 10, 1606, 10, 21, 994, 429, 405, 21, 1488, 994, 429, 405, 21, 994, 405, 994, 994, 1379, 994, 405, 1379, 997, 1379, 999, 1379, 994, 1019, 1614, 10, 1019, 1005, 1433, 1019, 1005, 74, 1433, 1022, 1005, 1433, 1022, 1005, 74, 1433, 1019, 1005, 74, 1022, 1005, 74, 74, 1019, 1022, 1019, 1035, 10, 1005, 21, 1035, 10, 960, 21, 1035, 1028, 10, 994, 21, 1028, 10, 997, 21, 1028, 1077, 1077, 1077, 1005, 74, 1219, 1005, 74, 74, 1628, 1005, 74, 74, 1488, 1488, 1632, 1488 };
			static constexpr uint16_t function_arg_names[] = { 195, 195, 96, 96, 96, 274, 1550, 1550, 1550, 1550, 195, 1556, 338, 1556, 338, 87, 96, 338, 90, 87, 96, 988, 448, 185, 1340, 1556, 195, 96, 87, 342, 338, 195, 96, 87, 338, 450, 338, 418, 96, 87, 338, 96, 87, 338, 96, 87, 338, 96, 30, 31, 338, 96, 30, 31, 415, 338, 96, 30, 31, 342, 338, 96, 87, 342, 338, 23, 338, 1564, 78, 418, 23, 338, 1564, 78, 418, 222, 338, 1564, 78, 418, 1020, 1064, 1566, 1567, 338, 1061, 1568, 1569, 667, 1570, 338, 1459, 1571, 1572, 1573, 338, 87, 961, 854, 195, 87, 998, 854, 195, 23, 1276, 195, 23, 1276, 195, 23, 195, 90, 1276, 195, 90, 1276, 195, 167, 1105, 1105, 969, 969, 1110, 1110, 1492, 157, 998, 1501, 944, 915, 78, 90, 87, 915, 90, 87, 915, 90, 915, 78, 86, 87, 915, 86, 87, 915, 86, 915, 78, 87, 915, 87, 915, 915, 915, 1118, 90, 1119, 87, 915, 1118, 90, 87, 915, 90, 87, 915, 90, 915, 96, 78, 90, 87, 915, 96, 90, 87, 915, 96, 90, 915, 915, 338, 961, 338, 961, 338, 915, 988, 995, 433, 435, 450, 436, 995, 433, 450, 995, 435, 450, 995, 450, 995, 436, 450, 435, 995, 450, 435, 995, 450, 995, 433, 435, 90, 434, 436, 995, 433, 90, 434, 995, 435, 90, 436, 995, 90, 995, 430, 406, 90, 995, 430, 90, 995, 406, 90, 995, 90, 995, 1604, 1605, 1607, 1608, 1609, 1489, 995, 1604, 1605, 1607, 1608, 1609, 995, 430, 406, 1609, 1489, 995, 430, 406, 1609, 995, 406, 995, 995, 338, 995, 406, 338, 998, 338, 998, 338, 995, 1020, 1615, 1064, 1020, 915, 338, 1020, 915, 78, 338, 1023, 915, 338, 1023, 915, 78, 338, 1020, 915, 78, 1023, 915, 78, 452, 1020, 1023, 1020, 1029, 274, 915, 854, 1029, 274, 961, 854, 1029, 1029, 274, 995, 854, 1029, 274, 998, 854, 1029, 1078, 1078, 1078, 915, 78, 1220, 915, 78, 452, 1220, 915, 78, 452, 1489, 1489, 28, 1489 };
	};
	constexpr uint16_t ReflectionDevice::constructor_bases[];
	constexpr uint16_t ReflectionDevice::constructor_arg_types[];
	constexpr uint16_t ReflectionDevice::constructor_arg_names[];
	constexpr uint16_t ReflectionDevice::function_names[];
	constexpr uint16_t ReflectionDevice::function_types[];
	constexpr uint16_t ReflectionDevice::function_bases[];
	constexpr uint16_t ReflectionDevice::function_arg_types[];
	constexpr uint16_t ReflectionDevice::function_arg_names[];
	static ReflectionDevice reflection_device;
	
	// Tellusim::D3D12Device
	class ReflectionD3D12Device : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Device::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_device;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Device, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<D3D12Device, TypeList<Context&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<D3D12Device, TypeList<Surface&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<D3D12Device, TypeList<Window&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Device>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(D3D12Device::*)(Buffer&, uint32_t)>(&D3D12Device::setBufferState));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(D3D12Device::*)(Texture&, uint32_t)>(&D3D12Device::setTextureState));
					case 2: return FunctionPtr(new FunctionImpl<ID3D12Device*(D3D12Device::*)() const>(&D3D12Device::getD3D12Device));
					case 3: return FunctionPtr(new FunctionImpl<ID3D12CommandQueue*(D3D12Device::*)() const>(&D3D12Device::getQueue));
					case 4: return FunctionPtr(new FunctionImpl<ID3D12GraphicsCommandList*(D3D12Device::*)() const>(&D3D12Device::getCommand));
					case 5: return FunctionPtr(new FunctionImpl<D3D12Device(D3D12Device::*)() const>(&D3D12Device::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(D3D12Device::*)()>(&D3D12Device::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(D3D12Device::*)()>(&D3D12Device::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<D3D12Device&(D3D12Device::*)()>(&D3D12Device::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<D3D12Device&(D3D12Device::*)()>(&D3D12Device::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(D3D12Device::*)() const>(&D3D12Device::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(D3D12Device::*)() const>(&D3D12Device::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(D3D12Device::*)() const>(&D3D12Device::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Device::*)() const>(&D3D12Device::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(D3D12Device::*)() const>(&D3D12Device::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 2, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 1539, 1491, 1540 };
			static constexpr uint16_t constructor_arg_names[] = { 1182, 1492, 157 };
			static constexpr uint16_t function_names[] = { 922, 1393, 1635, 1141, 1101, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 1140, 1142, 1082, 1634, 1634, 1634, 1634, 1634, 1634, 1634, 1634, 1634, 1634 };
			static constexpr uint16_t function_bases[] = { 0, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 1005, 10, 994, 10 };
			static constexpr uint16_t function_arg_names[] = { 915, 916, 995, 916 };
	};
	constexpr uint16_t ReflectionD3D12Device::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Device::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Device::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Device::function_names[];
	constexpr uint16_t ReflectionD3D12Device::function_types[];
	constexpr uint16_t ReflectionD3D12Device::function_bases[];
	constexpr uint16_t ReflectionD3D12Device::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Device::function_arg_names[];
	static ReflectionD3D12Device reflection_d3d12_device;
	
	// Tellusim::D3D11Device
	class ReflectionD3D11Device : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D11Device::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_device;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D11Device, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<D3D11Device, TypeList<Context&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<D3D11Device, TypeList<Surface&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<D3D11Device, TypeList<Window&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D11Device>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<ID3D11Device*(D3D11Device::*)() const>(&D3D11Device::getD3D11Device));
					case 1: return FunctionPtr(new FunctionImpl<ID3D11DeviceContext*(D3D11Device::*)() const>(&D3D11Device::getCommand));
					case 2: return FunctionPtr(new FunctionImpl<D3D11Device(D3D11Device::*)() const>(&D3D11Device::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D11Device::*)()>(&D3D11Device::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(D3D11Device::*)()>(&D3D11Device::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D11Device&(D3D11Device::*)()>(&D3D11Device::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<D3D11Device&(D3D11Device::*)()>(&D3D11Device::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D11Device::*)() const>(&D3D11Device::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D11Device::*)() const>(&D3D11Device::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(D3D11Device::*)() const>(&D3D11Device::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Device::*)() const>(&D3D11Device::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(D3D11Device::*)() const>(&D3D11Device::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 2, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 1539, 1491, 1540 };
			static constexpr uint16_t constructor_arg_names[] = { 1182, 1492, 157 };
			static constexpr uint16_t function_names[] = { 1637, 1101, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1148, 1150, 1636, 1636, 1636, 1636, 1636, 1636, 1636, 1636, 1636, 1636 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D11Device::constructor_bases[];
	constexpr uint16_t ReflectionD3D11Device::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D11Device::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D11Device::function_names[];
	constexpr uint16_t ReflectionD3D11Device::function_types[];
	constexpr uint16_t ReflectionD3D11Device::function_bases[];
	constexpr uint16_t ReflectionD3D11Device::function_arg_types[];
	constexpr uint16_t ReflectionD3D11Device::function_arg_names[];
	static ReflectionD3D11Device reflection_d3d11_device;
	
	// Tellusim::MTLDevice
	class ReflectionMTLDevice : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLDevice::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_device;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLDevice, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<MTLDevice, TypeList<Context&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<MTLDevice, TypeList<Surface&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<MTLDevice, TypeList<Window&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLDevice>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(MTLDevice::*)() const>(&MTLDevice::getMTLDevice));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(MTLDevice::*)() const>(&MTLDevice::getQueue));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(MTLDevice::*)() const>(&MTLDevice::getCommand));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(MTLDevice::*)() const>(&MTLDevice::getEncoder));
					case 4: return FunctionPtr(new FunctionVoidImpl<void*(MTLDevice::*)(void*) const>(&MTLDevice::getRenderEncoder));
					case 5: return FunctionPtr(new FunctionVoidImpl<void*(MTLDevice::*)() const>(&MTLDevice::getComputeEncoder));
					case 6: return FunctionPtr(new FunctionVoidImpl<void*(MTLDevice::*)() const>(&MTLDevice::getTracingEncoder));
					case 7: return FunctionPtr(new FunctionVoidImpl<void*(MTLDevice::*)() const>(&MTLDevice::getBlitEncoder));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(MTLDevice::*)() const>(&MTLDevice::endEncoder));
					case 9: return FunctionPtr(new FunctionImpl<MTLDevice(MTLDevice::*)() const>(&MTLDevice::clonePtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(MTLDevice::*)()>(&MTLDevice::clearPtr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(MTLDevice::*)()>(&MTLDevice::destroyPtr));
					case 12: return FunctionPtr(new FunctionImpl<MTLDevice&(MTLDevice::*)()>(&MTLDevice::acquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<MTLDevice&(MTLDevice::*)()>(&MTLDevice::unacquirePtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(MTLDevice::*)() const>(&MTLDevice::isValidPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(MTLDevice::*)() const>(&MTLDevice::isOwnerPtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(MTLDevice::*)() const>(&MTLDevice::isConstPtr));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(MTLDevice::*)() const>(&MTLDevice::getCountPtr));
					case 18: return FunctionPtr(new FunctionImpl<const void*(MTLDevice::*)() const>(&MTLDevice::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 2, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 1539, 1491, 1540 };
			static constexpr uint16_t constructor_arg_names[] = { 1182, 1492, 157 };
			static constexpr uint16_t function_names[] = { 1639, 1141, 1101, 1085, 1152, 1154, 1155, 1156, 1157, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 6, 6, 6, 6, 6, 6, 1638, 1638, 1638, 1638, 1638, 1638, 1638, 1638, 1638, 1638 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 85 };
			static constexpr uint16_t function_arg_names[] = { 1153 };
	};
	constexpr uint16_t ReflectionMTLDevice::constructor_bases[];
	constexpr uint16_t ReflectionMTLDevice::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLDevice::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLDevice::function_names[];
	constexpr uint16_t ReflectionMTLDevice::function_types[];
	constexpr uint16_t ReflectionMTLDevice::function_bases[];
	constexpr uint16_t ReflectionMTLDevice::function_arg_types[];
	constexpr uint16_t ReflectionMTLDevice::function_arg_names[];
	static ReflectionMTLDevice reflection_mtl_device;
	
	// Tellusim::VKDevice
	class ReflectionVKDevice : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKDevice::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_device;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKDevice, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<VKDevice, TypeList<Context&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<VKDevice, TypeList<Surface&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<VKDevice, TypeList<Window&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKDevice>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(VKDevice::*)(Buffer&, uint32_t)>(&VKDevice::setBufferAccess));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(VKDevice::*)(Texture&, uint32_t)>(&VKDevice::setTextureLayout));
					case 2: return FunctionPtr(new FunctionImpl<bool(VKDevice::*)(void*, uint64_t, bool) const>(&VKDevice::waitVKFence));
					case 3: return FunctionPtr(new FunctionImpl<bool(VKDevice::*)(void*) const>(&VKDevice::signalVKFence));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(VKDevice::*)(void*, uint32_t) const>(&VKDevice::waitSemaphore));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(VKDevice::*)(void*) const>(&VKDevice::signalSemaphore));
					case 6: return FunctionPtr(new FunctionImpl<bool(VKDevice::*)(uint32_t) const>(&VKDevice::hasMemoryType));
					case 7: return FunctionPtr(new FunctionImpl<uint32_t(VKDevice::*)(uint32_t, uint32_t) const>(&VKDevice::getMemoryIndex));
					case 8: return FunctionPtr(new FunctionImpl<VkInstance(VKDevice::*)() const>(&VKDevice::getInstance));
					case 9: return FunctionPtr(new FunctionImpl<VkPhysicalDevice(VKDevice::*)() const>(&VKDevice::getAdapter));
					case 10: return FunctionPtr(new FunctionImpl<VkDevice(VKDevice::*)() const>(&VKDevice::getVKDevice));
					case 11: return FunctionPtr(new FunctionImpl<VkQueue(VKDevice::*)() const>(&VKDevice::getQueue));
					case 12: return FunctionPtr(new FunctionImpl<VkCommandBuffer(VKDevice::*)() const>(&VKDevice::getCommand));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(VKDevice::*)() const>(&VKDevice::getFamily));
					case 14: return FunctionPtr(new FunctionImpl<VKDevice(VKDevice::*)() const>(&VKDevice::clonePtr));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(VKDevice::*)()>(&VKDevice::clearPtr));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(VKDevice::*)()>(&VKDevice::destroyPtr));
					case 17: return FunctionPtr(new FunctionImpl<VKDevice&(VKDevice::*)()>(&VKDevice::acquirePtr));
					case 18: return FunctionPtr(new FunctionImpl<VKDevice&(VKDevice::*)()>(&VKDevice::unacquirePtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(VKDevice::*)() const>(&VKDevice::isValidPtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(VKDevice::*)() const>(&VKDevice::isOwnerPtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(VKDevice::*)() const>(&VKDevice::isConstPtr));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(VKDevice::*)() const>(&VKDevice::getCountPtr));
					case 23: return FunctionPtr(new FunctionImpl<const void*(VKDevice::*)() const>(&VKDevice::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 2, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 1539, 1491, 1540 };
			static constexpr uint16_t constructor_arg_names[] = { 1182, 1492, 157 };
			static constexpr uint16_t function_names[] = { 941, 1411, 1641, 1644, 1645, 1647, 1648, 1649, 1167, 1168, 1651, 1141, 1101, 1170, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 21, 21, 6, 6, 21, 10, 1159, 1163, 1165, 1169, 1090, 10, 1640, 1640, 1640, 1640, 1640, 1640, 1640, 1640, 1640, 1640 };
			static constexpr uint16_t function_bases[] = { 0, 2, 4, 7, 8, 10, 11, 12, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14 };
			static constexpr uint16_t function_arg_types[] = { 1005, 10, 994, 10, 85, 39, 21, 85, 85, 10, 85, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 915, 937, 995, 639, 1489, 1642, 1643, 1489, 1646, 53, 1646, 338, 1650, 338 };
	};
	constexpr uint16_t ReflectionVKDevice::constructor_bases[];
	constexpr uint16_t ReflectionVKDevice::constructor_arg_types[];
	constexpr uint16_t ReflectionVKDevice::constructor_arg_names[];
	constexpr uint16_t ReflectionVKDevice::function_names[];
	constexpr uint16_t ReflectionVKDevice::function_types[];
	constexpr uint16_t ReflectionVKDevice::function_bases[];
	constexpr uint16_t ReflectionVKDevice::function_arg_types[];
	constexpr uint16_t ReflectionVKDevice::function_arg_names[];
	static ReflectionVKDevice reflection_vk_device;
	
	// Tellusim::FUDevice
	class ReflectionFUDevice : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUDevice::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_device;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUDevice, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUDevice, TypeList<const Array<Device>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUDevice>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUDevice::*)(uint32_t)>(&FUDevice::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUDevice::*)() const>(&FUDevice::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUDevice::*)() const>(&FUDevice::getNumDevices));
					case 3: return FunctionPtr(new FunctionImpl<const Device(FUDevice::*)(uint32_t) const>(&FUDevice::getDevice));
					case 4: return FunctionPtr(new FunctionImpl<Device(FUDevice::*)(uint32_t)>(&FUDevice::getDevice));
					case 5: return FunctionPtr(new FunctionImpl<FUDevice(FUDevice::*)() const>(&FUDevice::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUDevice::*)()>(&FUDevice::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUDevice::*)()>(&FUDevice::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUDevice&(FUDevice::*)()>(&FUDevice::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUDevice&(FUDevice::*)()>(&FUDevice::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUDevice::*)() const>(&FUDevice::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUDevice::*)() const>(&FUDevice::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUDevice::*)() const>(&FUDevice::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUDevice::*)() const>(&FUDevice::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUDevice::*)() const>(&FUDevice::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1653, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1654, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1655, 9, 9, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1538, 1538, 1652, 1652, 1652, 1652, 1652, 1652, 1652, 1652, 1652, 1652 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUDevice::constructor_bases[];
	constexpr uint16_t ReflectionFUDevice::constructor_arg_types[];
	constexpr uint16_t ReflectionFUDevice::constructor_arg_names[];
	constexpr uint16_t ReflectionFUDevice::function_names[];
	constexpr uint16_t ReflectionFUDevice::function_types[];
	constexpr uint16_t ReflectionFUDevice::function_bases[];
	constexpr uint16_t ReflectionFUDevice::function_arg_types[];
	constexpr uint16_t ReflectionFUDevice::function_arg_names[];
	static ReflectionFUDevice reflection_fu_device;
	
	// Tellusim::Kernel
	class ReflectionKernel : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Kernel::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Kernel, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Kernel>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Kernel::*)() const>(&Kernel::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Kernel::*)() const>(&Kernel::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Kernel::*)()>(&Kernel::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Kernel::*)() const>(&Kernel::isCreated));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Kernel::*)(const char*)>(&Kernel::setName));
					case 6: return FunctionPtr(new FunctionImpl<String(Kernel::*)() const>(&Kernel::getName));
					case 7: return FunctionPtr(new FunctionImpl<bool(Kernel::*)()>(&Kernel::create));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(Kernel::*)(const Kernel&)>(&Kernel::setParameters));
					case 9: return FunctionPtr(new FunctionImpl<bool(Kernel::*)(Stream&) const>(&Kernel::saveState));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Kernel::*)(Shader&, bool)>(&Kernel::setShader, Shader::null, false));
					case 11: return FunctionPtr(new FunctionImpl<Shader(Kernel::*)() const>(&Kernel::getComputeShader));
					case 12: return FunctionPtr(new FunctionImpl<bool(Kernel::*)(const char*, const String&, const char**, uint32_t)>(&Kernel::loadShader, {}, String::null, nullptr, 0));
					case 13: return FunctionPtr(new FunctionImpl<bool(Kernel::*)(const char*, const String&, const char**, uint32_t)>(&Kernel::loadShaderGLSL, {}, String::null, nullptr, 0));
					case 14: return FunctionPtr(new FunctionImpl<bool(Kernel::*)(const char*)>(&Kernel::loadShaderSPIRV));
					case 15: return FunctionPtr(new FunctionImpl<bool(Kernel::*)(const char*, const String&, const char**, uint32_t)>(&Kernel::createShader, {}, String::null, nullptr, 0));
					case 16: return FunctionPtr(new FunctionImpl<bool(Kernel::*)(const char*, const String&, const char**, uint32_t)>(&Kernel::createShaderGLSL, {}, String::null, nullptr, 0));
					case 17: return FunctionPtr(new FunctionImpl<bool(Kernel::*)(const Array<uint32_t>&)>(&Kernel::createShaderSPIRV));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)()>(&Kernel::addSampler));
					case 19: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setSamplers));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getNumSamplers));
					case 21: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setSamplerOffset));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getSamplerOffset));
					case 23: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t, uint32_t, bool)>(&Kernel::setSamplerArray));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)(uint32_t) const>(&Kernel::getSamplerArray));
					case 25: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)()>(&Kernel::addTexture));
					case 26: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setTextures));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getNumTextures));
					case 28: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setTextureOffset));
					case 29: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getTextureOffset));
					case 30: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t, uint32_t, bool)>(&Kernel::setTextureArray));
					case 31: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)(uint32_t) const>(&Kernel::getTextureArray));
					case 32: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)()>(&Kernel::addSurface));
					case 33: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setSurfaces));
					case 34: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getNumSurfaces));
					case 35: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setSurfaceOffset));
					case 36: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getSurfaceOffset));
					case 37: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t, uint32_t, bool)>(&Kernel::setSurfaceArray));
					case 38: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)(uint32_t) const>(&Kernel::getSurfaceArray));
					case 39: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)(BindFlags)>(&Kernel::addUniform, Tellusim::BindFlagNone));
					case 40: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t, BindFlags)>(&Kernel::setUniforms, {}, Tellusim::BindFlagNone));
					case 41: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getNumUniforms));
					case 42: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setUniformOffset));
					case 43: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getUniformOffset));
					case 44: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t, BindFlags)>(&Kernel::setUniformFlags));
					case 45: return FunctionPtr(new FunctionImpl<BindFlags(Kernel::*)(uint32_t) const>(&Kernel::getUniformFlags));
					case 46: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)(BindFlags)>(&Kernel::addStorage, Tellusim::BindFlagNone));
					case 47: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t, BindFlags)>(&Kernel::setStorages, {}, Tellusim::BindFlagNone));
					case 48: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getNumStorages));
					case 49: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setStorageOffset));
					case 50: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getStorageOffset));
					case 51: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t, BindFlags)>(&Kernel::setStorageFlags));
					case 52: return FunctionPtr(new FunctionImpl<BindFlags(Kernel::*)(uint32_t) const>(&Kernel::getStorageFlags));
					case 53: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)()>(&Kernel::addTracing));
					case 54: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setTracings));
					case 55: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getNumTracings));
					case 56: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setTracingOffset));
					case 57: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getTracingOffset));
					case 58: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)()>(&Kernel::addTexel));
					case 59: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setTexels));
					case 60: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getNumTexels));
					case 61: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setTexelOffset));
					case 62: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getTexelOffset));
					case 63: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)(TableType, uint32_t)>(&Kernel::addTable));
					case 64: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getNumTables));
					case 65: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t)>(&Kernel::setTableOffset));
					case 66: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getTableOffset));
					case 67: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t, TableType, uint32_t, BindFlags)>(&Kernel::setTableType, {}, (TableType)0, {}, Tellusim::BindFlagNone));
					case 68: return FunctionPtr(new FunctionImpl<TableType(Kernel::*)(uint32_t) const>(&Kernel::getTableType));
					case 69: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)(uint32_t) const>(&Kernel::getTableSize));
					case 70: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)(uint32_t, BindFlags)>(&Kernel::setTableFlags));
					case 71: return FunctionPtr(new FunctionImpl<BindFlags(Kernel::*)(uint32_t) const>(&Kernel::getTableFlags));
					case 72: return FunctionPtr(new FunctionVoidImpl<void(Kernel::*)(uint32_t, uint32_t, uint32_t)>(&Kernel::setGroupSize, {}, 1, 1));
					case 73: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getGroupSizeX));
					case 74: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getGroupSizeY));
					case 75: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getGroupSizeZ));
					case 76: return FunctionPtr(new FunctionImpl<Kernel(Kernel::*)() const>(&Kernel::clonePtr));
					case 77: return FunctionPtr(new FunctionVoidImpl<void(Kernel::*)()>(&Kernel::clearPtr));
					case 78: return FunctionPtr(new FunctionVoidImpl<void(Kernel::*)()>(&Kernel::destroyPtr));
					case 79: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)()>(&Kernel::acquirePtr));
					case 80: return FunctionPtr(new FunctionImpl<Kernel&(Kernel::*)()>(&Kernel::unacquirePtr));
					case 81: return FunctionPtr(new FunctionImpl<bool(Kernel::*)() const>(&Kernel::isValidPtr));
					case 82: return FunctionPtr(new FunctionImpl<bool(Kernel::*)() const>(&Kernel::isOwnerPtr));
					case 83: return FunctionPtr(new FunctionImpl<bool(Kernel::*)() const>(&Kernel::isConstPtr));
					case 84: return FunctionPtr(new FunctionImpl<uint32_t(Kernel::*)() const>(&Kernel::getCountPtr));
					case 85: return FunctionPtr(new FunctionImpl<const void*(Kernel::*)() const>(&Kernel::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 172, 75, 24, 1332, 1236, 1656, 1659, 1577, 1578, 1579, 1576, 1580, 1581, 1660, 989, 1375, 1256, 1257, 1661, 1663, 1664, 996, 1428, 1258, 1259, 1665, 1421, 1666, 1667, 1668, 1260, 1261, 1669, 1670, 1671, 1673, 1674, 1006, 1262, 1675, 1676, 1677, 1678, 1679, 1016, 1263, 1680, 1681, 1682, 1021, 1484, 1264, 1265, 1683, 1684, 1685, 1266, 1267, 1686, 1688, 1268, 1269, 1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 6, 16, 21, 6, 21, 6, 1235, 21, 21, 21, 21, 21, 21, 10, 1107, 10, 1107, 10, 1107, 10, 10, 1107, 10, 1107, 10, 1107, 10, 10, 1107, 10, 1107, 10, 1107, 10, 10, 1107, 10, 1107, 10, 1107, 1672, 10, 1107, 10, 1107, 10, 1107, 1672, 10, 1107, 10, 1107, 10, 10, 1107, 10, 1107, 10, 10, 10, 1107, 10, 1107, 1687, 10, 1107, 1672, 6, 10, 10, 10, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107, 1107 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 3, 5, 5, 9, 13, 14, 18, 22, 23, 23, 24, 24, 25, 25, 28, 29, 29, 30, 30, 31, 31, 34, 35, 35, 36, 36, 37, 37, 40, 41, 42, 44, 44, 45, 45, 47, 48, 49, 51, 51, 52, 52, 54, 55, 55, 56, 56, 57, 57, 57, 58, 58, 59, 59, 61, 61, 62, 62, 66, 67, 68, 70, 71, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74, 74 };
			static constexpr uint16_t function_arg_types[] = { 22, 1583, 145, 1657, 21, 22, 94, 876, 10, 22, 94, 876, 10, 22, 22, 94, 876, 10, 22, 94, 876, 10, 586, 10, 10, 10, 10, 21, 10, 10, 10, 10, 10, 21, 10, 10, 10, 10, 10, 21, 10, 1672, 10, 1672, 10, 10, 1672, 10, 1672, 10, 1672, 10, 10, 1672, 10, 10, 10, 10, 10, 1687, 10, 10, 10, 1687, 10, 1672, 10, 10, 10, 1672, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 1105, 222, 1658, 854, 23, 1276, 1277, 87, 23, 1276, 1277, 87, 23, 90, 1276, 1277, 87, 90, 1276, 1277, 87, 167, 17, 78, 274, 17, 1662, 274, 17, 78, 274, 17, 1662, 274, 17, 78, 274, 17, 1662, 274, 338, 17, 338, 78, 274, 338, 274, 338, 17, 338, 78, 274, 338, 274, 17, 78, 17, 78, 195, 87, 78, 274, 195, 87, 338, 274, 274, 274, 338, 274, 30, 31, 415 };
	};
	constexpr uint16_t ReflectionKernel::constructor_bases[];
	constexpr uint16_t ReflectionKernel::constructor_arg_types[];
	constexpr uint16_t ReflectionKernel::constructor_arg_names[];
	constexpr uint16_t ReflectionKernel::function_names[];
	constexpr uint16_t ReflectionKernel::function_types[];
	constexpr uint16_t ReflectionKernel::function_bases[];
	constexpr uint16_t ReflectionKernel::function_arg_types[];
	constexpr uint16_t ReflectionKernel::function_arg_names[];
	static ReflectionKernel reflection_kernel;
	
	// Tellusim::D3D12Kernel
	class ReflectionD3D12Kernel : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Kernel::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_kernel;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Kernel, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Kernel>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<ID3D12RootSignature*(D3D12Kernel::*)() const>(&D3D12Kernel::getRootSignature));
					case 1: return FunctionPtr(new FunctionImpl<D3D12Kernel(D3D12Kernel::*)() const>(&D3D12Kernel::clonePtr));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(D3D12Kernel::*)()>(&D3D12Kernel::clearPtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D12Kernel::*)()>(&D3D12Kernel::destroyPtr));
					case 4: return FunctionPtr(new FunctionImpl<D3D12Kernel&(D3D12Kernel::*)()>(&D3D12Kernel::acquirePtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D12Kernel&(D3D12Kernel::*)()>(&D3D12Kernel::unacquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<bool(D3D12Kernel::*)() const>(&D3D12Kernel::isValidPtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D12Kernel::*)() const>(&D3D12Kernel::isOwnerPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D12Kernel::*)() const>(&D3D12Kernel::isConstPtr));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Kernel::*)() const>(&D3D12Kernel::getCountPtr));
					case 10: return FunctionPtr(new FunctionImpl<const void*(D3D12Kernel::*)() const>(&D3D12Kernel::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1699, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1700, 1698, 1698, 1698, 1698, 1698, 1698, 1698, 1698, 1698, 1698 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D12Kernel::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Kernel::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Kernel::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Kernel::function_names[];
	constexpr uint16_t ReflectionD3D12Kernel::function_types[];
	constexpr uint16_t ReflectionD3D12Kernel::function_bases[];
	constexpr uint16_t ReflectionD3D12Kernel::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Kernel::function_arg_names[];
	static ReflectionD3D12Kernel reflection_d3d12_kernel;
	
	// Tellusim::MTLKernel
	class ReflectionMTLKernel : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLKernel::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_kernel;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLKernel, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLKernel>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MTLKernel::*)(bool)>(&MTLKernel::setIndirect));
					case 1: return FunctionPtr(new FunctionImpl<bool(MTLKernel::*)() const>(&MTLKernel::isIndirect));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(MTLKernel::*)() const>(&MTLKernel::getComputeFunction));
					case 3: return FunctionPtr(new FunctionImpl<MTLKernel(MTLKernel::*)() const>(&MTLKernel::clonePtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(MTLKernel::*)()>(&MTLKernel::clearPtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(MTLKernel::*)()>(&MTLKernel::destroyPtr));
					case 6: return FunctionPtr(new FunctionImpl<MTLKernel&(MTLKernel::*)()>(&MTLKernel::acquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<MTLKernel&(MTLKernel::*)()>(&MTLKernel::unacquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(MTLKernel::*)() const>(&MTLKernel::isValidPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(MTLKernel::*)() const>(&MTLKernel::isOwnerPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(MTLKernel::*)() const>(&MTLKernel::isConstPtr));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(MTLKernel::*)() const>(&MTLKernel::getCountPtr));
					case 12: return FunctionPtr(new FunctionImpl<const void*(MTLKernel::*)() const>(&MTLKernel::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1308, 1310, 1702, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701, 1701 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 21 };
			static constexpr uint16_t function_arg_names[] = { 1309 };
	};
	constexpr uint16_t ReflectionMTLKernel::constructor_bases[];
	constexpr uint16_t ReflectionMTLKernel::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLKernel::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLKernel::function_names[];
	constexpr uint16_t ReflectionMTLKernel::function_types[];
	constexpr uint16_t ReflectionMTLKernel::function_bases[];
	constexpr uint16_t ReflectionMTLKernel::function_arg_types[];
	constexpr uint16_t ReflectionMTLKernel::function_arg_names[];
	static ReflectionMTLKernel reflection_mtl_kernel;
	
	// Tellusim::FUKernel
	class ReflectionFUKernel : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUKernel::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_kernel;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUKernel, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUKernel, TypeList<const Array<Kernel>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUKernel>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUKernel::*)(uint32_t)>(&FUKernel::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUKernel::*)() const>(&FUKernel::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUKernel::*)() const>(&FUKernel::getNumKernels));
					case 3: return FunctionPtr(new FunctionImpl<const Kernel(FUKernel::*)(uint32_t) const>(&FUKernel::getKernel));
					case 4: return FunctionPtr(new FunctionImpl<Kernel(FUKernel::*)(uint32_t)>(&FUKernel::getKernel));
					case 5: return FunctionPtr(new FunctionImpl<FUKernel(FUKernel::*)() const>(&FUKernel::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUKernel::*)()>(&FUKernel::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUKernel::*)()>(&FUKernel::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUKernel&(FUKernel::*)()>(&FUKernel::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUKernel&(FUKernel::*)()>(&FUKernel::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUKernel::*)() const>(&FUKernel::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUKernel::*)() const>(&FUKernel::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUKernel::*)() const>(&FUKernel::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUKernel::*)() const>(&FUKernel::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUKernel::*)() const>(&FUKernel::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1704, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1705, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1706, 1106, 1106, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1107, 1107, 1703, 1703, 1703, 1703, 1703, 1703, 1703, 1703, 1703, 1703 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUKernel::constructor_bases[];
	constexpr uint16_t ReflectionFUKernel::constructor_arg_types[];
	constexpr uint16_t ReflectionFUKernel::constructor_arg_names[];
	constexpr uint16_t ReflectionFUKernel::function_names[];
	constexpr uint16_t ReflectionFUKernel::function_types[];
	constexpr uint16_t ReflectionFUKernel::function_bases[];
	constexpr uint16_t ReflectionFUKernel::function_arg_types[];
	constexpr uint16_t ReflectionFUKernel::function_arg_names[];
	static ReflectionFUKernel reflection_fu_kernel;
	
	// Tellusim::Pipeline
	class ReflectionPipeline : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Pipeline::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Pipeline, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Pipeline>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Pipeline::*)() const>(&Pipeline::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Pipeline::*)() const>(&Pipeline::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)()>(&Pipeline::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::isCreated));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(const char*)>(&Pipeline::setName));
					case 6: return FunctionPtr(new FunctionImpl<String(Pipeline::*)() const>(&Pipeline::getName));
					case 7: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)()>(&Pipeline::create));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(const Pipeline&)>(&Pipeline::setParameters));
					case 9: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)(Stream&) const>(&Pipeline::saveState));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Shader&, bool)>(&Pipeline::addShader, Shader::null, false));
					case 11: return FunctionPtr(new FunctionImpl<Shader(Pipeline::*)() const>(&Pipeline::getVertexShader));
					case 12: return FunctionPtr(new FunctionImpl<Shader(Pipeline::*)() const>(&Pipeline::getControlShader));
					case 13: return FunctionPtr(new FunctionImpl<Shader(Pipeline::*)() const>(&Pipeline::getEvaluateShader));
					case 14: return FunctionPtr(new FunctionImpl<Shader(Pipeline::*)() const>(&Pipeline::getGeometryShader));
					case 15: return FunctionPtr(new FunctionImpl<Shader(Pipeline::*)() const>(&Pipeline::getFragmentShader));
					case 16: return FunctionPtr(new FunctionImpl<Shader(Pipeline::*)() const>(&Pipeline::getTaskShader));
					case 17: return FunctionPtr(new FunctionImpl<Shader(Pipeline::*)() const>(&Pipeline::getMeshShader));
					case 18: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Pipeline::loadShader, {}, {}, String::null, nullptr, 0));
					case 19: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Pipeline::loadShaderGLSL, {}, {}, String::null, nullptr, 0));
					case 20: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)(Shader::Type, const char*)>(&Pipeline::loadShaderSPIRV));
					case 21: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Pipeline::createShader, {}, {}, String::null, nullptr, 0));
					case 22: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Pipeline::createShaderGLSL, {}, {}, String::null, nullptr, 0));
					case 23: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)(Shader::Type, const Array<uint32_t>&)>(&Pipeline::createShaderSPIRV));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(Shader::Mask)>(&Pipeline::addSampler));
					case 25: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumSamplers));
					case 26: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t)>(&Pipeline::setSamplerOffset));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getSamplerOffset));
					case 28: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Shader::Mask)>(&Pipeline::setSamplerMask));
					case 29: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t) const>(&Pipeline::getSamplerMask));
					case 30: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, Shader::Mask, bool)>(&Pipeline::setSamplerMasks, {}, {}, {}, false));
					case 31: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t, uint32_t) const>(&Pipeline::getSamplerMasks));
					case 32: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, bool)>(&Pipeline::setSamplerArray));
					case 33: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getSamplerArray));
					case 34: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(Shader::Mask)>(&Pipeline::addTexture));
					case 35: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumTextures));
					case 36: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t)>(&Pipeline::setTextureOffset));
					case 37: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getTextureOffset));
					case 38: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Shader::Mask)>(&Pipeline::setTextureMask));
					case 39: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t) const>(&Pipeline::getTextureMask));
					case 40: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, Shader::Mask, bool)>(&Pipeline::setTextureMasks, {}, {}, {}, false));
					case 41: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t, uint32_t) const>(&Pipeline::getTextureMasks));
					case 42: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, bool)>(&Pipeline::setTextureArray));
					case 43: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getTextureArray));
					case 44: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(Shader::Mask)>(&Pipeline::addSurface));
					case 45: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumSurfaces));
					case 46: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t)>(&Pipeline::setSurfaceOffset));
					case 47: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getSurfaceOffset));
					case 48: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Shader::Mask)>(&Pipeline::setSurfaceMask));
					case 49: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t) const>(&Pipeline::getSurfaceMask));
					case 50: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, Shader::Mask, bool)>(&Pipeline::setSurfaceMasks, {}, {}, {}, false));
					case 51: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t, uint32_t) const>(&Pipeline::getSurfaceMasks));
					case 52: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, bool)>(&Pipeline::setSurfaceArray));
					case 53: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getSurfaceArray));
					case 54: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(Shader::Mask, BindFlags)>(&Pipeline::addUniform, {}, Tellusim::BindFlagNone));
					case 55: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumUniforms));
					case 56: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t)>(&Pipeline::setUniformOffset));
					case 57: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getUniformOffset));
					case 58: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Shader::Mask, BindFlags)>(&Pipeline::setUniformMask, {}, {}, Tellusim::BindFlagNone));
					case 59: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t) const>(&Pipeline::getUniformMask));
					case 60: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, Shader::Mask, BindFlags)>(&Pipeline::setUniformMasks, {}, {}, {}, Tellusim::BindFlagNone));
					case 61: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t, uint32_t) const>(&Pipeline::getUniformMasks));
					case 62: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, BindFlags)>(&Pipeline::setUniformFlags));
					case 63: return FunctionPtr(new FunctionImpl<BindFlags(Pipeline::*)(uint32_t) const>(&Pipeline::getUniformFlags));
					case 64: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(Shader::Mask, BindFlags)>(&Pipeline::addStorage, {}, Tellusim::BindFlagNone));
					case 65: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumStorages));
					case 66: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t)>(&Pipeline::setStorageOffset));
					case 67: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getStorageOffset));
					case 68: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Shader::Mask, BindFlags)>(&Pipeline::setStorageMask, {}, {}, Tellusim::BindFlagNone));
					case 69: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t) const>(&Pipeline::getStorageMask));
					case 70: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, Shader::Mask, BindFlags)>(&Pipeline::setStorageMasks, {}, {}, {}, Tellusim::BindFlagNone));
					case 71: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t, uint32_t) const>(&Pipeline::getStorageMasks));
					case 72: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, BindFlags)>(&Pipeline::setStorageFlags));
					case 73: return FunctionPtr(new FunctionImpl<BindFlags(Pipeline::*)(uint32_t) const>(&Pipeline::getStorageFlags));
					case 74: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(Shader::Mask)>(&Pipeline::addTracing));
					case 75: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumTracings));
					case 76: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t)>(&Pipeline::setTracingOffset));
					case 77: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getTracingOffset));
					case 78: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Shader::Mask)>(&Pipeline::setTracingMask));
					case 79: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t) const>(&Pipeline::getTracingMask));
					case 80: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, Shader::Mask)>(&Pipeline::setTracingMasks));
					case 81: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t, uint32_t) const>(&Pipeline::getTracingMasks));
					case 82: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(Shader::Mask)>(&Pipeline::addTexel));
					case 83: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumTexels));
					case 84: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t)>(&Pipeline::setTexelOffset));
					case 85: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getTexelOffset));
					case 86: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Shader::Mask)>(&Pipeline::setTexelMask));
					case 87: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t) const>(&Pipeline::getTexelMask));
					case 88: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t, Shader::Mask)>(&Pipeline::setTexelMasks));
					case 89: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t, uint32_t) const>(&Pipeline::getTexelMasks));
					case 90: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(TableType, uint32_t, Shader::Mask, BindFlags)>(&Pipeline::addTable, (TableType)0, {}, {}, Tellusim::BindFlagNone));
					case 91: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumTables));
					case 92: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t)>(&Pipeline::setTableOffset));
					case 93: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getTableOffset));
					case 94: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, TableType, uint32_t, Shader::Mask, BindFlags)>(&Pipeline::setTableType, {}, (TableType)0, {}, {}, Tellusim::BindFlagNone));
					case 95: return FunctionPtr(new FunctionImpl<TableType(Pipeline::*)(uint32_t) const>(&Pipeline::getTableType));
					case 96: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getTableSize));
					case 97: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Shader::Mask, BindFlags)>(&Pipeline::setTableMask, {}, {}, Tellusim::BindFlagNone));
					case 98: return FunctionPtr(new FunctionImpl<Shader::Mask(Pipeline::*)(uint32_t) const>(&Pipeline::getTableMask));
					case 99: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, BindFlags)>(&Pipeline::setTableFlags));
					case 100: return FunctionPtr(new FunctionImpl<BindFlags(Pipeline::*)(uint32_t) const>(&Pipeline::getTableFlags));
					case 101: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumVertices));
					case 102: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getVertexStride));
					case 103: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getVertexRate));
					case 104: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(Pipeline::Attribute, Format, uint32_t, size_t, size_t, uint32_t)>(&Pipeline::addAttribute, (Pipeline::Attribute)0, (Format)0, {}, {}, {}, 0));
					case 105: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Pipeline::Attribute, Format, uint32_t, size_t, size_t, uint32_t)>(&Pipeline::setAttribute, {}, (Pipeline::Attribute)0, (Format)0, {}, {}, {}, 0));
					case 106: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Pipeline::Attribute)>(&Pipeline::setAttributeType));
					case 107: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, Format)>(&Pipeline::setAttributeFormat));
					case 108: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t)>(&Pipeline::setAttributeVertex));
					case 109: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, size_t)>(&Pipeline::setAttributeOffset));
					case 110: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, size_t)>(&Pipeline::setAttributeStride));
					case 111: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)(uint32_t, uint32_t)>(&Pipeline::setAttributeRate));
					case 112: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumAttributes));
					case 113: return FunctionPtr(new FunctionImpl<Pipeline::Attribute(Pipeline::*)(uint32_t) const>(&Pipeline::getAttributeType));
					case 114: return FunctionPtr(new FunctionImpl<Format(Pipeline::*)(uint32_t) const>(&Pipeline::getAttributeFormat));
					case 115: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getAttributeVertex));
					case 116: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getAttributeOffset));
					case 117: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getAttributeStride));
					case 118: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)(uint32_t) const>(&Pipeline::getAttributeRate));
					case 119: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::Primitive)>(&Pipeline::setPrimitive));
					case 120: return FunctionPtr(new FunctionImpl<Pipeline::Primitive(Pipeline::*)() const>(&Pipeline::getPrimitive));
					case 121: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::FillMode)>(&Pipeline::setFillMode));
					case 122: return FunctionPtr(new FunctionImpl<Pipeline::FillMode(Pipeline::*)() const>(&Pipeline::getFillMode));
					case 123: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::CullMode)>(&Pipeline::setCullMode));
					case 124: return FunctionPtr(new FunctionImpl<Pipeline::CullMode(Pipeline::*)() const>(&Pipeline::getCullMode));
					case 125: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::FrontMode)>(&Pipeline::setFrontMode));
					case 126: return FunctionPtr(new FunctionImpl<Pipeline::FrontMode(Pipeline::*)() const>(&Pipeline::getFrontMode));
					case 127: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(float32_t, float32_t, float32_t)>(&Pipeline::setDepthBias, {}, {}, 0.0f));
					case 128: return FunctionPtr(new FunctionImpl<float32_t(Pipeline::*)() const>(&Pipeline::getDepthBias));
					case 129: return FunctionPtr(new FunctionImpl<float32_t(Pipeline::*)() const>(&Pipeline::getDepthSlope));
					case 130: return FunctionPtr(new FunctionImpl<float32_t(Pipeline::*)() const>(&Pipeline::getDepthClamp));
					case 131: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t)>(&Pipeline::setMultisample));
					case 132: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getMultisample));
					case 133: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t)>(&Pipeline::setSampleMask));
					case 134: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getSampleMask));
					case 135: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(bool)>(&Pipeline::setDepthClip));
					case 136: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::getDepthClip));
					case 137: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(bool)>(&Pipeline::setDepthReplace));
					case 138: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::getDepthReplace));
					case 139: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(bool)>(&Pipeline::setScissorTest));
					case 140: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::getScissorTest));
					case 141: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(bool)>(&Pipeline::setRasterDiscard));
					case 142: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::getRasterDiscard));
					case 143: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(bool)>(&Pipeline::setSampleShading));
					case 144: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::getSampleShading));
					case 145: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(bool)>(&Pipeline::setAlphaToCoverage));
					case 146: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::getAlphaToCoverage));
					case 147: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(bool)>(&Pipeline::setMultisampleRaster));
					case 148: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::getMultisampleRaster));
					case 149: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(bool)>(&Pipeline::setConservativeRaster));
					case 150: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::getConservativeRaster));
					case 151: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t)>(&Pipeline::setNumViewports));
					case 152: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumTargets));
					case 153: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumViewports));
					case 154: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t)>(&Pipeline::setNumClipDistances));
					case 155: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getNumClipDistances));
					case 156: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::BlendOp, Pipeline::BlendFunc, Pipeline::BlendFunc)>(&Pipeline::setBlend));
					case 157: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::BlendOp, Pipeline::BlendFunc, Pipeline::BlendFunc)>(&Pipeline::setBlendColor));
					case 158: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::BlendOp, Pipeline::BlendFunc, Pipeline::BlendFunc)>(&Pipeline::setBlendAlpha));
					case 159: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t, Pipeline::BlendOp, Pipeline::BlendFunc, Pipeline::BlendFunc)>(&Pipeline::setBlend));
					case 160: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t, Pipeline::BlendOp, Pipeline::BlendFunc, Pipeline::BlendFunc)>(&Pipeline::setBlendColor));
					case 161: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t, Pipeline::BlendOp, Pipeline::BlendFunc, Pipeline::BlendFunc)>(&Pipeline::setBlendAlpha));
					case 162: return FunctionPtr(new FunctionImpl<Pipeline::BlendOp(Pipeline::*)(uint32_t) const>(&Pipeline::getBlendColorOp));
					case 163: return FunctionPtr(new FunctionImpl<Pipeline::BlendOp(Pipeline::*)(uint32_t) const>(&Pipeline::getBlendAlphaOp));
					case 164: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(Pipeline::*)(uint32_t) const>(&Pipeline::getBlendSrcColorFunc));
					case 165: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(Pipeline::*)(uint32_t) const>(&Pipeline::getBlendSrcAlphaFunc));
					case 166: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(Pipeline::*)(uint32_t) const>(&Pipeline::getBlendDestColorFunc));
					case 167: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(Pipeline::*)(uint32_t) const>(&Pipeline::getBlendDestAlphaFunc));
					case 168: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::ColorMask)>(&Pipeline::setColorMask));
					case 169: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t, Pipeline::ColorMask)>(&Pipeline::setColorMask));
					case 170: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t, Format)>(&Pipeline::setColorFormat));
					case 171: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Format, uint32_t)>(&Pipeline::setColorFormat, (Format)0, 1));
					case 172: return FunctionPtr(new FunctionImpl<Pipeline::ColorMask(Pipeline::*)(uint32_t) const>(&Pipeline::getColorMask));
					case 173: return FunctionPtr(new FunctionImpl<Format(Pipeline::*)(uint32_t) const>(&Pipeline::getColorFormat));
					case 174: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::DepthMask)>(&Pipeline::setDepthMask));
					case 175: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::DepthFunc)>(&Pipeline::setDepthFunc));
					case 176: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Format)>(&Pipeline::setDepthFormat));
					case 177: return FunctionPtr(new FunctionImpl<Pipeline::DepthMask(Pipeline::*)() const>(&Pipeline::getDepthMask));
					case 178: return FunctionPtr(new FunctionImpl<Pipeline::DepthFunc(Pipeline::*)() const>(&Pipeline::getDepthFunc));
					case 179: return FunctionPtr(new FunctionImpl<Format(Pipeline::*)() const>(&Pipeline::getDepthFormat));
					case 180: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t)>(&Pipeline::setStencilMask));
					case 181: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t)>(&Pipeline::setStencilBackMask));
					case 182: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(uint32_t)>(&Pipeline::setStencilFrontMask));
					case 183: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::StencilFunc, Pipeline::StencilOp)>(&Pipeline::setStencilFunc));
					case 184: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::StencilFunc, Pipeline::StencilOp)>(&Pipeline::setStencilBackFunc));
					case 185: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::StencilFunc, Pipeline::StencilOp)>(&Pipeline::setStencilFrontFunc));
					case 186: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::StencilFunc, Pipeline::StencilOp, Pipeline::StencilOp, Pipeline::StencilOp)>(&Pipeline::setStencilFunc));
					case 187: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::StencilFunc, Pipeline::StencilOp, Pipeline::StencilOp, Pipeline::StencilOp)>(&Pipeline::setStencilBackFunc));
					case 188: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)(Pipeline::StencilFunc, Pipeline::StencilOp, Pipeline::StencilOp, Pipeline::StencilOp)>(&Pipeline::setStencilFrontFunc));
					case 189: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getStencilBackMask));
					case 190: return FunctionPtr(new FunctionImpl<Pipeline::StencilFunc(Pipeline::*)() const>(&Pipeline::getStencilBackFunc));
					case 191: return FunctionPtr(new FunctionImpl<Pipeline::StencilOp(Pipeline::*)() const>(&Pipeline::getStencilBackFailOp));
					case 192: return FunctionPtr(new FunctionImpl<Pipeline::StencilOp(Pipeline::*)() const>(&Pipeline::getStencilBackDepthFailOp));
					case 193: return FunctionPtr(new FunctionImpl<Pipeline::StencilOp(Pipeline::*)() const>(&Pipeline::getStencilBackDepthPassOp));
					case 194: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getStencilFrontMask));
					case 195: return FunctionPtr(new FunctionImpl<Pipeline::StencilFunc(Pipeline::*)() const>(&Pipeline::getStencilFrontFunc));
					case 196: return FunctionPtr(new FunctionImpl<Pipeline::StencilOp(Pipeline::*)() const>(&Pipeline::getStencilFrontFailOp));
					case 197: return FunctionPtr(new FunctionImpl<Pipeline::StencilOp(Pipeline::*)() const>(&Pipeline::getStencilFrontDepthFailOp));
					case 198: return FunctionPtr(new FunctionImpl<Pipeline::StencilOp(Pipeline::*)() const>(&Pipeline::getStencilFrontDepthPassOp));
					case 199: return FunctionPtr(new FunctionImpl<Pipeline(Pipeline::*)() const>(&Pipeline::clonePtr));
					case 200: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)()>(&Pipeline::clearPtr));
					case 201: return FunctionPtr(new FunctionVoidImpl<void(Pipeline::*)()>(&Pipeline::destroyPtr));
					case 202: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)()>(&Pipeline::acquirePtr));
					case 203: return FunctionPtr(new FunctionImpl<Pipeline&(Pipeline::*)()>(&Pipeline::unacquirePtr));
					case 204: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::isValidPtr));
					case 205: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::isOwnerPtr));
					case 206: return FunctionPtr(new FunctionImpl<bool(Pipeline::*)() const>(&Pipeline::isConstPtr));
					case 207: return FunctionPtr(new FunctionImpl<uint32_t(Pipeline::*)() const>(&Pipeline::getCountPtr));
					case 208: return FunctionPtr(new FunctionImpl<const void*(Pipeline::*)() const>(&Pipeline::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 172, 75, 24, 1332, 1236, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1577, 1578, 1579, 1576, 1580, 1581, 1660, 1375, 1256, 1257, 1716, 1717, 1719, 1720, 1661, 1663, 1664, 1428, 1258, 1259, 1721, 1722, 1723, 1724, 1665, 1421, 1666, 1668, 1260, 1261, 1725, 1726, 1727, 1728, 1669, 1670, 1671, 1674, 1006, 1262, 1729, 1730, 1731, 1732, 1675, 1676, 1677, 1679, 1016, 1263, 1733, 1734, 1735, 1736, 1680, 1681, 1682, 1484, 1264, 1265, 1737, 1738, 1739, 1740, 1683, 1685, 1266, 1267, 1741, 1742, 1743, 1744, 1686, 1688, 1268, 1269, 1689, 1690, 1691, 1745, 1746, 1692, 1693, 1448, 1450, 1747, 593, 896, 1751, 1752, 1753, 1754, 1755, 1756, 684, 1757, 1759, 1760, 1761, 1762, 1763, 1764, 1767, 1769, 1771, 1773, 1775, 1777, 1779, 1781, 1784, 1785, 1786, 1787, 13, 1788, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1503, 1808, 1809, 1811, 1812, 1053, 1815, 1812, 1053, 1815, 1816, 1818, 1819, 1821, 1822, 1823, 1824, 1824, 1826, 1826, 1827, 1494, 1829, 1831, 1833, 1834, 1836, 1495, 1838, 1839, 1840, 1841, 1845, 1846, 1841, 1845, 1846, 1849, 1850, 1852, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 6, 16, 21, 6, 21, 6, 1235, 1235, 1235, 1235, 1235, 1235, 1235, 21, 21, 21, 21, 21, 21, 10, 10, 971, 10, 971, 1718, 971, 1718, 971, 10, 10, 10, 971, 10, 971, 1718, 971, 1718, 971, 10, 10, 10, 971, 10, 971, 1718, 971, 1718, 971, 10, 10, 10, 971, 10, 971, 1718, 971, 1718, 971, 1672, 10, 10, 971, 10, 971, 1718, 971, 1718, 971, 1672, 10, 10, 971, 10, 971, 1718, 971, 1718, 10, 10, 971, 10, 971, 1718, 971, 1718, 10, 10, 971, 10, 971, 1687, 10, 971, 1718, 971, 1672, 10, 10, 10, 10, 971, 971, 971, 971, 971, 971, 971, 10, 1758, 340, 10, 10, 10, 10, 6, 1768, 6, 1772, 6, 1776, 6, 1780, 6, 123, 123, 123, 6, 10, 6, 10, 6, 21, 6, 21, 6, 21, 6, 21, 6, 21, 6, 21, 6, 21, 6, 21, 6, 10, 10, 6, 10, 6, 6, 6, 6, 6, 6, 1817, 1817, 1820, 1820, 1820, 1820, 6, 6, 6, 6, 1828, 340, 6, 6, 6, 1835, 1837, 340, 6, 6, 6, 6, 6, 6, 6, 6, 6, 10, 1851, 1853, 1853, 1853, 10, 1851, 1853, 1853, 1853, 971, 971, 971, 971, 971, 971, 971, 971, 971, 971 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 3, 5, 5, 5, 5, 5, 5, 5, 5, 10, 15, 17, 22, 27, 29, 30, 30, 31, 31, 33, 34, 38, 40, 43, 44, 45, 45, 46, 46, 48, 49, 53, 55, 58, 59, 60, 60, 61, 61, 63, 64, 68, 70, 73, 74, 76, 76, 77, 77, 80, 81, 85, 87, 89, 90, 92, 92, 93, 93, 96, 97, 101, 103, 105, 106, 107, 107, 108, 108, 110, 111, 114, 116, 117, 117, 118, 118, 120, 121, 124, 126, 130, 130, 131, 131, 136, 137, 138, 141, 142, 144, 145, 145, 146, 147, 153, 160, 162, 164, 166, 168, 170, 172, 172, 173, 174, 175, 176, 177, 178, 179, 179, 180, 180, 181, 181, 182, 182, 185, 185, 185, 185, 186, 186, 187, 187, 188, 188, 189, 189, 190, 190, 191, 191, 192, 192, 193, 193, 194, 194, 195, 195, 196, 196, 196, 197, 197, 200, 203, 206, 210, 214, 218, 219, 220, 221, 222, 223, 224, 225, 227, 229, 231, 232, 233, 234, 235, 236, 236, 236, 236, 237, 238, 239, 241, 243, 245, 249, 253, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257, 257 };
			static constexpr uint16_t function_arg_types[] = { 22, 1586, 145, 1657, 21, 1237, 22, 94, 876, 10, 1237, 22, 94, 876, 10, 1237, 22, 1237, 22, 94, 876, 10, 1237, 22, 94, 876, 10, 1237, 586, 1715, 10, 10, 1715, 10, 10, 10, 1715, 21, 10, 10, 10, 10, 21, 10, 1715, 10, 10, 1715, 10, 10, 10, 1715, 21, 10, 10, 10, 10, 21, 10, 1715, 10, 10, 1715, 10, 10, 10, 1715, 21, 10, 10, 10, 10, 21, 10, 1715, 1672, 10, 10, 1715, 1672, 10, 10, 10, 1715, 1672, 10, 10, 10, 1672, 10, 1715, 1672, 10, 10, 1715, 1672, 10, 10, 10, 1715, 1672, 10, 10, 10, 1672, 10, 1715, 10, 10, 1715, 10, 10, 10, 1715, 10, 10, 1715, 10, 10, 1715, 10, 10, 10, 1715, 10, 10, 1687, 10, 1715, 1672, 10, 10, 1687, 10, 1715, 1672, 10, 10, 10, 1715, 1672, 10, 10, 1672, 10, 10, 10, 1748, 340, 10, 74, 74, 10, 10, 1748, 340, 10, 74, 74, 10, 10, 1748, 10, 340, 10, 10, 10, 74, 10, 74, 10, 10, 10, 10, 10, 10, 10, 10, 1765, 1770, 1774, 1778, 123, 123, 123, 10, 10, 21, 21, 21, 21, 21, 21, 21, 21, 10, 10, 1813, 1814, 1814, 1813, 1814, 1814, 1813, 1814, 1814, 10, 1813, 1814, 1814, 10, 1813, 1814, 1814, 10, 1813, 1814, 1814, 10, 10, 10, 10, 10, 10, 1825, 10, 1825, 10, 340, 340, 10, 10, 10, 1830, 1832, 340, 10, 10, 10, 1842, 1843, 1842, 1843, 1842, 1843, 1842, 1843, 1843, 1843, 1842, 1843, 1843, 1843, 1842, 1843, 1843, 1843 };
			static constexpr uint16_t function_arg_names[] = { 23, 969, 222, 1658, 854, 195, 23, 1276, 1277, 87, 195, 23, 1276, 1277, 87, 195, 23, 195, 90, 1276, 1277, 87, 195, 90, 1276, 1277, 87, 195, 167, 53, 78, 274, 53, 274, 274, 17, 53, 1662, 274, 17, 274, 17, 1662, 274, 53, 78, 274, 53, 274, 274, 17, 53, 1662, 274, 17, 274, 17, 1662, 274, 53, 78, 274, 53, 274, 274, 17, 53, 1662, 274, 17, 274, 17, 1662, 274, 53, 338, 78, 274, 53, 338, 274, 274, 17, 53, 338, 274, 17, 274, 338, 274, 53, 338, 78, 274, 53, 338, 274, 274, 17, 53, 338, 274, 17, 274, 338, 274, 53, 78, 274, 53, 274, 274, 17, 53, 274, 17, 53, 78, 274, 53, 274, 274, 17, 53, 274, 17, 195, 87, 53, 338, 78, 274, 195, 87, 53, 338, 274, 274, 274, 53, 338, 274, 274, 338, 274, 274, 274, 589, 96, 1749, 78, 452, 1750, 274, 589, 96, 1749, 78, 452, 1750, 274, 589, 274, 96, 274, 1749, 274, 78, 274, 452, 274, 1750, 274, 274, 274, 274, 274, 274, 1766, 185, 185, 185, 1356, 1782, 1783, 32, 1789, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 1309, 978, 1810, 1501, 90, 86, 1501, 90, 86, 1501, 90, 86, 274, 1501, 90, 86, 274, 1501, 90, 86, 274, 1501, 90, 86, 274, 274, 274, 274, 274, 274, 53, 274, 53, 274, 96, 96, 17, 274, 274, 53, 1162, 96, 53, 53, 53, 1162, 1844, 1162, 1844, 1162, 1844, 1162, 1847, 1848, 1844, 1162, 1847, 1848, 1844, 1162, 1847, 1848, 1844 };
	};
	constexpr uint16_t ReflectionPipeline::constructor_bases[];
	constexpr uint16_t ReflectionPipeline::constructor_arg_types[];
	constexpr uint16_t ReflectionPipeline::constructor_arg_names[];
	constexpr uint16_t ReflectionPipeline::function_names[];
	constexpr uint16_t ReflectionPipeline::function_types[];
	constexpr uint16_t ReflectionPipeline::function_bases[];
	constexpr uint16_t ReflectionPipeline::function_arg_types[];
	constexpr uint16_t ReflectionPipeline::function_arg_names[];
	static ReflectionPipeline reflection_pipeline;
	
	// Tellusim::D3D12Pipeline
	class ReflectionD3D12Pipeline : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Pipeline::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_pipeline;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Pipeline, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Pipeline>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<ID3D12RootSignature*(D3D12Pipeline::*)() const>(&D3D12Pipeline::getRootSignature));
					case 1: return FunctionPtr(new FunctionImpl<D3D12Pipeline(D3D12Pipeline::*)() const>(&D3D12Pipeline::clonePtr));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(D3D12Pipeline::*)()>(&D3D12Pipeline::clearPtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D12Pipeline::*)()>(&D3D12Pipeline::destroyPtr));
					case 4: return FunctionPtr(new FunctionImpl<D3D12Pipeline&(D3D12Pipeline::*)()>(&D3D12Pipeline::acquirePtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D12Pipeline&(D3D12Pipeline::*)()>(&D3D12Pipeline::unacquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<bool(D3D12Pipeline::*)() const>(&D3D12Pipeline::isValidPtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D12Pipeline::*)() const>(&D3D12Pipeline::isOwnerPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D12Pipeline::*)() const>(&D3D12Pipeline::isConstPtr));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Pipeline::*)() const>(&D3D12Pipeline::getCountPtr));
					case 10: return FunctionPtr(new FunctionImpl<const void*(D3D12Pipeline::*)() const>(&D3D12Pipeline::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1699, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1700, 1861, 1861, 1861, 1861, 1861, 1861, 1861, 1861, 1861, 1861 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D12Pipeline::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Pipeline::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Pipeline::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Pipeline::function_names[];
	constexpr uint16_t ReflectionD3D12Pipeline::function_types[];
	constexpr uint16_t ReflectionD3D12Pipeline::function_bases[];
	constexpr uint16_t ReflectionD3D12Pipeline::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Pipeline::function_arg_names[];
	static ReflectionD3D12Pipeline reflection_d3d12_pipeline;
	
	// Tellusim::MTLPipeline
	class ReflectionMTLPipeline : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLPipeline::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_pipeline;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLPipeline, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLPipeline>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MTLPipeline::*)(bool)>(&MTLPipeline::setIndirect));
					case 1: return FunctionPtr(new FunctionImpl<bool(MTLPipeline::*)() const>(&MTLPipeline::isIndirect));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(MTLPipeline::*)() const>(&MTLPipeline::getVertexFunction));
					case 3: return FunctionPtr(new FunctionVoidImpl<void*(MTLPipeline::*)() const>(&MTLPipeline::getFragmentFunction));
					case 4: return FunctionPtr(new FunctionImpl<MTLPipeline(MTLPipeline::*)() const>(&MTLPipeline::clonePtr));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(MTLPipeline::*)()>(&MTLPipeline::clearPtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(MTLPipeline::*)()>(&MTLPipeline::destroyPtr));
					case 7: return FunctionPtr(new FunctionImpl<MTLPipeline&(MTLPipeline::*)()>(&MTLPipeline::acquirePtr));
					case 8: return FunctionPtr(new FunctionImpl<MTLPipeline&(MTLPipeline::*)()>(&MTLPipeline::unacquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(MTLPipeline::*)() const>(&MTLPipeline::isValidPtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(MTLPipeline::*)() const>(&MTLPipeline::isOwnerPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(MTLPipeline::*)() const>(&MTLPipeline::isConstPtr));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(MTLPipeline::*)() const>(&MTLPipeline::getCountPtr));
					case 13: return FunctionPtr(new FunctionImpl<const void*(MTLPipeline::*)() const>(&MTLPipeline::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1308, 1310, 1863, 1864, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 6, 1862, 1862, 1862, 1862, 1862, 1862, 1862, 1862, 1862, 1862 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 21 };
			static constexpr uint16_t function_arg_names[] = { 1309 };
	};
	constexpr uint16_t ReflectionMTLPipeline::constructor_bases[];
	constexpr uint16_t ReflectionMTLPipeline::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLPipeline::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLPipeline::function_names[];
	constexpr uint16_t ReflectionMTLPipeline::function_types[];
	constexpr uint16_t ReflectionMTLPipeline::function_bases[];
	constexpr uint16_t ReflectionMTLPipeline::function_arg_types[];
	constexpr uint16_t ReflectionMTLPipeline::function_arg_names[];
	static ReflectionMTLPipeline reflection_mtl_pipeline;
	
	// Tellusim::FUPipeline
	class ReflectionFUPipeline : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUPipeline::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_pipeline;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUPipeline, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUPipeline, TypeList<const Array<Pipeline>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUPipeline>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUPipeline::*)(uint32_t)>(&FUPipeline::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUPipeline::*)() const>(&FUPipeline::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUPipeline::*)() const>(&FUPipeline::getNumPipelines));
					case 3: return FunctionPtr(new FunctionImpl<const Pipeline(FUPipeline::*)(uint32_t) const>(&FUPipeline::getPipeline));
					case 4: return FunctionPtr(new FunctionImpl<Pipeline(FUPipeline::*)(uint32_t)>(&FUPipeline::getPipeline));
					case 5: return FunctionPtr(new FunctionImpl<FUPipeline(FUPipeline::*)() const>(&FUPipeline::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUPipeline::*)()>(&FUPipeline::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUPipeline::*)()>(&FUPipeline::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUPipeline&(FUPipeline::*)()>(&FUPipeline::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUPipeline&(FUPipeline::*)()>(&FUPipeline::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUPipeline::*)() const>(&FUPipeline::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUPipeline::*)() const>(&FUPipeline::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUPipeline::*)() const>(&FUPipeline::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUPipeline::*)() const>(&FUPipeline::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUPipeline::*)() const>(&FUPipeline::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1866, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1867, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1868, 970, 970, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 971, 971, 1865, 1865, 1865, 1865, 1865, 1865, 1865, 1865, 1865, 1865 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUPipeline::constructor_bases[];
	constexpr uint16_t ReflectionFUPipeline::constructor_arg_types[];
	constexpr uint16_t ReflectionFUPipeline::constructor_arg_names[];
	constexpr uint16_t ReflectionFUPipeline::function_names[];
	constexpr uint16_t ReflectionFUPipeline::function_types[];
	constexpr uint16_t ReflectionFUPipeline::function_bases[];
	constexpr uint16_t ReflectionFUPipeline::function_arg_types[];
	constexpr uint16_t ReflectionFUPipeline::function_arg_names[];
	static ReflectionFUPipeline reflection_fu_pipeline;
	
	// Tellusim::Traversal
	class ReflectionTraversal : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Traversal::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Traversal, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Traversal>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Traversal::*)() const>(&Traversal::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Traversal::*)() const>(&Traversal::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Traversal::*)()>(&Traversal::clear));
					case 4: return FunctionPtr(new FunctionImpl<bool(Traversal::*)() const>(&Traversal::isCreated));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Traversal::*)(const char*)>(&Traversal::setName));
					case 6: return FunctionPtr(new FunctionImpl<String(Traversal::*)() const>(&Traversal::getName));
					case 7: return FunctionPtr(new FunctionImpl<bool(Traversal::*)()>(&Traversal::create));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(Traversal::*)(const Traversal&)>(&Traversal::setParameters));
					case 9: return FunctionPtr(new FunctionImpl<bool(Traversal::*)(Stream&) const>(&Traversal::saveState));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Traversal::*)(Shader&, bool)>(&Traversal::addShader, Shader::null, false));
					case 11: return FunctionPtr(new FunctionImpl<Shader(Traversal::*)() const>(&Traversal::getRayGenShader));
					case 12: return FunctionPtr(new FunctionImpl<bool(Traversal::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Traversal::loadShader, {}, {}, String::null, nullptr, 0));
					case 13: return FunctionPtr(new FunctionImpl<bool(Traversal::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Traversal::loadShaderGLSL, {}, {}, String::null, nullptr, 0));
					case 14: return FunctionPtr(new FunctionImpl<bool(Traversal::*)(Shader::Type, const char*)>(&Traversal::loadShaderSPIRV));
					case 15: return FunctionPtr(new FunctionImpl<bool(Traversal::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Traversal::createShader, {}, {}, String::null, nullptr, 0));
					case 16: return FunctionPtr(new FunctionImpl<bool(Traversal::*)(Shader::Type, const char*, const String&, const char**, uint32_t)>(&Traversal::createShaderGLSL, {}, {}, String::null, nullptr, 0));
					case 17: return FunctionPtr(new FunctionImpl<bool(Traversal::*)(Shader::Type, const Array<uint32_t>&)>(&Traversal::createShaderSPIRV));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(Shader::Mask)>(&Traversal::addSampler));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getNumSamplers));
					case 20: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t)>(&Traversal::setSamplerOffset));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getSamplerOffset));
					case 22: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, Shader::Mask)>(&Traversal::setSamplerMask));
					case 23: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t) const>(&Traversal::getSamplerMask));
					case 24: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, Shader::Mask, bool)>(&Traversal::setSamplerMasks, {}, {}, {}, false));
					case 25: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t, uint32_t) const>(&Traversal::getSamplerMasks));
					case 26: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, bool)>(&Traversal::setSamplerArray));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(uint32_t) const>(&Traversal::getSamplerArray));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(Shader::Mask)>(&Traversal::addTexture));
					case 29: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getNumTextures));
					case 30: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t)>(&Traversal::setTextureOffset));
					case 31: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getTextureOffset));
					case 32: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, Shader::Mask)>(&Traversal::setTextureMask));
					case 33: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t) const>(&Traversal::getTextureMask));
					case 34: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, Shader::Mask, bool)>(&Traversal::setTextureMasks, {}, {}, {}, false));
					case 35: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t, uint32_t) const>(&Traversal::getTextureMasks));
					case 36: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, bool)>(&Traversal::setTextureArray));
					case 37: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(uint32_t) const>(&Traversal::getTextureArray));
					case 38: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(Shader::Mask)>(&Traversal::addSurface));
					case 39: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getNumSurfaces));
					case 40: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t)>(&Traversal::setSurfaceOffset));
					case 41: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getSurfaceOffset));
					case 42: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, Shader::Mask)>(&Traversal::setSurfaceMask));
					case 43: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t) const>(&Traversal::getSurfaceMask));
					case 44: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, Shader::Mask, bool)>(&Traversal::setSurfaceMasks, {}, {}, {}, false));
					case 45: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t, uint32_t) const>(&Traversal::getSurfaceMasks));
					case 46: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, bool)>(&Traversal::setSurfaceArray));
					case 47: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(uint32_t) const>(&Traversal::getSurfaceArray));
					case 48: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(Shader::Mask, BindFlags)>(&Traversal::addUniform, {}, Tellusim::BindFlagNone));
					case 49: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getNumUniforms));
					case 50: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t)>(&Traversal::setUniformOffset));
					case 51: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getUniformOffset));
					case 52: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, Shader::Mask, BindFlags)>(&Traversal::setUniformMask, {}, {}, Tellusim::BindFlagNone));
					case 53: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t) const>(&Traversal::getUniformMask));
					case 54: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, Shader::Mask, BindFlags)>(&Traversal::setUniformMasks, {}, {}, {}, Tellusim::BindFlagNone));
					case 55: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t, uint32_t) const>(&Traversal::getUniformMasks));
					case 56: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, BindFlags)>(&Traversal::setUniformFlags));
					case 57: return FunctionPtr(new FunctionImpl<BindFlags(Traversal::*)(uint32_t) const>(&Traversal::getUniformFlags));
					case 58: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(Shader::Mask, BindFlags)>(&Traversal::addStorage, {}, Tellusim::BindFlagNone));
					case 59: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getNumStorages));
					case 60: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t)>(&Traversal::setStorageOffset));
					case 61: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getStorageOffset));
					case 62: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, Shader::Mask, BindFlags)>(&Traversal::setStorageMask, {}, {}, Tellusim::BindFlagNone));
					case 63: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t) const>(&Traversal::getStorageMask));
					case 64: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, Shader::Mask, BindFlags)>(&Traversal::setStorageMasks, {}, {}, {}, Tellusim::BindFlagNone));
					case 65: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t, uint32_t) const>(&Traversal::getStorageMasks));
					case 66: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, BindFlags)>(&Traversal::setStorageFlags));
					case 67: return FunctionPtr(new FunctionImpl<BindFlags(Traversal::*)(uint32_t) const>(&Traversal::getStorageFlags));
					case 68: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(Shader::Mask)>(&Traversal::addTracing));
					case 69: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getNumTracings));
					case 70: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t)>(&Traversal::setTracingOffset));
					case 71: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getTracingOffset));
					case 72: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, Shader::Mask)>(&Traversal::setTracingMask));
					case 73: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t) const>(&Traversal::getTracingMask));
					case 74: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, Shader::Mask)>(&Traversal::setTracingMasks));
					case 75: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t, uint32_t) const>(&Traversal::getTracingMasks));
					case 76: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(Shader::Mask)>(&Traversal::addTexel));
					case 77: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getNumTexels));
					case 78: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t)>(&Traversal::setTexelOffset));
					case 79: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getTexelOffset));
					case 80: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, Shader::Mask)>(&Traversal::setTexelMask));
					case 81: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t) const>(&Traversal::getTexelMask));
					case 82: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, uint32_t, Shader::Mask)>(&Traversal::setTexelMasks));
					case 83: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t, uint32_t) const>(&Traversal::getTexelMasks));
					case 84: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(TableType, uint32_t, Shader::Mask, BindFlags)>(&Traversal::addTable, (TableType)0, {}, {}, Tellusim::BindFlagNone));
					case 85: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getNumTables));
					case 86: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t)>(&Traversal::setTableOffset));
					case 87: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getTableOffset));
					case 88: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, TableType, uint32_t, Shader::Mask, BindFlags)>(&Traversal::setTableType, {}, (TableType)0, {}, {}, Tellusim::BindFlagNone));
					case 89: return FunctionPtr(new FunctionImpl<TableType(Traversal::*)(uint32_t) const>(&Traversal::getTableType));
					case 90: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)(uint32_t) const>(&Traversal::getTableSize));
					case 91: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, Shader::Mask, BindFlags)>(&Traversal::setTableMask, {}, {}, Tellusim::BindFlagNone));
					case 92: return FunctionPtr(new FunctionImpl<Shader::Mask(Traversal::*)(uint32_t) const>(&Traversal::getTableMask));
					case 93: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)(uint32_t, BindFlags)>(&Traversal::setTableFlags));
					case 94: return FunctionPtr(new FunctionImpl<BindFlags(Traversal::*)(uint32_t) const>(&Traversal::getTableFlags));
					case 95: return FunctionPtr(new FunctionVoidImpl<void(Traversal::*)(uint32_t)>(&Traversal::setRecursionDepth));
					case 96: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getRecursionDepth));
					case 97: return FunctionPtr(new FunctionImpl<Traversal(Traversal::*)() const>(&Traversal::clonePtr));
					case 98: return FunctionPtr(new FunctionVoidImpl<void(Traversal::*)()>(&Traversal::clearPtr));
					case 99: return FunctionPtr(new FunctionVoidImpl<void(Traversal::*)()>(&Traversal::destroyPtr));
					case 100: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)()>(&Traversal::acquirePtr));
					case 101: return FunctionPtr(new FunctionImpl<Traversal&(Traversal::*)()>(&Traversal::unacquirePtr));
					case 102: return FunctionPtr(new FunctionImpl<bool(Traversal::*)() const>(&Traversal::isValidPtr));
					case 103: return FunctionPtr(new FunctionImpl<bool(Traversal::*)() const>(&Traversal::isOwnerPtr));
					case 104: return FunctionPtr(new FunctionImpl<bool(Traversal::*)() const>(&Traversal::isConstPtr));
					case 105: return FunctionPtr(new FunctionImpl<uint32_t(Traversal::*)() const>(&Traversal::getCountPtr));
					case 106: return FunctionPtr(new FunctionImpl<const void*(Traversal::*)() const>(&Traversal::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 5, 904, 172, 75, 24, 1332, 1236, 1707, 1869, 1577, 1578, 1579, 1576, 1580, 1581, 1660, 1375, 1256, 1257, 1716, 1717, 1719, 1720, 1661, 1663, 1664, 1428, 1258, 1259, 1721, 1722, 1723, 1724, 1665, 1421, 1666, 1668, 1260, 1261, 1725, 1726, 1727, 1728, 1669, 1670, 1671, 1674, 1006, 1262, 1729, 1730, 1731, 1732, 1675, 1676, 1677, 1679, 1016, 1263, 1733, 1734, 1735, 1736, 1680, 1681, 1682, 1484, 1264, 1265, 1737, 1738, 1739, 1740, 1683, 1685, 1266, 1267, 1741, 1742, 1743, 1744, 1686, 1688, 1268, 1269, 1689, 1690, 1691, 1745, 1746, 1692, 1693, 1870, 1871, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 21, 6, 16, 21, 6, 21, 6, 1235, 21, 21, 21, 21, 21, 21, 10, 10, 1112, 10, 1112, 1718, 1112, 1718, 1112, 10, 10, 10, 1112, 10, 1112, 1718, 1112, 1718, 1112, 10, 10, 10, 1112, 10, 1112, 1718, 1112, 1718, 1112, 10, 10, 10, 1112, 10, 1112, 1718, 1112, 1718, 1112, 1672, 10, 10, 1112, 10, 1112, 1718, 1112, 1718, 1112, 1672, 10, 10, 1112, 10, 1112, 1718, 1112, 1718, 10, 10, 1112, 10, 1112, 1718, 1112, 1718, 10, 10, 1112, 10, 1112, 1687, 10, 1112, 1718, 1112, 1672, 6, 10, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 1112, 1112 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 3, 5, 5, 10, 15, 17, 22, 27, 29, 30, 30, 31, 31, 33, 34, 38, 40, 43, 44, 45, 45, 46, 46, 48, 49, 53, 55, 58, 59, 60, 60, 61, 61, 63, 64, 68, 70, 73, 74, 76, 76, 77, 77, 80, 81, 85, 87, 89, 90, 92, 92, 93, 93, 96, 97, 101, 103, 105, 106, 107, 107, 108, 108, 110, 111, 114, 116, 117, 117, 118, 118, 120, 121, 124, 126, 130, 130, 131, 131, 136, 137, 138, 141, 142, 144, 145, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, 146 };
			static constexpr uint16_t function_arg_types[] = { 22, 1589, 145, 1657, 21, 1237, 22, 94, 876, 10, 1237, 22, 94, 876, 10, 1237, 22, 1237, 22, 94, 876, 10, 1237, 22, 94, 876, 10, 1237, 586, 1715, 10, 10, 1715, 10, 10, 10, 1715, 21, 10, 10, 10, 10, 21, 10, 1715, 10, 10, 1715, 10, 10, 10, 1715, 21, 10, 10, 10, 10, 21, 10, 1715, 10, 10, 1715, 10, 10, 10, 1715, 21, 10, 10, 10, 10, 21, 10, 1715, 1672, 10, 10, 1715, 1672, 10, 10, 10, 1715, 1672, 10, 10, 10, 1672, 10, 1715, 1672, 10, 10, 1715, 1672, 10, 10, 10, 1715, 1672, 10, 10, 10, 1672, 10, 1715, 10, 10, 1715, 10, 10, 10, 1715, 10, 10, 1715, 10, 10, 1715, 10, 10, 10, 1715, 10, 10, 1687, 10, 1715, 1672, 10, 10, 1687, 10, 1715, 1672, 10, 10, 10, 1715, 1672, 10, 10, 1672, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 1110, 222, 1658, 854, 195, 23, 1276, 1277, 87, 195, 23, 1276, 1277, 87, 195, 23, 195, 90, 1276, 1277, 87, 195, 90, 1276, 1277, 87, 195, 167, 53, 78, 274, 53, 274, 274, 17, 53, 1662, 274, 17, 274, 17, 1662, 274, 53, 78, 274, 53, 274, 274, 17, 53, 1662, 274, 17, 274, 17, 1662, 274, 53, 78, 274, 53, 274, 274, 17, 53, 1662, 274, 17, 274, 17, 1662, 274, 53, 338, 78, 274, 53, 338, 274, 274, 17, 53, 338, 274, 17, 274, 338, 274, 53, 338, 78, 274, 53, 338, 274, 274, 17, 53, 338, 274, 17, 274, 338, 274, 53, 78, 274, 53, 274, 274, 17, 53, 274, 17, 53, 78, 274, 53, 274, 274, 17, 53, 274, 17, 195, 87, 53, 338, 78, 274, 195, 87, 53, 338, 274, 274, 274, 53, 338, 274, 274, 338, 274, 415 };
	};
	constexpr uint16_t ReflectionTraversal::constructor_bases[];
	constexpr uint16_t ReflectionTraversal::constructor_arg_types[];
	constexpr uint16_t ReflectionTraversal::constructor_arg_names[];
	constexpr uint16_t ReflectionTraversal::function_names[];
	constexpr uint16_t ReflectionTraversal::function_types[];
	constexpr uint16_t ReflectionTraversal::function_bases[];
	constexpr uint16_t ReflectionTraversal::function_arg_types[];
	constexpr uint16_t ReflectionTraversal::function_arg_names[];
	static ReflectionTraversal reflection_traversal;
	
	// Tellusim::D3D12Traversal
	class ReflectionD3D12Traversal : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Traversal::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_traversal;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Traversal, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Traversal>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<ID3D12RootSignature*(D3D12Traversal::*)() const>(&D3D12Traversal::getRootSignature));
					case 1: return FunctionPtr(new FunctionImpl<D3D12Traversal(D3D12Traversal::*)() const>(&D3D12Traversal::clonePtr));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(D3D12Traversal::*)()>(&D3D12Traversal::clearPtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D12Traversal::*)()>(&D3D12Traversal::destroyPtr));
					case 4: return FunctionPtr(new FunctionImpl<D3D12Traversal&(D3D12Traversal::*)()>(&D3D12Traversal::acquirePtr));
					case 5: return FunctionPtr(new FunctionImpl<D3D12Traversal&(D3D12Traversal::*)()>(&D3D12Traversal::unacquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<bool(D3D12Traversal::*)() const>(&D3D12Traversal::isValidPtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(D3D12Traversal::*)() const>(&D3D12Traversal::isOwnerPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(D3D12Traversal::*)() const>(&D3D12Traversal::isConstPtr));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Traversal::*)() const>(&D3D12Traversal::getCountPtr));
					case 10: return FunctionPtr(new FunctionImpl<const void*(D3D12Traversal::*)() const>(&D3D12Traversal::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1699, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1700, 1872, 1872, 1872, 1872, 1872, 1872, 1872, 1872, 1872, 1872 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionD3D12Traversal::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Traversal::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Traversal::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Traversal::function_names[];
	constexpr uint16_t ReflectionD3D12Traversal::function_types[];
	constexpr uint16_t ReflectionD3D12Traversal::function_bases[];
	constexpr uint16_t ReflectionD3D12Traversal::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Traversal::function_arg_names[];
	static ReflectionD3D12Traversal reflection_d3d12_traversal;
	
	// Tellusim::FUTraversal
	class ReflectionFUTraversal : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FUTraversal::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_traversal;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FUTraversal, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<FUTraversal, TypeList<const Array<Traversal>&, bool>>({}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FUTraversal>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FUTraversal::*)(uint32_t)>(&FUTraversal::setMask));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(FUTraversal::*)() const>(&FUTraversal::getMask));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(FUTraversal::*)() const>(&FUTraversal::getNumTraversals));
					case 3: return FunctionPtr(new FunctionImpl<const Traversal(FUTraversal::*)(uint32_t) const>(&FUTraversal::getTraversal));
					case 4: return FunctionPtr(new FunctionImpl<Traversal(FUTraversal::*)(uint32_t)>(&FUTraversal::getTraversal));
					case 5: return FunctionPtr(new FunctionImpl<FUTraversal(FUTraversal::*)() const>(&FUTraversal::clonePtr));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(FUTraversal::*)()>(&FUTraversal::clearPtr));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(FUTraversal::*)()>(&FUTraversal::destroyPtr));
					case 8: return FunctionPtr(new FunctionImpl<FUTraversal&(FUTraversal::*)()>(&FUTraversal::acquirePtr));
					case 9: return FunctionPtr(new FunctionImpl<FUTraversal&(FUTraversal::*)()>(&FUTraversal::unacquirePtr));
					case 10: return FunctionPtr(new FunctionImpl<bool(FUTraversal::*)() const>(&FUTraversal::isValidPtr));
					case 11: return FunctionPtr(new FunctionImpl<bool(FUTraversal::*)() const>(&FUTraversal::isOwnerPtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(FUTraversal::*)() const>(&FUTraversal::isConstPtr));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(FUTraversal::*)() const>(&FUTraversal::getCountPtr));
					case 14: return FunctionPtr(new FunctionImpl<const void*(FUTraversal::*)() const>(&FUTraversal::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1874, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 1875, 854 };
			static constexpr uint16_t function_names[] = { 962, 963, 1876, 1111, 1111, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 10, 1112, 1112, 1873, 1873, 1873, 1873, 1873, 1873, 1873, 1873, 1873, 1873 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 1, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 53, 274, 274 };
	};
	constexpr uint16_t ReflectionFUTraversal::constructor_bases[];
	constexpr uint16_t ReflectionFUTraversal::constructor_arg_types[];
	constexpr uint16_t ReflectionFUTraversal::constructor_arg_names[];
	constexpr uint16_t ReflectionFUTraversal::function_names[];
	constexpr uint16_t ReflectionFUTraversal::function_types[];
	constexpr uint16_t ReflectionFUTraversal::function_bases[];
	constexpr uint16_t ReflectionFUTraversal::function_arg_types[];
	constexpr uint16_t ReflectionFUTraversal::function_arg_names[];
	static ReflectionFUTraversal reflection_fu_traversal;
	
	// Tellusim::Surface
	class ReflectionSurface : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Surface::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Surface, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Surface, TypeList<Context&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<Surface, TypeList<Platform>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Surface>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Platform(Surface::*)() const>(&Surface::getPlatform));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Surface::*)() const>(&Surface::getPlatformName));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Surface::*)() const>(&Surface::getIndex));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(Surface::*)(uint32_t, uint32_t)>(&Surface::setSize));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(Surface::*)() const>(&Surface::getWidth));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(Surface::*)() const>(&Surface::getHeight));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(Surface::*)(uint32_t)>(&Surface::setMultisample));
					case 7: return FunctionPtr(new FunctionImpl<uint32_t(Surface::*)() const>(&Surface::getMultisample));
					case 8: return FunctionPtr(new FunctionImpl<bool(Surface::*)() const>(&Surface::hasMultisample));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(Surface::*)(uint32_t, uint32_t)>(&Surface::setColorLayer));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Surface::*)(uint32_t, uint32_t)>(&Surface::setDepthLayer));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(Surface::*)() const>(&Surface::getColorLayer));
					case 12: return FunctionPtr(new FunctionImpl<uint32_t(Surface::*)() const>(&Surface::getDepthLayer));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(Surface::*)() const>(&Surface::getColorLayers));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(Surface::*)() const>(&Surface::getDepthLayers));
					case 15: return FunctionPtr(new FunctionImpl<bool(Surface::*)() const>(&Surface::hasColorLayers));
					case 16: return FunctionPtr(new FunctionImpl<bool(Surface::*)() const>(&Surface::hasDepthLayers));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(Surface::*)(Format)>(&Surface::setColorFormat));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(Surface::*)(Format)>(&Surface::setDepthFormat));
					case 19: return FunctionPtr(new FunctionImpl<Format(Surface::*)() const>(&Surface::getColorFormat));
					case 20: return FunctionPtr(new FunctionImpl<Format(Surface::*)() const>(&Surface::getDepthFormat));
					case 21: return FunctionPtr(new FunctionImpl<Surface(Surface::*)() const>(&Surface::clonePtr));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(Surface::*)()>(&Surface::clearPtr));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(Surface::*)()>(&Surface::destroyPtr));
					case 24: return FunctionPtr(new FunctionImpl<Surface&(Surface::*)()>(&Surface::acquirePtr));
					case 25: return FunctionPtr(new FunctionImpl<Surface&(Surface::*)()>(&Surface::unacquirePtr));
					case 26: return FunctionPtr(new FunctionImpl<bool(Surface::*)() const>(&Surface::isValidPtr));
					case 27: return FunctionPtr(new FunctionImpl<bool(Surface::*)() const>(&Surface::isOwnerPtr));
					case 28: return FunctionPtr(new FunctionImpl<bool(Surface::*)() const>(&Surface::isConstPtr));
					case 29: return FunctionPtr(new FunctionImpl<uint32_t(Surface::*)() const>(&Surface::getCountPtr));
					case 30: return FunctionPtr(new FunctionImpl<const void*(Surface::*)() const>(&Surface::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 1539, 8 };
			static constexpr uint16_t constructor_arg_names[] = { 1182, 25 };
			static constexpr uint16_t function_names[] = { 7, 903, 460, 29, 11, 12, 1787, 13, 1380, 1878, 1880, 1881, 1882, 1883, 1884, 1885, 1886, 1826, 1833, 1494, 1495, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 8, 138, 10, 6, 10, 10, 6, 10, 21, 6, 6, 10, 10, 10, 10, 21, 21, 6, 6, 340, 340, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877, 1877 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 2, 2, 2, 3, 3, 3, 5, 7, 7, 7, 7, 7, 7, 7, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10, 10, 10, 10, 10, 340, 340 };
			static constexpr uint16_t function_arg_names[] = { 30, 31, 32, 1879, 342, 1879, 342, 96, 96 };
	};
	constexpr uint16_t ReflectionSurface::constructor_bases[];
	constexpr uint16_t ReflectionSurface::constructor_arg_types[];
	constexpr uint16_t ReflectionSurface::constructor_arg_names[];
	constexpr uint16_t ReflectionSurface::function_names[];
	constexpr uint16_t ReflectionSurface::function_types[];
	constexpr uint16_t ReflectionSurface::function_bases[];
	constexpr uint16_t ReflectionSurface::function_arg_types[];
	constexpr uint16_t ReflectionSurface::function_arg_names[];
	static ReflectionSurface reflection_surface;
	
	// Tellusim::D3D12Surface
	class ReflectionD3D12Surface : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D12Surface::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_surface;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D12Surface, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<D3D12Surface, TypeList<D3D12Context&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D12Surface>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<IDXGIFactory4*(D3D12Surface::*)() const>(&D3D12Surface::getFactory));
					case 1: return FunctionPtr(new FunctionImpl<ID3D12Device*(D3D12Surface::*)() const>(&D3D12Surface::getDevice));
					case 2: return FunctionPtr(new FunctionImpl<ID3D12CommandQueue*(D3D12Surface::*)() const>(&D3D12Surface::getQueue));
					case 3: return FunctionPtr(new FunctionImpl<ID3D12GraphicsCommandList*(D3D12Surface::*)() const>(&D3D12Surface::getCommand));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(D3D12Surface::*)(IDXGISwapChain*)>(&D3D12Surface::setSwapChain));
					case 5: return FunctionPtr(new FunctionImpl<IDXGISwapChain*(D3D12Surface::*)() const>(&D3D12Surface::getSwapChain));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(D3D12Surface::*)(ID3D12Resource*)>(&D3D12Surface::setRenderTarget));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(D3D12Surface::*)(ID3D12Resource*)>(&D3D12Surface::setDepthStencil));
					case 8: return FunctionPtr(new FunctionImpl<ID3D12Resource*(D3D12Surface::*)() const>(&D3D12Surface::getRenderTarget));
					case 9: return FunctionPtr(new FunctionImpl<ID3D12Resource*(D3D12Surface::*)() const>(&D3D12Surface::getDepthStencil));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(D3D12Surface::*)(size_t)>(&D3D12Surface::setRenderTargetView));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(D3D12Surface::*)(size_t)>(&D3D12Surface::setDepthStencilView));
					case 12: return FunctionPtr(new FunctionImpl<size_t(D3D12Surface::*)() const>(&D3D12Surface::getRenderTargetView));
					case 13: return FunctionPtr(new FunctionImpl<size_t(D3D12Surface::*)() const>(&D3D12Surface::getDepthStencilView));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Surface::*)() const>(&D3D12Surface::getColorDXGIFormat));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Surface::*)() const>(&D3D12Surface::getDepthDXGIFormat));
					case 16: return FunctionPtr(new FunctionImpl<D3D12Surface(D3D12Surface::*)() const>(&D3D12Surface::clonePtr));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(D3D12Surface::*)()>(&D3D12Surface::clearPtr));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(D3D12Surface::*)()>(&D3D12Surface::destroyPtr));
					case 19: return FunctionPtr(new FunctionImpl<D3D12Surface&(D3D12Surface::*)()>(&D3D12Surface::acquirePtr));
					case 20: return FunctionPtr(new FunctionImpl<D3D12Surface&(D3D12Surface::*)()>(&D3D12Surface::unacquirePtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(D3D12Surface::*)() const>(&D3D12Surface::isValidPtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(D3D12Surface::*)() const>(&D3D12Surface::isOwnerPtr));
					case 23: return FunctionPtr(new FunctionImpl<bool(D3D12Surface::*)() const>(&D3D12Surface::isConstPtr));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(D3D12Surface::*)() const>(&D3D12Surface::getCountPtr));
					case 25: return FunctionPtr(new FunctionImpl<const void*(D3D12Surface::*)() const>(&D3D12Surface::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1 };
			static constexpr uint16_t constructor_arg_types[] = { 1888 };
			static constexpr uint16_t constructor_arg_names[] = { 1182 };
			static constexpr uint16_t function_names[] = { 1138, 9, 1141, 1101, 1889, 1892, 1894, 1896, 1898, 1899, 1900, 1902, 1391, 1392, 1904, 1905, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1139, 1140, 1142, 1082, 6, 1893, 6, 6, 918, 918, 6, 6, 74, 74, 10, 10, 1887, 1887, 1887, 1887, 1887, 1887, 1887, 1887, 1887, 1887 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };
			static constexpr uint16_t function_arg_types[] = { 1890, 914, 914, 74, 74 };
			static constexpr uint16_t function_arg_names[] = { 1891, 1895, 1897, 1901, 1903 };
	};
	constexpr uint16_t ReflectionD3D12Surface::constructor_bases[];
	constexpr uint16_t ReflectionD3D12Surface::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D12Surface::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D12Surface::function_names[];
	constexpr uint16_t ReflectionD3D12Surface::function_types[];
	constexpr uint16_t ReflectionD3D12Surface::function_bases[];
	constexpr uint16_t ReflectionD3D12Surface::function_arg_types[];
	constexpr uint16_t ReflectionD3D12Surface::function_arg_names[];
	static ReflectionD3D12Surface reflection_d3d12_surface;
	
	// Tellusim::D3D11Surface
	class ReflectionD3D11Surface : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return D3D11Surface::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_surface;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<D3D11Surface, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<D3D11Surface, TypeList<D3D11Context&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<D3D11Surface>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<IDXGIFactory*(D3D11Surface::*)() const>(&D3D11Surface::getFactory));
					case 1: return FunctionPtr(new FunctionImpl<ID3D11Device*(D3D11Surface::*)() const>(&D3D11Surface::getDevice));
					case 2: return FunctionPtr(new FunctionImpl<ID3D11DeviceContext*(D3D11Surface::*)() const>(&D3D11Surface::getContext));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(D3D11Surface::*)(IDXGISwapChain*)>(&D3D11Surface::setSwapChain));
					case 4: return FunctionPtr(new FunctionImpl<IDXGISwapChain*(D3D11Surface::*)() const>(&D3D11Surface::getSwapChain));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(D3D11Surface::*)(ID3D11Texture2D*)>(&D3D11Surface::setRenderTarget));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(D3D11Surface::*)(ID3D11Texture2D*)>(&D3D11Surface::setDepthStencil));
					case 7: return FunctionPtr(new FunctionImpl<ID3D11Texture2D*(D3D11Surface::*)() const>(&D3D11Surface::getRenderTarget));
					case 8: return FunctionPtr(new FunctionImpl<ID3D11Texture2D*(D3D11Surface::*)() const>(&D3D11Surface::getDepthStencil));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(D3D11Surface::*)(ID3D11RenderTargetView*)>(&D3D11Surface::setRenderTargetView));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(D3D11Surface::*)(ID3D11DepthStencilView*)>(&D3D11Surface::setDepthStencilView));
					case 11: return FunctionPtr(new FunctionImpl<ID3D11RenderTargetView*(D3D11Surface::*)() const>(&D3D11Surface::getRenderTargetView));
					case 12: return FunctionPtr(new FunctionImpl<ID3D11DepthStencilView*(D3D11Surface::*)() const>(&D3D11Surface::getDepthStencilView));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Surface::*)() const>(&D3D11Surface::getColorDXGIFormat));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Surface::*)() const>(&D3D11Surface::getDepthDXGIFormat));
					case 15: return FunctionPtr(new FunctionImpl<D3D11Surface(D3D11Surface::*)() const>(&D3D11Surface::clonePtr));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(D3D11Surface::*)()>(&D3D11Surface::clearPtr));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(D3D11Surface::*)()>(&D3D11Surface::destroyPtr));
					case 18: return FunctionPtr(new FunctionImpl<D3D11Surface&(D3D11Surface::*)()>(&D3D11Surface::acquirePtr));
					case 19: return FunctionPtr(new FunctionImpl<D3D11Surface&(D3D11Surface::*)()>(&D3D11Surface::unacquirePtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(D3D11Surface::*)() const>(&D3D11Surface::isValidPtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(D3D11Surface::*)() const>(&D3D11Surface::isOwnerPtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(D3D11Surface::*)() const>(&D3D11Surface::isConstPtr));
					case 23: return FunctionPtr(new FunctionImpl<uint32_t(D3D11Surface::*)() const>(&D3D11Surface::getCountPtr));
					case 24: return FunctionPtr(new FunctionImpl<const void*(D3D11Surface::*)() const>(&D3D11Surface::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1 };
			static constexpr uint16_t constructor_arg_types[] = { 1907 };
			static constexpr uint16_t constructor_arg_names[] = { 1182 };
			static constexpr uint16_t function_names[] = { 1138, 9, 1908, 1889, 1892, 1894, 1896, 1898, 1899, 1900, 1902, 1391, 1392, 1904, 1905, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1147, 1148, 1150, 6, 1893, 6, 6, 1398, 1398, 6, 6, 1399, 1400, 10, 10, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906, 1906 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };
			static constexpr uint16_t function_arg_types[] = { 1890, 1396, 1396, 1909, 1910 };
			static constexpr uint16_t function_arg_names[] = { 1891, 1895, 1897, 1901, 1903 };
	};
	constexpr uint16_t ReflectionD3D11Surface::constructor_bases[];
	constexpr uint16_t ReflectionD3D11Surface::constructor_arg_types[];
	constexpr uint16_t ReflectionD3D11Surface::constructor_arg_names[];
	constexpr uint16_t ReflectionD3D11Surface::function_names[];
	constexpr uint16_t ReflectionD3D11Surface::function_types[];
	constexpr uint16_t ReflectionD3D11Surface::function_bases[];
	constexpr uint16_t ReflectionD3D11Surface::function_arg_types[];
	constexpr uint16_t ReflectionD3D11Surface::function_arg_names[];
	static ReflectionD3D11Surface reflection_d3d11_surface;
	
	// Tellusim::MTLSurface
	class ReflectionMTLSurface : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MTLSurface::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_surface;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MTLSurface, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<MTLSurface, TypeList<MTLContext&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MTLSurface>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(MTLSurface::*)() const>(&MTLSurface::getDevice));
					case 1: return FunctionPtr(new FunctionVoidImpl<void*(MTLSurface::*)() const>(&MTLSurface::getQueue));
					case 2: return FunctionPtr(new FunctionVoidImpl<void*(MTLSurface::*)() const>(&MTLSurface::getCommand));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(MTLSurface::*)(void*)>(&MTLSurface::setDescriptor));
					case 4: return FunctionPtr(new FunctionVoidImpl<void*(MTLSurface::*)() const>(&MTLSurface::getDescriptor));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(MTLSurface::*)() const>(&MTLSurface::getColorPixelFormat));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(MTLSurface::*)() const>(&MTLSurface::getDepthPixelFormat));
					case 7: return FunctionPtr(new FunctionImpl<MTLSurface(MTLSurface::*)() const>(&MTLSurface::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(MTLSurface::*)()>(&MTLSurface::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(MTLSurface::*)()>(&MTLSurface::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<MTLSurface&(MTLSurface::*)()>(&MTLSurface::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<MTLSurface&(MTLSurface::*)()>(&MTLSurface::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(MTLSurface::*)() const>(&MTLSurface::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(MTLSurface::*)() const>(&MTLSurface::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(MTLSurface::*)() const>(&MTLSurface::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(MTLSurface::*)() const>(&MTLSurface::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(MTLSurface::*)() const>(&MTLSurface::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1 };
			static constexpr uint16_t constructor_arg_types[] = { 1912 };
			static constexpr uint16_t constructor_arg_names[] = { 1182 };
			static constexpr uint16_t function_names[] = { 9, 1141, 1101, 1913, 1526, 1914, 1915, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 6, 6, 10, 10, 1911, 1911, 1911, 1911, 1911, 1911, 1911, 1911, 1911, 1911 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
			static constexpr uint16_t function_arg_types[] = { 85 };
			static constexpr uint16_t function_arg_names[] = { 1153 };
	};
	constexpr uint16_t ReflectionMTLSurface::constructor_bases[];
	constexpr uint16_t ReflectionMTLSurface::constructor_arg_types[];
	constexpr uint16_t ReflectionMTLSurface::constructor_arg_names[];
	constexpr uint16_t ReflectionMTLSurface::function_names[];
	constexpr uint16_t ReflectionMTLSurface::function_types[];
	constexpr uint16_t ReflectionMTLSurface::function_bases[];
	constexpr uint16_t ReflectionMTLSurface::function_arg_types[];
	constexpr uint16_t ReflectionMTLSurface::function_arg_names[];
	static ReflectionMTLSurface reflection_mtl_surface;
	
	// Tellusim::VKSurface
	class ReflectionVKSurface : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return VKSurface::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_surface;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<VKSurface, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<VKSurface, TypeList<VKContext&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<VKSurface>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<VkInstance(VKSurface::*)() const>(&VKSurface::getInstance));
					case 1: return FunctionPtr(new FunctionImpl<VkPhysicalDevice(VKSurface::*)() const>(&VKSurface::getAdapter));
					case 2: return FunctionPtr(new FunctionImpl<VkDevice(VKSurface::*)() const>(&VKSurface::getDevice));
					case 3: return FunctionPtr(new FunctionImpl<VkQueue(VKSurface::*)() const>(&VKSurface::getQueue));
					case 4: return FunctionPtr(new FunctionImpl<VkCommandBuffer(VKSurface::*)() const>(&VKSurface::getCommand));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(VKSurface::*)() const>(&VKSurface::getFamily));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(VKSurface::*)(VkImage)>(&VKSurface::setColorImage));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(VKSurface::*)(VkImage)>(&VKSurface::setDepthImage));
					case 8: return FunctionPtr(new FunctionImpl<VkImage(VKSurface::*)() const>(&VKSurface::getColorImage));
					case 9: return FunctionPtr(new FunctionImpl<VkImage(VKSurface::*)() const>(&VKSurface::getDepthImage));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(VKSurface::*)(VkImageView)>(&VKSurface::setColorImageView));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(VKSurface::*)(VkImageView)>(&VKSurface::setDepthImageView));
					case 12: return FunctionPtr(new FunctionImpl<VkImageView(VKSurface::*)() const>(&VKSurface::getColorImageView));
					case 13: return FunctionPtr(new FunctionImpl<VkImageView(VKSurface::*)() const>(&VKSurface::getDepthImageView));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(VKSurface::*)(VkRenderPass)>(&VKSurface::setRenderPass));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(VKSurface::*)(VkFramebuffer)>(&VKSurface::setFramebuffer));
					case 16: return FunctionPtr(new FunctionImpl<VkRenderPass(VKSurface::*)() const>(&VKSurface::getRenderPass));
					case 17: return FunctionPtr(new FunctionImpl<VkFramebuffer(VKSurface::*)() const>(&VKSurface::getFramebuffer));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(VKSurface::*)() const>(&VKSurface::getColorPixelFormat));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(VKSurface::*)() const>(&VKSurface::getDepthPixelFormat));
					case 20: return FunctionPtr(new FunctionImpl<VKSurface(VKSurface::*)() const>(&VKSurface::clonePtr));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(VKSurface::*)()>(&VKSurface::clearPtr));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(VKSurface::*)()>(&VKSurface::destroyPtr));
					case 23: return FunctionPtr(new FunctionImpl<VKSurface&(VKSurface::*)()>(&VKSurface::acquirePtr));
					case 24: return FunctionPtr(new FunctionImpl<VKSurface&(VKSurface::*)()>(&VKSurface::unacquirePtr));
					case 25: return FunctionPtr(new FunctionImpl<bool(VKSurface::*)() const>(&VKSurface::isValidPtr));
					case 26: return FunctionPtr(new FunctionImpl<bool(VKSurface::*)() const>(&VKSurface::isOwnerPtr));
					case 27: return FunctionPtr(new FunctionImpl<bool(VKSurface::*)() const>(&VKSurface::isConstPtr));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(VKSurface::*)() const>(&VKSurface::getCountPtr));
					case 29: return FunctionPtr(new FunctionImpl<const void*(VKSurface::*)() const>(&VKSurface::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1 };
			static constexpr uint16_t constructor_arg_types[] = { 1917 };
			static constexpr uint16_t constructor_arg_names[] = { 1182 };
			static constexpr uint16_t function_names[] = { 1167, 1168, 9, 1141, 1101, 1170, 1918, 1919, 1920, 1921, 1922, 1924, 1925, 1926, 1927, 1929, 1528, 1530, 1914, 1915, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1159, 1163, 1165, 1169, 1090, 10, 6, 6, 1406, 1406, 6, 6, 1410, 1410, 6, 6, 1529, 1531, 10, 10, 1916, 1916, 1916, 1916, 1916, 1916, 1916, 1916, 1916, 1916 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 1, 2, 2, 2, 3, 4, 4, 4, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6 };
			static constexpr uint16_t function_arg_types[] = { 1406, 1406, 1410, 1410, 1529, 1531 };
			static constexpr uint16_t function_arg_names[] = { 450, 450, 1923, 1923, 1928, 1930 };
	};
	constexpr uint16_t ReflectionVKSurface::constructor_bases[];
	constexpr uint16_t ReflectionVKSurface::constructor_arg_types[];
	constexpr uint16_t ReflectionVKSurface::constructor_arg_names[];
	constexpr uint16_t ReflectionVKSurface::function_names[];
	constexpr uint16_t ReflectionVKSurface::function_types[];
	constexpr uint16_t ReflectionVKSurface::function_bases[];
	constexpr uint16_t ReflectionVKSurface::function_arg_types[];
	constexpr uint16_t ReflectionVKSurface::function_arg_names[];
	static ReflectionVKSurface reflection_vk_surface;
	
	// Tellusim::GLSurface
	class ReflectionGLSurface : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLSurface::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_surface;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLSurface, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<GLSurface, TypeList<GLContext&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLSurface>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(GLSurface::*)() const>(&GLSurface::getContext));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(GLSurface::*)(uint32_t)>(&GLSurface::setColorTextureID));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(GLSurface::*)(uint32_t)>(&GLSurface::setDepthTextureID));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(GLSurface::*)() const>(&GLSurface::getColorTextureID));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(GLSurface::*)() const>(&GLSurface::getDepthTextureID));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(GLSurface::*)(uint32_t)>(&GLSurface::setFramebufferID));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(GLSurface::*)() const>(&GLSurface::getFramebufferID));
					case 7: return FunctionPtr(new FunctionImpl<uint32_t(GLSurface::*)() const>(&GLSurface::getColorInternalFormat));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(GLSurface::*)() const>(&GLSurface::getDepthInternalFormat));
					case 9: return FunctionPtr(new FunctionImpl<GLSurface(GLSurface::*)() const>(&GLSurface::clonePtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(GLSurface::*)()>(&GLSurface::clearPtr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(GLSurface::*)()>(&GLSurface::destroyPtr));
					case 12: return FunctionPtr(new FunctionImpl<GLSurface&(GLSurface::*)()>(&GLSurface::acquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<GLSurface&(GLSurface::*)()>(&GLSurface::unacquirePtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(GLSurface::*)() const>(&GLSurface::isValidPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(GLSurface::*)() const>(&GLSurface::isOwnerPtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(GLSurface::*)() const>(&GLSurface::isConstPtr));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(GLSurface::*)() const>(&GLSurface::getCountPtr));
					case 18: return FunctionPtr(new FunctionImpl<const void*(GLSurface::*)() const>(&GLSurface::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1 };
			static constexpr uint16_t constructor_arg_types[] = { 1932 };
			static constexpr uint16_t constructor_arg_names[] = { 1182 };
			static constexpr uint16_t function_names[] = { 1908, 1933, 1934, 1935, 1936, 1937, 1533, 1939, 1940, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 10, 10, 6, 10, 10, 10, 1931, 1931, 1931, 1931, 1931, 1931, 1931, 1931, 1931, 1931 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 1416, 1416, 1938 };
	};
	constexpr uint16_t ReflectionGLSurface::constructor_bases[];
	constexpr uint16_t ReflectionGLSurface::constructor_arg_types[];
	constexpr uint16_t ReflectionGLSurface::constructor_arg_names[];
	constexpr uint16_t ReflectionGLSurface::function_names[];
	constexpr uint16_t ReflectionGLSurface::function_types[];
	constexpr uint16_t ReflectionGLSurface::function_bases[];
	constexpr uint16_t ReflectionGLSurface::function_arg_types[];
	constexpr uint16_t ReflectionGLSurface::function_arg_names[];
	static ReflectionGLSurface reflection_gl_surface;
	
	// Tellusim::GLESSurface
	class ReflectionGLESSurface : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return GLESSurface::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_surface;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<GLESSurface, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<GLESSurface, TypeList<GLESContext&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<GLESSurface>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void*(GLESSurface::*)() const>(&GLESSurface::getContext));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(GLESSurface::*)(uint32_t)>(&GLESSurface::setColorTextureID));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(GLESSurface::*)(uint32_t)>(&GLESSurface::setDepthTextureID));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(GLESSurface::*)() const>(&GLESSurface::getColorTextureID));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(GLESSurface::*)() const>(&GLESSurface::getDepthTextureID));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(GLESSurface::*)(uint32_t)>(&GLESSurface::setFramebufferID));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(GLESSurface::*)() const>(&GLESSurface::getFramebufferID));
					case 7: return FunctionPtr(new FunctionImpl<uint32_t(GLESSurface::*)() const>(&GLESSurface::getColorInternalFormat));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(GLESSurface::*)() const>(&GLESSurface::getDepthInternalFormat));
					case 9: return FunctionPtr(new FunctionImpl<GLESSurface(GLESSurface::*)() const>(&GLESSurface::clonePtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(GLESSurface::*)()>(&GLESSurface::clearPtr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(GLESSurface::*)()>(&GLESSurface::destroyPtr));
					case 12: return FunctionPtr(new FunctionImpl<GLESSurface&(GLESSurface::*)()>(&GLESSurface::acquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<GLESSurface&(GLESSurface::*)()>(&GLESSurface::unacquirePtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(GLESSurface::*)() const>(&GLESSurface::isValidPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(GLESSurface::*)() const>(&GLESSurface::isOwnerPtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(GLESSurface::*)() const>(&GLESSurface::isConstPtr));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(GLESSurface::*)() const>(&GLESSurface::getCountPtr));
					case 18: return FunctionPtr(new FunctionImpl<const void*(GLESSurface::*)() const>(&GLESSurface::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1 };
			static constexpr uint16_t constructor_arg_types[] = { 1942 };
			static constexpr uint16_t constructor_arg_names[] = { 1182 };
			static constexpr uint16_t function_names[] = { 1908, 1933, 1934, 1935, 1936, 1937, 1533, 1939, 1940, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 10, 10, 6, 10, 10, 10, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941, 1941 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 1416, 1416, 1938 };
	};
	constexpr uint16_t ReflectionGLESSurface::constructor_bases[];
	constexpr uint16_t ReflectionGLESSurface::constructor_arg_types[];
	constexpr uint16_t ReflectionGLESSurface::constructor_arg_names[];
	constexpr uint16_t ReflectionGLESSurface::function_names[];
	constexpr uint16_t ReflectionGLESSurface::function_types[];
	constexpr uint16_t ReflectionGLESSurface::function_bases[];
	constexpr uint16_t ReflectionGLESSurface::function_arg_types[];
	constexpr uint16_t ReflectionGLESSurface::function_arg_names[];
	static ReflectionGLESSurface reflection_gles_surface;
	
	// Tellusim::Window
	class ReflectionWindow : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Window::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Window, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Window, TypeList<Platform, uint32_t>>((Platform)0, Maxu32));
					case 2: return ConstructorPtr(new ConstructorImpl<Window, TypeList<Surface&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Window>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<uint32_t()>(&Window::getNumWindows));
					case 1: return FunctionPtr(new FunctionImpl<Window(uint32_t)>(&Window::getWindow));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(bool)>(&Window::update, false));
					case 3: return FunctionPtr(new FunctionImpl<Platform(Window::*)() const>(&Window::getPlatform));
					case 4: return FunctionPtr(new FunctionImpl<const char*(Window::*)() const>(&Window::getPlatformName));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)() const>(&Window::getIndex));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(Surface&)>(&Window::setSurface));
					case 7: return FunctionPtr(new FunctionImpl<Surface(Window::*)() const>(&Window::getSurface));
					case 8: return FunctionPtr(new FunctionVoidImpl<void*(Window::*)() const>(&Window::getHandle));
					case 9: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isCreated));
					case 10: return FunctionPtr(new FunctionImpl<bool(Window::*)(const char*, Window::Flags)>(&Window::create, {}, Window::DefaultFlags));
					case 11: return FunctionPtr(new FunctionImpl<bool(Window::*)(const String&, Window::Flags)>(&Window::create, {}, Window::DefaultFlags));
					case 12: return FunctionPtr(new FunctionImpl<bool(Window::*)(Window::Flags)>(&Window::create, Window::DefaultFlags));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(Window::*)()>(&Window::release));
					case 14: return FunctionPtr(new FunctionImpl<bool(Window::*)(const Color&)>(&Window::clear));
					case 15: return FunctionPtr(new FunctionImpl<bool(Window::*)(Image&) const>(&Window::grab));
					case 16: return FunctionPtr(new FunctionImpl<bool(Window::*)()>(&Window::render));
					case 17: return FunctionPtr(new FunctionImpl<bool(Window::*)()>(&Window::present));
					case 18: return FunctionPtr(new FunctionImpl<bool(Window::*)()>(&Window::finish));
					case 19: return FunctionPtr(new FunctionImpl<Format(Window::*)() const>(&Window::getColorFormat));
					case 20: return FunctionPtr(new FunctionImpl<Format(Window::*)() const>(&Window::getDepthFormat));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)() const>(&Window::getMultisample));
					case 22: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::hasMultisample));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(Window::Flags)>(&Window::setFlags));
					case 24: return FunctionPtr(new FunctionImpl<Window::Flags(Window::*)() const>(&Window::getFlags));
					case 25: return FunctionPtr(new FunctionImpl<bool(Window::*)(Window::Flags) const>(&Window::hasFlag));
					case 26: return FunctionPtr(new FunctionImpl<bool(Window::*)(Window::Flags) const>(&Window::hasFlags));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(uint32_t)>(&Window::setRefreshRate));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)() const>(&Window::getRefreshRate));
					case 29: return FunctionPtr(new FunctionImpl<bool(Window::*)(bool)>(&Window::setHidden));
					case 30: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isHidden));
					case 31: return FunctionPtr(new FunctionImpl<bool(Window::*)(bool)>(&Window::setFocused));
					case 32: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isFocused));
					case 33: return FunctionPtr(new FunctionImpl<bool(Window::*)(bool)>(&Window::setMinimized));
					case 34: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isMinimized));
					case 35: return FunctionPtr(new FunctionImpl<bool(Window::*)(bool)>(&Window::setFullscreen));
					case 36: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isFullscreen));
					case 37: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isOccluded));
					case 38: return FunctionPtr(new FunctionImpl<bool(Window::*)(const char*)>(&Window::setTitle));
					case 39: return FunctionPtr(new FunctionImpl<bool(Window::*)(const String&)>(&Window::setTitle));
					case 40: return FunctionPtr(new FunctionImpl<String(Window::*)() const>(&Window::getTitle));
					case 41: return FunctionPtr(new FunctionImpl<bool(Window::*)(const Image&)>(&Window::setIcon));
					case 42: return FunctionPtr(new FunctionImpl<Image(Window::*)() const>(&Window::getIcon));
					case 43: return FunctionPtr(new FunctionImpl<bool(Window::*)(int32_t, int32_t, uint32_t, uint32_t, bool)>(&Window::setGeometry, {}, {}, {}, {}, false));
					case 44: return FunctionPtr(new FunctionImpl<bool(Window::*)(int32_t, int32_t, bool)>(&Window::setPosition, {}, {}, false));
					case 45: return FunctionPtr(new FunctionImpl<int32_t(Window::*)(bool) const>(&Window::getPositionX, false));
					case 46: return FunctionPtr(new FunctionImpl<int32_t(Window::*)(bool) const>(&Window::getPositionY, false));
					case 47: return FunctionPtr(new FunctionImpl<bool(Window::*)(uint32_t, uint32_t, bool)>(&Window::setSize, {}, {}, false));
					case 48: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)() const>(&Window::getWidth));
					case 49: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)() const>(&Window::getHeight));
					case 50: return FunctionPtr(new FunctionImpl<float32_t(Window::*)() const>(&Window::getScale));
					case 51: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)() const>(&Window::getDpiX));
					case 52: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)() const>(&Window::getDpiY));
					case 53: return FunctionPtr(new FunctionImpl<bool(Window::*)(int32_t, int32_t, bool)>(&Window::setMouse, {}, {}, false));
					case 54: return FunctionPtr(new FunctionImpl<int32_t(Window::*)() const>(&Window::getMouseX));
					case 55: return FunctionPtr(new FunctionImpl<int32_t(Window::*)() const>(&Window::getMouseY));
					case 56: return FunctionPtr(new FunctionImpl<bool(Window::*)(int32_t, int32_t)>(&Window::setMouseDelta));
					case 57: return FunctionPtr(new FunctionImpl<int32_t(Window::*)() const>(&Window::getMouseDX));
					case 58: return FunctionPtr(new FunctionImpl<int32_t(Window::*)() const>(&Window::getMouseDY));
					case 59: return FunctionPtr(new FunctionImpl<bool(Window::*)(bool, bool)>(&Window::setMouseHidden, {}, false));
					case 60: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isMouseHidden));
					case 61: return FunctionPtr(new FunctionImpl<bool(Window::*)(bool, bool)>(&Window::setMouseClipped, {}, false));
					case 62: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isMouseClipped));
					case 63: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isMouseInside));
					case 64: return FunctionPtr(new FunctionImpl<bool(Window::*)(Window::Cursor, bool)>(&Window::setMouseCursor, (Window::Cursor)0, false));
					case 65: return FunctionPtr(new FunctionImpl<Window::Cursor(Window::*)() const>(&Window::getMouseCursor));
					case 66: return FunctionPtr(new FunctionImpl<bool(Window::*)(Window::Button)>(&Window::setMouseButtons));
					case 67: return FunctionPtr(new FunctionImpl<Window::Button(Window::*)() const>(&Window::getMouseButtons));
					case 68: return FunctionPtr(new FunctionImpl<bool(Window::*)(Window::Button, bool)>(&Window::setMouseButton));
					case 69: return FunctionPtr(new FunctionImpl<bool(Window::*)(Window::Button, bool) const>(&Window::getMouseButton, (Window::Button)0, false));
					case 70: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(Window::Button)>(&Window::releaseMouseButtons));
					case 71: return FunctionPtr(new FunctionImpl<Window::Button(Window::*)()>(&Window::clearMouseButtons));
					case 72: return FunctionPtr(new FunctionImpl<bool(Window::*)(Window::Axis, float32_t)>(&Window::setMouseAxis));
					case 73: return FunctionPtr(new FunctionImpl<float32_t(Window::*)(Window::Axis) const>(&Window::getMouseAxis));
					case 74: return FunctionPtr(new FunctionImpl<float32_t(Window::*)(Window::Axis)>(&Window::clearMouseAxis));
					case 75: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::MousePressedCallback&)>(&Window::setMousePressedCallback));
					case 76: return FunctionPtr(new FunctionImpl<Window::MousePressedCallback(Window::*)() const>(&Window::getMousePressedCallback));
					case 77: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::MouseReleasedCallback&)>(&Window::setMouseReleasedCallback));
					case 78: return FunctionPtr(new FunctionImpl<Window::MouseReleasedCallback(Window::*)() const>(&Window::getMouseReleasedCallback));
					case 79: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::MouseChangedCallback&)>(&Window::setMouseChangedCallback));
					case 80: return FunctionPtr(new FunctionImpl<Window::MouseChangedCallback(Window::*)() const>(&Window::getMouseChangedCallback));
					case 81: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::MouseRotatedCallback&)>(&Window::setMouseRotatedCallback));
					case 82: return FunctionPtr(new FunctionImpl<Window::MouseRotatedCallback(Window::*)() const>(&Window::getMouseRotatedCallback));
					case 83: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)() const>(&Window::getNumTouches));
					case 84: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)(int32_t, int32_t)>(&Window::addTouch));
					case 85: return FunctionPtr(new FunctionImpl<int32_t(Window::*)(uint32_t) const>(&Window::getTouchX));
					case 86: return FunctionPtr(new FunctionImpl<int32_t(Window::*)(uint32_t) const>(&Window::getTouchY));
					case 87: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)(int32_t, int32_t) const>(&Window::findTouch));
					case 88: return FunctionPtr(new FunctionVoidImpl<void(Window::*)()>(&Window::clearTouches));
					case 89: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::TouchChangedCallback&)>(&Window::setTouchChangedCallback));
					case 90: return FunctionPtr(new FunctionImpl<Window::TouchChangedCallback(Window::*)() const>(&Window::getTouchChangedCallback));
					case 91: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(uint32_t, bool)>(&Window::setKeyboardKey));
					case 92: return FunctionPtr(new FunctionImpl<bool(Window::*)(uint32_t, bool) const>(&Window::getKeyboardKey, {}, false));
					case 93: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::KeyboardPressedCallback&)>(&Window::setKeyboardPressedCallback));
					case 94: return FunctionPtr(new FunctionImpl<Window::KeyboardPressedCallback(Window::*)() const>(&Window::getKeyboardPressedCallback));
					case 95: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::KeyboardReleasedCallback&)>(&Window::setKeyboardReleasedCallback));
					case 96: return FunctionPtr(new FunctionImpl<Window::KeyboardReleasedCallback(Window::*)() const>(&Window::getKeyboardReleasedCallback));
					case 97: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::SizeChangedCallback&)>(&Window::setSizeChangedCallback));
					case 98: return FunctionPtr(new FunctionImpl<Window::SizeChangedCallback(Window::*)() const>(&Window::getSizeChangedCallback));
					case 99: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::FocusChangedCallback&)>(&Window::setFocusChangedCallback));
					case 100: return FunctionPtr(new FunctionImpl<Window::FocusChangedCallback(Window::*)() const>(&Window::getFocusChangedCallback));
					case 101: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::CloseClickedCallback&)>(&Window::setCloseClickedCallback));
					case 102: return FunctionPtr(new FunctionImpl<Window::CloseClickedCallback(Window::*)() const>(&Window::getCloseClickedCallback));
					case 103: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::PauseChangedCallback&)>(&Window::setPauseChangedCallback));
					case 104: return FunctionPtr(new FunctionImpl<Window::PauseChangedCallback(Window::*)() const>(&Window::getPauseChangedCallback));
					case 105: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::FileDroppedCallback&)>(&Window::setFileDroppedCallback));
					case 106: return FunctionPtr(new FunctionImpl<Window::FileDroppedCallback(Window::*)() const>(&Window::getFileDroppedCallback));
					case 107: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::UpdateCallback&)>(&Window::setUpdateCallback));
					case 108: return FunctionPtr(new FunctionImpl<Window::UpdateCallback(Window::*)() const>(&Window::getUpdateCallback));
					case 109: return FunctionPtr(new FunctionVoidImpl<void(Window::*)(const Window::PresentCallback&)>(&Window::setPresentCallback));
					case 110: return FunctionPtr(new FunctionImpl<Window::PresentCallback(Window::*)() const>(&Window::getPresentCallback));
					case 111: return FunctionPtr(new FunctionImpl<Window::MainLoopCallback(Window::*)() const>(&Window::getMainLoopCallback));
					case 112: return FunctionPtr(new FunctionImpl<bool(Window::*)(const Window::MainLoopCallback&)>(&Window::run));
					case 113: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isRunning));
					case 114: return FunctionPtr(new FunctionVoidImpl<void(Window::*)()>(&Window::stop));
					case 115: return FunctionPtr(new FunctionImpl<bool(Window::*)(const char*)>(&Window::setCopyText));
					case 116: return FunctionPtr(new FunctionImpl<bool(Window::*)(const String&)>(&Window::setCopyText));
					case 117: return FunctionPtr(new FunctionImpl<String(Window::*)() const>(&Window::getPasteText));
					case 118: return FunctionPtr(new FunctionImpl<Window(Window::*)() const>(&Window::clonePtr));
					case 119: return FunctionPtr(new FunctionVoidImpl<void(Window::*)()>(&Window::clearPtr));
					case 120: return FunctionPtr(new FunctionVoidImpl<void(Window::*)()>(&Window::destroyPtr));
					case 121: return FunctionPtr(new FunctionImpl<Window&(Window::*)()>(&Window::acquirePtr));
					case 122: return FunctionPtr(new FunctionImpl<Window&(Window::*)()>(&Window::unacquirePtr));
					case 123: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isValidPtr));
					case 124: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isOwnerPtr));
					case 125: return FunctionPtr(new FunctionImpl<bool(Window::*)() const>(&Window::isConstPtr));
					case 126: return FunctionPtr(new FunctionImpl<uint32_t(Window::*)() const>(&Window::getCountPtr));
					case 127: return FunctionPtr(new FunctionImpl<const void*(Window::*)() const>(&Window::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 8, 10, 1491 };
			static constexpr uint16_t constructor_arg_names[] = { 25, 274, 1492 };
			static constexpr uint16_t function_names[] = { 1944, 1945, 1083, 7, 903, 460, 1946, 1947, 1948, 904, 24, 24, 24, 171, 5, 1951, 1952, 1953, 1133, 1494, 1495, 13, 1380, 1298, 906, 907, 908, 1954, 1955, 1956, 1958, 1959, 1961, 1962, 1964, 1965, 1967, 1968, 1969, 1969, 1970, 1971, 1972, 544, 1975, 1976, 1977, 29, 11, 12, 761, 1978, 1979, 1980, 1981, 1982, 1983, 1986, 1987, 1988, 1989, 1990, 1992, 1993, 1994, 1997, 1999, 2002, 2004, 2006, 2007, 2008, 2009, 2012, 2013, 2014, 2016, 2018, 2020, 2022, 2024, 2026, 2028, 2030, 2031, 2032, 2034, 2035, 2036, 2037, 2039, 2041, 2043, 2044, 2046, 2048, 2050, 2052, 2054, 2056, 2058, 2060, 2062, 2064, 2066, 2068, 2070, 2072, 2074, 2076, 2078, 2080, 51, 2083, 2084, 2085, 2085, 2087, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 10, 1943, 6, 8, 138, 10, 6, 1877, 6, 21, 21, 21, 21, 6, 21, 21, 21, 21, 21, 340, 340, 10, 21, 6, 642, 21, 21, 6, 10, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 16, 21, 336, 21, 21, 1, 1, 21, 10, 10, 123, 10, 10, 21, 1, 1, 21, 1, 1, 21, 21, 21, 21, 21, 21, 1998, 21, 2003, 21, 21, 6, 2003, 21, 123, 123, 6, 2017, 6, 2021, 6, 2025, 6, 2029, 10, 10, 1, 1, 10, 6, 6, 2040, 6, 21, 6, 2047, 6, 2051, 6, 2055, 6, 2059, 6, 2063, 6, 2067, 6, 2071, 6, 2075, 6, 2079, 2081, 21, 21, 6, 21, 21, 16, 1943, 1943, 1943, 1943, 1943, 1943, 1943, 1943, 1943, 1943 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 2, 2, 2, 2, 3, 3, 3, 3, 5, 7, 8, 8, 9, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 12, 13, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 18, 19, 20, 20, 21, 21, 26, 29, 30, 31, 34, 34, 34, 34, 34, 34, 37, 37, 37, 39, 39, 39, 41, 41, 43, 43, 43, 45, 45, 46, 46, 48, 50, 51, 51, 53, 54, 55, 56, 56, 57, 57, 58, 58, 59, 59, 59, 61, 62, 63, 65, 65, 66, 66, 68, 70, 71, 71, 72, 72, 73, 73, 74, 74, 75, 75, 76, 76, 77, 77, 78, 78, 79, 79, 79, 80, 80, 80, 81, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82, 82 };
			static constexpr uint16_t function_arg_types[] = { 10, 21, 1491, 22, 1950, 94, 1950, 1950, 637, 1601, 1950, 1950, 1950, 10, 21, 21, 21, 21, 22, 94, 425, 1, 1, 10, 10, 21, 1, 1, 21, 21, 21, 10, 10, 21, 1, 1, 21, 1, 1, 21, 21, 21, 21, 1995, 21, 2000, 2000, 21, 2000, 21, 2000, 2010, 123, 2010, 2010, 2015, 2019, 2023, 2027, 1, 1, 10, 10, 1, 1, 2038, 10, 21, 10, 21, 2045, 2049, 2053, 2057, 2061, 2065, 2069, 2073, 2077, 2082, 22, 94 };
			static constexpr uint16_t function_arg_names[] = { 274, 57, 1492, 1949, 338, 1949, 338, 338, 638, 450, 338, 338, 338, 1750, 1957, 1960, 1963, 1966, 1949, 1949, 450, 1973, 1974, 30, 31, 728, 1973, 1974, 728, 1949, 1949, 30, 31, 728, 1973, 1974, 728, 1984, 1985, 1957, 728, 1991, 728, 1996, 728, 2001, 2005, 105, 2005, 5, 2001, 2011, 105, 2011, 2011, 1162, 1162, 1162, 1162, 1973, 1974, 2033, 2033, 1973, 1974, 1162, 2042, 105, 2042, 5, 1162, 1162, 1162, 1162, 1162, 1162, 1162, 1162, 1162, 1162, 2086, 2086 };
	};
	constexpr uint16_t ReflectionWindow::constructor_bases[];
	constexpr uint16_t ReflectionWindow::constructor_arg_types[];
	constexpr uint16_t ReflectionWindow::constructor_arg_names[];
	constexpr uint16_t ReflectionWindow::function_names[];
	constexpr uint16_t ReflectionWindow::function_types[];
	constexpr uint16_t ReflectionWindow::function_bases[];
	constexpr uint16_t ReflectionWindow::function_arg_types[];
	constexpr uint16_t ReflectionWindow::function_arg_names[];
	static ReflectionWindow reflection_window;
	
	// Tellusim::Font
	class ReflectionFont : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Font::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Font, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Font>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(Font::*)()>(&Font::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(Font::*)() const>(&Font::isLoaded));
					case 2: return FunctionPtr(new FunctionImpl<bool(Font::*)(const char*)>(&Font::load));
					case 3: return FunctionPtr(new FunctionImpl<bool(Font::*)(Stream&)>(&Font::load));
					case 4: return FunctionPtr(new FunctionImpl<float32_t(Font::*)(const FontStyle&, uint32_t)>(&Font::getAdvance));
					case 5: return FunctionPtr(new FunctionImpl<Rect(Font::*)(const Vector3f&, const FontStyle&, const char*)>(&Font::getRect));
					case 6: return FunctionPtr(new FunctionImpl<Rect(Font::*)(const Vector3f&, const FontStyle&, const uint32_t*)>(&Font::getRect));
					case 7: return FunctionPtr(new FunctionImpl<Rect(Font::*)(const FontBatch*, uint32_t)>(&Font::getRect));
					case 8: return FunctionPtr(new FunctionImpl<Rect(Font::*)(const FontBatch32*, uint32_t)>(&Font::getRect));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(Font::*)(const Device&, const FontStyle&, const char*)>(&Font::create));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Font::*)(const Device&, const FontStyle&, const uint32_t*)>(&Font::create));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(Font::*)(const Device&, const FontBatch*, uint32_t)>(&Font::create));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(Font::*)(const Device&, const FontBatch32*, uint32_t)>(&Font::create));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(Font::*)(Command&, const Vector3f&, const FontStyle&, const char*)>(&Font::draw));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(Font::*)(Command&, const Vector3f&, const FontStyle&, const uint32_t*)>(&Font::draw));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(Font::*)(Command&, const FontBatch*, uint32_t)>(&Font::draw));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(Font::*)(Command&, const FontBatch32*, uint32_t)>(&Font::draw));
					case 17: return FunctionPtr(new FunctionImpl<bool(Font::*)(const Device&)>(&Font::flush));
					case 18: return FunctionPtr(new FunctionImpl<Font(Font::*)() const>(&Font::clonePtr));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(Font::*)()>(&Font::clearPtr));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(Font::*)()>(&Font::destroyPtr));
					case 21: return FunctionPtr(new FunctionImpl<Font&(Font::*)()>(&Font::acquirePtr));
					case 22: return FunctionPtr(new FunctionImpl<Font&(Font::*)()>(&Font::unacquirePtr));
					case 23: return FunctionPtr(new FunctionImpl<bool(Font::*)() const>(&Font::isValidPtr));
					case 24: return FunctionPtr(new FunctionImpl<bool(Font::*)() const>(&Font::isOwnerPtr));
					case 25: return FunctionPtr(new FunctionImpl<bool(Font::*)() const>(&Font::isConstPtr));
					case 26: return FunctionPtr(new FunctionImpl<uint32_t(Font::*)() const>(&Font::getCountPtr));
					case 27: return FunctionPtr(new FunctionImpl<const void*(Font::*)() const>(&Font::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 343, 221, 221, 2089, 2093, 2093, 2093, 2093, 24, 24, 24, 24, 2100, 2100, 2100, 2100, 91, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 21, 123, 2094, 2094, 2094, 2094, 6, 6, 6, 6, 6, 6, 6, 6, 21, 2088, 2088, 2088, 2088, 2088, 2088, 2088, 2088, 2088, 2088 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 1, 2, 4, 7, 10, 12, 14, 17, 20, 23, 26, 30, 34, 37, 40, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41 };
			static constexpr uint16_t function_arg_types[] = { 22, 145, 2090, 10, 711, 2090, 22, 711, 2090, 880, 2095, 10, 2098, 10, 2099, 2090, 22, 2099, 2090, 880, 2099, 2095, 10, 2099, 2098, 10, 2101, 711, 2090, 22, 2101, 711, 2090, 880, 2101, 2095, 10, 2101, 2098, 10, 2099 };
			static constexpr uint16_t function_arg_names[] = { 23, 222, 2091, 2092, 729, 2091, 93, 729, 2091, 93, 2096, 2097, 2096, 2097, 28, 2091, 93, 28, 2091, 93, 28, 2096, 2097, 28, 2096, 2097, 188, 729, 2091, 93, 188, 729, 2091, 93, 188, 2096, 2097, 188, 2096, 2097, 28 };
	};
	constexpr uint16_t ReflectionFont::constructor_bases[];
	constexpr uint16_t ReflectionFont::constructor_arg_types[];
	constexpr uint16_t ReflectionFont::constructor_arg_names[];
	constexpr uint16_t ReflectionFont::function_names[];
	constexpr uint16_t ReflectionFont::function_types[];
	constexpr uint16_t ReflectionFont::function_bases[];
	constexpr uint16_t ReflectionFont::function_arg_types[];
	constexpr uint16_t ReflectionFont::function_arg_names[];
	static ReflectionFont reflection_font;
	
	// Tellusim::CanvasElement
	class ReflectionCanvasElement : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CanvasElement::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CanvasElement, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CanvasElement>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<CanvasElement::Type(CanvasElement::*)() const>(&CanvasElement::getType));
					case 1: return FunctionPtr(new FunctionImpl<const char*(CanvasElement::Type)>(&CanvasElement::getTypeName));
					case 2: return FunctionPtr(new FunctionImpl<const char*(CanvasElement::*)() const>(&CanvasElement::getTypeName));
					case 3: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isText));
					case 4: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isMesh));
					case 5: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isRect));
					case 6: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isTriangle));
					case 7: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isEllipse));
					case 8: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isShape));
					case 9: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isStrip));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Canvas&)>(&CanvasElement::setCanvas));
					case 11: return FunctionPtr(new FunctionImpl<const Canvas(CanvasElement::*)() const>(&CanvasElement::getCanvas));
					case 12: return FunctionPtr(new FunctionImpl<Canvas(CanvasElement::*)()>(&CanvasElement::getCanvas));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(CanvasElement::Mode)>(&CanvasElement::setMode));
					case 14: return FunctionPtr(new FunctionImpl<CanvasElement::Mode(CanvasElement::*)() const>(&CanvasElement::getMode));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(CanvasElement::Align)>(&CanvasElement::setAlign));
					case 16: return FunctionPtr(new FunctionImpl<CanvasElement::Align(CanvasElement::*)() const>(&CanvasElement::getAlign));
					case 17: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)(CanvasElement::Align) const>(&CanvasElement::hasAlign));
					case 18: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)(CanvasElement::Align) const>(&CanvasElement::hasAligns));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(int32_t)>(&CanvasElement::setOrder));
					case 20: return FunctionPtr(new FunctionImpl<int32_t(CanvasElement::*)() const>(&CanvasElement::getOrder));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(bool)>(&CanvasElement::setEnabled));
					case 22: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isEnabled));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)()>(&CanvasElement::clearColor));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(CanvasElement::Stack)>(&CanvasElement::setColor));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(const Color&, CanvasElement::Stack)>(&CanvasElement::setColor, {}, CanvasElement::StackNone));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(float32_t, float32_t, float32_t, float32_t, CanvasElement::Stack)>(&CanvasElement::setColor, {}, {}, {}, {}, CanvasElement::StackNone));
					case 27: return FunctionPtr(new FunctionImpl<const Color&(CanvasElement::*)() const>(&CanvasElement::getColor));
					case 28: return FunctionPtr(new FunctionImpl<CanvasElement::Stack(CanvasElement::*)() const>(&CanvasElement::getColorOp));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)()>(&CanvasElement::clearTransform));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(CanvasElement::Stack)>(&CanvasElement::setTransform));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(const Matrix4x4f&, CanvasElement::Stack)>(&CanvasElement::setTransform, {}, CanvasElement::StackNone));
					case 32: return FunctionPtr(new FunctionImpl<const Matrix4x4f&(CanvasElement::*)() const>(&CanvasElement::getTransform));
					case 33: return FunctionPtr(new FunctionImpl<CanvasElement::Stack(CanvasElement::*)() const>(&CanvasElement::getTransformOp));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)()>(&CanvasElement::clearScissor));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(CanvasElement::Stack)>(&CanvasElement::setScissor));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(const Rect&, CanvasElement::Stack)>(&CanvasElement::setScissor, {}, CanvasElement::StackNone));
					case 37: return FunctionPtr(new FunctionImpl<const Rect&(CanvasElement::*)() const>(&CanvasElement::getScissor));
					case 38: return FunctionPtr(new FunctionImpl<CanvasElement::Stack(CanvasElement::*)() const>(&CanvasElement::getScissorOp));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(float32_t)>(&CanvasElement::setMipmap));
					case 40: return FunctionPtr(new FunctionImpl<float32_t(CanvasElement::*)() const>(&CanvasElement::getMipmap));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Sampler&)>(&CanvasElement::setSampler));
					case 42: return FunctionPtr(new FunctionImpl<Sampler(CanvasElement::*)() const>(&CanvasElement::getSampler));
					case 43: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Sampler::Filter)>(&CanvasElement::setFilter));
					case 44: return FunctionPtr(new FunctionImpl<Sampler::Filter(CanvasElement::*)() const>(&CanvasElement::getFilter));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(uint32_t)>(&CanvasElement::setAnisotropy));
					case 46: return FunctionPtr(new FunctionImpl<uint32_t(CanvasElement::*)() const>(&CanvasElement::getAnisotropy));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Sampler::WrapMode)>(&CanvasElement::setWrapMode));
					case 48: return FunctionPtr(new FunctionImpl<Sampler::WrapMode(CanvasElement::*)() const>(&CanvasElement::getWrapMode));
					case 49: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Texture&, bool)>(&CanvasElement::setTexture, Texture::null, false));
					case 50: return FunctionPtr(new FunctionImpl<Texture(CanvasElement::*)() const>(&CanvasElement::getTexture));
					case 51: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::getTextureLinear));
					case 52: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Pipeline)>(&CanvasElement::setPipeline));
					case 53: return FunctionPtr(new FunctionImpl<Pipeline(CanvasElement::*)() const>(&CanvasElement::getPipeline));
					case 54: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Pipeline::Primitive)>(&CanvasElement::setPrimitive));
					case 55: return FunctionPtr(new FunctionImpl<Pipeline::Primitive(CanvasElement::*)() const>(&CanvasElement::getPrimitive));
					case 56: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Pipeline::CullMode)>(&CanvasElement::setCullMode));
					case 57: return FunctionPtr(new FunctionImpl<Pipeline::CullMode(CanvasElement::*)() const>(&CanvasElement::getCullMode));
					case 58: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Pipeline::FrontMode)>(&CanvasElement::setFrontMode));
					case 59: return FunctionPtr(new FunctionImpl<Pipeline::FrontMode(CanvasElement::*)() const>(&CanvasElement::getFrontMode));
					case 60: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Pipeline::BlendOp, Pipeline::BlendFunc, Pipeline::BlendFunc)>(&CanvasElement::setBlend));
					case 61: return FunctionPtr(new FunctionImpl<Pipeline::BlendOp(CanvasElement::*)() const>(&CanvasElement::getBlendOp));
					case 62: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(CanvasElement::*)() const>(&CanvasElement::getBlendSrcFunc));
					case 63: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(CanvasElement::*)() const>(&CanvasElement::getBlendDestFunc));
					case 64: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Pipeline::ColorMask)>(&CanvasElement::setColorMask));
					case 65: return FunctionPtr(new FunctionImpl<Pipeline::ColorMask(CanvasElement::*)() const>(&CanvasElement::getColorMask));
					case 66: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Pipeline::DepthMask)>(&CanvasElement::setDepthMask));
					case 67: return FunctionPtr(new FunctionImpl<Pipeline::DepthMask(CanvasElement::*)() const>(&CanvasElement::getDepthMask));
					case 68: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Pipeline::DepthFunc)>(&CanvasElement::setDepthFunc));
					case 69: return FunctionPtr(new FunctionImpl<Pipeline::DepthFunc(CanvasElement::*)() const>(&CanvasElement::getDepthFunc));
					case 70: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(uint32_t)>(&CanvasElement::setStencilRef));
					case 71: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(Pipeline::StencilFunc, Pipeline::StencilOp, Pipeline::StencilOp, Pipeline::StencilOp)>(&CanvasElement::setStencilFunc));
					case 72: return FunctionPtr(new FunctionImpl<uint32_t(CanvasElement::*)() const>(&CanvasElement::getStencilRef));
					case 73: return FunctionPtr(new FunctionImpl<Pipeline::StencilFunc(CanvasElement::*)() const>(&CanvasElement::getStencilFunc));
					case 74: return FunctionPtr(new FunctionImpl<Pipeline::StencilOp(CanvasElement::*)() const>(&CanvasElement::getStencilFailOp));
					case 75: return FunctionPtr(new FunctionImpl<Pipeline::StencilOp(CanvasElement::*)() const>(&CanvasElement::getStencilDepthFailOp));
					case 76: return FunctionPtr(new FunctionImpl<Pipeline::StencilOp(CanvasElement::*)() const>(&CanvasElement::getStencilDepthPassOp));
					case 77: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)(const CanvasElement::DrawCallback&)>(&CanvasElement::setDrawCallback));
					case 78: return FunctionPtr(new FunctionImpl<CanvasElement::DrawCallback(CanvasElement::*)() const>(&CanvasElement::getDrawCallback));
					case 79: return FunctionPtr(new FunctionImpl<const Rect&(CanvasElement::*)()>(&CanvasElement::getRect));
					case 80: return FunctionPtr(new FunctionImpl<CanvasElement(CanvasElement::*)() const>(&CanvasElement::clonePtr));
					case 81: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)()>(&CanvasElement::clearPtr));
					case 82: return FunctionPtr(new FunctionVoidImpl<void(CanvasElement::*)()>(&CanvasElement::destroyPtr));
					case 83: return FunctionPtr(new FunctionImpl<CanvasElement&(CanvasElement::*)()>(&CanvasElement::acquirePtr));
					case 84: return FunctionPtr(new FunctionImpl<CanvasElement&(CanvasElement::*)()>(&CanvasElement::unacquirePtr));
					case 85: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isValidPtr));
					case 86: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isOwnerPtr));
					case 87: return FunctionPtr(new FunctionImpl<bool(CanvasElement::*)() const>(&CanvasElement::isConstPtr));
					case 88: return FunctionPtr(new FunctionImpl<uint32_t(CanvasElement::*)() const>(&CanvasElement::getCountPtr));
					case 89: return FunctionPtr(new FunctionImpl<const void*(CanvasElement::*)() const>(&CanvasElement::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 214, 345, 345, 2104, 1244, 2105, 533, 2106, 2107, 2108, 2109, 2112, 2112, 2114, 2116, 2118, 2121, 2123, 2124, 2126, 2128, 2129, 1493, 2130, 2131, 2131, 2131, 2133, 1505, 2135, 525, 525, 713, 2138, 2139, 979, 979, 2141, 2142, 2143, 2144, 986, 1376, 1334, 1336, 1339, 1341, 1343, 2145, 993, 1429, 2147, 967, 970, 1764, 1767, 1773, 1775, 1777, 1779, 1812, 2148, 2149, 2150, 1824, 1827, 1829, 1834, 1831, 1836, 1058, 1841, 2151, 2152, 2153, 2154, 2155, 2156, 2158, 2093, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 215, 138, 138, 21, 21, 21, 21, 21, 21, 21, 6, 2113, 2113, 6, 2117, 6, 2122, 21, 21, 6, 1, 6, 21, 6, 6, 6, 6, 654, 2134, 6, 6, 6, 2137, 2134, 6, 6, 6, 2094, 2134, 6, 123, 6, 1331, 6, 1337, 6, 10, 6, 1350, 6, 1377, 21, 6, 971, 6, 1768, 6, 1776, 6, 1780, 6, 1817, 1820, 1820, 6, 1828, 6, 1835, 6, 1837, 6, 6, 10, 1851, 1853, 1853, 1853, 6, 2159, 2094, 2102, 2102, 2102, 2102, 2102, 2102, 2102, 2102, 2102, 2102 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 3, 3, 4, 4, 5, 6, 7, 7, 8, 8, 8, 9, 11, 16, 16, 16, 16, 17, 19, 19, 19, 19, 20, 22, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 29, 29, 29, 30, 30, 31, 31, 32, 32, 33, 33, 36, 36, 36, 36, 37, 37, 38, 38, 39, 39, 40, 44, 44, 44, 44, 44, 44, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45, 45 };
			static constexpr uint16_t function_arg_types[] = { 2103, 2110, 2115, 2119, 2119, 2119, 1, 21, 2132, 637, 2132, 123, 123, 123, 123, 2132, 2132, 2136, 2132, 2132, 2140, 2132, 123, 987, 1335, 10, 1344, 994, 21, 971, 1765, 1774, 1778, 1813, 1814, 1814, 1825, 1830, 1832, 10, 1842, 1843, 1843, 1843, 2157 };
			static constexpr uint16_t function_arg_names[] = { 195, 2111, 185, 2120, 2120, 2125, 2127, 1309, 1501, 638, 1501, 1054, 1055, 1056, 1057, 1501, 1501, 511, 1501, 1501, 981, 1501, 393, 988, 448, 1340, 185, 995, 2146, 969, 1766, 185, 185, 1501, 90, 86, 53, 53, 1162, 1059, 1162, 1847, 1848, 1844, 1162 };
	};
	constexpr uint16_t ReflectionCanvasElement::constructor_bases[];
	constexpr uint16_t ReflectionCanvasElement::constructor_arg_types[];
	constexpr uint16_t ReflectionCanvasElement::constructor_arg_names[];
	constexpr uint16_t ReflectionCanvasElement::function_names[];
	constexpr uint16_t ReflectionCanvasElement::function_types[];
	constexpr uint16_t ReflectionCanvasElement::function_bases[];
	constexpr uint16_t ReflectionCanvasElement::function_arg_types[];
	constexpr uint16_t ReflectionCanvasElement::function_arg_names[];
	static ReflectionCanvasElement reflection_canvas_element;
	
	// Tellusim::CanvasText
	class ReflectionCanvasText : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CanvasText::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_canvas_element;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CanvasText, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<CanvasText, TypeList<Canvas&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<CanvasText, TypeList<Canvas&, const char*>>());
					case 3: return ConstructorPtr(new ConstructorImpl<CanvasText, TypeList<Canvas&, const String&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CanvasText>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)(const char*)>(&CanvasText::setFontName));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)(const String&)>(&CanvasText::setFontName));
					case 2: return FunctionPtr(new FunctionImpl<String(CanvasText::*)() const>(&CanvasText::getFontName));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)(const Color&)>(&CanvasText::setFontColor));
					case 4: return FunctionPtr(new FunctionImpl<const Color&(CanvasText::*)() const>(&CanvasText::getFontColor));
					case 5: return FunctionPtr(new FunctionImpl<bool(CanvasText::*)(uint32_t)>(&CanvasText::setFontSize));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(CanvasText::*)() const>(&CanvasText::getFontSize));
					case 7: return FunctionPtr(new FunctionImpl<bool(CanvasText::*)(uint32_t)>(&CanvasText::setFontScale));
					case 8: return FunctionPtr(new FunctionImpl<uint32_t(CanvasText::*)() const>(&CanvasText::getFontScale));
					case 9: return FunctionPtr(new FunctionImpl<bool(CanvasText::*)(const FontStyle&)>(&CanvasText::setFontStyle));
					case 10: return FunctionPtr(new FunctionImpl<const FontStyle&(CanvasText::*)() const>(&CanvasText::getFontStyleConst));
					case 11: return FunctionPtr(new FunctionImpl<const FontStyle&(CanvasText::*)() const>(&CanvasText::getFontStyle));
					case 12: return FunctionPtr(new FunctionImpl<FontStyle&(CanvasText::*)()>(&CanvasText::getFontStyle));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)(const Vector3f&)>(&CanvasText::setPosition));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)(float32_t, float32_t, float32_t)>(&CanvasText::setPosition, {}, {}, 0.0f));
					case 15: return FunctionPtr(new FunctionImpl<const Vector3f&(CanvasText::*)() const>(&CanvasText::getPosition));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)(const char*)>(&CanvasText::setText));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)(const String&)>(&CanvasText::setText));
					case 18: return FunctionPtr(new FunctionImpl<String(CanvasText::*)() const>(&CanvasText::getText));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)()>(&CanvasText::clearBatches));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)(const Array<FontBatch>&)>(&CanvasText::setBatches));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)(const FontBatch*, uint32_t)>(&CanvasText::setBatches));
					case 22: return FunctionPtr(new FunctionImpl<CanvasText(CanvasText::*)() const>(&CanvasText::clonePtr));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)()>(&CanvasText::clearPtr));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(CanvasText::*)()>(&CanvasText::destroyPtr));
					case 25: return FunctionPtr(new FunctionImpl<CanvasText&(CanvasText::*)()>(&CanvasText::acquirePtr));
					case 26: return FunctionPtr(new FunctionImpl<CanvasText&(CanvasText::*)()>(&CanvasText::unacquirePtr));
					case 27: return FunctionPtr(new FunctionImpl<bool(CanvasText::*)() const>(&CanvasText::isValidPtr));
					case 28: return FunctionPtr(new FunctionImpl<bool(CanvasText::*)() const>(&CanvasText::isOwnerPtr));
					case 29: return FunctionPtr(new FunctionImpl<bool(CanvasText::*)() const>(&CanvasText::isConstPtr));
					case 30: return FunctionPtr(new FunctionImpl<uint32_t(CanvasText::*)() const>(&CanvasText::getCountPtr));
					case 31: return FunctionPtr(new FunctionImpl<const void*(CanvasText::*)() const>(&CanvasText::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 5 };
			static constexpr uint16_t constructor_arg_types[] = { 2110, 2110, 22, 2110, 94 };
			static constexpr uint16_t constructor_arg_names[] = { 2111, 2111, 2086, 2111, 2086 };
			static constexpr uint16_t function_names[] = { 2161, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169, 2170, 2172, 2172, 1975, 1975, 2174, 2175, 2175, 2176, 2177, 2178, 2178, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 16, 6, 654, 21, 10, 21, 10, 21, 2171, 2171, 2171, 6, 6, 762, 6, 6, 16, 6, 6, 6, 2160, 2160, 2160, 2160, 2160, 2160, 2160, 2160, 2160, 2160 };
			static constexpr uint16_t function_bases[] = { 0, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 10, 10, 11, 12, 12, 12, 13, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15 };
			static constexpr uint16_t function_arg_types[] = { 22, 94, 637, 10, 10, 2090, 711, 123, 123, 123, 22, 94, 2179, 2095, 10 };
			static constexpr uint16_t function_arg_names[] = { 23, 23, 638, 527, 527, 2091, 729, 1973, 1974, 2173, 2086, 2086, 2096, 2096, 2097 };
	};
	constexpr uint16_t ReflectionCanvasText::constructor_bases[];
	constexpr uint16_t ReflectionCanvasText::constructor_arg_types[];
	constexpr uint16_t ReflectionCanvasText::constructor_arg_names[];
	constexpr uint16_t ReflectionCanvasText::function_names[];
	constexpr uint16_t ReflectionCanvasText::function_types[];
	constexpr uint16_t ReflectionCanvasText::function_bases[];
	constexpr uint16_t ReflectionCanvasText::function_arg_types[];
	constexpr uint16_t ReflectionCanvasText::function_arg_names[];
	static ReflectionCanvasText reflection_canvas_text;
	
	// Tellusim::CanvasMesh
	class ReflectionCanvasMesh : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CanvasMesh::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_canvas_element;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CanvasMesh, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<CanvasMesh, TypeList<Canvas&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<CanvasMesh, TypeList<Canvas&, CanvasElement::Mode>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CanvasMesh>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(const char*)>(&CanvasMesh::setTextureName));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(const String&)>(&CanvasMesh::setTextureName));
					case 2: return FunctionPtr(new FunctionImpl<String(CanvasMesh::*)() const>(&CanvasMesh::getTextureName));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(const GradientStyle&)>(&CanvasMesh::setGradientStyle));
					case 4: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasMesh::*)() const>(&CanvasMesh::getGradientStyleConst));
					case 5: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasMesh::*)() const>(&CanvasMesh::getGradientStyle));
					case 6: return FunctionPtr(new FunctionImpl<GradientStyle&(CanvasMesh::*)()>(&CanvasMesh::getGradientStyle));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)()>(&CanvasMesh::clearVertices));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t)>(&CanvasMesh::setNumVertices));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t)>(&CanvasMesh::reserveVertices));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)() const>(&CanvasMesh::getNumVertices));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(const CanvasVertex*, uint32_t)>(&CanvasMesh::setVertices));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(const CanvasVertex*, uint32_t)>(&CanvasMesh::addVertices));
					case 13: return FunctionPtr(new FunctionImpl<const CanvasVertex*(CanvasMesh::*)() const>(&CanvasMesh::getVertices));
					case 14: return FunctionPtr(new FunctionImpl<CanvasVertex*(CanvasMesh::*)()>(&CanvasMesh::getVertices));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, const CanvasVertex&)>(&CanvasMesh::setVertex));
					case 16: return FunctionPtr(new FunctionImpl<const CanvasVertex&(CanvasMesh::*)(uint32_t) const>(&CanvasMesh::getVertex));
					case 17: return FunctionPtr(new FunctionImpl<CanvasVertex&(CanvasMesh::*)(uint32_t)>(&CanvasMesh::getVertex));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, const Vector3f&)>(&CanvasMesh::setVertexPosition));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, float32_t, float32_t, float32_t)>(&CanvasMesh::setVertexPosition, {}, {}, {}, 0.0f));
					case 20: return FunctionPtr(new FunctionImpl<Vector3f(CanvasMesh::*)(uint32_t) const>(&CanvasMesh::getVertexPosition));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, const Vector2f&)>(&CanvasMesh::setVertexTexCoord));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, float32_t, float32_t)>(&CanvasMesh::setVertexTexCoord));
					case 23: return FunctionPtr(new FunctionImpl<Vector2f(CanvasMesh::*)(uint32_t) const>(&CanvasMesh::getVertexTexCoord));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, const Color&)>(&CanvasMesh::setVertexColor));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, uint32_t)>(&CanvasMesh::setVertexColor));
					case 26: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)(uint32_t) const>(&CanvasMesh::getVertexColor));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)(const Vector3f&)>(&CanvasMesh::addVertex));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)(const Vector3f&, uint32_t)>(&CanvasMesh::addVertex));
					case 29: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)(const Vector3f&, const Vector2f&)>(&CanvasMesh::addVertex));
					case 30: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)(const Vector3f&, const Vector2f&, uint32_t)>(&CanvasMesh::addVertex));
					case 31: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)(float32_t, float32_t, float32_t, float32_t, float32_t, uint32_t)>(&CanvasMesh::addVertex, {}, {}, {}, {}, {}, 0xffffffffu));
					case 32: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)(float32_t, float32_t, float32_t, uint32_t)>(&CanvasMesh::addVertex, {}, {}, {}, 0xffffffffu));
					case 33: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)(float32_t, float32_t, uint32_t)>(&CanvasMesh::addVertex, {}, {}, 0xffffffffu));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)()>(&CanvasMesh::clearIndices));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t)>(&CanvasMesh::setNumIndices));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t)>(&CanvasMesh::reserveIndices));
					case 37: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)() const>(&CanvasMesh::getNumIndices));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(const uint32_t*, uint32_t)>(&CanvasMesh::setIndices));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(const uint32_t*, uint32_t)>(&CanvasMesh::addIndices));
					case 40: return FunctionPtr(new FunctionImpl<const uint32_t*(CanvasMesh::*)() const>(&CanvasMesh::getIndices));
					case 41: return FunctionPtr(new FunctionImpl<uint32_t*(CanvasMesh::*)()>(&CanvasMesh::getIndices));
					case 42: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, uint32_t)>(&CanvasMesh::setIndex));
					case 43: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)(uint32_t) const>(&CanvasMesh::getIndex));
					case 44: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t)>(&CanvasMesh::addIndex));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, uint32_t)>(&CanvasMesh::addIndices));
					case 46: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, uint32_t, uint32_t)>(&CanvasMesh::addIndices));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(uint32_t, uint32_t, uint32_t, uint32_t)>(&CanvasMesh::addIndices));
					case 48: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)(const Rect&)>(&CanvasMesh::setRect));
					case 49: return FunctionPtr(new FunctionImpl<CanvasMesh(CanvasMesh::*)() const>(&CanvasMesh::clonePtr));
					case 50: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)()>(&CanvasMesh::clearPtr));
					case 51: return FunctionPtr(new FunctionVoidImpl<void(CanvasMesh::*)()>(&CanvasMesh::destroyPtr));
					case 52: return FunctionPtr(new FunctionImpl<CanvasMesh&(CanvasMesh::*)()>(&CanvasMesh::acquirePtr));
					case 53: return FunctionPtr(new FunctionImpl<CanvasMesh&(CanvasMesh::*)()>(&CanvasMesh::unacquirePtr));
					case 54: return FunctionPtr(new FunctionImpl<bool(CanvasMesh::*)() const>(&CanvasMesh::isValidPtr));
					case 55: return FunctionPtr(new FunctionImpl<bool(CanvasMesh::*)() const>(&CanvasMesh::isOwnerPtr));
					case 56: return FunctionPtr(new FunctionImpl<bool(CanvasMesh::*)() const>(&CanvasMesh::isConstPtr));
					case 57: return FunctionPtr(new FunctionImpl<uint32_t(CanvasMesh::*)() const>(&CanvasMesh::getCountPtr));
					case 58: return FunctionPtr(new FunctionImpl<const void*(CanvasMesh::*)() const>(&CanvasMesh::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 2110, 2110, 2115 };
			static constexpr uint16_t constructor_arg_names[] = { 2111, 2111, 185 };
			static constexpr uint16_t function_names[] = { 2181, 2181, 2182, 2183, 2185, 2187, 2187, 2188, 1447, 2189, 1448, 2190, 2193, 2194, 2194, 2196, 2198, 2198, 2199, 2199, 2200, 2201, 2201, 2205, 2207, 2207, 2208, 2209, 2209, 2209, 2209, 2209, 2209, 2209, 665, 1454, 666, 674, 583, 562, 585, 585, 582, 460, 2210, 562, 562, 562, 2215, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 16, 6, 2186, 2186, 2186, 6, 6, 6, 10, 6, 6, 2195, 2195, 6, 2195, 2195, 6, 6, 762, 6, 6, 2206, 6, 6, 10, 10, 10, 10, 10, 10, 10, 10, 6, 6, 6, 10, 6, 6, 10, 10, 6, 10, 6, 6, 6, 6, 6, 2180, 2180, 2180, 2180, 2180, 2180, 2180, 2180, 2180, 2180 };
			static constexpr uint16_t function_bases[] = { 0, 1, 2, 2, 3, 3, 3, 3, 3, 4, 5, 5, 7, 9, 9, 9, 11, 12, 13, 15, 19, 20, 22, 25, 26, 28, 30, 31, 32, 34, 36, 39, 45, 49, 52, 52, 53, 54, 54, 56, 58, 58, 58, 60, 61, 62, 64, 67, 71, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72, 72 };
			static constexpr uint16_t function_arg_types[] = { 22, 94, 2184, 10, 10, 2191, 10, 2191, 10, 10, 2197, 10, 10, 10, 711, 10, 123, 123, 123, 10, 10, 2202, 10, 123, 123, 10, 10, 637, 10, 10, 10, 711, 711, 10, 711, 2202, 711, 2202, 10, 123, 123, 123, 123, 123, 10, 123, 123, 123, 10, 123, 123, 10, 10, 10, 880, 10, 880, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 2140 };
			static constexpr uint16_t function_arg_names[] = { 23, 23, 2091, 1061, 1061, 2192, 1061, 2192, 1061, 274, 1749, 274, 274, 274, 729, 274, 1973, 1974, 2173, 274, 274, 735, 274, 2203, 2204, 274, 274, 638, 274, 638, 274, 729, 729, 638, 729, 735, 729, 735, 638, 1973, 1974, 2173, 2203, 2204, 638, 1973, 1974, 2173, 638, 1973, 1974, 638, 667, 667, 561, 667, 561, 667, 274, 105, 274, 2211, 2211, 2212, 2211, 2212, 2213, 2211, 2212, 2213, 2214, 2216 };
	};
	constexpr uint16_t ReflectionCanvasMesh::constructor_bases[];
	constexpr uint16_t ReflectionCanvasMesh::constructor_arg_types[];
	constexpr uint16_t ReflectionCanvasMesh::constructor_arg_names[];
	constexpr uint16_t ReflectionCanvasMesh::function_names[];
	constexpr uint16_t ReflectionCanvasMesh::function_types[];
	constexpr uint16_t ReflectionCanvasMesh::function_bases[];
	constexpr uint16_t ReflectionCanvasMesh::function_arg_types[];
	constexpr uint16_t ReflectionCanvasMesh::function_arg_names[];
	static ReflectionCanvasMesh reflection_canvas_mesh;
	
	// Tellusim::CanvasRect
	class ReflectionCanvasRect : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CanvasRect::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_canvas_element;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CanvasRect, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<CanvasRect, TypeList<Canvas&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<CanvasRect, TypeList<Canvas&, float32_t>>());
					case 3: return ConstructorPtr(new ConstructorImpl<CanvasRect, TypeList<Canvas&, float32_t, const Vector2f&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CanvasRect>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(float32_t)>(&CanvasRect::setRadius));
					case 1: return FunctionPtr(new FunctionImpl<float32_t(CanvasRect::*)() const>(&CanvasRect::getRadius));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(const char*)>(&CanvasRect::setTextureName));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(const String&)>(&CanvasRect::setTextureName));
					case 4: return FunctionPtr(new FunctionImpl<String(CanvasRect::*)() const>(&CanvasRect::getTextureName));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(const Color&)>(&CanvasRect::setStrokeColor));
					case 6: return FunctionPtr(new FunctionImpl<const Color&(CanvasRect::*)()>(&CanvasRect::getStrokeColor));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(const StrokeStyle&)>(&CanvasRect::setStrokeStyle));
					case 8: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasRect::*)() const>(&CanvasRect::getStrokeStyleConst));
					case 9: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasRect::*)() const>(&CanvasRect::getStrokeStyle));
					case 10: return FunctionPtr(new FunctionImpl<StrokeStyle&(CanvasRect::*)()>(&CanvasRect::getStrokeStyle));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(const GradientStyle&)>(&CanvasRect::setGradientStyle));
					case 12: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasRect::*)() const>(&CanvasRect::getGradientStyleConst));
					case 13: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasRect::*)() const>(&CanvasRect::getGradientStyle));
					case 14: return FunctionPtr(new FunctionImpl<GradientStyle&(CanvasRect::*)()>(&CanvasRect::getGradientStyle));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(const Vector2f&)>(&CanvasRect::setSize));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(float32_t, float32_t)>(&CanvasRect::setSize));
					case 17: return FunctionPtr(new FunctionImpl<const Vector2f&(CanvasRect::*)() const>(&CanvasRect::getSize));
					case 18: return FunctionPtr(new FunctionImpl<float32_t(CanvasRect::*)() const>(&CanvasRect::getWidth));
					case 19: return FunctionPtr(new FunctionImpl<float32_t(CanvasRect::*)() const>(&CanvasRect::getHeight));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(const Vector3f&)>(&CanvasRect::setPosition));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(float32_t, float32_t, float32_t)>(&CanvasRect::setPosition, {}, {}, 0.0f));
					case 22: return FunctionPtr(new FunctionImpl<const Vector3f&(CanvasRect::*)() const>(&CanvasRect::getPosition));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(const Rect&)>(&CanvasRect::setTexCoord));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)(float32_t, float32_t, float32_t, float32_t)>(&CanvasRect::setTexCoord));
					case 25: return FunctionPtr(new FunctionImpl<const Rect&(CanvasRect::*)() const>(&CanvasRect::getTexCoord));
					case 26: return FunctionPtr(new FunctionImpl<CanvasRect(CanvasRect::*)() const>(&CanvasRect::clonePtr));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)()>(&CanvasRect::clearPtr));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(CanvasRect::*)()>(&CanvasRect::destroyPtr));
					case 29: return FunctionPtr(new FunctionImpl<CanvasRect&(CanvasRect::*)()>(&CanvasRect::acquirePtr));
					case 30: return FunctionPtr(new FunctionImpl<CanvasRect&(CanvasRect::*)()>(&CanvasRect::unacquirePtr));
					case 31: return FunctionPtr(new FunctionImpl<bool(CanvasRect::*)() const>(&CanvasRect::isValidPtr));
					case 32: return FunctionPtr(new FunctionImpl<bool(CanvasRect::*)() const>(&CanvasRect::isOwnerPtr));
					case 33: return FunctionPtr(new FunctionImpl<bool(CanvasRect::*)() const>(&CanvasRect::isConstPtr));
					case 34: return FunctionPtr(new FunctionImpl<uint32_t(CanvasRect::*)() const>(&CanvasRect::getCountPtr));
					case 35: return FunctionPtr(new FunctionImpl<const void*(CanvasRect::*)() const>(&CanvasRect::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 6 };
			static constexpr uint16_t constructor_arg_types[] = { 2110, 2110, 123, 2110, 123, 2202 };
			static constexpr uint16_t constructor_arg_names[] = { 2111, 2111, 2218, 2111, 2218, 87 };
			static constexpr uint16_t function_names[] = { 2219, 2220, 2181, 2181, 2182, 2221, 2222, 2223, 2225, 2227, 2227, 2183, 2185, 2187, 2187, 29, 29, 73, 11, 12, 1975, 1975, 2174, 2228, 2228, 2232, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 123, 6, 6, 16, 6, 654, 6, 2226, 2226, 2226, 6, 2186, 2186, 2186, 6, 6, 2206, 123, 123, 6, 6, 762, 6, 6, 2094, 2217, 2217, 2217, 2217, 2217, 2217, 2217, 2217, 2217, 2217 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 9, 9, 9, 9, 10, 13, 13, 14, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 };
			static constexpr uint16_t function_arg_types[] = { 123, 22, 94, 637, 2224, 2184, 2202, 123, 123, 711, 123, 123, 123, 2140, 123, 123, 123, 123 };
			static constexpr uint16_t function_arg_names[] = { 2218, 23, 23, 638, 2091, 2091, 87, 30, 31, 729, 1973, 1974, 2173, 735, 2229, 805, 2230, 2231 };
	};
	constexpr uint16_t ReflectionCanvasRect::constructor_bases[];
	constexpr uint16_t ReflectionCanvasRect::constructor_arg_types[];
	constexpr uint16_t ReflectionCanvasRect::constructor_arg_names[];
	constexpr uint16_t ReflectionCanvasRect::function_names[];
	constexpr uint16_t ReflectionCanvasRect::function_types[];
	constexpr uint16_t ReflectionCanvasRect::function_bases[];
	constexpr uint16_t ReflectionCanvasRect::function_arg_types[];
	constexpr uint16_t ReflectionCanvasRect::function_arg_names[];
	static ReflectionCanvasRect reflection_canvas_rect;
	
	// Tellusim::CanvasTriangle
	class ReflectionCanvasTriangle : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CanvasTriangle::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_canvas_element;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CanvasTriangle, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<CanvasTriangle, TypeList<Canvas&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<CanvasTriangle, TypeList<Canvas&, float32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CanvasTriangle>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(float32_t)>(&CanvasTriangle::setRadius));
					case 1: return FunctionPtr(new FunctionImpl<float32_t(CanvasTriangle::*)() const>(&CanvasTriangle::getRadius));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(const Color&)>(&CanvasTriangle::setStrokeColor));
					case 3: return FunctionPtr(new FunctionImpl<const Color&(CanvasTriangle::*)() const>(&CanvasTriangle::getStrokeColor));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(const StrokeStyle&)>(&CanvasTriangle::setStrokeStyle));
					case 5: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasTriangle::*)() const>(&CanvasTriangle::getStrokeStyleConst));
					case 6: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasTriangle::*)() const>(&CanvasTriangle::getStrokeStyle));
					case 7: return FunctionPtr(new FunctionImpl<StrokeStyle&(CanvasTriangle::*)()>(&CanvasTriangle::getStrokeStyle));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(const GradientStyle&)>(&CanvasTriangle::setGradientStyle));
					case 9: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasTriangle::*)() const>(&CanvasTriangle::getGradientStyleConst));
					case 10: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasTriangle::*)() const>(&CanvasTriangle::getGradientStyle));
					case 11: return FunctionPtr(new FunctionImpl<GradientStyle&(CanvasTriangle::*)()>(&CanvasTriangle::getGradientStyle));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(const Vector3f&)>(&CanvasTriangle::setPosition0));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(const Vector3f&)>(&CanvasTriangle::setPosition1));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(const Vector3f&)>(&CanvasTriangle::setPosition2));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(float32_t, float32_t, float32_t)>(&CanvasTriangle::setPosition0, {}, {}, 0.0f));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(float32_t, float32_t, float32_t)>(&CanvasTriangle::setPosition1, {}, {}, 0.0f));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(float32_t, float32_t, float32_t)>(&CanvasTriangle::setPosition2, {}, {}, 0.0f));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)(const Vector3f&, const Vector3f&, const Vector3f&)>(&CanvasTriangle::setPosition));
					case 19: return FunctionPtr(new FunctionImpl<const Vector3f&(CanvasTriangle::*)() const>(&CanvasTriangle::getPosition0));
					case 20: return FunctionPtr(new FunctionImpl<const Vector3f&(CanvasTriangle::*)() const>(&CanvasTriangle::getPosition1));
					case 21: return FunctionPtr(new FunctionImpl<const Vector3f&(CanvasTriangle::*)() const>(&CanvasTriangle::getPosition2));
					case 22: return FunctionPtr(new FunctionImpl<CanvasTriangle(CanvasTriangle::*)() const>(&CanvasTriangle::clonePtr));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)()>(&CanvasTriangle::clearPtr));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(CanvasTriangle::*)()>(&CanvasTriangle::destroyPtr));
					case 25: return FunctionPtr(new FunctionImpl<CanvasTriangle&(CanvasTriangle::*)()>(&CanvasTriangle::acquirePtr));
					case 26: return FunctionPtr(new FunctionImpl<CanvasTriangle&(CanvasTriangle::*)()>(&CanvasTriangle::unacquirePtr));
					case 27: return FunctionPtr(new FunctionImpl<bool(CanvasTriangle::*)() const>(&CanvasTriangle::isValidPtr));
					case 28: return FunctionPtr(new FunctionImpl<bool(CanvasTriangle::*)() const>(&CanvasTriangle::isOwnerPtr));
					case 29: return FunctionPtr(new FunctionImpl<bool(CanvasTriangle::*)() const>(&CanvasTriangle::isConstPtr));
					case 30: return FunctionPtr(new FunctionImpl<uint32_t(CanvasTriangle::*)() const>(&CanvasTriangle::getCountPtr));
					case 31: return FunctionPtr(new FunctionImpl<const void*(CanvasTriangle::*)() const>(&CanvasTriangle::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 2110, 2110, 123 };
			static constexpr uint16_t constructor_arg_names[] = { 2111, 2111, 2218 };
			static constexpr uint16_t function_names[] = { 2219, 2220, 2221, 2222, 2223, 2225, 2227, 2227, 2183, 2185, 2187, 2187, 2234, 2235, 2236, 2234, 2235, 2236, 1975, 2240, 2241, 2242, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 123, 6, 654, 6, 2226, 2226, 2226, 6, 2186, 2186, 2186, 6, 6, 6, 6, 6, 6, 6, 762, 762, 762, 2233, 2233, 2233, 2233, 2233, 2233, 2233, 2233, 2233, 2233 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 6, 7, 10, 13, 16, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19 };
			static constexpr uint16_t function_arg_types[] = { 123, 637, 2224, 2184, 711, 711, 711, 123, 123, 123, 123, 123, 123, 123, 123, 123, 711, 711, 711 };
			static constexpr uint16_t function_arg_names[] = { 2218, 638, 2091, 2091, 729, 729, 729, 1973, 1974, 2173, 1973, 1974, 2173, 1973, 1974, 2173, 2237, 2238, 2239 };
	};
	constexpr uint16_t ReflectionCanvasTriangle::constructor_bases[];
	constexpr uint16_t ReflectionCanvasTriangle::constructor_arg_types[];
	constexpr uint16_t ReflectionCanvasTriangle::constructor_arg_names[];
	constexpr uint16_t ReflectionCanvasTriangle::function_names[];
	constexpr uint16_t ReflectionCanvasTriangle::function_types[];
	constexpr uint16_t ReflectionCanvasTriangle::function_bases[];
	constexpr uint16_t ReflectionCanvasTriangle::function_arg_types[];
	constexpr uint16_t ReflectionCanvasTriangle::function_arg_names[];
	static ReflectionCanvasTriangle reflection_canvas_triangle;
	
	// Tellusim::CanvasEllipse
	class ReflectionCanvasEllipse : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CanvasEllipse::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_canvas_element;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CanvasEllipse, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<CanvasEllipse, TypeList<Canvas&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<CanvasEllipse, TypeList<Canvas&, float32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CanvasEllipse>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(float32_t)>(&CanvasEllipse::setRadius));
					case 1: return FunctionPtr(new FunctionImpl<float32_t(CanvasEllipse::*)() const>(&CanvasEllipse::getRadius));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const char*)>(&CanvasEllipse::setTextureName));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const String&)>(&CanvasEllipse::setTextureName));
					case 4: return FunctionPtr(new FunctionImpl<String(CanvasEllipse::*)() const>(&CanvasEllipse::getTextureName));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const Color&)>(&CanvasEllipse::setStrokeColor));
					case 6: return FunctionPtr(new FunctionImpl<const Color&(CanvasEllipse::*)() const>(&CanvasEllipse::getStrokeColor));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const StrokeStyle&)>(&CanvasEllipse::setStrokeStyle));
					case 8: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasEllipse::*)() const>(&CanvasEllipse::getStrokeStyleConst));
					case 9: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasEllipse::*)() const>(&CanvasEllipse::getStrokeStyle));
					case 10: return FunctionPtr(new FunctionImpl<StrokeStyle&(CanvasEllipse::*)()>(&CanvasEllipse::getStrokeStyle));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const GradientStyle&)>(&CanvasEllipse::setGradientStyle));
					case 12: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasEllipse::*)() const>(&CanvasEllipse::getGradientStyleConst));
					case 13: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasEllipse::*)() const>(&CanvasEllipse::getGradientStyle));
					case 14: return FunctionPtr(new FunctionImpl<GradientStyle&(CanvasEllipse::*)()>(&CanvasEllipse::getGradientStyle));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const Vector3f&)>(&CanvasEllipse::setPosition));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const Vector3f&)>(&CanvasEllipse::setPosition0));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const Vector3f&)>(&CanvasEllipse::setPosition1));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(float32_t, float32_t, float32_t)>(&CanvasEllipse::setPosition, {}, {}, 0.0f));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(float32_t, float32_t, float32_t)>(&CanvasEllipse::setPosition0, {}, {}, 0.0f));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(float32_t, float32_t, float32_t)>(&CanvasEllipse::setPosition1, {}, {}, 0.0f));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const Vector3f&, const Vector3f&)>(&CanvasEllipse::setPosition));
					case 22: return FunctionPtr(new FunctionImpl<const Vector3f&(CanvasEllipse::*)() const>(&CanvasEllipse::getPosition0));
					case 23: return FunctionPtr(new FunctionImpl<const Vector3f&(CanvasEllipse::*)() const>(&CanvasEllipse::getPosition1));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(const Rect&)>(&CanvasEllipse::setTexCoord));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)(float32_t, float32_t, float32_t, float32_t)>(&CanvasEllipse::setTexCoord));
					case 26: return FunctionPtr(new FunctionImpl<const Rect&(CanvasEllipse::*)() const>(&CanvasEllipse::getTexCoord));
					case 27: return FunctionPtr(new FunctionImpl<CanvasEllipse(CanvasEllipse::*)() const>(&CanvasEllipse::clonePtr));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)()>(&CanvasEllipse::clearPtr));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(CanvasEllipse::*)()>(&CanvasEllipse::destroyPtr));
					case 30: return FunctionPtr(new FunctionImpl<CanvasEllipse&(CanvasEllipse::*)()>(&CanvasEllipse::acquirePtr));
					case 31: return FunctionPtr(new FunctionImpl<CanvasEllipse&(CanvasEllipse::*)()>(&CanvasEllipse::unacquirePtr));
					case 32: return FunctionPtr(new FunctionImpl<bool(CanvasEllipse::*)() const>(&CanvasEllipse::isValidPtr));
					case 33: return FunctionPtr(new FunctionImpl<bool(CanvasEllipse::*)() const>(&CanvasEllipse::isOwnerPtr));
					case 34: return FunctionPtr(new FunctionImpl<bool(CanvasEllipse::*)() const>(&CanvasEllipse::isConstPtr));
					case 35: return FunctionPtr(new FunctionImpl<uint32_t(CanvasEllipse::*)() const>(&CanvasEllipse::getCountPtr));
					case 36: return FunctionPtr(new FunctionImpl<const void*(CanvasEllipse::*)() const>(&CanvasEllipse::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 2110, 2110, 123 };
			static constexpr uint16_t constructor_arg_names[] = { 2111, 2111, 2218 };
			static constexpr uint16_t function_names[] = { 2219, 2220, 2181, 2181, 2182, 2221, 2222, 2223, 2225, 2227, 2227, 2183, 2185, 2187, 2187, 1975, 2234, 2235, 1975, 2234, 2235, 1975, 2240, 2241, 2228, 2228, 2232, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 123, 6, 6, 16, 6, 654, 6, 2226, 2226, 2226, 6, 2186, 2186, 2186, 6, 6, 6, 6, 6, 6, 6, 762, 762, 6, 6, 2094, 2243, 2243, 2243, 2243, 2243, 2243, 2243, 2243, 2243, 2243 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 8, 9, 12, 15, 18, 20, 20, 20, 21, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25 };
			static constexpr uint16_t function_arg_types[] = { 123, 22, 94, 637, 2224, 2184, 711, 711, 711, 123, 123, 123, 123, 123, 123, 123, 123, 123, 711, 711, 2140, 123, 123, 123, 123 };
			static constexpr uint16_t function_arg_names[] = { 2218, 23, 23, 638, 2091, 2091, 729, 729, 729, 1973, 1974, 2173, 1973, 1974, 2173, 1973, 1974, 2173, 2237, 2238, 735, 2229, 805, 2230, 2231 };
	};
	constexpr uint16_t ReflectionCanvasEllipse::constructor_bases[];
	constexpr uint16_t ReflectionCanvasEllipse::constructor_arg_types[];
	constexpr uint16_t ReflectionCanvasEllipse::constructor_arg_names[];
	constexpr uint16_t ReflectionCanvasEllipse::function_names[];
	constexpr uint16_t ReflectionCanvasEllipse::function_types[];
	constexpr uint16_t ReflectionCanvasEllipse::function_bases[];
	constexpr uint16_t ReflectionCanvasEllipse::function_arg_types[];
	constexpr uint16_t ReflectionCanvasEllipse::function_arg_names[];
	static ReflectionCanvasEllipse reflection_canvas_ellipse;
	
	// Tellusim::CanvasShape
	class ReflectionCanvasShape : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CanvasShape::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_canvas_element;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CanvasShape, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<CanvasShape, TypeList<Canvas&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<CanvasShape, TypeList<Canvas&, bool>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CanvasShape>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(bool)>(&CanvasShape::setCubic));
					case 1: return FunctionPtr(new FunctionImpl<bool(CanvasShape::*)() const>(&CanvasShape::isCubic));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(float32_t)>(&CanvasShape::setThreshold));
					case 3: return FunctionPtr(new FunctionImpl<float32_t(CanvasShape::*)() const>(&CanvasShape::getThreshold));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(const Color&)>(&CanvasShape::setStrokeColor));
					case 5: return FunctionPtr(new FunctionImpl<const Color&(CanvasShape::*)() const>(&CanvasShape::getStrokeColor));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(const StrokeStyle&)>(&CanvasShape::setStrokeStyle));
					case 7: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasShape::*)() const>(&CanvasShape::getStrokeStyleConst));
					case 8: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasShape::*)() const>(&CanvasShape::getStrokeStyle));
					case 9: return FunctionPtr(new FunctionImpl<StrokeStyle&(CanvasShape::*)()>(&CanvasShape::getStrokeStyle));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(const GradientStyle&)>(&CanvasShape::setGradientStyle));
					case 11: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasShape::*)() const>(&CanvasShape::getGradientStyleConst));
					case 12: return FunctionPtr(new FunctionImpl<const GradientStyle&(CanvasShape::*)() const>(&CanvasShape::getGradientStyle));
					case 13: return FunctionPtr(new FunctionImpl<GradientStyle&(CanvasShape::*)()>(&CanvasShape::getGradientStyle));
					case 14: return FunctionPtr(new FunctionImpl<bool(CanvasShape::*)(const char*, float32_t)>(&CanvasShape::createSVG, {}, 1.0f));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)()>(&CanvasShape::clearPositions));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(uint32_t)>(&CanvasShape::setNumPositions));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(uint32_t)>(&CanvasShape::reservePositions));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(CanvasShape::*)() const>(&CanvasShape::getNumPositions));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(const Vector3f*, uint32_t)>(&CanvasShape::setPositions));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(const Vector3f*, uint32_t)>(&CanvasShape::addPositions));
					case 21: return FunctionPtr(new FunctionImpl<const Vector3f*(CanvasShape::*)() const>(&CanvasShape::getPositions));
					case 22: return FunctionPtr(new FunctionImpl<Vector3f*(CanvasShape::*)()>(&CanvasShape::getPositions));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(uint32_t, const Vector3f&)>(&CanvasShape::setPosition));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(uint32_t, float32_t, float32_t, float32_t)>(&CanvasShape::setPosition, {}, {}, {}, 0.0f));
					case 25: return FunctionPtr(new FunctionImpl<const Vector3f&(CanvasShape::*)(uint32_t) const>(&CanvasShape::getPosition));
					case 26: return FunctionPtr(new FunctionImpl<Vector3f&(CanvasShape::*)(uint32_t)>(&CanvasShape::getPosition));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(CanvasShape::*)(const Vector2f&)>(&CanvasShape::addPosition));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(CanvasShape::*)(const Vector3f&)>(&CanvasShape::addPosition));
					case 29: return FunctionPtr(new FunctionImpl<uint32_t(CanvasShape::*)(float32_t, float32_t, float32_t)>(&CanvasShape::addPosition, {}, {}, 0.0f));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(const Rect&)>(&CanvasShape::setTexCoord));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)(float32_t, float32_t, float32_t, float32_t)>(&CanvasShape::setTexCoord));
					case 32: return FunctionPtr(new FunctionImpl<const Rect&(CanvasShape::*)() const>(&CanvasShape::getTexCoord));
					case 33: return FunctionPtr(new FunctionImpl<CanvasShape(CanvasShape::*)() const>(&CanvasShape::clonePtr));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)()>(&CanvasShape::clearPtr));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(CanvasShape::*)()>(&CanvasShape::destroyPtr));
					case 36: return FunctionPtr(new FunctionImpl<CanvasShape&(CanvasShape::*)()>(&CanvasShape::acquirePtr));
					case 37: return FunctionPtr(new FunctionImpl<CanvasShape&(CanvasShape::*)()>(&CanvasShape::unacquirePtr));
					case 38: return FunctionPtr(new FunctionImpl<bool(CanvasShape::*)() const>(&CanvasShape::isValidPtr));
					case 39: return FunctionPtr(new FunctionImpl<bool(CanvasShape::*)() const>(&CanvasShape::isOwnerPtr));
					case 40: return FunctionPtr(new FunctionImpl<bool(CanvasShape::*)() const>(&CanvasShape::isConstPtr));
					case 41: return FunctionPtr(new FunctionImpl<uint32_t(CanvasShape::*)() const>(&CanvasShape::getCountPtr));
					case 42: return FunctionPtr(new FunctionImpl<const void*(CanvasShape::*)() const>(&CanvasShape::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 2110, 2110, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 2111, 2111, 2245 };
			static constexpr uint16_t function_names[] = { 2246, 2247, 2248, 2249, 2221, 2222, 2223, 2225, 2227, 2227, 2183, 2185, 2187, 2187, 2250, 2251, 2252, 2254, 2255, 2256, 2259, 2260, 2260, 1975, 1975, 2174, 2174, 2261, 2261, 2261, 2228, 2228, 2232, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 123, 6, 654, 6, 2226, 2226, 2226, 6, 2186, 2186, 2186, 21, 6, 6, 6, 10, 6, 6, 762, 762, 6, 6, 762, 762, 10, 10, 10, 6, 6, 2094, 2244, 2244, 2244, 2244, 2244, 2244, 2244, 2244, 2244, 2244 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 7, 7, 8, 9, 9, 11, 13, 13, 13, 15, 19, 20, 21, 22, 23, 26, 27, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31 };
			static constexpr uint16_t function_arg_types[] = { 21, 123, 637, 2224, 2184, 22, 123, 10, 10, 2257, 10, 2257, 10, 10, 711, 10, 123, 123, 123, 10, 10, 2202, 711, 123, 123, 123, 2140, 123, 123, 123, 123 };
			static constexpr uint16_t function_arg_names[] = { 2245, 591, 638, 2091, 2091, 90, 527, 2253, 2253, 2258, 2253, 2258, 2253, 274, 729, 274, 1973, 1974, 2173, 274, 274, 729, 729, 1973, 1974, 2173, 735, 2229, 805, 2230, 2231 };
	};
	constexpr uint16_t ReflectionCanvasShape::constructor_bases[];
	constexpr uint16_t ReflectionCanvasShape::constructor_arg_types[];
	constexpr uint16_t ReflectionCanvasShape::constructor_arg_names[];
	constexpr uint16_t ReflectionCanvasShape::function_names[];
	constexpr uint16_t ReflectionCanvasShape::function_types[];
	constexpr uint16_t ReflectionCanvasShape::function_bases[];
	constexpr uint16_t ReflectionCanvasShape::function_arg_types[];
	constexpr uint16_t ReflectionCanvasShape::function_arg_names[];
	static ReflectionCanvasShape reflection_canvas_shape;
	
	// Tellusim::CanvasStrip
	class ReflectionCanvasStrip : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CanvasStrip::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_canvas_element;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CanvasStrip, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<CanvasStrip, TypeList<Canvas&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<CanvasStrip, TypeList<Canvas&, float32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CanvasStrip>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(float32_t)>(&CanvasStrip::setWidth));
					case 1: return FunctionPtr(new FunctionImpl<float32_t(CanvasStrip::*)() const>(&CanvasStrip::getWidth));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(float32_t)>(&CanvasStrip::setOffset));
					case 3: return FunctionPtr(new FunctionImpl<float32_t(CanvasStrip::*)() const>(&CanvasStrip::getOffset));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(const Color&)>(&CanvasStrip::setStrokeColor));
					case 5: return FunctionPtr(new FunctionImpl<const Color&(CanvasStrip::*)() const>(&CanvasStrip::getStrokeColor));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(const StrokeStyle&)>(&CanvasStrip::setStrokeStyle));
					case 7: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasStrip::*)() const>(&CanvasStrip::getStrokeStyleConst));
					case 8: return FunctionPtr(new FunctionImpl<const StrokeStyle&(CanvasStrip::*)() const>(&CanvasStrip::getStrokeStyle));
					case 9: return FunctionPtr(new FunctionImpl<StrokeStyle&(CanvasStrip::*)()>(&CanvasStrip::getStrokeStyle));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(const Vector2f&, const Vector2f&, const Vector2f&, float32_t)>(&CanvasStrip::createQuadratic, {}, {}, {}, 1.0f));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(const Vector3f&, const Vector3f&, const Vector3f&, float32_t)>(&CanvasStrip::createQuadratic, {}, {}, {}, 1.0f));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(const Vector2f&, const Vector2f&, const Vector2f&, const Vector2f&, float32_t)>(&CanvasStrip::createCubic, {}, {}, {}, {}, 1.0f));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(const Vector3f&, const Vector3f&, const Vector3f&, const Vector3f&, float32_t)>(&CanvasStrip::createCubic, {}, {}, {}, {}, 1.0f));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)()>(&CanvasStrip::clearPositions));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(uint32_t)>(&CanvasStrip::setNumPositions));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(uint32_t)>(&CanvasStrip::reservePositions));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(CanvasStrip::*)() const>(&CanvasStrip::getNumPositions));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(const Vector3f*, uint32_t)>(&CanvasStrip::setPositions));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(const Vector3f*, uint32_t)>(&CanvasStrip::addPositions));
					case 20: return FunctionPtr(new FunctionImpl<const Vector3f*(CanvasStrip::*)() const>(&CanvasStrip::getPositions));
					case 21: return FunctionPtr(new FunctionImpl<Vector3f*(CanvasStrip::*)()>(&CanvasStrip::getPositions));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(uint32_t, const Vector3f&)>(&CanvasStrip::setPosition));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)(uint32_t, float32_t, float32_t, float32_t)>(&CanvasStrip::setPosition, {}, {}, {}, 0.0f));
					case 24: return FunctionPtr(new FunctionImpl<const Vector3f&(CanvasStrip::*)(uint32_t) const>(&CanvasStrip::getPosition));
					case 25: return FunctionPtr(new FunctionImpl<Vector3f&(CanvasStrip::*)(uint32_t)>(&CanvasStrip::getPosition));
					case 26: return FunctionPtr(new FunctionImpl<uint32_t(CanvasStrip::*)(const Vector2f&)>(&CanvasStrip::addPosition));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(CanvasStrip::*)(const Vector3f&)>(&CanvasStrip::addPosition));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(CanvasStrip::*)(float32_t, float32_t, float32_t)>(&CanvasStrip::addPosition, {}, {}, 0.0f));
					case 29: return FunctionPtr(new FunctionImpl<CanvasStrip(CanvasStrip::*)() const>(&CanvasStrip::clonePtr));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)()>(&CanvasStrip::clearPtr));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(CanvasStrip::*)()>(&CanvasStrip::destroyPtr));
					case 32: return FunctionPtr(new FunctionImpl<CanvasStrip&(CanvasStrip::*)()>(&CanvasStrip::acquirePtr));
					case 33: return FunctionPtr(new FunctionImpl<CanvasStrip&(CanvasStrip::*)()>(&CanvasStrip::unacquirePtr));
					case 34: return FunctionPtr(new FunctionImpl<bool(CanvasStrip::*)() const>(&CanvasStrip::isValidPtr));
					case 35: return FunctionPtr(new FunctionImpl<bool(CanvasStrip::*)() const>(&CanvasStrip::isOwnerPtr));
					case 36: return FunctionPtr(new FunctionImpl<bool(CanvasStrip::*)() const>(&CanvasStrip::isConstPtr));
					case 37: return FunctionPtr(new FunctionImpl<uint32_t(CanvasStrip::*)() const>(&CanvasStrip::getCountPtr));
					case 38: return FunctionPtr(new FunctionImpl<const void*(CanvasStrip::*)() const>(&CanvasStrip::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3 };
			static constexpr uint16_t constructor_arg_types[] = { 2110, 2110, 123 };
			static constexpr uint16_t constructor_arg_names[] = { 2111, 2111, 30 };
			static constexpr uint16_t function_names[] = { 2263, 11, 2264, 404, 2221, 2222, 2223, 2225, 2227, 2227, 2265, 2265, 2269, 2269, 2251, 2252, 2254, 2255, 2256, 2259, 2260, 2260, 1975, 1975, 2174, 2174, 2261, 2261, 2261, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 123, 6, 123, 6, 654, 6, 2226, 2226, 2226, 6, 6, 6, 6, 6, 6, 6, 10, 6, 6, 762, 762, 6, 6, 762, 762, 10, 10, 10, 2262, 2262, 2262, 2262, 2262, 2262, 2262, 2262, 2262, 2262 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 4, 4, 8, 12, 17, 22, 22, 23, 24, 24, 26, 28, 28, 28, 30, 34, 35, 36, 37, 38, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41 };
			static constexpr uint16_t function_arg_types[] = { 123, 123, 637, 2224, 2202, 2202, 2202, 123, 711, 711, 711, 123, 2202, 2202, 2202, 2202, 123, 711, 711, 711, 711, 123, 10, 10, 2257, 10, 2257, 10, 10, 711, 10, 123, 123, 123, 10, 10, 2202, 711, 123, 123, 123 };
			static constexpr uint16_t function_arg_names[] = { 30, 78, 638, 2091, 2266, 2267, 2268, 591, 2266, 2267, 2268, 591, 2266, 2267, 2268, 2270, 591, 2266, 2267, 2268, 2270, 591, 2253, 2253, 2258, 2253, 2258, 2253, 274, 729, 274, 1973, 1974, 2173, 274, 274, 729, 729, 1973, 1974, 2173 };
	};
	constexpr uint16_t ReflectionCanvasStrip::constructor_bases[];
	constexpr uint16_t ReflectionCanvasStrip::constructor_arg_types[];
	constexpr uint16_t ReflectionCanvasStrip::constructor_arg_names[];
	constexpr uint16_t ReflectionCanvasStrip::function_names[];
	constexpr uint16_t ReflectionCanvasStrip::function_types[];
	constexpr uint16_t ReflectionCanvasStrip::function_bases[];
	constexpr uint16_t ReflectionCanvasStrip::function_arg_types[];
	constexpr uint16_t ReflectionCanvasStrip::function_arg_names[];
	static ReflectionCanvasStrip reflection_canvas_strip;
	
	// Tellusim::Canvas
	class ReflectionCanvas : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Canvas::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Canvas, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Canvas, TypeList<Canvas*>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Canvas>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)()>(&Canvas::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(Canvas::*)() const>(&Canvas::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)(const Target&, uint32_t) const>(&Canvas::getScale, Target::null, 100));
					case 3: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const Device&, Format, Format, uint32_t, uint32_t)>(&Canvas::create, Device::null, (Format)0, (Format)0, 1, 0));
					case 4: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const Device&, const Target&, uint32_t)>(&Canvas::create, Device::null, Target::null, 0));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(uint32_t)>(&Canvas::setPipelineHash));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)() const>(&Canvas::getPipelineHash));
					case 7: return FunctionPtr(new FunctionImpl<Format(Canvas::*)() const>(&Canvas::getColorFormat));
					case 8: return FunctionPtr(new FunctionImpl<Format(Canvas::*)() const>(&Canvas::getDepthFormat));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)() const>(&Canvas::getMultisample));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(int32_t)>(&Canvas::setOrder));
					case 11: return FunctionPtr(new FunctionImpl<int32_t(Canvas::*)() const>(&Canvas::getOrder));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(bool)>(&Canvas::setEnabled));
					case 13: return FunctionPtr(new FunctionImpl<bool(Canvas::*)() const>(&Canvas::isEnabled));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const Viewport&)>(&Canvas::setViewport));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(uint32_t, uint32_t)>(&Canvas::setViewport));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(float32_t, float32_t)>(&Canvas::setViewport));
					case 17: return FunctionPtr(new FunctionImpl<const Viewport&(Canvas::*)() const>(&Canvas::getViewport));
					case 18: return FunctionPtr(new FunctionImpl<float32_t(Canvas::*)() const>(&Canvas::getWidth));
					case 19: return FunctionPtr(new FunctionImpl<float32_t(Canvas::*)() const>(&Canvas::getHeight));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)()>(&Canvas::clearColor));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const Color&)>(&Canvas::setColor));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(float32_t, float32_t, float32_t, float32_t)>(&Canvas::setColor));
					case 23: return FunctionPtr(new FunctionImpl<const Color&(Canvas::*)() const>(&Canvas::getColor));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)()>(&Canvas::clearScissor));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const Rect&)>(&Canvas::setScissor));
					case 26: return FunctionPtr(new FunctionImpl<const Rect&(Canvas::*)() const>(&Canvas::getScissor));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)()>(&Canvas::clearTransform));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const Matrix4x4f&)>(&Canvas::setTransform));
					case 29: return FunctionPtr(new FunctionImpl<const Matrix4x4f&(Canvas::*)() const>(&Canvas::getTransform));
					case 30: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)(Canvas&)>(&Canvas::setParent));
					case 31: return FunctionPtr(new FunctionImpl<const Canvas(Canvas::*)() const>(&Canvas::getParent));
					case 32: return FunctionPtr(new FunctionImpl<Canvas(Canvas::*)()>(&Canvas::getParent));
					case 33: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)(Canvas&)>(&Canvas::addChild));
					case 34: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(Canvas&)>(&Canvas::removeChild));
					case 35: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(Canvas&)>(&Canvas::raiseChild));
					case 36: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(Canvas&)>(&Canvas::lowerChild));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)()>(&Canvas::releaseChildren));
					case 38: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)(const Canvas&) const>(&Canvas::findChild));
					case 39: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const Canvas&) const>(&Canvas::isChild));
					case 40: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)() const>(&Canvas::getNumChildren));
					case 41: return FunctionPtr(new FunctionImpl<const Array<Canvas>(Canvas::*)() const>(&Canvas::getChildren));
					case 42: return FunctionPtr(new FunctionImpl<Array<Canvas>(Canvas::*)()>(&Canvas::getChildren));
					case 43: return FunctionPtr(new FunctionImpl<const Canvas(Canvas::*)(uint32_t) const>(&Canvas::getChild));
					case 44: return FunctionPtr(new FunctionImpl<Canvas(Canvas::*)(uint32_t)>(&Canvas::getChild));
					case 45: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)(CanvasElement&)>(&Canvas::addElement));
					case 46: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(CanvasElement&)>(&Canvas::removeElement));
					case 47: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(CanvasElement&)>(&Canvas::raiseElement));
					case 48: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(CanvasElement&)>(&Canvas::lowerElement));
					case 49: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)(const CanvasElement&) const>(&Canvas::findElement));
					case 50: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const CanvasElement&) const>(&Canvas::isElement));
					case 51: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)() const>(&Canvas::getNumElements));
					case 52: return FunctionPtr(new FunctionImpl<const Array<CanvasElement>(Canvas::*)() const>(&Canvas::getElements));
					case 53: return FunctionPtr(new FunctionImpl<Array<CanvasElement>(Canvas::*)()>(&Canvas::getElements));
					case 54: return FunctionPtr(new FunctionImpl<const CanvasElement(Canvas::*)(uint32_t) const>(&Canvas::getElement));
					case 55: return FunctionPtr(new FunctionImpl<CanvasElement(Canvas::*)(uint32_t)>(&Canvas::getElement));
					case 56: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const char*) const>(&Canvas::isFont));
					case 57: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const char*, Stream&)>(&Canvas::addFont));
					case 58: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const char*, const uint8_t(*)[256])>(&Canvas::addFont));
					case 59: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const char*)>(&Canvas::removeFont));
					case 60: return FunctionPtr(new FunctionImpl<Font(Canvas::*)(const char*)>(&Canvas::getFont));
					case 61: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const char*) const>(&Canvas::isTexture));
					case 62: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const char*, Stream&)>(&Canvas::addTexture));
					case 63: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const char*, Texture&)>(&Canvas::addTexture));
					case 64: return FunctionPtr(new FunctionImpl<bool(Canvas::*)(const char*, const uint8_t(*)[256])>(&Canvas::addTexture));
					case 65: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const char*)>(&Canvas::removeTexture));
					case 66: return FunctionPtr(new FunctionImpl<Texture(Canvas::*)(const char*)>(&Canvas::getTexture));
					case 67: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(Pipeline::DepthMask)>(&Canvas::setDepthMask));
					case 68: return FunctionPtr(new FunctionImpl<Pipeline::DepthMask(Canvas::*)() const>(&Canvas::getDepthMask));
					case 69: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(Pipeline::DepthFunc)>(&Canvas::setDepthFunc));
					case 70: return FunctionPtr(new FunctionImpl<Pipeline::DepthFunc(Canvas::*)() const>(&Canvas::getDepthFunc));
					case 71: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(Command&, const Target&)>(&Canvas::draw));
					case 72: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(Command&)>(&Canvas::draw));
					case 73: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const Canvas::CreateCallback&)>(&Canvas::setCreateCallback));
					case 74: return FunctionPtr(new FunctionImpl<Canvas::CreateCallback(Canvas::*)() const>(&Canvas::getCreateCallback));
					case 75: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const Canvas::PipelineCallback&)>(&Canvas::setPipelineCallback));
					case 76: return FunctionPtr(new FunctionImpl<Canvas::PipelineCallback(Canvas::*)() const>(&Canvas::getPipelineCallback));
					case 77: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const Canvas::BeginCallback&)>(&Canvas::setBeginCallback));
					case 78: return FunctionPtr(new FunctionImpl<Canvas::BeginCallback(Canvas::*)() const>(&Canvas::getBeginCallback));
					case 79: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)(const Canvas::DrawCallback&)>(&Canvas::setDrawCallback));
					case 80: return FunctionPtr(new FunctionImpl<Canvas::DrawCallback(Canvas::*)() const>(&Canvas::getDrawCallback));
					case 81: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)() const>(&Canvas::getNumDrawPipelines));
					case 82: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)() const>(&Canvas::getNumDrawElements));
					case 83: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)() const>(&Canvas::getNumDrawCommands));
					case 84: return FunctionPtr(new FunctionImpl<Rect(Canvas::*)() const>(&Canvas::getRect));
					case 85: return FunctionPtr(new FunctionImpl<Canvas(Canvas::*)() const>(&Canvas::clonePtr));
					case 86: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)()>(&Canvas::clearPtr));
					case 87: return FunctionPtr(new FunctionVoidImpl<void(Canvas::*)()>(&Canvas::destroyPtr));
					case 88: return FunctionPtr(new FunctionImpl<Canvas&(Canvas::*)()>(&Canvas::acquirePtr));
					case 89: return FunctionPtr(new FunctionImpl<Canvas&(Canvas::*)()>(&Canvas::unacquirePtr));
					case 90: return FunctionPtr(new FunctionImpl<bool(Canvas::*)() const>(&Canvas::isValidPtr));
					case 91: return FunctionPtr(new FunctionImpl<bool(Canvas::*)() const>(&Canvas::isOwnerPtr));
					case 92: return FunctionPtr(new FunctionImpl<bool(Canvas::*)() const>(&Canvas::isConstPtr));
					case 93: return FunctionPtr(new FunctionImpl<uint32_t(Canvas::*)() const>(&Canvas::getCountPtr));
					case 94: return FunctionPtr(new FunctionImpl<const void*(Canvas::*)() const>(&Canvas::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1 };
			static constexpr uint16_t constructor_arg_types[] = { 2271 };
			static constexpr uint16_t constructor_arg_names[] = { 458 };
			static constexpr uint16_t function_names[] = { 5, 904, 761, 24, 24, 2273, 2274, 1494, 1495, 13, 2126, 2128, 2129, 1493, 972, 972, 972, 2275, 11, 12, 2130, 2131, 2131, 2133, 2139, 979, 2141, 2135, 525, 713, 464, 466, 466, 470, 472, 2277, 2278, 473, 474, 858, 476, 477, 477, 478, 478, 2280, 2283, 2284, 2285, 2286, 2288, 2289, 2290, 2290, 2291, 2291, 2292, 2293, 2293, 2294, 2295, 2296, 1664, 1664, 1664, 2297, 1429, 1829, 1834, 1831, 1836, 2100, 2100, 2298, 2300, 2302, 2304, 2306, 2308, 2156, 2158, 2311, 2312, 2313, 2093, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 10, 21, 21, 6, 10, 340, 340, 10, 6, 1, 6, 21, 6, 6, 6, 2276, 123, 123, 6, 6, 6, 654, 6, 6, 2094, 6, 6, 2137, 10, 2113, 2113, 10, 21, 21, 21, 6, 10, 21, 10, 19, 19, 2113, 2113, 10, 21, 21, 21, 10, 21, 10, 19, 19, 2102, 2102, 21, 21, 21, 6, 2088, 21, 21, 21, 21, 6, 1377, 6, 1835, 6, 1837, 6, 6, 6, 2301, 6, 2305, 6, 2309, 6, 2159, 10, 10, 10, 2094, 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113, 2113 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 2, 7, 10, 11, 11, 11, 11, 11, 12, 12, 13, 13, 14, 16, 18, 18, 18, 18, 18, 19, 23, 23, 23, 24, 24, 24, 25, 25, 26, 26, 26, 27, 28, 29, 30, 30, 31, 32, 32, 32, 32, 33, 34, 35, 36, 37, 38, 39, 40, 40, 40, 40, 41, 42, 43, 45, 47, 48, 49, 50, 52, 54, 56, 57, 58, 59, 59, 60, 60, 62, 63, 64, 64, 65, 65, 66, 66, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67, 67 };
			static constexpr uint16_t function_arg_types[] = { 2272, 10, 2099, 340, 340, 10, 10, 2099, 2272, 10, 10, 1, 21, 973, 10, 10, 123, 123, 637, 123, 123, 123, 123, 2140, 2136, 2110, 2110, 2110, 2110, 2110, 2279, 2279, 10, 10, 2281, 2281, 2281, 2281, 2287, 2287, 10, 10, 22, 22, 145, 22, 168, 22, 22, 22, 22, 145, 22, 994, 22, 168, 22, 22, 1830, 1832, 2101, 2272, 2101, 2299, 2303, 2307, 2310 };
			static constexpr uint16_t function_arg_names[] = { 944, 527, 28, 638, 415, 32, 527, 28, 944, 527, 180, 2127, 1309, 974, 30, 31, 30, 31, 638, 1054, 1055, 1056, 1057, 981, 511, 458, 471, 471, 471, 471, 471, 471, 274, 274, 2282, 2282, 2282, 2282, 2282, 2282, 274, 274, 23, 23, 222, 23, 169, 23, 23, 23, 23, 222, 23, 995, 23, 169, 23, 23, 53, 1162, 188, 944, 188, 1162, 1162, 1162, 1162 };
	};
	constexpr uint16_t ReflectionCanvas::constructor_bases[];
	constexpr uint16_t ReflectionCanvas::constructor_arg_types[];
	constexpr uint16_t ReflectionCanvas::constructor_arg_names[];
	constexpr uint16_t ReflectionCanvas::function_names[];
	constexpr uint16_t ReflectionCanvas::function_types[];
	constexpr uint16_t ReflectionCanvas::function_bases[];
	constexpr uint16_t ReflectionCanvas::function_arg_types[];
	constexpr uint16_t ReflectionCanvas::function_arg_names[];
	static ReflectionCanvas reflection_canvas;
	
	// Tellusim::Control
	class ReflectionControl : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Control::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Control, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<Control, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<Control, TypeList<Control*, float32_t, float32_t>>({}, {}, 0.0f));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Control>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Control::Type(Control::*)() const>(&Control::getType));
					case 1: return FunctionPtr(new FunctionImpl<const char*(Control::Type)>(&Control::getTypeName));
					case 2: return FunctionPtr(new FunctionImpl<const char*(Control::*)() const>(&Control::getTypeName));
					case 3: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isUnknown));
					case 4: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isRoot));
					case 5: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isText));
					case 6: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isRect));
					case 7: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isGrid));
					case 8: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isGroup));
					case 9: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isPanel));
					case 10: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isDialog));
					case 11: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isWindow));
					case 12: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isCheck));
					case 13: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isCombo));
					case 14: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isButton));
					case 15: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isSlider));
					case 16: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isScroll));
					case 17: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isSplit));
					case 18: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isArea));
					case 19: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isTree));
					case 20: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isEdit));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(Control::Align)>(&Control::setAlign));
					case 22: return FunctionPtr(new FunctionImpl<Control::Align(Control::*)() const>(&Control::getAlign));
					case 23: return FunctionPtr(new FunctionImpl<bool(Control::*)(Control::Align) const>(&Control::hasAlign));
					case 24: return FunctionPtr(new FunctionImpl<bool(Control::*)(Control::Align) const>(&Control::hasAligns));
					case 25: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isSpacer));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(bool)>(&Control::setEnabled));
					case 27: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isEnabled));
					case 28: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::wasEnabled));
					case 29: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::wasUpdated));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(bool)>(&Control::setDisabled));
					case 31: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isDisabled));
					case 32: return FunctionPtr(new FunctionImpl<Canvas(Control::*)() const>(&Control::getCanvas));
					case 33: return FunctionPtr(new FunctionImpl<const ControlRoot(Control::*)() const>(&Control::getRoot));
					case 34: return FunctionPtr(new FunctionImpl<ControlRoot(Control::*)()>(&Control::getRoot));
					case 35: return FunctionPtr(new FunctionImpl<const ControlPanel(Control::*)() const>(&Control::getPanel));
					case 36: return FunctionPtr(new FunctionImpl<ControlPanel(Control::*)()>(&Control::getPanel));
					case 37: return FunctionPtr(new FunctionImpl<uint32_t(Control::*)(Control&)>(&Control::setParent));
					case 38: return FunctionPtr(new FunctionImpl<const Control(Control::*)() const>(&Control::getParent));
					case 39: return FunctionPtr(new FunctionImpl<Control(Control::*)()>(&Control::getParent));
					case 40: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isParentEnabled));
					case 41: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isParentDisabled));
					case 42: return FunctionPtr(new FunctionImpl<uint32_t(Control::*)(Control&)>(&Control::addChild));
					case 43: return FunctionPtr(new FunctionImpl<bool(Control::*)(Control&)>(&Control::removeChild));
					case 44: return FunctionPtr(new FunctionImpl<bool(Control::*)(Control&)>(&Control::raiseChild));
					case 45: return FunctionPtr(new FunctionImpl<bool(Control::*)(Control&)>(&Control::lowerChild));
					case 46: return FunctionPtr(new FunctionVoidImpl<void(Control::*)()>(&Control::releaseChildren));
					case 47: return FunctionPtr(new FunctionImpl<uint32_t(Control::*)(const Control&) const>(&Control::findChild));
					case 48: return FunctionPtr(new FunctionImpl<bool(Control::*)(const Control&) const>(&Control::isChild));
					case 49: return FunctionPtr(new FunctionImpl<uint32_t(Control::*)() const>(&Control::getNumChildren));
					case 50: return FunctionPtr(new FunctionImpl<const Array<Control>(Control::*)() const>(&Control::getChildren));
					case 51: return FunctionPtr(new FunctionImpl<Array<Control>(Control::*)()>(&Control::getChildren));
					case 52: return FunctionPtr(new FunctionImpl<const Control(Control::*)(uint32_t) const>(&Control::getChild));
					case 53: return FunctionPtr(new FunctionImpl<Control(Control::*)(uint32_t)>(&Control::getChild));
					case 54: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(const Vector2f&)>(&Control::setSize));
					case 55: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(float32_t, float32_t)>(&Control::setSize));
					case 56: return FunctionPtr(new FunctionImpl<const Vector2f&(Control::*)() const>(&Control::getSize));
					case 57: return FunctionPtr(new FunctionImpl<float32_t(Control::*)() const>(&Control::getWidth));
					case 58: return FunctionPtr(new FunctionImpl<float32_t(Control::*)() const>(&Control::getHeight));
					case 59: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(const Vector3f&)>(&Control::setPosition));
					case 60: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(float32_t, float32_t, float32_t)>(&Control::setPosition, {}, {}, 0.0f));
					case 61: return FunctionPtr(new FunctionImpl<const Vector3f&(Control::*)() const>(&Control::getPosition));
					case 62: return FunctionPtr(new FunctionImpl<float32_t(Control::*)() const>(&Control::getPositionX));
					case 63: return FunctionPtr(new FunctionImpl<float32_t(Control::*)() const>(&Control::getPositionY));
					case 64: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(const Vector3f&)>(&Control::setOffset));
					case 65: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(float32_t, float32_t, float32_t)>(&Control::setOffset, {}, {}, 0.0f));
					case 66: return FunctionPtr(new FunctionImpl<const Vector3f&(Control::*)() const>(&Control::getOffset));
					case 67: return FunctionPtr(new FunctionImpl<float32_t(Control::*)() const>(&Control::getOffsetX));
					case 68: return FunctionPtr(new FunctionImpl<float32_t(Control::*)() const>(&Control::getOffsetY));
					case 69: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(float32_t)>(&Control::setMargin));
					case 70: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(float32_t, float32_t)>(&Control::setMargin));
					case 71: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(float32_t, float32_t, float32_t, float32_t)>(&Control::setMargin));
					case 72: return FunctionPtr(new FunctionVoidImpl<void(Control::*)(const Rect&)>(&Control::setMargin));
					case 73: return FunctionPtr(new FunctionImpl<const Rect&(Control::*)() const>(&Control::getMargin));
					case 74: return FunctionPtr(new FunctionImpl<const Rect&(Control::*)() const>(&Control::getRect));
					case 75: return FunctionPtr(new FunctionImpl<Control::State(Control::*)() const>(&Control::getState));
					case 76: return FunctionPtr(new FunctionImpl<Control(Control::*)() const>(&Control::clonePtr));
					case 77: return FunctionPtr(new FunctionVoidImpl<void(Control::*)()>(&Control::clearPtr));
					case 78: return FunctionPtr(new FunctionVoidImpl<void(Control::*)()>(&Control::destroyPtr));
					case 79: return FunctionPtr(new FunctionImpl<Control&(Control::*)()>(&Control::acquirePtr));
					case 80: return FunctionPtr(new FunctionImpl<Control&(Control::*)()>(&Control::unacquirePtr));
					case 81: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isValidPtr));
					case 82: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isOwnerPtr));
					case 83: return FunctionPtr(new FunctionImpl<bool(Control::*)() const>(&Control::isConstPtr));
					case 84: return FunctionPtr(new FunctionImpl<uint32_t(Control::*)() const>(&Control::getCountPtr));
					case 85: return FunctionPtr(new FunctionImpl<const void*(Control::*)() const>(&Control::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 4 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 123, 123 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 30, 31 };
			static constexpr uint16_t function_names[] = { 214, 345, 345, 530, 467, 2104, 2105, 2317, 540, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329, 2118, 2121, 2123, 2124, 2331, 2129, 1493, 2332, 2333, 2334, 2336, 2112, 856, 856, 2338, 2338, 464, 466, 466, 2341, 2342, 470, 472, 2277, 2278, 473, 474, 858, 476, 477, 477, 478, 478, 29, 29, 73, 11, 12, 1975, 1975, 2174, 1976, 1977, 2264, 2264, 404, 2344, 2345, 2346, 2346, 2346, 2346, 2350, 2093, 2351, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 215, 138, 138, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 6, 2122, 21, 21, 21, 6, 21, 21, 21, 6, 21, 2113, 2337, 2337, 2339, 2339, 10, 2314, 2314, 21, 21, 10, 21, 21, 21, 6, 10, 21, 10, 19, 19, 2314, 2314, 6, 6, 2206, 123, 123, 6, 6, 762, 123, 123, 6, 6, 762, 123, 123, 6, 6, 6, 6, 2094, 2094, 2352, 2314, 2314, 2314, 2314, 2314, 2314, 2314, 2314, 2314, 2314 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 9, 10, 11, 11, 12, 13, 13, 13, 13, 14, 15, 16, 18, 18, 18, 18, 19, 22, 22, 22, 22, 23, 26, 26, 26, 26, 27, 29, 33, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34, 34 };
			static constexpr uint16_t function_arg_types[] = { 2316, 2330, 2330, 2330, 21, 21, 2340, 2340, 2340, 2340, 2340, 2343, 2343, 10, 10, 2202, 123, 123, 711, 123, 123, 123, 711, 123, 123, 123, 123, 123, 123, 123, 123, 123, 123, 2140 };
			static constexpr uint16_t function_arg_names[] = { 195, 2120, 2120, 2125, 1309, 2335, 458, 471, 471, 471, 471, 471, 471, 274, 274, 87, 30, 31, 729, 1973, 1974, 2173, 78, 1973, 1974, 2173, 105, 2347, 2348, 2229, 805, 2230, 2231, 2349 };
	};
	constexpr uint16_t ReflectionControl::constructor_bases[];
	constexpr uint16_t ReflectionControl::constructor_arg_types[];
	constexpr uint16_t ReflectionControl::constructor_arg_names[];
	constexpr uint16_t ReflectionControl::function_names[];
	constexpr uint16_t ReflectionControl::function_types[];
	constexpr uint16_t ReflectionControl::function_bases[];
	constexpr uint16_t ReflectionControl::function_arg_types[];
	constexpr uint16_t ReflectionControl::function_arg_names[];
	static ReflectionControl reflection_control;
	
	// Tellusim::ControlRoot
	class ReflectionControlRoot : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlRoot::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlRoot, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlRoot, TypeList<Canvas&, bool>>(Canvas::null, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlRoot>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const Viewport&)>(&ControlRoot::setViewport));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(uint32_t, uint32_t)>(&ControlRoot::setViewport));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(float32_t, float32_t)>(&ControlRoot::setViewport));
					case 3: return FunctionPtr(new FunctionImpl<const Viewport&(ControlRoot::*)() const>(&ControlRoot::getViewport));
					case 4: return FunctionPtr(new FunctionImpl<String(ControlRoot::*)() const>(&ControlRoot::getFontName));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const char*)>(&ControlRoot::setFontName));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const String&)>(&ControlRoot::setFontName));
					case 7: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(const uint8_t(*)[256], const char*)>(&ControlRoot::setFontBlob, {}, nullptr));
					case 8: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(uint32_t, bool)>(&ControlRoot::setFontSize, {}, false));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(ControlRoot::*)() const>(&ControlRoot::getFontSize));
					case 10: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(uint32_t, bool)>(&ControlRoot::setFontScale, {}, false));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(ControlRoot::*)() const>(&ControlRoot::getFontScale));
					case 12: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(const FontStyle&, bool)>(&ControlRoot::setFontStyle, {}, false));
					case 13: return FunctionPtr(new FunctionImpl<const FontStyle&(ControlRoot::*)() const>(&ControlRoot::getFontStyle));
					case 14: return FunctionPtr(new FunctionImpl<FontStyle&(ControlRoot::*)()>(&ControlRoot::getFontStyle));
					case 15: return FunctionPtr(new FunctionImpl<String(ControlRoot::*)() const>(&ControlRoot::getTextureName));
					case 16: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(const char*, uint32_t, uint32_t, float32_t)>(&ControlRoot::setTextureName, {}, 0, 0, 0.0f));
					case 17: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(const String&, uint32_t, uint32_t, float32_t)>(&ControlRoot::setTextureName, {}, 0, 0, 0.0f));
					case 18: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(const uint8_t(*)[256], const char*, uint32_t, uint32_t, float32_t)>(&ControlRoot::setTextureBlob, {}, nullptr, 0, 0, 0.0f));
					case 19: return FunctionPtr(new FunctionImpl<float32_t(ControlRoot::*)() const>(&ControlRoot::getTextureWidth));
					case 20: return FunctionPtr(new FunctionImpl<float32_t(ControlRoot::*)() const>(&ControlRoot::getTextureHeight));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control::Type, Control::State, const Color&)>(&ControlRoot::setTextColor));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control::Type, Control::State, const Vector3f&)>(&ControlRoot::setTextOffset));
					case 23: return FunctionPtr(new FunctionImpl<const Color&(ControlRoot::*)(Control::Type, Control::State) const>(&ControlRoot::getTextColor));
					case 24: return FunctionPtr(new FunctionImpl<const Vector3f&(ControlRoot::*)(Control::Type, Control::State) const>(&ControlRoot::getTextOffset));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control::Mesh, Control::State, const Color&)>(&ControlRoot::setMeshColor));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control::Mesh, const Rect&, const Rect&, const Vector2f&)>(&ControlRoot::setMeshRegion));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control::Mesh, const Rect&, const Rect&, const Vector2f&)>(&ControlRoot::setMeshRegions));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(ControlRoot::*)(Control::Mesh, Control::State) const>(&ControlRoot::getMeshColor));
					case 29: return FunctionPtr(new FunctionImpl<const Rect&(ControlRoot::*)(Control::Mesh) const>(&ControlRoot::getMeshGrid));
					case 30: return FunctionPtr(new FunctionImpl<const Rect&(ControlRoot::*)(Control::Mesh) const>(&ControlRoot::getMeshMargin));
					case 31: return FunctionPtr(new FunctionImpl<const Rect&(ControlRoot::*)(Control::Mesh, Control::State) const>(&ControlRoot::getMeshRegion));
					case 32: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(float32_t)>(&ControlRoot::setGroupRadius));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const Color&)>(&ControlRoot::setGroupColor));
					case 34: return FunctionPtr(new FunctionImpl<float32_t(ControlRoot::*)() const>(&ControlRoot::getGroupRadius));
					case 35: return FunctionPtr(new FunctionImpl<const Color&(ControlRoot::*)() const>(&ControlRoot::getGroupColor));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(float32_t)>(&ControlRoot::setPanelRadius));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const Color&)>(&ControlRoot::setPanelColor));
					case 38: return FunctionPtr(new FunctionImpl<float32_t(ControlRoot::*)() const>(&ControlRoot::getPanelRadius));
					case 39: return FunctionPtr(new FunctionImpl<const Color&(ControlRoot::*)() const>(&ControlRoot::getPanelColor));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const Color&)>(&ControlRoot::setCheckedColor));
					case 41: return FunctionPtr(new FunctionImpl<const Color&(ControlRoot::*)() const>(&ControlRoot::getCheckedColor));
					case 42: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(int32_t, int32_t, Control::Button)>(&ControlRoot::setMouse));
					case 43: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(float32_t, float32_t, Control::Button)>(&ControlRoot::setMouse));
					case 44: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlRoot::*)() const>(&ControlRoot::getMouse));
					case 45: return FunctionPtr(new FunctionImpl<Control::Button(ControlRoot::*)() const>(&ControlRoot::getMouseButtons));
					case 46: return FunctionPtr(new FunctionImpl<float32_t(ControlRoot::*)() const>(&ControlRoot::getMouseX));
					case 47: return FunctionPtr(new FunctionImpl<float32_t(ControlRoot::*)() const>(&ControlRoot::getMouseY));
					case 48: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control::Axis, float32_t)>(&ControlRoot::setMouseAxis));
					case 49: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control::Align, bool)>(&ControlRoot::setMouseAlign, (Control::Align)0, true));
					case 50: return FunctionPtr(new FunctionImpl<Control::Align(ControlRoot::*)() const>(&ControlRoot::getMouseAlign));
					case 51: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(Control::Align) const>(&ControlRoot::hasMouseAlign));
					case 52: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(Control::Align) const>(&ControlRoot::hasMouseAligns));
					case 53: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(uint32_t, uint32_t, bool)>(&ControlRoot::setKeyboardKey));
					case 54: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(uint32_t, bool)>(&ControlRoot::getKeyboardKey, {}, false));
					case 55: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)()>(&ControlRoot::clearCurrentControl));
					case 56: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control, bool)>(&ControlRoot::setCurrentControl, {}, false));
					case 57: return FunctionPtr(new FunctionImpl<Control(ControlRoot::*)() const>(&ControlRoot::getCurrentControl));
					case 58: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)() const>(&ControlRoot::getControlGrab));
					case 59: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)()>(&ControlRoot::clearFocusedControl));
					case 60: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control)>(&ControlRoot::setFocusedControl));
					case 61: return FunctionPtr(new FunctionImpl<Control(ControlRoot::*)() const>(&ControlRoot::getFocusedControl));
					case 62: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)() const>(&ControlRoot::isFocusedControl));
					case 63: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)()>(&ControlRoot::clearMouseControl));
					case 64: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control)>(&ControlRoot::setMouseControl));
					case 65: return FunctionPtr(new FunctionImpl<Control(ControlRoot::*)() const>(&ControlRoot::getMouseControl));
					case 66: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)() const>(&ControlRoot::isMouseControl));
					case 67: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)()>(&ControlRoot::clearInputControl));
					case 68: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control)>(&ControlRoot::setInputControl));
					case 69: return FunctionPtr(new FunctionImpl<Control(ControlRoot::*)() const>(&ControlRoot::getInputControl));
					case 70: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)() const>(&ControlRoot::isInputControl));
					case 71: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)()>(&ControlRoot::clearModalControl));
					case 72: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(Control)>(&ControlRoot::setModalControl));
					case 73: return FunctionPtr(new FunctionImpl<Control(ControlRoot::*)() const>(&ControlRoot::getModalControl));
					case 74: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)() const>(&ControlRoot::isModalControl));
					case 75: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)(uint32_t, int32_t)>(&ControlRoot::update, 0, 0));
					case 76: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const char*)>(&ControlRoot::setCopyText));
					case 77: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const String&)>(&ControlRoot::setCopyText));
					case 78: return FunctionPtr(new FunctionImpl<String(ControlRoot::*)()>(&ControlRoot::getPasteText));
					case 79: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const ControlRoot::CopyCallback&)>(&ControlRoot::setCopyCallback));
					case 80: return FunctionPtr(new FunctionImpl<ControlRoot::CopyCallback(ControlRoot::*)() const>(&ControlRoot::getCopyCallback));
					case 81: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)(const ControlRoot::PasteCallback&)>(&ControlRoot::setPasteCallback));
					case 82: return FunctionPtr(new FunctionImpl<ControlRoot::PasteCallback(ControlRoot::*)() const>(&ControlRoot::getPasteCallback));
					case 83: return FunctionPtr(new FunctionImpl<ControlRoot(ControlRoot::*)() const>(&ControlRoot::clonePtr));
					case 84: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)()>(&ControlRoot::clearPtr));
					case 85: return FunctionPtr(new FunctionVoidImpl<void(ControlRoot::*)()>(&ControlRoot::destroyPtr));
					case 86: return FunctionPtr(new FunctionImpl<ControlRoot&(ControlRoot::*)()>(&ControlRoot::acquirePtr));
					case 87: return FunctionPtr(new FunctionImpl<ControlRoot&(ControlRoot::*)()>(&ControlRoot::unacquirePtr));
					case 88: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)() const>(&ControlRoot::isValidPtr));
					case 89: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)() const>(&ControlRoot::isOwnerPtr));
					case 90: return FunctionPtr(new FunctionImpl<bool(ControlRoot::*)() const>(&ControlRoot::isConstPtr));
					case 91: return FunctionPtr(new FunctionImpl<uint32_t(ControlRoot::*)() const>(&ControlRoot::getCountPtr));
					case 92: return FunctionPtr(new FunctionImpl<const void*(ControlRoot::*)() const>(&ControlRoot::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2 };
			static constexpr uint16_t constructor_arg_types[] = { 2110, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 2111, 169 };
			static constexpr uint16_t function_names[] = { 972, 972, 972, 2275, 2162, 2161, 2161, 2353, 2165, 2166, 2167, 2168, 2169, 2172, 2172, 2182, 2181, 2181, 2355, 2356, 2357, 2358, 2360, 2361, 2362, 2363, 2365, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377, 2378, 2379, 2380, 2381, 1980, 1980, 2383, 2002, 1981, 1982, 2009, 2386, 2387, 2388, 2389, 2041, 2043, 2390, 2391, 2393, 2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409, 2410, 1083, 2085, 2085, 2087, 2411, 2413, 2415, 2417, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 6, 2276, 16, 6, 6, 21, 21, 10, 21, 10, 21, 2171, 2171, 16, 21, 21, 21, 123, 123, 6, 6, 654, 762, 6, 6, 6, 10, 2094, 2094, 2094, 6, 6, 123, 654, 6, 6, 123, 654, 6, 654, 6, 6, 2206, 2003, 123, 123, 6, 6, 2122, 21, 21, 21, 21, 6, 6, 2314, 21, 6, 6, 2314, 21, 6, 6, 2314, 21, 6, 6, 2314, 21, 6, 6, 2314, 21, 21, 6, 6, 16, 6, 2414, 6, 2418, 2337, 2337, 2337, 2337, 2337, 2337, 2337, 2337, 2337, 2337 };
			static constexpr uint16_t function_bases[] = { 0, 1, 3, 5, 5, 5, 6, 7, 9, 11, 11, 13, 13, 15, 15, 15, 15, 19, 23, 28, 28, 28, 31, 34, 36, 38, 41, 45, 49, 51, 52, 53, 55, 56, 57, 57, 57, 58, 59, 59, 59, 60, 60, 63, 66, 66, 66, 66, 66, 68, 70, 70, 71, 72, 75, 77, 77, 79, 79, 79, 79, 80, 80, 80, 80, 81, 81, 81, 81, 82, 82, 82, 82, 83, 83, 83, 85, 86, 87, 87, 88, 88, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, 89 };
			static constexpr uint16_t function_arg_types[] = { 973, 10, 10, 123, 123, 22, 94, 168, 22, 10, 21, 10, 21, 2090, 21, 22, 10, 10, 123, 94, 10, 10, 123, 168, 22, 10, 10, 123, 2316, 2359, 637, 2316, 2359, 711, 2316, 2359, 2316, 2359, 2364, 2359, 637, 2364, 2140, 2140, 2202, 2364, 2140, 2140, 2202, 2364, 2359, 2364, 2364, 2364, 2359, 123, 637, 123, 637, 637, 1, 1, 2382, 123, 123, 2382, 2384, 123, 2330, 21, 2330, 2330, 10, 10, 21, 10, 21, 2314, 21, 2314, 2314, 2314, 2314, 10, 1, 22, 94, 2412, 2416 };
			static constexpr uint16_t function_arg_names[] = { 974, 30, 31, 30, 31, 23, 23, 169, 23, 87, 1083, 527, 1083, 2091, 1083, 23, 30, 31, 2354, 23, 30, 31, 2354, 169, 23, 30, 31, 2354, 195, 916, 638, 195, 916, 78, 195, 916, 195, 916, 456, 916, 638, 456, 2366, 430, 2354, 456, 2366, 1604, 2354, 456, 916, 456, 456, 456, 916, 2218, 638, 2218, 638, 638, 1973, 1974, 2001, 1973, 1974, 2001, 2011, 2385, 2120, 5, 2120, 2125, 2042, 2092, 105, 2042, 5, 2392, 1951, 2392, 2392, 2392, 2392, 527, 2127, 2086, 2086, 1162, 1162 };
	};
	constexpr uint16_t ReflectionControlRoot::constructor_bases[];
	constexpr uint16_t ReflectionControlRoot::constructor_arg_types[];
	constexpr uint16_t ReflectionControlRoot::constructor_arg_names[];
	constexpr uint16_t ReflectionControlRoot::function_names[];
	constexpr uint16_t ReflectionControlRoot::function_types[];
	constexpr uint16_t ReflectionControlRoot::function_bases[];
	constexpr uint16_t ReflectionControlRoot::function_arg_types[];
	constexpr uint16_t ReflectionControlRoot::function_arg_names[];
	static ReflectionControlRoot reflection_control_root;
	
	// Tellusim::ControlText
	class ReflectionControlText : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlText::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlText, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlText, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlText, TypeList<Control*, const char*>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlText, TypeList<Control*, const String&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlText>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(CanvasElement::Mode)>(&ControlText::setMode));
					case 1: return FunctionPtr(new FunctionImpl<CanvasElement::Mode(ControlText::*)() const>(&ControlText::getMode));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(Pipeline&)>(&ControlText::setPipeline));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(Pipeline&, const CanvasElement::DrawCallback&)>(&ControlText::setPipeline));
					case 4: return FunctionPtr(new FunctionImpl<Pipeline(ControlText::*)() const>(&ControlText::getPipeline));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(const Color&)>(&ControlText::setColor));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(float32_t, float32_t, float32_t, float32_t)>(&ControlText::setColor));
					case 7: return FunctionPtr(new FunctionImpl<const Color&(ControlText::*)() const>(&ControlText::getColor));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(Sampler::Filter)>(&ControlText::setFilter));
					case 9: return FunctionPtr(new FunctionImpl<Sampler::Filter(ControlText::*)() const>(&ControlText::getFilter));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(uint32_t)>(&ControlText::setAnisotropy));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(ControlText::*)() const>(&ControlText::getAnisotropy));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(Pipeline::BlendOp, Pipeline::BlendFunc, Pipeline::BlendFunc)>(&ControlText::setBlend));
					case 13: return FunctionPtr(new FunctionImpl<Pipeline::BlendOp(ControlText::*)() const>(&ControlText::getBlendOp));
					case 14: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(ControlText::*)() const>(&ControlText::getBlendSrcFunc));
					case 15: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(ControlText::*)() const>(&ControlText::getBlendDestFunc));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(const char*)>(&ControlText::setFontName));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(const String&)>(&ControlText::setFontName));
					case 18: return FunctionPtr(new FunctionImpl<String(ControlText::*)() const>(&ControlText::getFontName));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(const Color&)>(&ControlText::setFontColor));
					case 20: return FunctionPtr(new FunctionImpl<const Color&(ControlText::*)() const>(&ControlText::getFontColor));
					case 21: return FunctionPtr(new FunctionImpl<bool(ControlText::*)(uint32_t)>(&ControlText::setFontSize));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(ControlText::*)() const>(&ControlText::getFontSize));
					case 23: return FunctionPtr(new FunctionImpl<bool(ControlText::*)(const FontStyle&)>(&ControlText::setFontStyle));
					case 24: return FunctionPtr(new FunctionImpl<const FontStyle&(ControlText::*)() const>(&ControlText::getFontStyleConst));
					case 25: return FunctionPtr(new FunctionImpl<const FontStyle&(ControlText::*)() const>(&ControlText::getFontStyle));
					case 26: return FunctionPtr(new FunctionImpl<FontStyle&(ControlText::*)()>(&ControlText::getFontStyle));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(Control::Align)>(&ControlText::setFontAlign));
					case 28: return FunctionPtr(new FunctionImpl<Control::Align(ControlText::*)() const>(&ControlText::getFontAlign));
					case 29: return FunctionPtr(new FunctionImpl<bool(ControlText::*)(Control::Align) const>(&ControlText::hasFontAlign));
					case 30: return FunctionPtr(new FunctionImpl<bool(ControlText::*)(Control::Align) const>(&ControlText::hasFontAligns));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(const char*)>(&ControlText::setText));
					case 32: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)(const String&)>(&ControlText::setText));
					case 33: return FunctionPtr(new FunctionImpl<String(ControlText::*)() const>(&ControlText::getText));
					case 34: return FunctionPtr(new FunctionImpl<CanvasText(ControlText::*)()>(&ControlText::getCanvasText));
					case 35: return FunctionPtr(new FunctionImpl<ControlText(ControlText::*)() const>(&ControlText::clonePtr));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)()>(&ControlText::clearPtr));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(ControlText::*)()>(&ControlText::destroyPtr));
					case 38: return FunctionPtr(new FunctionImpl<ControlText&(ControlText::*)()>(&ControlText::acquirePtr));
					case 39: return FunctionPtr(new FunctionImpl<ControlText&(ControlText::*)()>(&ControlText::unacquirePtr));
					case 40: return FunctionPtr(new FunctionImpl<bool(ControlText::*)() const>(&ControlText::isValidPtr));
					case 41: return FunctionPtr(new FunctionImpl<bool(ControlText::*)() const>(&ControlText::isOwnerPtr));
					case 42: return FunctionPtr(new FunctionImpl<bool(ControlText::*)() const>(&ControlText::isConstPtr));
					case 43: return FunctionPtr(new FunctionImpl<uint32_t(ControlText::*)() const>(&ControlText::getCountPtr));
					case 44: return FunctionPtr(new FunctionImpl<const void*(ControlText::*)() const>(&ControlText::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 5 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 22, 2315, 94 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2086, 458, 2086 };
			static constexpr uint16_t function_names[] = { 2114, 2116, 967, 967, 970, 2131, 2131, 2133, 1334, 1336, 1339, 1341, 1812, 2148, 2149, 2150, 2161, 2161, 2162, 2163, 2164, 2165, 2166, 2169, 2170, 2172, 2172, 2420, 2421, 2422, 2423, 2175, 2175, 2176, 2424, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 2117, 6, 6, 971, 6, 6, 654, 6, 1337, 6, 10, 6, 1817, 1820, 1820, 6, 6, 16, 6, 654, 21, 10, 21, 2171, 2171, 2171, 6, 2122, 21, 21, 6, 6, 16, 2160, 2419, 2419, 2419, 2419, 2419, 2419, 2419, 2419, 2419, 2419 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 4, 4, 5, 9, 9, 10, 10, 11, 11, 14, 14, 14, 14, 15, 16, 16, 17, 17, 18, 18, 19, 19, 19, 19, 20, 20, 21, 22, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24 };
			static constexpr uint16_t function_arg_types[] = { 2115, 968, 968, 2157, 637, 123, 123, 123, 123, 1335, 10, 1813, 1814, 1814, 22, 94, 637, 10, 2090, 2330, 2330, 2330, 22, 94 };
			static constexpr uint16_t function_arg_names[] = { 185, 969, 969, 1162, 638, 1054, 1055, 1056, 1057, 448, 1340, 1501, 90, 86, 23, 23, 638, 87, 2091, 2120, 2120, 2125, 2086, 2086 };
	};
	constexpr uint16_t ReflectionControlText::constructor_bases[];
	constexpr uint16_t ReflectionControlText::constructor_arg_types[];
	constexpr uint16_t ReflectionControlText::constructor_arg_names[];
	constexpr uint16_t ReflectionControlText::function_names[];
	constexpr uint16_t ReflectionControlText::function_types[];
	constexpr uint16_t ReflectionControlText::function_bases[];
	constexpr uint16_t ReflectionControlText::function_arg_types[];
	constexpr uint16_t ReflectionControlText::function_arg_names[];
	static ReflectionControlText reflection_control_text;
	
	// Tellusim::ControlRect
	class ReflectionControlRect : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlRect::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlRect, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlRect, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlRect, TypeList<Control*, Texture&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlRect, TypeList<Control*, const char*>>());
					case 4: return ConstructorPtr(new ConstructorImpl<ControlRect, TypeList<Control*, CanvasElement::Mode>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlRect>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(bool)>(&ControlRect::setCallback));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlRect::*)() const>(&ControlRect::getCallback));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(bool)>(&ControlRect::setFullscreen));
					case 3: return FunctionPtr(new FunctionImpl<bool(ControlRect::*)() const>(&ControlRect::isFullscreen));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(CanvasElement::Mode)>(&ControlRect::setMode));
					case 5: return FunctionPtr(new FunctionImpl<CanvasElement::Mode(ControlRect::*)() const>(&ControlRect::getMode));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(Pipeline&)>(&ControlRect::setPipeline));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(Pipeline&, const CanvasElement::DrawCallback&)>(&ControlRect::setPipeline));
					case 8: return FunctionPtr(new FunctionImpl<Pipeline(ControlRect::*)() const>(&ControlRect::getPipeline));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(float32_t)>(&ControlRect::setRadius));
					case 10: return FunctionPtr(new FunctionImpl<float32_t(ControlRect::*)() const>(&ControlRect::getRadius));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const Color&)>(&ControlRect::setColor));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(float32_t, float32_t, float32_t, float32_t)>(&ControlRect::setColor));
					case 13: return FunctionPtr(new FunctionImpl<const Color&(ControlRect::*)() const>(&ControlRect::getColor));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const StrokeStyle&)>(&ControlRect::setStrokeStyle));
					case 15: return FunctionPtr(new FunctionImpl<const StrokeStyle&(ControlRect::*)() const>(&ControlRect::getStrokeStyleConst));
					case 16: return FunctionPtr(new FunctionImpl<const StrokeStyle&(ControlRect::*)() const>(&ControlRect::getStrokeStyle));
					case 17: return FunctionPtr(new FunctionImpl<StrokeStyle&(ControlRect::*)()>(&ControlRect::getStrokeStyle));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const GradientStyle&)>(&ControlRect::setGradientStyle));
					case 19: return FunctionPtr(new FunctionImpl<const GradientStyle&(ControlRect::*)() const>(&ControlRect::getGradientStyleConst));
					case 20: return FunctionPtr(new FunctionImpl<const GradientStyle&(ControlRect::*)() const>(&ControlRect::getGradientStyle));
					case 21: return FunctionPtr(new FunctionImpl<GradientStyle&(ControlRect::*)()>(&ControlRect::getGradientStyle));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(float32_t)>(&ControlRect::setMipmap));
					case 23: return FunctionPtr(new FunctionImpl<float32_t(ControlRect::*)() const>(&ControlRect::getMipmap));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(Sampler::Filter)>(&ControlRect::setFilter));
					case 25: return FunctionPtr(new FunctionImpl<Sampler::Filter(ControlRect::*)() const>(&ControlRect::getFilter));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(uint32_t)>(&ControlRect::setAnisotropy));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(ControlRect::*)() const>(&ControlRect::getAnisotropy));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(Sampler::WrapMode)>(&ControlRect::setWrapMode));
					case 29: return FunctionPtr(new FunctionImpl<Sampler::WrapMode(ControlRect::*)() const>(&ControlRect::getWrapMode));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(Pipeline::BlendOp, Pipeline::BlendFunc, Pipeline::BlendFunc)>(&ControlRect::setBlend));
					case 31: return FunctionPtr(new FunctionImpl<Pipeline::BlendOp(ControlRect::*)() const>(&ControlRect::getBlendOp));
					case 32: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(ControlRect::*)() const>(&ControlRect::getBlendSrcFunc));
					case 33: return FunctionPtr(new FunctionImpl<Pipeline::BlendFunc(ControlRect::*)() const>(&ControlRect::getBlendDestFunc));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(Texture&, bool)>(&ControlRect::setTexture, Texture::null, false));
					case 35: return FunctionPtr(new FunctionImpl<Texture(ControlRect::*)() const>(&ControlRect::getTexture));
					case 36: return FunctionPtr(new FunctionImpl<bool(ControlRect::*)() const>(&ControlRect::getTextureLinear));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const char*)>(&ControlRect::setTextureName));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const String&)>(&ControlRect::setTextureName));
					case 39: return FunctionPtr(new FunctionImpl<String(ControlRect::*)() const>(&ControlRect::getTextureName));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(float32_t, float32_t)>(&ControlRect::setTextureScale));
					case 41: return FunctionPtr(new FunctionImpl<float32_t(ControlRect::*)() const>(&ControlRect::getTextureScaleX));
					case 42: return FunctionPtr(new FunctionImpl<float32_t(ControlRect::*)() const>(&ControlRect::getTextureScaleY));
					case 43: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(bool, bool)>(&ControlRect::setTextureFlip));
					case 44: return FunctionPtr(new FunctionImpl<bool(ControlRect::*)() const>(&ControlRect::getTextureFlipX));
					case 45: return FunctionPtr(new FunctionImpl<bool(ControlRect::*)() const>(&ControlRect::getTextureFlipY));
					case 46: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(bool)>(&ControlRect::setTextureProj));
					case 47: return FunctionPtr(new FunctionImpl<bool(ControlRect::*)() const>(&ControlRect::getTextureProj));
					case 48: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const Rect&)>(&ControlRect::setTexCoord));
					case 49: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(float32_t, float32_t, float32_t, float32_t)>(&ControlRect::setTexCoord));
					case 50: return FunctionPtr(new FunctionImpl<const Rect&(ControlRect::*)() const>(&ControlRect::getTexCoord));
					case 51: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const ControlRect::PressedCallback&)>(&ControlRect::setPressedCallback));
					case 52: return FunctionPtr(new FunctionImpl<ControlRect::PressedCallback(ControlRect::*)() const>(&ControlRect::getPressedCallback));
					case 53: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const ControlRect::ReleasedCallback&)>(&ControlRect::setReleasedCallback));
					case 54: return FunctionPtr(new FunctionImpl<ControlRect::ReleasedCallback(ControlRect::*)() const>(&ControlRect::getReleasedCallback));
					case 55: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const ControlRect::ClickedCallback&)>(&ControlRect::setClickedCallback));
					case 56: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const ControlRect::ClickedCallback&)>(&ControlRect::setClicked2Callback));
					case 57: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)(const ControlRect::ClickedCallback&)>(&ControlRect::setClickedRightCallback));
					case 58: return FunctionPtr(new FunctionImpl<ControlRect::ClickedCallback(ControlRect::*)() const>(&ControlRect::getClickedCallback));
					case 59: return FunctionPtr(new FunctionImpl<ControlRect::ClickedCallback(ControlRect::*)() const>(&ControlRect::getClicked2Callback));
					case 60: return FunctionPtr(new FunctionImpl<ControlRect::ClickedCallback(ControlRect::*)() const>(&ControlRect::getClickedRightCallback));
					case 61: return FunctionPtr(new FunctionImpl<CanvasRect(ControlRect::*)()>(&ControlRect::getCanvasRect));
					case 62: return FunctionPtr(new FunctionImpl<CanvasMesh(ControlRect::*)()>(&ControlRect::getCanvasMesh));
					case 63: return FunctionPtr(new FunctionImpl<ControlRect(ControlRect::*)() const>(&ControlRect::clonePtr));
					case 64: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)()>(&ControlRect::clearPtr));
					case 65: return FunctionPtr(new FunctionVoidImpl<void(ControlRect::*)()>(&ControlRect::destroyPtr));
					case 66: return FunctionPtr(new FunctionImpl<ControlRect&(ControlRect::*)()>(&ControlRect::acquirePtr));
					case 67: return FunctionPtr(new FunctionImpl<ControlRect&(ControlRect::*)()>(&ControlRect::unacquirePtr));
					case 68: return FunctionPtr(new FunctionImpl<bool(ControlRect::*)() const>(&ControlRect::isValidPtr));
					case 69: return FunctionPtr(new FunctionImpl<bool(ControlRect::*)() const>(&ControlRect::isOwnerPtr));
					case 70: return FunctionPtr(new FunctionImpl<bool(ControlRect::*)() const>(&ControlRect::isConstPtr));
					case 71: return FunctionPtr(new FunctionImpl<uint32_t(ControlRect::*)() const>(&ControlRect::getCountPtr));
					case 72: return FunctionPtr(new FunctionImpl<const void*(ControlRect::*)() const>(&ControlRect::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 5, 7 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 994, 2315, 22, 2315, 2115 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 995, 458, 23, 458, 185 };
			static constexpr uint16_t function_names[] = { 227, 2426, 1965, 1967, 2114, 2116, 967, 967, 970, 2219, 2220, 2131, 2131, 2133, 2223, 2225, 2227, 2227, 2183, 2185, 2187, 2187, 2143, 2144, 1334, 1336, 1339, 1341, 1343, 2145, 1812, 2148, 2149, 2150, 993, 1429, 2147, 2181, 2181, 2182, 2427, 2430, 2431, 2432, 2435, 2436, 2437, 2439, 2228, 2228, 2232, 2440, 2442, 2444, 2446, 2448, 2450, 2451, 2452, 2454, 2455, 2456, 2457, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 21, 6, 2117, 6, 6, 971, 6, 123, 6, 6, 654, 6, 2226, 2226, 2226, 6, 2186, 2186, 2186, 6, 123, 6, 1337, 6, 10, 6, 1350, 6, 1817, 1820, 1820, 6, 1377, 21, 6, 6, 16, 6, 123, 123, 6, 21, 21, 6, 21, 6, 6, 2094, 6, 2443, 6, 2447, 6, 6, 6, 2453, 2453, 2453, 2217, 2180, 2425, 2425, 2425, 2425, 2425, 2425, 2425, 2425, 2425, 2425 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 3, 4, 6, 6, 7, 7, 8, 12, 12, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 21, 21, 21, 21, 23, 23, 23, 24, 25, 25, 27, 27, 27, 29, 29, 29, 30, 30, 31, 35, 35, 36, 36, 37, 37, 38, 39, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40, 40 };
			static constexpr uint16_t function_arg_types[] = { 21, 21, 2115, 968, 968, 2157, 123, 637, 123, 123, 123, 123, 2224, 2184, 123, 1335, 10, 1344, 1813, 1814, 1814, 994, 21, 22, 94, 123, 123, 21, 21, 21, 2140, 123, 123, 123, 123, 2441, 2445, 2449, 2449, 2449 };
			static constexpr uint16_t function_arg_names[] = { 225, 1966, 185, 969, 969, 1162, 2218, 638, 1054, 1055, 1056, 1057, 2091, 2091, 393, 448, 1340, 185, 1501, 90, 86, 995, 2146, 23, 23, 2428, 2429, 2433, 2434, 2438, 735, 2229, 805, 2230, 2231, 1162, 1162, 1162, 1162, 1162 };
	};
	constexpr uint16_t ReflectionControlRect::constructor_bases[];
	constexpr uint16_t ReflectionControlRect::constructor_arg_types[];
	constexpr uint16_t ReflectionControlRect::constructor_arg_names[];
	constexpr uint16_t ReflectionControlRect::function_names[];
	constexpr uint16_t ReflectionControlRect::function_types[];
	constexpr uint16_t ReflectionControlRect::function_bases[];
	constexpr uint16_t ReflectionControlRect::function_arg_types[];
	constexpr uint16_t ReflectionControlRect::function_arg_names[];
	static ReflectionControlRect reflection_control_rect;
	
	// Tellusim::ControlGrid
	class ReflectionControlGrid : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlGrid::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlGrid, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlGrid, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlGrid, TypeList<Control*, uint32_t>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlGrid, TypeList<Control*, uint32_t, float32_t, float32_t>>({}, {}, {}, 0.0f));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlGrid>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlGrid::*)(uint32_t)>(&ControlGrid::setColumns));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(ControlGrid::*)() const>(&ControlGrid::getColumns));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlGrid::*)(const Vector2f&)>(&ControlGrid::setSpacing));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(ControlGrid::*)(float32_t, float32_t)>(&ControlGrid::setSpacing));
					case 4: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlGrid::*)() const>(&ControlGrid::getSpacing));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ControlGrid::*)(uint32_t, float32_t)>(&ControlGrid::setColumnRatio));
					case 6: return FunctionPtr(new FunctionImpl<float32_t(ControlGrid::*)(uint32_t) const>(&ControlGrid::getColumnRatio));
					case 7: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlGrid::*)() const>(&ControlGrid::getControlsSize));
					case 8: return FunctionPtr(new FunctionImpl<ControlGrid(ControlGrid::*)() const>(&ControlGrid::clonePtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(ControlGrid::*)()>(&ControlGrid::clearPtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(ControlGrid::*)()>(&ControlGrid::destroyPtr));
					case 11: return FunctionPtr(new FunctionImpl<ControlGrid&(ControlGrid::*)()>(&ControlGrid::acquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<ControlGrid&(ControlGrid::*)()>(&ControlGrid::unacquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(ControlGrid::*)() const>(&ControlGrid::isValidPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(ControlGrid::*)() const>(&ControlGrid::isOwnerPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(ControlGrid::*)() const>(&ControlGrid::isConstPtr));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(ControlGrid::*)() const>(&ControlGrid::getCountPtr));
					case 17: return FunctionPtr(new FunctionImpl<const void*(ControlGrid::*)() const>(&ControlGrid::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 7 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 10, 2315, 10, 123, 123 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2459, 458, 2459, 1973, 1974 };
			static constexpr uint16_t function_names[] = { 2460, 2461, 2462, 2462, 2464, 2465, 2467, 2468, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 6, 6, 2206, 6, 123, 2206, 2458, 2458, 2458, 2458, 2458, 2458, 2458, 2458, 2458, 2458 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 4, 4, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 };
			static constexpr uint16_t function_arg_types[] = { 10, 2202, 123, 123, 10, 123, 10 };
			static constexpr uint16_t function_arg_names[] = { 2459, 2463, 1973, 1974, 274, 2466, 274 };
	};
	constexpr uint16_t ReflectionControlGrid::constructor_bases[];
	constexpr uint16_t ReflectionControlGrid::constructor_arg_types[];
	constexpr uint16_t ReflectionControlGrid::constructor_arg_names[];
	constexpr uint16_t ReflectionControlGrid::function_names[];
	constexpr uint16_t ReflectionControlGrid::function_types[];
	constexpr uint16_t ReflectionControlGrid::function_bases[];
	constexpr uint16_t ReflectionControlGrid::function_arg_types[];
	constexpr uint16_t ReflectionControlGrid::function_arg_names[];
	static ReflectionControlGrid reflection_control_grid;
	
	// Tellusim::ControlGroup
	class ReflectionControlGroup : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlGroup::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_text;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlGroup, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlGroup, TypeList<Control*, bool>>({}, false));
					case 2: return ConstructorPtr(new ConstructorImpl<ControlGroup, TypeList<Control*, const char*, bool>>({}, {}, false));
					case 3: return ConstructorPtr(new ConstructorImpl<ControlGroup, TypeList<Control*, const String&, bool>>({}, {}, false));
					case 4: return ConstructorPtr(new ConstructorImpl<ControlGroup, TypeList<Control*, const char*, uint32_t, bool>>({}, {}, {}, false));
					case 5: return ConstructorPtr(new ConstructorImpl<ControlGroup, TypeList<Control*, const char*, uint32_t, float32_t, float32_t, bool>>({}, {}, {}, {}, {}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlGroup>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(bool, bool)>(&ControlGroup::setAbove, {}, true));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlGroup::*)() const>(&ControlGroup::isAbove));
					case 2: return FunctionPtr(new FunctionImpl<bool(ControlGroup::*)() const>(&ControlGroup::isBelow));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(bool)>(&ControlGroup::setFoldable));
					case 4: return FunctionPtr(new FunctionImpl<bool(ControlGroup::*)() const>(&ControlGroup::isFoldable));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(bool)>(&ControlGroup::setExpanded));
					case 6: return FunctionPtr(new FunctionImpl<bool(ControlGroup::*)() const>(&ControlGroup::isExpanded));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(bool)>(&ControlGroup::setBackground));
					case 8: return FunctionPtr(new FunctionImpl<bool(ControlGroup::*)() const>(&ControlGroup::getBackground));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(float32_t)>(&ControlGroup::setGroupRadius));
					case 10: return FunctionPtr(new FunctionImpl<float32_t(ControlGroup::*)() const>(&ControlGroup::getGroupRadius));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(const Color&)>(&ControlGroup::setGroupColor));
					case 12: return FunctionPtr(new FunctionImpl<const Color&(ControlGroup::*)() const>(&ControlGroup::getGroupColor));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(const StrokeStyle&)>(&ControlGroup::setStrokeStyle));
					case 14: return FunctionPtr(new FunctionImpl<const StrokeStyle&(ControlGroup::*)() const>(&ControlGroup::getStrokeStyleConst));
					case 15: return FunctionPtr(new FunctionImpl<const StrokeStyle&(ControlGroup::*)() const>(&ControlGroup::getStrokeStyle));
					case 16: return FunctionPtr(new FunctionImpl<StrokeStyle&(ControlGroup::*)()>(&ControlGroup::getStrokeStyle));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(const GradientStyle&)>(&ControlGroup::setGradientStyle));
					case 18: return FunctionPtr(new FunctionImpl<const GradientStyle&(ControlGroup::*)() const>(&ControlGroup::getGradientStyleConst));
					case 19: return FunctionPtr(new FunctionImpl<const GradientStyle&(ControlGroup::*)() const>(&ControlGroup::getGradientStyle));
					case 20: return FunctionPtr(new FunctionImpl<GradientStyle&(ControlGroup::*)()>(&ControlGroup::getGradientStyle));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(const char*)>(&ControlGroup::setFoldedText));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(const String&)>(&ControlGroup::setFoldedText));
					case 23: return FunctionPtr(new FunctionImpl<String(ControlGroup::*)() const>(&ControlGroup::getFoldedText));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(const char*)>(&ControlGroup::setExpandedText));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(const String&)>(&ControlGroup::setExpandedText));
					case 26: return FunctionPtr(new FunctionImpl<String(ControlGroup::*)() const>(&ControlGroup::getExpandedText));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(uint32_t)>(&ControlGroup::setColumns));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(ControlGroup::*)() const>(&ControlGroup::getColumns));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(const Vector2f&)>(&ControlGroup::setSpacing));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(float32_t, float32_t)>(&ControlGroup::setSpacing));
					case 31: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlGroup::*)() const>(&ControlGroup::getSpacing));
					case 32: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(uint32_t, float32_t)>(&ControlGroup::setColumnRatio));
					case 33: return FunctionPtr(new FunctionImpl<float32_t(ControlGroup::*)(uint32_t) const>(&ControlGroup::getColumnRatio));
					case 34: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlGroup::*)() const>(&ControlGroup::getControlsSize));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)(const ControlGroup::ClickedCallback&)>(&ControlGroup::setClickedCallback));
					case 36: return FunctionPtr(new FunctionImpl<ControlGroup::ClickedCallback(ControlGroup::*)() const>(&ControlGroup::getClickedCallback));
					case 37: return FunctionPtr(new FunctionImpl<bool(ControlGroup::*)()>(&ControlGroup::isClicked));
					case 38: return FunctionPtr(new FunctionImpl<CanvasRect(ControlGroup::*)()>(&ControlGroup::getCanvasRect));
					case 39: return FunctionPtr(new FunctionImpl<ControlGroup(ControlGroup::*)() const>(&ControlGroup::clonePtr));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)()>(&ControlGroup::clearPtr));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(ControlGroup::*)()>(&ControlGroup::destroyPtr));
					case 42: return FunctionPtr(new FunctionImpl<ControlGroup&(ControlGroup::*)()>(&ControlGroup::acquirePtr));
					case 43: return FunctionPtr(new FunctionImpl<ControlGroup&(ControlGroup::*)()>(&ControlGroup::unacquirePtr));
					case 44: return FunctionPtr(new FunctionImpl<bool(ControlGroup::*)() const>(&ControlGroup::isValidPtr));
					case 45: return FunctionPtr(new FunctionImpl<bool(ControlGroup::*)() const>(&ControlGroup::isOwnerPtr));
					case 46: return FunctionPtr(new FunctionImpl<bool(ControlGroup::*)() const>(&ControlGroup::isConstPtr));
					case 47: return FunctionPtr(new FunctionImpl<uint32_t(ControlGroup::*)() const>(&ControlGroup::getCountPtr));
					case 48: return FunctionPtr(new FunctionImpl<const void*(ControlGroup::*)() const>(&ControlGroup::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2, 5, 8, 12, 18 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 21, 2315, 22, 21, 2315, 94, 21, 2315, 22, 10, 21, 2315, 22, 10, 123, 123, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 2470, 458, 2086, 2470, 458, 2086, 2470, 458, 2086, 2459, 2470, 458, 2086, 2459, 1973, 1974, 2470 };
			static constexpr uint16_t function_names[] = { 2471, 2472, 2473, 2474, 2476, 2477, 2479, 2480, 2482, 2372, 2374, 2373, 2375, 2223, 2225, 2227, 2227, 2183, 2185, 2187, 2187, 2483, 2483, 2484, 2485, 2485, 2486, 2460, 2461, 2462, 2462, 2464, 2465, 2467, 2468, 2448, 2452, 2488, 2456, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 6, 21, 6, 21, 6, 21, 6, 123, 6, 654, 6, 2226, 2226, 2226, 6, 2186, 2186, 2186, 6, 6, 16, 6, 6, 16, 6, 10, 6, 6, 2206, 6, 123, 2206, 6, 2453, 21, 2217, 2469, 2469, 2469, 2469, 2469, 2469, 2469, 2469, 2469, 2469 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 11, 11, 12, 13, 13, 14, 14, 15, 17, 17, 19, 20, 20, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21 };
			static constexpr uint16_t function_arg_types[] = { 21, 21, 21, 21, 21, 123, 637, 2224, 2184, 22, 94, 22, 94, 10, 2202, 123, 123, 10, 123, 10, 2487 };
			static constexpr uint16_t function_arg_names[] = { 2470, 2086, 2475, 2478, 2481, 2218, 638, 2091, 2091, 2086, 2086, 2086, 2086, 2459, 2463, 1973, 1974, 274, 2466, 274, 1162 };
	};
	constexpr uint16_t ReflectionControlGroup::constructor_bases[];
	constexpr uint16_t ReflectionControlGroup::constructor_arg_types[];
	constexpr uint16_t ReflectionControlGroup::constructor_arg_names[];
	constexpr uint16_t ReflectionControlGroup::function_names[];
	constexpr uint16_t ReflectionControlGroup::function_types[];
	constexpr uint16_t ReflectionControlGroup::function_bases[];
	constexpr uint16_t ReflectionControlGroup::function_arg_types[];
	constexpr uint16_t ReflectionControlGroup::function_arg_names[];
	static ReflectionControlGroup reflection_control_group;
	
	// Tellusim::ControlPanel
	class ReflectionControlPanel : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlPanel::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_rect;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlPanel, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlPanel, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlPanel, TypeList<Control*, uint32_t>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlPanel, TypeList<Control*, uint32_t, float32_t, float32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlPanel>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlPanel::*)(uint32_t)>(&ControlPanel::setColumns));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(ControlPanel::*)() const>(&ControlPanel::getColumns));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlPanel::*)(const Vector2f&)>(&ControlPanel::setSpacing));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(ControlPanel::*)(float32_t, float32_t)>(&ControlPanel::setSpacing));
					case 4: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlPanel::*)() const>(&ControlPanel::getSpacing));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ControlPanel::*)(uint32_t, float32_t)>(&ControlPanel::setColumnRatio));
					case 6: return FunctionPtr(new FunctionImpl<float32_t(ControlPanel::*)(uint32_t) const>(&ControlPanel::getColumnRatio));
					case 7: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlPanel::*)() const>(&ControlPanel::getControlsSize));
					case 8: return FunctionPtr(new FunctionImpl<ControlPanel(ControlPanel::*)() const>(&ControlPanel::clonePtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(ControlPanel::*)()>(&ControlPanel::clearPtr));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(ControlPanel::*)()>(&ControlPanel::destroyPtr));
					case 11: return FunctionPtr(new FunctionImpl<ControlPanel&(ControlPanel::*)()>(&ControlPanel::acquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<ControlPanel&(ControlPanel::*)()>(&ControlPanel::unacquirePtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(ControlPanel::*)() const>(&ControlPanel::isValidPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(ControlPanel::*)() const>(&ControlPanel::isOwnerPtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(ControlPanel::*)() const>(&ControlPanel::isConstPtr));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(ControlPanel::*)() const>(&ControlPanel::getCountPtr));
					case 17: return FunctionPtr(new FunctionImpl<const void*(ControlPanel::*)() const>(&ControlPanel::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 7 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 10, 2315, 10, 123, 123 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2459, 458, 2459, 1973, 1974 };
			static constexpr uint16_t function_names[] = { 2460, 2461, 2462, 2462, 2464, 2465, 2467, 2468, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 10, 6, 6, 2206, 6, 123, 2206, 2339, 2339, 2339, 2339, 2339, 2339, 2339, 2339, 2339, 2339 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 4, 4, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 };
			static constexpr uint16_t function_arg_types[] = { 10, 2202, 123, 123, 10, 123, 10 };
			static constexpr uint16_t function_arg_names[] = { 2459, 2463, 1973, 1974, 274, 2466, 274 };
	};
	constexpr uint16_t ReflectionControlPanel::constructor_bases[];
	constexpr uint16_t ReflectionControlPanel::constructor_arg_types[];
	constexpr uint16_t ReflectionControlPanel::constructor_arg_names[];
	constexpr uint16_t ReflectionControlPanel::function_names[];
	constexpr uint16_t ReflectionControlPanel::function_types[];
	constexpr uint16_t ReflectionControlPanel::function_bases[];
	constexpr uint16_t ReflectionControlPanel::function_arg_types[];
	constexpr uint16_t ReflectionControlPanel::function_arg_names[];
	static ReflectionControlPanel reflection_control_panel;
	
	// Tellusim::ControlDialog
	class ReflectionControlDialog : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlDialog::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_panel;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlDialog, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlDialog, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlDialog, TypeList<Control*, uint32_t>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlDialog, TypeList<Control*, uint32_t, float32_t, float32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlDialog>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlDialog::*)(bool)>(&ControlDialog::setConstrained));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlDialog::*)() const>(&ControlDialog::isConstrained));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlDialog::*)(bool)>(&ControlDialog::setResizable));
					case 3: return FunctionPtr(new FunctionImpl<bool(ControlDialog::*)() const>(&ControlDialog::isResizable));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(ControlDialog::*)(float32_t)>(&ControlDialog::setResizeArea));
					case 5: return FunctionPtr(new FunctionImpl<float32_t(ControlDialog::*)() const>(&ControlDialog::getResizeArea));
					case 6: return FunctionPtr(new FunctionImpl<Control::Align(ControlDialog::*)() const>(&ControlDialog::getResizeAlign));
					case 7: return FunctionPtr(new FunctionImpl<bool(ControlDialog::*)(Control::Align) const>(&ControlDialog::hasResizeAlign));
					case 8: return FunctionPtr(new FunctionImpl<bool(ControlDialog::*)(Control::Align) const>(&ControlDialog::hasResizeAligns));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(ControlDialog::*)(const Vector2f&)>(&ControlDialog::setMousePosition));
					case 10: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlDialog::*)() const>(&ControlDialog::getMousePosition));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(ControlDialog::*)(const ControlDialog::UpdatedCallback&)>(&ControlDialog::setUpdatedCallback));
					case 12: return FunctionPtr(new FunctionImpl<ControlDialog::UpdatedCallback(ControlDialog::*)() const>(&ControlDialog::getUpdatedCallback));
					case 13: return FunctionPtr(new FunctionImpl<bool(ControlDialog::*)()>(&ControlDialog::isUpdated));
					case 14: return FunctionPtr(new FunctionImpl<ControlDialog(ControlDialog::*)() const>(&ControlDialog::clonePtr));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(ControlDialog::*)()>(&ControlDialog::clearPtr));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(ControlDialog::*)()>(&ControlDialog::destroyPtr));
					case 17: return FunctionPtr(new FunctionImpl<ControlDialog&(ControlDialog::*)()>(&ControlDialog::acquirePtr));
					case 18: return FunctionPtr(new FunctionImpl<ControlDialog&(ControlDialog::*)()>(&ControlDialog::unacquirePtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(ControlDialog::*)() const>(&ControlDialog::isValidPtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(ControlDialog::*)() const>(&ControlDialog::isOwnerPtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(ControlDialog::*)() const>(&ControlDialog::isConstPtr));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(ControlDialog::*)() const>(&ControlDialog::getCountPtr));
					case 23: return FunctionPtr(new FunctionImpl<const void*(ControlDialog::*)() const>(&ControlDialog::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 7 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 10, 2315, 10, 123, 123 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2459, 458, 2459, 1973, 1974 };
			static constexpr uint16_t function_names[] = { 2490, 2492, 2493, 2495, 2496, 2498, 2499, 2500, 2501, 2502, 2503, 2504, 2506, 2508, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 21, 6, 123, 2122, 21, 21, 6, 2206, 6, 2507, 21, 2489, 2489, 2489, 2489, 2489, 2489, 2489, 2489, 2489, 2489 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 3, 3, 4, 5, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7 };
			static constexpr uint16_t function_arg_types[] = { 21, 21, 123, 2330, 2330, 2202, 2505 };
			static constexpr uint16_t function_arg_names[] = { 2491, 2494, 2497, 2120, 2125, 729, 1162 };
	};
	constexpr uint16_t ReflectionControlDialog::constructor_bases[];
	constexpr uint16_t ReflectionControlDialog::constructor_arg_types[];
	constexpr uint16_t ReflectionControlDialog::constructor_arg_names[];
	constexpr uint16_t ReflectionControlDialog::function_names[];
	constexpr uint16_t ReflectionControlDialog::function_types[];
	constexpr uint16_t ReflectionControlDialog::function_bases[];
	constexpr uint16_t ReflectionControlDialog::function_arg_types[];
	constexpr uint16_t ReflectionControlDialog::function_arg_names[];
	static ReflectionControlDialog reflection_control_dialog;
	
	// Tellusim::ControlWindow
	class ReflectionControlWindow : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlWindow::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_dialog;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlWindow, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlWindow, TypeList<ControlRoot*, Window&, Window&>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlWindow, TypeList<ControlRoot*, Window&, Window&, uint32_t>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlWindow, TypeList<ControlRoot*, Window&, Window&, uint32_t, float32_t, float32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlWindow>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<Window(ControlWindow::*)() const>(&ControlWindow::getParentWindow));
					case 1: return FunctionPtr(new FunctionImpl<Window(ControlWindow::*)() const>(&ControlWindow::getDialogWindow));
					case 2: return FunctionPtr(new FunctionImpl<ControlWindow(ControlWindow::*)() const>(&ControlWindow::clonePtr));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(ControlWindow::*)()>(&ControlWindow::clearPtr));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(ControlWindow::*)()>(&ControlWindow::destroyPtr));
					case 5: return FunctionPtr(new FunctionImpl<ControlWindow&(ControlWindow::*)()>(&ControlWindow::acquirePtr));
					case 6: return FunctionPtr(new FunctionImpl<ControlWindow&(ControlWindow::*)()>(&ControlWindow::unacquirePtr));
					case 7: return FunctionPtr(new FunctionImpl<bool(ControlWindow::*)() const>(&ControlWindow::isValidPtr));
					case 8: return FunctionPtr(new FunctionImpl<bool(ControlWindow::*)() const>(&ControlWindow::isOwnerPtr));
					case 9: return FunctionPtr(new FunctionImpl<bool(ControlWindow::*)() const>(&ControlWindow::isConstPtr));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(ControlWindow::*)() const>(&ControlWindow::getCountPtr));
					case 11: return FunctionPtr(new FunctionImpl<const void*(ControlWindow::*)() const>(&ControlWindow::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 3, 7, 13 };
			static constexpr uint16_t constructor_arg_types[] = { 2510, 1540, 1540, 2510, 1540, 1540, 10, 2510, 1540, 1540, 10, 123, 123 };
			static constexpr uint16_t constructor_arg_names[] = { 2511, 458, 157, 2511, 458, 157, 2459, 2511, 458, 157, 2459, 1973, 1974 };
			static constexpr uint16_t function_names[] = { 2512, 2513, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 1943, 1943, 2509, 2509, 2509, 2509, 2509, 2509, 2509, 2509, 2509, 2509 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
			static constexpr uint16_t function_arg_types[] = { 0 };
			static constexpr uint16_t function_arg_names[] = { 0 };
	};
	constexpr uint16_t ReflectionControlWindow::constructor_bases[];
	constexpr uint16_t ReflectionControlWindow::constructor_arg_types[];
	constexpr uint16_t ReflectionControlWindow::constructor_arg_names[];
	constexpr uint16_t ReflectionControlWindow::function_names[];
	constexpr uint16_t ReflectionControlWindow::function_types[];
	constexpr uint16_t ReflectionControlWindow::function_bases[];
	constexpr uint16_t ReflectionControlWindow::function_arg_types[];
	constexpr uint16_t ReflectionControlWindow::function_arg_names[];
	static ReflectionControlWindow reflection_control_window;
	
	// Tellusim::ControlCheck
	class ReflectionControlCheck : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlCheck::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_text;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlCheck, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlCheck, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlCheck, TypeList<Control*, const char*>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlCheck, TypeList<Control*, const String&>>());
					case 4: return ConstructorPtr(new ConstructorImpl<ControlCheck, TypeList<Control*, const char*, bool>>());
					case 5: return ConstructorPtr(new ConstructorImpl<ControlCheck, TypeList<Control*, const String&, bool>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlCheck>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlCheck::*)(const char*)>(&ControlCheck::setCheckText));
					case 1: return FunctionPtr(new FunctionVoidImpl<void(ControlCheck::*)(const String&)>(&ControlCheck::setCheckText));
					case 2: return FunctionPtr(new FunctionImpl<String(ControlCheck::*)() const>(&ControlCheck::getCheckText));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(ControlCheck::*)(const Color&)>(&ControlCheck::setCheckColor));
					case 4: return FunctionPtr(new FunctionImpl<const Color&(ControlCheck::*)() const>(&ControlCheck::getCheckColor));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ControlCheck::*)(const Color&)>(&ControlCheck::setCheckedColor));
					case 6: return FunctionPtr(new FunctionImpl<const Color&(ControlCheck::*)() const>(&ControlCheck::getCheckedColor));
					case 7: return FunctionPtr(new FunctionImpl<bool(ControlCheck::*)(bool)>(&ControlCheck::switchChecked, false));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(ControlCheck::*)(bool, bool)>(&ControlCheck::setChecked, {}, false));
					case 9: return FunctionPtr(new FunctionImpl<bool(ControlCheck::*)() const>(&ControlCheck::isChecked));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(ControlCheck::*)(const ControlCheck::ClickedCallback&)>(&ControlCheck::setClickedCallback));
					case 11: return FunctionPtr(new FunctionImpl<ControlCheck::ClickedCallback(ControlCheck::*)() const>(&ControlCheck::getClickedCallback));
					case 12: return FunctionPtr(new FunctionImpl<bool(ControlCheck::*)()>(&ControlCheck::isClicked));
					case 13: return FunctionPtr(new FunctionImpl<CanvasMesh(ControlCheck::*)()>(&ControlCheck::getCanvasMesh));
					case 14: return FunctionPtr(new FunctionImpl<ControlCheck(ControlCheck::*)() const>(&ControlCheck::clonePtr));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(ControlCheck::*)()>(&ControlCheck::clearPtr));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(ControlCheck::*)()>(&ControlCheck::destroyPtr));
					case 17: return FunctionPtr(new FunctionImpl<ControlCheck&(ControlCheck::*)()>(&ControlCheck::acquirePtr));
					case 18: return FunctionPtr(new FunctionImpl<ControlCheck&(ControlCheck::*)()>(&ControlCheck::unacquirePtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(ControlCheck::*)() const>(&ControlCheck::isValidPtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(ControlCheck::*)() const>(&ControlCheck::isOwnerPtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(ControlCheck::*)() const>(&ControlCheck::isConstPtr));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(ControlCheck::*)() const>(&ControlCheck::getCountPtr));
					case 23: return FunctionPtr(new FunctionImpl<const void*(ControlCheck::*)() const>(&ControlCheck::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 5, 8, 11 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 22, 2315, 94, 2315, 22, 21, 2315, 94, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2086, 458, 2086, 458, 2086, 2515, 458, 2086, 2515 };
			static constexpr uint16_t function_names[] = { 2516, 2516, 2517, 2518, 2519, 2380, 2381, 2520, 2521, 2522, 2448, 2452, 2488, 2457, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 6, 16, 6, 654, 6, 654, 21, 6, 21, 6, 2453, 21, 2180, 2514, 2514, 2514, 2514, 2514, 2514, 2514, 2514, 2514, 2514 };
			static constexpr uint16_t function_bases[] = { 0, 1, 2, 2, 3, 3, 4, 4, 5, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 };
			static constexpr uint16_t function_arg_types[] = { 22, 94, 637, 637, 21, 21, 21, 2523 };
			static constexpr uint16_t function_arg_names[] = { 2086, 2086, 638, 638, 225, 2515, 225, 1162 };
	};
	constexpr uint16_t ReflectionControlCheck::constructor_bases[];
	constexpr uint16_t ReflectionControlCheck::constructor_arg_types[];
	constexpr uint16_t ReflectionControlCheck::constructor_arg_names[];
	constexpr uint16_t ReflectionControlCheck::function_names[];
	constexpr uint16_t ReflectionControlCheck::function_types[];
	constexpr uint16_t ReflectionControlCheck::function_bases[];
	constexpr uint16_t ReflectionControlCheck::function_arg_types[];
	constexpr uint16_t ReflectionControlCheck::function_arg_names[];
	static ReflectionControlCheck reflection_control_check;
	
	// Tellusim::ControlCombo
	class ReflectionControlCombo : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlCombo::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_text;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlCombo, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlCombo, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlCombo, TypeList<Control*, const InitializerList<const char*>&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlCombo, TypeList<Control*, const InitializerList<const char*>&, uint32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlCombo>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(bool)>(&ControlCombo::setMultiSelection));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlCombo::*)() const>(&ControlCombo::isMultiSelection));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(const char*)>(&ControlCombo::setComboText));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(const String&)>(&ControlCombo::setComboText));
					case 4: return FunctionPtr(new FunctionImpl<String(ControlCombo::*)() const>(&ControlCombo::getComboText));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(const Color&)>(&ControlCombo::setComboColor));
					case 6: return FunctionPtr(new FunctionImpl<const Color&(ControlCombo::*)() const>(&ControlCombo::getComboColor));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(float32_t)>(&ControlCombo::setItemsSpacing));
					case 8: return FunctionPtr(new FunctionImpl<float32_t(ControlCombo::*)() const>(&ControlCombo::getItemsSpacing));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)()>(&ControlCombo::clearItems));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(ControlCombo::*)(const char*)>(&ControlCombo::addItem));
					case 11: return FunctionPtr(new FunctionImpl<uint32_t(ControlCombo::*)(const String&)>(&ControlCombo::addItem));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(uint32_t, const char*)>(&ControlCombo::addItem));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(uint32_t, const String&)>(&ControlCombo::addItem));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(const InitializerList<const char*>&)>(&ControlCombo::addItems));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(uint32_t)>(&ControlCombo::removeItem));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(ControlCombo::*)() const>(&ControlCombo::getNumItems));
					case 17: return FunctionPtr(new FunctionImpl<bool(ControlCombo::*)(uint32_t)>(&ControlCombo::switchItemSelected));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(uint32_t, bool)>(&ControlCombo::setItemSelected));
					case 19: return FunctionPtr(new FunctionImpl<bool(ControlCombo::*)(uint32_t) const>(&ControlCombo::isItemSelected));
					case 20: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(uint32_t, const char*)>(&ControlCombo::setItemText));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(uint32_t, const String&)>(&ControlCombo::setItemText));
					case 22: return FunctionPtr(new FunctionImpl<String(ControlCombo::*)(uint32_t) const>(&ControlCombo::getItemText));
					case 23: return FunctionPtr(new FunctionImpl<uint32_t(ControlCombo::*)(const char*) const>(&ControlCombo::findItemText));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(ControlCombo::*)(const String&) const>(&ControlCombo::findItemText));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(uint32_t, const Color&)>(&ControlCombo::setItemColor));
					case 26: return FunctionPtr(new FunctionImpl<const Color&(ControlCombo::*)(uint32_t) const>(&ControlCombo::getItemColor));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(uint32_t, bool)>(&ControlCombo::setCurrentIndex, {}, false));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(const char*, bool)>(&ControlCombo::setCurrentText, {}, false));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(const String&, bool)>(&ControlCombo::setCurrentText, {}, false));
					case 30: return FunctionPtr(new FunctionImpl<uint32_t(ControlCombo::*)() const>(&ControlCombo::getCurrentIndex));
					case 31: return FunctionPtr(new FunctionImpl<String(ControlCombo::*)() const>(&ControlCombo::getCurrentText));
					case 32: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(const ControlCombo::ClickedCallback&)>(&ControlCombo::setClickedCallback));
					case 33: return FunctionPtr(new FunctionImpl<ControlCombo::ClickedCallback(ControlCombo::*)() const>(&ControlCombo::getClickedCallback));
					case 34: return FunctionPtr(new FunctionImpl<bool(ControlCombo::*)()>(&ControlCombo::isClicked));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)(const ControlCombo::ChangedCallback&)>(&ControlCombo::setChangedCallback));
					case 36: return FunctionPtr(new FunctionImpl<ControlCombo::ChangedCallback(ControlCombo::*)() const>(&ControlCombo::getChangedCallback));
					case 37: return FunctionPtr(new FunctionImpl<bool(ControlCombo::*)()>(&ControlCombo::isChanged));
					case 38: return FunctionPtr(new FunctionImpl<CanvasMesh(ControlCombo::*)()>(&ControlCombo::getCanvasMesh));
					case 39: return FunctionPtr(new FunctionImpl<ControlCombo(ControlCombo::*)() const>(&ControlCombo::clonePtr));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)()>(&ControlCombo::clearPtr));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(ControlCombo::*)()>(&ControlCombo::destroyPtr));
					case 42: return FunctionPtr(new FunctionImpl<ControlCombo&(ControlCombo::*)()>(&ControlCombo::acquirePtr));
					case 43: return FunctionPtr(new FunctionImpl<ControlCombo&(ControlCombo::*)()>(&ControlCombo::unacquirePtr));
					case 44: return FunctionPtr(new FunctionImpl<bool(ControlCombo::*)() const>(&ControlCombo::isValidPtr));
					case 45: return FunctionPtr(new FunctionImpl<bool(ControlCombo::*)() const>(&ControlCombo::isOwnerPtr));
					case 46: return FunctionPtr(new FunctionImpl<bool(ControlCombo::*)() const>(&ControlCombo::isConstPtr));
					case 47: return FunctionPtr(new FunctionImpl<uint32_t(ControlCombo::*)() const>(&ControlCombo::getCountPtr));
					case 48: return FunctionPtr(new FunctionImpl<const void*(ControlCombo::*)() const>(&ControlCombo::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 6 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 2525, 2315, 2525, 10 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2526, 458, 2526, 274 };
			static constexpr uint16_t function_names[] = { 2527, 2529, 2530, 2530, 2531, 2532, 2533, 2534, 2535, 2536, 2537, 2537, 2537, 2537, 2538, 2539, 2540, 2541, 2542, 2544, 2545, 2545, 2546, 2547, 2547, 2548, 2549, 2550, 2551, 2551, 2552, 2553, 2448, 2452, 2488, 2555, 2557, 2559, 2457, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 6, 16, 6, 654, 6, 123, 6, 10, 10, 6, 6, 6, 6, 10, 21, 6, 21, 6, 6, 16, 10, 10, 6, 654, 6, 6, 6, 10, 16, 6, 2453, 21, 6, 2558, 21, 2180, 2524, 2524, 2524, 2524, 2524, 2524, 2524, 2524, 2524, 2524 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 3, 3, 4, 4, 5, 5, 5, 6, 7, 9, 11, 12, 13, 13, 14, 16, 17, 19, 21, 22, 23, 24, 26, 27, 29, 31, 33, 33, 33, 34, 34, 34, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35, 35 };
			static constexpr uint16_t function_arg_types[] = { 21, 22, 94, 637, 123, 22, 94, 10, 22, 10, 94, 2525, 10, 10, 10, 21, 10, 10, 22, 10, 94, 10, 22, 94, 10, 637, 10, 10, 21, 22, 21, 94, 21, 2554, 2556 };
			static constexpr uint16_t function_arg_names[] = { 2528, 2086, 2086, 638, 2463, 2086, 2086, 274, 2086, 274, 2086, 2526, 274, 274, 274, 2543, 274, 274, 2086, 274, 2086, 274, 2086, 2086, 274, 638, 274, 274, 225, 2086, 225, 2086, 225, 1162, 1162 };
	};
	constexpr uint16_t ReflectionControlCombo::constructor_bases[];
	constexpr uint16_t ReflectionControlCombo::constructor_arg_types[];
	constexpr uint16_t ReflectionControlCombo::constructor_arg_names[];
	constexpr uint16_t ReflectionControlCombo::function_names[];
	constexpr uint16_t ReflectionControlCombo::function_types[];
	constexpr uint16_t ReflectionControlCombo::function_bases[];
	constexpr uint16_t ReflectionControlCombo::function_arg_types[];
	constexpr uint16_t ReflectionControlCombo::function_arg_names[];
	static ReflectionControlCombo reflection_control_combo;
	
	// Tellusim::ControlButton
	class ReflectionControlButton : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlButton::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_text;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlButton, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlButton, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlButton, TypeList<Control*, const char*>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlButton, TypeList<Control*, const String&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlButton>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)(bool)>(&ControlButton::setBackground));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlButton::*)() const>(&ControlButton::getBackground));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)(CanvasElement::Mode)>(&ControlButton::setButtonMode));
					case 3: return FunctionPtr(new FunctionImpl<CanvasElement::Mode(ControlButton::*)() const>(&ControlButton::getButtonMode));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)(float32_t)>(&ControlButton::setButtonRadius));
					case 5: return FunctionPtr(new FunctionImpl<float32_t(ControlButton::*)() const>(&ControlButton::getButtonRadius));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)(const Color&)>(&ControlButton::setButtonColor));
					case 7: return FunctionPtr(new FunctionImpl<const Color&(ControlButton::*)() const>(&ControlButton::getButtonColor));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)(const StrokeStyle&)>(&ControlButton::setStrokeStyle));
					case 9: return FunctionPtr(new FunctionImpl<const StrokeStyle&(ControlButton::*)() const>(&ControlButton::getStrokeStyleConst));
					case 10: return FunctionPtr(new FunctionImpl<const StrokeStyle&(ControlButton::*)() const>(&ControlButton::getStrokeStyle));
					case 11: return FunctionPtr(new FunctionImpl<StrokeStyle&(ControlButton::*)()>(&ControlButton::getStrokeStyle));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)(const GradientStyle&)>(&ControlButton::setGradientStyle));
					case 13: return FunctionPtr(new FunctionImpl<const GradientStyle&(ControlButton::*)() const>(&ControlButton::getGradientStyleConst));
					case 14: return FunctionPtr(new FunctionImpl<const GradientStyle&(ControlButton::*)() const>(&ControlButton::getGradientStyle));
					case 15: return FunctionPtr(new FunctionImpl<GradientStyle&(ControlButton::*)()>(&ControlButton::getGradientStyle));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)(const ControlButton::PressedCallback&)>(&ControlButton::setPressedCallback));
					case 17: return FunctionPtr(new FunctionImpl<ControlButton::PressedCallback(ControlButton::*)() const>(&ControlButton::getPressedCallback));
					case 18: return FunctionPtr(new FunctionImpl<bool(ControlButton::*)()>(&ControlButton::isPressed));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)(const ControlButton::ReleasedCallback&)>(&ControlButton::setReleasedCallback));
					case 20: return FunctionPtr(new FunctionImpl<ControlButton::ReleasedCallback(ControlButton::*)() const>(&ControlButton::getReleasedCallback));
					case 21: return FunctionPtr(new FunctionImpl<bool(ControlButton::*)()>(&ControlButton::isReleased));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)(const ControlButton::ClickedCallback&)>(&ControlButton::setClickedCallback));
					case 23: return FunctionPtr(new FunctionImpl<ControlButton::ClickedCallback(ControlButton::*)() const>(&ControlButton::getClickedCallback));
					case 24: return FunctionPtr(new FunctionImpl<bool(ControlButton::*)()>(&ControlButton::isClicked));
					case 25: return FunctionPtr(new FunctionImpl<CanvasRect(ControlButton::*)()>(&ControlButton::getCanvasRect));
					case 26: return FunctionPtr(new FunctionImpl<CanvasMesh(ControlButton::*)()>(&ControlButton::getCanvasMesh));
					case 27: return FunctionPtr(new FunctionImpl<ControlButton(ControlButton::*)() const>(&ControlButton::clonePtr));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)()>(&ControlButton::clearPtr));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(ControlButton::*)()>(&ControlButton::destroyPtr));
					case 30: return FunctionPtr(new FunctionImpl<ControlButton&(ControlButton::*)()>(&ControlButton::acquirePtr));
					case 31: return FunctionPtr(new FunctionImpl<ControlButton&(ControlButton::*)()>(&ControlButton::unacquirePtr));
					case 32: return FunctionPtr(new FunctionImpl<bool(ControlButton::*)() const>(&ControlButton::isValidPtr));
					case 33: return FunctionPtr(new FunctionImpl<bool(ControlButton::*)() const>(&ControlButton::isOwnerPtr));
					case 34: return FunctionPtr(new FunctionImpl<bool(ControlButton::*)() const>(&ControlButton::isConstPtr));
					case 35: return FunctionPtr(new FunctionImpl<uint32_t(ControlButton::*)() const>(&ControlButton::getCountPtr));
					case 36: return FunctionPtr(new FunctionImpl<const void*(ControlButton::*)() const>(&ControlButton::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 5 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 22, 2315, 94 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2086, 458, 2086 };
			static constexpr uint16_t function_names[] = { 2480, 2482, 2561, 2562, 2563, 2564, 2565, 2566, 2223, 2225, 2227, 2227, 2183, 2185, 2187, 2187, 2440, 2442, 2568, 2444, 2446, 2570, 2448, 2452, 2488, 2456, 2457, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 2117, 6, 123, 6, 654, 6, 2226, 2226, 2226, 6, 2186, 2186, 2186, 6, 2443, 21, 6, 2447, 21, 6, 2453, 21, 2217, 2180, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560, 2560 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5, 6, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
			static constexpr uint16_t function_arg_types[] = { 21, 2115, 123, 637, 2224, 2184, 2567, 2569, 2571 };
			static constexpr uint16_t function_arg_names[] = { 2481, 185, 2218, 638, 2091, 2091, 1162, 1162, 1162 };
	};
	constexpr uint16_t ReflectionControlButton::constructor_bases[];
	constexpr uint16_t ReflectionControlButton::constructor_arg_types[];
	constexpr uint16_t ReflectionControlButton::constructor_arg_names[];
	constexpr uint16_t ReflectionControlButton::function_names[];
	constexpr uint16_t ReflectionControlButton::function_types[];
	constexpr uint16_t ReflectionControlButton::function_bases[];
	constexpr uint16_t ReflectionControlButton::function_arg_types[];
	constexpr uint16_t ReflectionControlButton::function_arg_names[];
	static ReflectionControlButton reflection_control_button;
	
	// Tellusim::ControlSlider
	class ReflectionControlSlider : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlSlider::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_text;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<Control*, const char*>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<Control*, const String&>>());
					case 4: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<Control*, const char*, uint32_t>>());
					case 5: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<Control*, const char*, uint32_t, float64_t>>());
					case 6: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<Control*, const char*, uint32_t, float64_t, float64_t, float64_t>>());
					case 7: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<Control*, const char*, float64_t, float64_t, float64_t>>());
					case 8: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<Control*, const char*, uint32_t, uint32_t, uint32_t>>());
					case 9: return ConstructorPtr(new ConstructorImpl<ControlSlider, TypeList<Control*, const char*, int32_t, int32_t, int32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlSlider>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(const Color&)>(&ControlSlider::setSliderColor));
					case 1: return FunctionPtr(new FunctionImpl<const Color&(ControlSlider::*)() const>(&ControlSlider::getSliderColor));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(uint32_t)>(&ControlSlider::setDigits));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(ControlSlider::*)() const>(&ControlSlider::getDigits));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(bool)>(&ControlSlider::setTextEnabled));
					case 5: return FunctionPtr(new FunctionImpl<bool(ControlSlider::*)() const>(&ControlSlider::isTextEnabled));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(float64_t)>(&ControlSlider::setStep));
					case 7: return FunctionPtr(new FunctionImpl<float64_t(ControlSlider::*)() const>(&ControlSlider::getStep));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(float64_t)>(&ControlSlider::setBase));
					case 9: return FunctionPtr(new FunctionImpl<float64_t(ControlSlider::*)() const>(&ControlSlider::getBase));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(const char*)>(&ControlSlider::setFormat));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(const String&)>(&ControlSlider::setFormat));
					case 12: return FunctionPtr(new FunctionImpl<String(ControlSlider::*)() const>(&ControlSlider::getFormat));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(float64_t, bool, bool)>(&ControlSlider::setValue, {}, false, false));
					case 14: return FunctionPtr(new FunctionImpl<float64_t(ControlSlider::*)(bool) const>(&ControlSlider::getValue, false));
					case 15: return FunctionPtr(new FunctionImpl<float32_t(ControlSlider::*)(bool) const>(&ControlSlider::getValuef32, false));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(ControlSlider::*)(bool) const>(&ControlSlider::getValueu32, false));
					case 17: return FunctionPtr(new FunctionImpl<int32_t(ControlSlider::*)(bool) const>(&ControlSlider::getValuei32, false));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(float64_t, float64_t, bool)>(&ControlSlider::setRange, {}, {}, false));
					case 19: return FunctionPtr(new FunctionImpl<float64_t(ControlSlider::*)(bool) const>(&ControlSlider::getMinRange, false));
					case 20: return FunctionPtr(new FunctionImpl<float64_t(ControlSlider::*)(bool) const>(&ControlSlider::getMaxRange, false));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(float32_t)>(&ControlSlider::setHandleSize));
					case 22: return FunctionPtr(new FunctionImpl<float32_t(ControlSlider::*)() const>(&ControlSlider::getHandleSize));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(const ControlSlider::FormatCallback&)>(&ControlSlider::setFormatCallback));
					case 24: return FunctionPtr(new FunctionImpl<ControlSlider::FormatCallback(ControlSlider::*)() const>(&ControlSlider::getFormatCallback));
					case 25: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(const ControlSlider::ReleasedCallback&)>(&ControlSlider::setReleasedCallback));
					case 26: return FunctionPtr(new FunctionImpl<ControlSlider::ReleasedCallback(ControlSlider::*)() const>(&ControlSlider::getReleasedCallback));
					case 27: return FunctionPtr(new FunctionImpl<bool(ControlSlider::*)()>(&ControlSlider::isReleased));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(const ControlSlider::ClickedCallback&)>(&ControlSlider::setClickedCallback));
					case 29: return FunctionPtr(new FunctionImpl<ControlSlider::ClickedCallback(ControlSlider::*)() const>(&ControlSlider::getClickedCallback));
					case 30: return FunctionPtr(new FunctionImpl<bool(ControlSlider::*)()>(&ControlSlider::isClicked));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)(const ControlSlider::ChangedCallback&)>(&ControlSlider::setChangedCallback));
					case 32: return FunctionPtr(new FunctionImpl<ControlSlider::ChangedCallback(ControlSlider::*)() const>(&ControlSlider::getChangedCallback));
					case 33: return FunctionPtr(new FunctionImpl<bool(ControlSlider::*)(bool)>(&ControlSlider::isChanged, true));
					case 34: return FunctionPtr(new FunctionImpl<CanvasMesh(ControlSlider::*)()>(&ControlSlider::getCanvasMesh));
					case 35: return FunctionPtr(new FunctionImpl<ControlSlider(ControlSlider::*)() const>(&ControlSlider::clonePtr));
					case 36: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)()>(&ControlSlider::clearPtr));
					case 37: return FunctionPtr(new FunctionVoidImpl<void(ControlSlider::*)()>(&ControlSlider::destroyPtr));
					case 38: return FunctionPtr(new FunctionImpl<ControlSlider&(ControlSlider::*)()>(&ControlSlider::acquirePtr));
					case 39: return FunctionPtr(new FunctionImpl<ControlSlider&(ControlSlider::*)()>(&ControlSlider::unacquirePtr));
					case 40: return FunctionPtr(new FunctionImpl<bool(ControlSlider::*)() const>(&ControlSlider::isValidPtr));
					case 41: return FunctionPtr(new FunctionImpl<bool(ControlSlider::*)() const>(&ControlSlider::isOwnerPtr));
					case 42: return FunctionPtr(new FunctionImpl<bool(ControlSlider::*)() const>(&ControlSlider::isConstPtr));
					case 43: return FunctionPtr(new FunctionImpl<uint32_t(ControlSlider::*)() const>(&ControlSlider::getCountPtr));
					case 44: return FunctionPtr(new FunctionImpl<const void*(ControlSlider::*)() const>(&ControlSlider::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 5, 8, 12, 18, 23, 28, 33 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 22, 2315, 94, 2315, 22, 10, 2315, 22, 10, 126, 2315, 22, 10, 126, 126, 126, 2315, 22, 126, 126, 126, 2315, 22, 10, 10, 10, 2315, 22, 1, 1, 1 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2086, 458, 2086, 458, 2086, 867, 458, 2086, 867, 105, 458, 2086, 867, 105, 445, 720, 458, 2086, 105, 445, 720, 458, 2086, 105, 445, 720, 458, 2086, 105, 445, 720 };
			static constexpr uint16_t function_names[] = { 2573, 2574, 2575, 2576, 2577, 2578, 2579, 2581, 2582, 2584, 2585, 2585, 349, 587, 588, 2586, 2587, 2588, 2589, 2590, 2591, 2592, 2593, 2594, 2596, 2444, 2446, 2570, 2448, 2452, 2488, 2555, 2557, 2559, 2457, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 654, 6, 10, 6, 21, 6, 126, 6, 126, 6, 6, 16, 6, 126, 123, 10, 1, 6, 126, 126, 6, 123, 6, 2597, 6, 2447, 21, 6, 2453, 21, 6, 2558, 21, 2180, 2572, 2572, 2572, 2572, 2572, 2572, 2572, 2572, 2572, 2572 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 7, 7, 10, 11, 12, 13, 14, 17, 18, 19, 20, 20, 21, 21, 22, 22, 22, 23, 23, 23, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25 };
			static constexpr uint16_t function_arg_types[] = { 637, 10, 21, 126, 126, 22, 94, 126, 21, 21, 21, 21, 21, 21, 126, 126, 21, 21, 21, 123, 2595, 2598, 2599, 2600, 21 };
			static constexpr uint16_t function_arg_names[] = { 638, 867, 1309, 2580, 2583, 96, 96, 105, 225, 868, 868, 868, 868, 868, 445, 720, 868, 868, 868, 87, 1162, 1162, 1162, 1162, 5 };
	};
	constexpr uint16_t ReflectionControlSlider::constructor_bases[];
	constexpr uint16_t ReflectionControlSlider::constructor_arg_types[];
	constexpr uint16_t ReflectionControlSlider::constructor_arg_names[];
	constexpr uint16_t ReflectionControlSlider::function_names[];
	constexpr uint16_t ReflectionControlSlider::function_types[];
	constexpr uint16_t ReflectionControlSlider::function_bases[];
	constexpr uint16_t ReflectionControlSlider::function_arg_types[];
	constexpr uint16_t ReflectionControlSlider::function_arg_names[];
	static ReflectionControlSlider reflection_control_slider;
	
	// Tellusim::ControlScroll
	class ReflectionControlScroll : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlScroll::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_text;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlScroll, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlScroll, TypeList<Control*, bool>>({}, false));
					case 2: return ConstructorPtr(new ConstructorImpl<ControlScroll, TypeList<Control*, float64_t, bool>>({}, {}, false));
					case 3: return ConstructorPtr(new ConstructorImpl<ControlScroll, TypeList<Control*, float64_t, float64_t, float64_t, bool>>({}, {}, {}, {}, false));
					case 4: return ConstructorPtr(new ConstructorImpl<ControlScroll, TypeList<Control*, uint32_t, uint32_t, uint32_t, bool>>({}, {}, {}, {}, false));
					case 5: return ConstructorPtr(new ConstructorImpl<ControlScroll, TypeList<Control*, int32_t, int32_t, int32_t, bool>>({}, {}, {}, {}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlScroll>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(bool, bool)>(&ControlScroll::setVertical, {}, true));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlScroll::*)() const>(&ControlScroll::isHorizontal));
					case 2: return FunctionPtr(new FunctionImpl<bool(ControlScroll::*)() const>(&ControlScroll::isVertical));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(const char*)>(&ControlScroll::setPrevText));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(const String&)>(&ControlScroll::setPrevText));
					case 5: return FunctionPtr(new FunctionImpl<String(ControlScroll::*)() const>(&ControlScroll::getPrevText));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(const char*)>(&ControlScroll::setNextText));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(const String&)>(&ControlScroll::setNextText));
					case 8: return FunctionPtr(new FunctionImpl<String(ControlScroll::*)() const>(&ControlScroll::getNextText));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(const Color&)>(&ControlScroll::setScrollColor));
					case 10: return FunctionPtr(new FunctionImpl<const Color&(ControlScroll::*)() const>(&ControlScroll::getScrollColor));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(float64_t)>(&ControlScroll::setStep));
					case 12: return FunctionPtr(new FunctionImpl<float64_t(ControlScroll::*)() const>(&ControlScroll::getStep));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(float64_t, bool)>(&ControlScroll::setValue, {}, false));
					case 14: return FunctionPtr(new FunctionImpl<float64_t(ControlScroll::*)() const>(&ControlScroll::getValue));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(float64_t)>(&ControlScroll::setFrame));
					case 16: return FunctionPtr(new FunctionImpl<float64_t(ControlScroll::*)() const>(&ControlScroll::getFrame));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(float64_t)>(&ControlScroll::setRange));
					case 18: return FunctionPtr(new FunctionImpl<float64_t(ControlScroll::*)() const>(&ControlScroll::getRange));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(Control::Align)>(&ControlScroll::setFrameAlign));
					case 20: return FunctionPtr(new FunctionImpl<Control::Align(ControlScroll::*)() const>(&ControlScroll::getFrameAlign));
					case 21: return FunctionPtr(new FunctionImpl<bool(ControlScroll::*)(Control::Align) const>(&ControlScroll::hasFrameAlign));
					case 22: return FunctionPtr(new FunctionImpl<bool(ControlScroll::*)(Control::Align) const>(&ControlScroll::hasFrameAligns));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(const ControlScroll::ClickedCallback&)>(&ControlScroll::setClickedCallback));
					case 24: return FunctionPtr(new FunctionImpl<ControlScroll::ClickedCallback(ControlScroll::*)() const>(&ControlScroll::getClickedCallback));
					case 25: return FunctionPtr(new FunctionImpl<bool(ControlScroll::*)()>(&ControlScroll::isClicked));
					case 26: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)(const ControlScroll::ChangedCallback&)>(&ControlScroll::setChangedCallback));
					case 27: return FunctionPtr(new FunctionImpl<ControlScroll::ChangedCallback(ControlScroll::*)() const>(&ControlScroll::getChangedCallback));
					case 28: return FunctionPtr(new FunctionImpl<bool(ControlScroll::*)(bool)>(&ControlScroll::isChanged, true));
					case 29: return FunctionPtr(new FunctionImpl<CanvasMesh(ControlScroll::*)()>(&ControlScroll::getCanvasMesh));
					case 30: return FunctionPtr(new FunctionImpl<ControlScroll(ControlScroll::*)() const>(&ControlScroll::clonePtr));
					case 31: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)()>(&ControlScroll::clearPtr));
					case 32: return FunctionPtr(new FunctionVoidImpl<void(ControlScroll::*)()>(&ControlScroll::destroyPtr));
					case 33: return FunctionPtr(new FunctionImpl<ControlScroll&(ControlScroll::*)()>(&ControlScroll::acquirePtr));
					case 34: return FunctionPtr(new FunctionImpl<ControlScroll&(ControlScroll::*)()>(&ControlScroll::unacquirePtr));
					case 35: return FunctionPtr(new FunctionImpl<bool(ControlScroll::*)() const>(&ControlScroll::isValidPtr));
					case 36: return FunctionPtr(new FunctionImpl<bool(ControlScroll::*)() const>(&ControlScroll::isOwnerPtr));
					case 37: return FunctionPtr(new FunctionImpl<bool(ControlScroll::*)() const>(&ControlScroll::isConstPtr));
					case 38: return FunctionPtr(new FunctionImpl<uint32_t(ControlScroll::*)() const>(&ControlScroll::getCountPtr));
					case 39: return FunctionPtr(new FunctionImpl<const void*(ControlScroll::*)() const>(&ControlScroll::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2, 5, 10, 15, 20 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 21, 2315, 126, 21, 2315, 126, 126, 126, 21, 2315, 10, 10, 10, 21, 2315, 1, 1, 1, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 2348, 458, 105, 2348, 458, 105, 2602, 1414, 2348, 458, 105, 2602, 1414, 2348, 458, 105, 2602, 1414, 2348 };
			static constexpr uint16_t function_names[] = { 2603, 2604, 2605, 2606, 2606, 2607, 2608, 2608, 2609, 2610, 2611, 2579, 2581, 587, 588, 2612, 2613, 2589, 2614, 2615, 2616, 2617, 2618, 2448, 2452, 2488, 2555, 2557, 2559, 2457, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 6, 6, 16, 6, 6, 16, 6, 654, 6, 126, 6, 126, 6, 126, 6, 126, 6, 2122, 21, 21, 6, 2453, 21, 6, 2558, 21, 2180, 2601, 2601, 2601, 2601, 2601, 2601, 2601, 2601, 2601, 2601 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15, 16, 16, 16, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18 };
			static constexpr uint16_t function_arg_types[] = { 21, 21, 22, 94, 22, 94, 637, 126, 126, 21, 126, 126, 2330, 2330, 2330, 2619, 2620, 21 };
			static constexpr uint16_t function_arg_names[] = { 2348, 2086, 2086, 2086, 2086, 2086, 638, 2580, 105, 225, 2602, 1414, 2120, 2120, 2125, 1162, 1162, 5 };
	};
	constexpr uint16_t ReflectionControlScroll::constructor_bases[];
	constexpr uint16_t ReflectionControlScroll::constructor_arg_types[];
	constexpr uint16_t ReflectionControlScroll::constructor_arg_names[];
	constexpr uint16_t ReflectionControlScroll::function_names[];
	constexpr uint16_t ReflectionControlScroll::function_types[];
	constexpr uint16_t ReflectionControlScroll::function_bases[];
	constexpr uint16_t ReflectionControlScroll::function_arg_types[];
	constexpr uint16_t ReflectionControlScroll::function_arg_names[];
	static ReflectionControlScroll reflection_control_scroll;
	
	// Tellusim::ControlSplit
	class ReflectionControlSplit : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlSplit::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlSplit, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlSplit, TypeList<Control*, bool>>({}, false));
					case 2: return ConstructorPtr(new ConstructorImpl<ControlSplit, TypeList<Control*, float32_t, bool>>({}, {}, false));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlSplit>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlSplit::*)(bool)>(&ControlSplit::setAbsolute));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlSplit::*)() const>(&ControlSplit::isAbsolute));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlSplit::*)(bool)>(&ControlSplit::setVertical));
					case 3: return FunctionPtr(new FunctionImpl<bool(ControlSplit::*)() const>(&ControlSplit::isHorizontal));
					case 4: return FunctionPtr(new FunctionImpl<bool(ControlSplit::*)() const>(&ControlSplit::isVertical));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ControlSplit::*)(float32_t)>(&ControlSplit::setValue));
					case 6: return FunctionPtr(new FunctionImpl<float32_t(ControlSplit::*)() const>(&ControlSplit::getValue));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(ControlSplit::*)(float32_t)>(&ControlSplit::setHandleSize));
					case 8: return FunctionPtr(new FunctionImpl<float32_t(ControlSplit::*)() const>(&ControlSplit::getHandleSize));
					case 9: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlSplit::*)() const>(&ControlSplit::getControlsSize));
					case 10: return FunctionPtr(new FunctionImpl<ControlSplit(ControlSplit::*)() const>(&ControlSplit::clonePtr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(ControlSplit::*)()>(&ControlSplit::clearPtr));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(ControlSplit::*)()>(&ControlSplit::destroyPtr));
					case 13: return FunctionPtr(new FunctionImpl<ControlSplit&(ControlSplit::*)()>(&ControlSplit::acquirePtr));
					case 14: return FunctionPtr(new FunctionImpl<ControlSplit&(ControlSplit::*)()>(&ControlSplit::unacquirePtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(ControlSplit::*)() const>(&ControlSplit::isValidPtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(ControlSplit::*)() const>(&ControlSplit::isOwnerPtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(ControlSplit::*)() const>(&ControlSplit::isConstPtr));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(ControlSplit::*)() const>(&ControlSplit::getCountPtr));
					case 19: return FunctionPtr(new FunctionImpl<const void*(ControlSplit::*)() const>(&ControlSplit::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 2, 5 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 21, 2315, 123, 21 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 2348, 458, 105, 2348 };
			static constexpr uint16_t function_names[] = { 2622, 2624, 2603, 2604, 2605, 587, 588, 2592, 2593, 2468, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 21, 21, 6, 123, 6, 123, 2206, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621, 2621 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 2, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4 };
			static constexpr uint16_t function_arg_types[] = { 21, 21, 123, 123 };
			static constexpr uint16_t function_arg_names[] = { 2623, 2348, 105, 87 };
	};
	constexpr uint16_t ReflectionControlSplit::constructor_bases[];
	constexpr uint16_t ReflectionControlSplit::constructor_arg_types[];
	constexpr uint16_t ReflectionControlSplit::constructor_arg_names[];
	constexpr uint16_t ReflectionControlSplit::function_names[];
	constexpr uint16_t ReflectionControlSplit::function_types[];
	constexpr uint16_t ReflectionControlSplit::function_bases[];
	constexpr uint16_t ReflectionControlSplit::function_arg_types[];
	constexpr uint16_t ReflectionControlSplit::function_arg_names[];
	static ReflectionControlSplit reflection_control_split;
	
	// Tellusim::ControlArea
	class ReflectionControlArea : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlArea::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlArea, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlArea, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlArea, TypeList<Control*, uint32_t>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlArea, TypeList<Control*, bool, bool>>());
					case 4: return ConstructorPtr(new ConstructorImpl<ControlArea, TypeList<Control*, uint32_t, float32_t, float32_t>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlArea>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(bool)>(&ControlArea::setAbsolute));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isAbsolute));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(bool)>(&ControlArea::setScalable));
					case 3: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isScalable));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(bool)>(&ControlArea::setScrollable));
					case 5: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isScrollable));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(float32_t)>(&ControlArea::setScale));
					case 7: return FunctionPtr(new FunctionImpl<float32_t(ControlArea::*)() const>(&ControlArea::getScale));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(float32_t, float32_t)>(&ControlArea::setScaleRange));
					case 9: return FunctionPtr(new FunctionImpl<float32_t(ControlArea::*)() const>(&ControlArea::getMinScale));
					case 10: return FunctionPtr(new FunctionImpl<float32_t(ControlArea::*)() const>(&ControlArea::getMaxScale));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(float64_t)>(&ControlArea::setHorizontalStep));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(float64_t)>(&ControlArea::setVerticalStep));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(float64_t, float64_t)>(&ControlArea::setStep));
					case 14: return FunctionPtr(new FunctionImpl<float64_t(ControlArea::*)() const>(&ControlArea::getHorizontalStep));
					case 15: return FunctionPtr(new FunctionImpl<float64_t(ControlArea::*)() const>(&ControlArea::getVerticalStep));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(float64_t)>(&ControlArea::setHorizontalValue));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(float64_t)>(&ControlArea::setVerticalValue));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(float64_t, float64_t)>(&ControlArea::setValue));
					case 19: return FunctionPtr(new FunctionImpl<float64_t(ControlArea::*)() const>(&ControlArea::getHorizontalValue));
					case 20: return FunctionPtr(new FunctionImpl<float64_t(ControlArea::*)() const>(&ControlArea::getVerticalValue));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(Control::Align)>(&ControlArea::setFrameAlign));
					case 22: return FunctionPtr(new FunctionImpl<Control::Align(ControlArea::*)() const>(&ControlArea::getFrameAlign));
					case 23: return FunctionPtr(new FunctionImpl<float64_t(ControlArea::*)() const>(&ControlArea::getHorizontalFrame));
					case 24: return FunctionPtr(new FunctionImpl<float64_t(ControlArea::*)() const>(&ControlArea::getVerticalFrame));
					case 25: return FunctionPtr(new FunctionImpl<float64_t(ControlArea::*)() const>(&ControlArea::getHorizontalRange));
					case 26: return FunctionPtr(new FunctionImpl<float64_t(ControlArea::*)() const>(&ControlArea::getVerticalRange));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(bool, bool)>(&ControlArea::setHorizontalEnabled, {}, false));
					case 28: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isHorizontalEnabled));
					case 29: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isHorizontalDynamic));
					case 30: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isHorizontalHidden));
					case 31: return FunctionPtr(new FunctionImpl<const ControlScroll(ControlArea::*)() const>(&ControlArea::getHorizontalScroll));
					case 32: return FunctionPtr(new FunctionImpl<ControlScroll(ControlArea::*)()>(&ControlArea::getHorizontalScroll));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(bool, bool)>(&ControlArea::setVerticalEnabled, {}, false));
					case 34: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isVerticalEnabled));
					case 35: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isVerticalDynamic));
					case 36: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isVerticalHidden));
					case 37: return FunctionPtr(new FunctionImpl<const ControlScroll(ControlArea::*)() const>(&ControlArea::getVerticalScroll));
					case 38: return FunctionPtr(new FunctionImpl<ControlScroll(ControlArea::*)()>(&ControlArea::getVerticalScroll));
					case 39: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)(uint32_t)>(&ControlArea::setFontSize));
					case 40: return FunctionPtr(new FunctionImpl<uint32_t(ControlArea::*)() const>(&ControlArea::getFontSize));
					case 41: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)(const FontStyle&)>(&ControlArea::setFontStyle));
					case 42: return FunctionPtr(new FunctionImpl<const FontStyle&(ControlArea::*)() const>(&ControlArea::getFontStyleConst));
					case 43: return FunctionPtr(new FunctionImpl<const FontStyle&(ControlArea::*)() const>(&ControlArea::getFontStyle));
					case 44: return FunctionPtr(new FunctionImpl<FontStyle&(ControlArea::*)()>(&ControlArea::getFontStyle));
					case 45: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(uint32_t)>(&ControlArea::setColumns));
					case 46: return FunctionPtr(new FunctionImpl<uint32_t(ControlArea::*)() const>(&ControlArea::getColumns));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(const Vector2f&)>(&ControlArea::setSpacing));
					case 48: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(float32_t, float32_t)>(&ControlArea::setSpacing));
					case 49: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlArea::*)() const>(&ControlArea::getSpacing));
					case 50: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)(uint32_t, float32_t)>(&ControlArea::setColumnRatio));
					case 51: return FunctionPtr(new FunctionImpl<float32_t(ControlArea::*)(uint32_t) const>(&ControlArea::getColumnRatio));
					case 52: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlArea::*)() const>(&ControlArea::getControlsSize));
					case 53: return FunctionPtr(new FunctionImpl<const Vector2f&(ControlArea::*)() const>(&ControlArea::getControlsOffset));
					case 54: return FunctionPtr(new FunctionImpl<const Rect&(ControlArea::*)() const>(&ControlArea::getViewRect));
					case 55: return FunctionPtr(new FunctionImpl<ControlArea(ControlArea::*)() const>(&ControlArea::clonePtr));
					case 56: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)()>(&ControlArea::clearPtr));
					case 57: return FunctionPtr(new FunctionVoidImpl<void(ControlArea::*)()>(&ControlArea::destroyPtr));
					case 58: return FunctionPtr(new FunctionImpl<ControlArea&(ControlArea::*)()>(&ControlArea::acquirePtr));
					case 59: return FunctionPtr(new FunctionImpl<ControlArea&(ControlArea::*)()>(&ControlArea::unacquirePtr));
					case 60: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isValidPtr));
					case 61: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isOwnerPtr));
					case 62: return FunctionPtr(new FunctionImpl<bool(ControlArea::*)() const>(&ControlArea::isConstPtr));
					case 63: return FunctionPtr(new FunctionImpl<uint32_t(ControlArea::*)() const>(&ControlArea::getCountPtr));
					case 64: return FunctionPtr(new FunctionImpl<const void*(ControlArea::*)() const>(&ControlArea::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 6, 10 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 10, 2315, 21, 21, 2315, 10, 123, 123 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2459, 458, 2347, 2348, 458, 2459, 1973, 1974 };
			static constexpr uint16_t function_names[] = { 2622, 2624, 2626, 2628, 2629, 2631, 754, 761, 2632, 2633, 2634, 2635, 2636, 2579, 2637, 2638, 2639, 2640, 587, 2641, 2642, 2615, 2616, 2643, 2644, 2645, 2646, 2647, 2649, 2650, 2651, 2652, 2652, 2653, 2654, 2655, 2656, 2657, 2657, 2165, 2166, 2169, 2170, 2172, 2172, 2460, 2461, 2462, 2462, 2464, 2465, 2467, 2468, 2658, 2659, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 21, 6, 21, 6, 123, 6, 123, 123, 6, 6, 6, 126, 126, 6, 6, 6, 126, 126, 6, 2122, 126, 126, 126, 126, 6, 21, 21, 21, 2601, 2601, 6, 21, 21, 21, 2601, 2601, 21, 10, 21, 2171, 2171, 2171, 6, 10, 6, 6, 2206, 6, 123, 2206, 2206, 2094, 2625, 2625, 2625, 2625, 2625, 2625, 2625, 2625, 2625, 2625 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 6, 6, 6, 7, 8, 10, 10, 10, 11, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15, 17, 17, 17, 17, 17, 17, 19, 19, 19, 19, 19, 19, 20, 20, 21, 21, 21, 21, 22, 22, 23, 25, 25, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28 };
			static constexpr uint16_t function_arg_types[] = { 21, 21, 21, 123, 123, 123, 126, 126, 126, 126, 126, 126, 126, 126, 2330, 21, 21, 21, 21, 10, 2090, 10, 2202, 123, 123, 10, 123, 10 };
			static constexpr uint16_t function_arg_names[] = { 2623, 2627, 2630, 527, 445, 720, 2580, 2580, 2347, 2348, 105, 105, 2347, 2348, 2120, 1309, 2648, 1309, 2648, 87, 2091, 2459, 2463, 1973, 1974, 274, 2466, 274 };
	};
	constexpr uint16_t ReflectionControlArea::constructor_bases[];
	constexpr uint16_t ReflectionControlArea::constructor_arg_types[];
	constexpr uint16_t ReflectionControlArea::constructor_arg_names[];
	constexpr uint16_t ReflectionControlArea::function_names[];
	constexpr uint16_t ReflectionControlArea::function_types[];
	constexpr uint16_t ReflectionControlArea::function_bases[];
	constexpr uint16_t ReflectionControlArea::function_arg_types[];
	constexpr uint16_t ReflectionControlArea::function_arg_names[];
	static ReflectionControlArea reflection_control_area;
	
	// Tellusim::ControlTree
	class ReflectionControlTree : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlTree::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_text;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlTree, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlTree, TypeList<Control*>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlTree>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(bool)>(&ControlTree::setSelectable));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)() const>(&ControlTree::isSelectable));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(bool)>(&ControlTree::setMultiSelection));
					case 3: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)() const>(&ControlTree::isMultiSelection));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const char*)>(&ControlTree::setFoldedText));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const String&)>(&ControlTree::setFoldedText));
					case 6: return FunctionPtr(new FunctionImpl<String(ControlTree::*)() const>(&ControlTree::getFoldedText));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const char*)>(&ControlTree::setExpandedText));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const String&)>(&ControlTree::setExpandedText));
					case 9: return FunctionPtr(new FunctionImpl<String(ControlTree::*)() const>(&ControlTree::getExpandedText));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(Texture&, uint32_t, uint32_t)>(&ControlTree::setTexture, Texture::null, 1, 1));
					case 11: return FunctionPtr(new FunctionImpl<Texture(ControlTree::*)() const>(&ControlTree::getTexture));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const char*, uint32_t, uint32_t)>(&ControlTree::setTextureName, {}, 1, 1));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const String&, uint32_t, uint32_t)>(&ControlTree::setTextureName, {}, 1, 1));
					case 14: return FunctionPtr(new FunctionImpl<String(ControlTree::*)() const>(&ControlTree::getTextureName));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, uint32_t)>(&ControlTree::setTextureGrid));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)() const>(&ControlTree::getTextureRows));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)() const>(&ControlTree::getTextureColumns));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)()>(&ControlTree::clearItems));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(const char*, uint32_t, bool)>(&ControlTree::addItem, {}, Maxu32, true));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(const String&, uint32_t, bool)>(&ControlTree::addItem, {}, Maxu32, true));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const InitializerList<const char*>&, uint32_t)>(&ControlTree::addItems, {}, Maxu32));
					case 22: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, bool)>(&ControlTree::removeItem, {}, false));
					case 23: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t)>(&ControlTree::viewItem));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)() const>(&ControlTree::getNumItems));
					case 25: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(uint32_t) const>(&ControlTree::getItem));
					case 26: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)(uint32_t, bool)>(&ControlTree::switchItemHidden, {}, false));
					case 27: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, bool, bool)>(&ControlTree::setItemHidden, {}, {}, false));
					case 28: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)(uint32_t) const>(&ControlTree::isItemHidden));
					case 29: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)(uint32_t, bool)>(&ControlTree::switchItemExpanded, {}, false));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, bool, bool)>(&ControlTree::setItemExpanded, {}, {}, false));
					case 31: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)(uint32_t) const>(&ControlTree::isItemExpanded));
					case 32: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)(uint32_t, bool)>(&ControlTree::switchItemSelected, {}, false));
					case 33: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, bool, bool)>(&ControlTree::setItemSelected, {}, {}, false));
					case 34: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)(uint32_t) const>(&ControlTree::isItemSelected));
					case 35: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, uint32_t)>(&ControlTree::setItemParent));
					case 36: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(uint32_t) const>(&ControlTree::getItemParent));
					case 37: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)(uint32_t, uint32_t, bool) const>(&ControlTree::isItemParent, {}, {}, false));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, uint32_t)>(&ControlTree::addItemChild));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, uint32_t)>(&ControlTree::removeItemChild));
					case 40: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, const Array<uint32_t>&)>(&ControlTree::addItemChildren));
					case 41: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, const Array<uint32_t>&)>(&ControlTree::removeItemChildren));
					case 42: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(uint32_t, uint32_t) const>(&ControlTree::findItemChild));
					case 43: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)(uint32_t, uint32_t) const>(&ControlTree::isItemChild));
					case 44: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(uint32_t) const>(&ControlTree::getNumItemChildren));
					case 45: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(uint32_t, uint32_t) const>(&ControlTree::getItemChild));
					case 46: return FunctionPtr(new FunctionImpl<Array<uint32_t>(ControlTree::*)(uint32_t) const>(&ControlTree::getItemChildren));
					case 47: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, const char*)>(&ControlTree::setItemText));
					case 48: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, const String&)>(&ControlTree::setItemText));
					case 49: return FunctionPtr(new FunctionImpl<String(ControlTree::*)(uint32_t) const>(&ControlTree::getItemText));
					case 50: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(const char*) const>(&ControlTree::findItemText));
					case 51: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(const String&) const>(&ControlTree::findItemText));
					case 52: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, const Color&)>(&ControlTree::setItemColor));
					case 53: return FunctionPtr(new FunctionImpl<const Color&(ControlTree::*)(uint32_t) const>(&ControlTree::getItemColor));
					case 54: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, uint32_t, uint32_t)>(&ControlTree::setItemTexture, {}, {}, 0));
					case 55: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(uint32_t) const>(&ControlTree::getItemTextureRow));
					case 56: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(uint32_t) const>(&ControlTree::getItemTextureColumn));
					case 57: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, void*)>(&ControlTree::setItemUserData));
					case 58: return FunctionPtr(new FunctionVoidImpl<void*(ControlTree::*)(uint32_t) const>(&ControlTree::getItemUserData));
					case 59: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(uint32_t, bool, bool, bool)>(&ControlTree::setCurrentItem, {}, false, false, false));
					case 60: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)() const>(&ControlTree::getCurrentItem));
					case 61: return FunctionPtr(new FunctionImpl<String(ControlTree::*)() const>(&ControlTree::getCurrentText));
					case 62: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)()>(&ControlTree::setSelection));
					case 63: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)()>(&ControlTree::clearSelection));
					case 64: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)()>(&ControlTree::inverseSelection));
					case 65: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)() const>(&ControlTree::getNumSelectedItems));
					case 66: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)(uint32_t) const>(&ControlTree::getSelectedItem));
					case 67: return FunctionPtr(new FunctionImpl<Array<uint32_t>(ControlTree::*)() const>(&ControlTree::getSelectedItems));
					case 68: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const ControlTree::ChangedCallback&)>(&ControlTree::setChangedCallback));
					case 69: return FunctionPtr(new FunctionImpl<ControlTree::ChangedCallback(ControlTree::*)() const>(&ControlTree::getChangedCallback));
					case 70: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const ControlTree::DraggedCallback&)>(&ControlTree::setDraggedCallback));
					case 71: return FunctionPtr(new FunctionImpl<ControlTree::DraggedCallback(ControlTree::*)() const>(&ControlTree::getDraggedCallback));
					case 72: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const ControlTree::DroppedCallback&)>(&ControlTree::setDroppedCallback));
					case 73: return FunctionPtr(new FunctionImpl<ControlTree::DroppedCallback(ControlTree::*)() const>(&ControlTree::getDroppedCallback));
					case 74: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const ControlTree::ClickedCallback&)>(&ControlTree::setClickedCallback));
					case 75: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const ControlTree::ClickedCallback&)>(&ControlTree::setClicked2Callback));
					case 76: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const ControlTree::ClickedCallback&)>(&ControlTree::setClickedRightCallback));
					case 77: return FunctionPtr(new FunctionImpl<ControlTree::ClickedCallback(ControlTree::*)() const>(&ControlTree::getClickedCallback));
					case 78: return FunctionPtr(new FunctionImpl<ControlTree::ClickedCallback(ControlTree::*)() const>(&ControlTree::getClicked2Callback));
					case 79: return FunctionPtr(new FunctionImpl<ControlTree::ClickedCallback(ControlTree::*)() const>(&ControlTree::getClickedRightCallback));
					case 80: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const ControlTree::ExpandedCallback&)>(&ControlTree::setExpandedCallback));
					case 81: return FunctionPtr(new FunctionImpl<ControlTree::ExpandedCallback(ControlTree::*)() const>(&ControlTree::getExpandedCallback));
					case 82: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)(const ControlTree::SelectedCallback&)>(&ControlTree::setSelectedCallback));
					case 83: return FunctionPtr(new FunctionImpl<ControlTree::SelectedCallback(ControlTree::*)() const>(&ControlTree::getSelectedCallback));
					case 84: return FunctionPtr(new FunctionImpl<ControlTree(ControlTree::*)() const>(&ControlTree::clonePtr));
					case 85: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)()>(&ControlTree::clearPtr));
					case 86: return FunctionPtr(new FunctionVoidImpl<void(ControlTree::*)()>(&ControlTree::destroyPtr));
					case 87: return FunctionPtr(new FunctionImpl<ControlTree&(ControlTree::*)()>(&ControlTree::acquirePtr));
					case 88: return FunctionPtr(new FunctionImpl<ControlTree&(ControlTree::*)()>(&ControlTree::unacquirePtr));
					case 89: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)() const>(&ControlTree::isValidPtr));
					case 90: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)() const>(&ControlTree::isOwnerPtr));
					case 91: return FunctionPtr(new FunctionImpl<bool(ControlTree::*)() const>(&ControlTree::isConstPtr));
					case 92: return FunctionPtr(new FunctionImpl<uint32_t(ControlTree::*)() const>(&ControlTree::getCountPtr));
					case 93: return FunctionPtr(new FunctionImpl<const void*(ControlTree::*)() const>(&ControlTree::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1 };
			static constexpr uint16_t constructor_arg_types[] = { 2315 };
			static constexpr uint16_t constructor_arg_names[] = { 458 };
			static constexpr uint16_t function_names[] = { 2661, 2663, 2527, 2529, 2483, 2483, 2484, 2485, 2485, 2486, 993, 1429, 2181, 2181, 2182, 2665, 2666, 2667, 2536, 2537, 2537, 2538, 2539, 2669, 2540, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2541, 2542, 2544, 2677, 2678, 2679, 2681, 2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2545, 2545, 2546, 2547, 2547, 2548, 2549, 2690, 2693, 2694, 2695, 2696, 2697, 2699, 2553, 2700, 2701, 2702, 2703, 2704, 2705, 2555, 2557, 2707, 2709, 2711, 2713, 2448, 2450, 2451, 2452, 2454, 2455, 2716, 2718, 2720, 2722, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 21, 6, 6, 16, 6, 6, 16, 6, 1377, 6, 6, 16, 6, 10, 10, 6, 10, 10, 6, 6, 6, 10, 10, 21, 6, 21, 21, 6, 21, 21, 6, 21, 6, 10, 21, 6, 6, 6, 6, 10, 21, 10, 10, 19, 6, 6, 16, 10, 10, 6, 654, 6, 10, 10, 6, 6, 6, 10, 16, 6, 6, 6, 10, 10, 19, 6, 2558, 6, 2710, 6, 2714, 6, 6, 6, 2453, 2453, 2453, 6, 2719, 6, 2723, 2660, 2660, 2660, 2660, 2660, 2660, 2660, 2660, 2660, 2660 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 4, 4, 5, 6, 6, 9, 9, 12, 15, 15, 17, 17, 17, 17, 20, 23, 25, 27, 28, 28, 29, 31, 34, 35, 37, 40, 41, 43, 46, 47, 49, 50, 53, 55, 57, 59, 61, 63, 65, 66, 68, 69, 71, 73, 74, 75, 76, 78, 79, 82, 83, 84, 86, 87, 91, 91, 91, 91, 91, 91, 91, 92, 92, 93, 93, 94, 94, 95, 95, 96, 97, 98, 98, 98, 98, 99, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100 };
			static constexpr uint16_t function_arg_types[] = { 21, 21, 22, 94, 22, 94, 994, 10, 10, 22, 10, 10, 94, 10, 10, 10, 10, 22, 10, 21, 94, 10, 21, 2525, 10, 10, 21, 10, 10, 10, 21, 10, 21, 21, 10, 10, 21, 10, 21, 21, 10, 10, 21, 10, 21, 21, 10, 10, 10, 10, 10, 10, 21, 10, 10, 10, 10, 10, 586, 10, 586, 10, 10, 10, 10, 10, 10, 10, 10, 10, 22, 10, 94, 10, 22, 94, 10, 637, 10, 10, 10, 10, 10, 10, 10, 85, 10, 10, 21, 21, 21, 10, 2706, 2708, 2712, 2715, 2715, 2715, 2717, 2721 };
			static constexpr uint16_t function_arg_names[] = { 2662, 2528, 2086, 2086, 2086, 2086, 995, 2664, 2459, 23, 2664, 2459, 23, 2664, 2459, 2664, 2459, 2086, 458, 2478, 2086, 458, 2478, 2526, 458, 2668, 298, 2668, 274, 2668, 298, 2668, 1957, 298, 2668, 2668, 298, 2668, 2478, 298, 2668, 2668, 298, 2668, 2543, 298, 2668, 2668, 458, 2668, 2668, 458, 2680, 2668, 471, 2668, 471, 2668, 298, 2668, 298, 2668, 471, 2668, 471, 2668, 2668, 274, 2668, 2668, 2086, 2668, 2086, 2668, 2086, 2086, 2668, 638, 2668, 2668, 2691, 2692, 2668, 2668, 2668, 167, 2668, 2668, 203, 2698, 225, 274, 1162, 1162, 1162, 1162, 1162, 1162, 1162, 1162 };
	};
	constexpr uint16_t ReflectionControlTree::constructor_bases[];
	constexpr uint16_t ReflectionControlTree::constructor_arg_types[];
	constexpr uint16_t ReflectionControlTree::constructor_arg_names[];
	constexpr uint16_t ReflectionControlTree::function_names[];
	constexpr uint16_t ReflectionControlTree::function_types[];
	constexpr uint16_t ReflectionControlTree::function_bases[];
	constexpr uint16_t ReflectionControlTree::function_arg_types[];
	constexpr uint16_t ReflectionControlTree::function_arg_names[];
	static ReflectionControlTree reflection_control_tree;
	
	// Tellusim::ControlEdit
	class ReflectionControlEdit : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return ControlEdit::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return &reflection_control_text;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<ControlEdit, TypeList<>>());
					case 1: return ConstructorPtr(new ConstructorImpl<ControlEdit, TypeList<Control*>>());
					case 2: return ConstructorPtr(new ConstructorImpl<ControlEdit, TypeList<Control*, const char*>>());
					case 3: return ConstructorPtr(new ConstructorImpl<ControlEdit, TypeList<Control*, const String&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<ControlEdit>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(bool)>(&ControlEdit::setFrame));
					case 1: return FunctionPtr(new FunctionImpl<bool(ControlEdit::*)() const>(&ControlEdit::getFrame));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(bool)>(&ControlEdit::setBackground));
					case 3: return FunctionPtr(new FunctionImpl<bool(ControlEdit::*)() const>(&ControlEdit::getBackground));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(const Color&)>(&ControlEdit::setEditColor));
					case 5: return FunctionPtr(new FunctionImpl<const Color&(ControlEdit::*)() const>(&ControlEdit::getEditColor));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(ControlEdit::EditMode)>(&ControlEdit::setEditMode));
					case 7: return FunctionPtr(new FunctionImpl<ControlEdit::EditMode(ControlEdit::*)() const>(&ControlEdit::getEditMode));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(uint32_t)>(&ControlEdit::setPasswordCode));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(ControlEdit::*)() const>(&ControlEdit::getPasswordCode));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(ControlEdit::*)() const>(&ControlEdit::getNumCodes));
					case 11: return FunctionPtr(new FunctionImpl<const uint32_t*(ControlEdit::*)() const>(&ControlEdit::getCodes));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(uint32_t, uint32_t)>(&ControlEdit::setCurrentIndex, {}, Maxu32));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(ControlEdit::*)() const>(&ControlEdit::getCurrentIndex));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(ControlEdit::*)() const>(&ControlEdit::getSelectionIndex));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(bool)>(&ControlEdit::setSelection, false));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)()>(&ControlEdit::clearSelection));
					case 17: return FunctionPtr(new FunctionImpl<String(ControlEdit::*)() const>(&ControlEdit::getSelectedText));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(const ControlEdit::ClickedCallback&)>(&ControlEdit::setClickedCallback));
					case 19: return FunctionPtr(new FunctionImpl<ControlEdit::ClickedCallback(ControlEdit::*)() const>(&ControlEdit::getClickedCallback));
					case 20: return FunctionPtr(new FunctionImpl<bool(ControlEdit::*)()>(&ControlEdit::isClicked));
					case 21: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(const ControlEdit::ChangedCallback&)>(&ControlEdit::setChangedCallback));
					case 22: return FunctionPtr(new FunctionImpl<ControlEdit::ChangedCallback(ControlEdit::*)() const>(&ControlEdit::getChangedCallback));
					case 23: return FunctionPtr(new FunctionImpl<bool(ControlEdit::*)()>(&ControlEdit::isChanged));
					case 24: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)(const ControlEdit::ReturnedCallback&)>(&ControlEdit::setReturnedCallback));
					case 25: return FunctionPtr(new FunctionImpl<ControlEdit::ReturnedCallback(ControlEdit::*)() const>(&ControlEdit::getReturnedCallback));
					case 26: return FunctionPtr(new FunctionImpl<bool(ControlEdit::*)()>(&ControlEdit::isReturned));
					case 27: return FunctionPtr(new FunctionImpl<CanvasMesh(ControlEdit::*)()>(&ControlEdit::getCanvasMesh));
					case 28: return FunctionPtr(new FunctionImpl<ControlEdit(ControlEdit::*)() const>(&ControlEdit::clonePtr));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)()>(&ControlEdit::clearPtr));
					case 30: return FunctionPtr(new FunctionVoidImpl<void(ControlEdit::*)()>(&ControlEdit::destroyPtr));
					case 31: return FunctionPtr(new FunctionImpl<ControlEdit&(ControlEdit::*)()>(&ControlEdit::acquirePtr));
					case 32: return FunctionPtr(new FunctionImpl<ControlEdit&(ControlEdit::*)()>(&ControlEdit::unacquirePtr));
					case 33: return FunctionPtr(new FunctionImpl<bool(ControlEdit::*)() const>(&ControlEdit::isValidPtr));
					case 34: return FunctionPtr(new FunctionImpl<bool(ControlEdit::*)() const>(&ControlEdit::isOwnerPtr));
					case 35: return FunctionPtr(new FunctionImpl<bool(ControlEdit::*)() const>(&ControlEdit::isConstPtr));
					case 36: return FunctionPtr(new FunctionImpl<uint32_t(ControlEdit::*)() const>(&ControlEdit::getCountPtr));
					case 37: return FunctionPtr(new FunctionImpl<const void*(ControlEdit::*)() const>(&ControlEdit::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0, 1, 3, 5 };
			static constexpr uint16_t constructor_arg_types[] = { 2315, 2315, 22, 2315, 94 };
			static constexpr uint16_t constructor_arg_names[] = { 458, 458, 2086, 458, 2086 };
			static constexpr uint16_t function_names[] = { 2612, 2613, 2480, 2482, 2725, 2726, 2727, 2729, 2731, 2732, 2733, 2734, 2550, 2552, 2736, 2700, 2701, 2738, 2448, 2452, 2488, 2555, 2557, 2559, 2741, 2743, 2745, 2457, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 21, 6, 654, 6, 2730, 6, 10, 10, 10, 6, 10, 10, 6, 6, 16, 6, 2453, 21, 6, 2558, 21, 6, 2744, 21, 2180, 2724, 2724, 2724, 2724, 2724, 2724, 2724, 2724, 2724, 2724 };
			static constexpr uint16_t function_bases[] = { 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 5, 5, 7, 7, 7, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11 };
			static constexpr uint16_t function_arg_types[] = { 21, 21, 637, 2728, 10, 10, 10, 21, 2739, 2740, 2742 };
			static constexpr uint16_t function_arg_names[] = { 2602, 2481, 638, 185, 2092, 274, 2735, 2737, 1162, 1162, 1162 };
	};
	constexpr uint16_t ReflectionControlEdit::constructor_bases[];
	constexpr uint16_t ReflectionControlEdit::constructor_arg_types[];
	constexpr uint16_t ReflectionControlEdit::constructor_arg_names[];
	constexpr uint16_t ReflectionControlEdit::function_names[];
	constexpr uint16_t ReflectionControlEdit::function_types[];
	constexpr uint16_t ReflectionControlEdit::function_bases[];
	constexpr uint16_t ReflectionControlEdit::function_arg_types[];
	constexpr uint16_t ReflectionControlEdit::function_arg_names[];
	static ReflectionControlEdit reflection_control_edit;
	
	// Tellusim::DialogMessage
	class ReflectionDialogMessage : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return DialogMessage::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<DialogMessage, TypeList<const char*, const char*>>(nullptr, nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<DialogMessage, TypeList<const String&, const char*>>({}, nullptr));
					case 2: return ConstructorPtr(new ConstructorImpl<DialogMessage, TypeList<const char*, const String&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<DialogMessage, TypeList<const String&, const String&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<DialogMessage>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(DialogMessage::*)(int32_t, int32_t)>(&DialogMessage::setPosition));
					case 1: return FunctionPtr(new FunctionImpl<int32_t(DialogMessage::*)() const>(&DialogMessage::getPositionX));
					case 2: return FunctionPtr(new FunctionImpl<int32_t(DialogMessage::*)() const>(&DialogMessage::getPositionY));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(DialogMessage::*)(const char*)>(&DialogMessage::setTitle));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(DialogMessage::*)(const String&)>(&DialogMessage::setTitle));
					case 5: return FunctionPtr(new FunctionImpl<String(DialogMessage::*)() const>(&DialogMessage::getTitle));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(DialogMessage::*)(const char*)>(&DialogMessage::setMessage));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(DialogMessage::*)(const String&)>(&DialogMessage::setMessage));
					case 8: return FunctionPtr(new FunctionImpl<String(DialogMessage::*)() const>(&DialogMessage::getMessage));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(DialogMessage::*)(const DialogMessage::UpdateCallback&)>(&DialogMessage::setUpdateCallback));
					case 10: return FunctionPtr(new FunctionImpl<DialogMessage::UpdateCallback(DialogMessage::*)() const>(&DialogMessage::getUpdateCallback));
					case 11: return FunctionPtr(new FunctionImpl<DialogMessage::Result(DialogMessage::*)(DialogMessage::Flags)>(&DialogMessage::run, DialogMessage::DefaultFlags));
					case 12: return FunctionPtr(new FunctionImpl<DialogMessage(DialogMessage::*)() const>(&DialogMessage::clonePtr));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(DialogMessage::*)()>(&DialogMessage::clearPtr));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(DialogMessage::*)()>(&DialogMessage::destroyPtr));
					case 15: return FunctionPtr(new FunctionImpl<DialogMessage&(DialogMessage::*)()>(&DialogMessage::acquirePtr));
					case 16: return FunctionPtr(new FunctionImpl<DialogMessage&(DialogMessage::*)()>(&DialogMessage::unacquirePtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(DialogMessage::*)() const>(&DialogMessage::isValidPtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(DialogMessage::*)() const>(&DialogMessage::isOwnerPtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(DialogMessage::*)() const>(&DialogMessage::isConstPtr));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(DialogMessage::*)() const>(&DialogMessage::getCountPtr));
					case 21: return FunctionPtr(new FunctionImpl<const void*(DialogMessage::*)() const>(&DialogMessage::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 2, 4, 6, 8 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 22, 94, 22, 22, 94, 94, 94 };
			static constexpr uint16_t constructor_arg_names[] = { 1949, 2747, 1949, 2747, 1949, 2747, 1949, 2747 };
			static constexpr uint16_t function_names[] = { 1975, 1976, 1977, 1969, 1969, 1970, 2748, 2748, 2749, 2072, 2074, 51, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 1, 1, 6, 6, 16, 6, 6, 16, 6, 2075, 2751, 2746, 2746, 2746, 2746, 2746, 2746, 2746, 2746, 2746, 2746 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 };
			static constexpr uint16_t function_arg_types[] = { 1, 1, 22, 94, 22, 94, 2750, 2752 };
			static constexpr uint16_t function_arg_names[] = { 1973, 1974, 1949, 1949, 2747, 2747, 1162, 338 };
	};
	constexpr uint16_t ReflectionDialogMessage::constructor_bases[];
	constexpr uint16_t ReflectionDialogMessage::constructor_arg_types[];
	constexpr uint16_t ReflectionDialogMessage::constructor_arg_names[];
	constexpr uint16_t ReflectionDialogMessage::function_names[];
	constexpr uint16_t ReflectionDialogMessage::function_types[];
	constexpr uint16_t ReflectionDialogMessage::function_bases[];
	constexpr uint16_t ReflectionDialogMessage::function_arg_types[];
	constexpr uint16_t ReflectionDialogMessage::function_arg_names[];
	static ReflectionDialogMessage reflection_dialog_message;
	
	// Tellusim::DialogFileOpen
	class ReflectionDialogFileOpen : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return DialogFileOpen::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<DialogFileOpen, TypeList<const char*, const char*>>(nullptr, nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<DialogFileOpen, TypeList<const String&, const char*>>({}, nullptr));
					case 2: return ConstructorPtr(new ConstructorImpl<DialogFileOpen, TypeList<const char*, const String&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<DialogFileOpen, TypeList<const String&, const String&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<DialogFileOpen>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)(int32_t, int32_t)>(&DialogFileOpen::setPosition));
					case 1: return FunctionPtr(new FunctionImpl<int32_t(DialogFileOpen::*)() const>(&DialogFileOpen::getPositionX));
					case 2: return FunctionPtr(new FunctionImpl<int32_t(DialogFileOpen::*)() const>(&DialogFileOpen::getPositionY));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)(const char*)>(&DialogFileOpen::setTitle));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)(const String&)>(&DialogFileOpen::setTitle));
					case 5: return FunctionPtr(new FunctionImpl<String(DialogFileOpen::*)() const>(&DialogFileOpen::getTitle));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)(const char*)>(&DialogFileOpen::setFilter));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)(const String&)>(&DialogFileOpen::setFilter));
					case 8: return FunctionPtr(new FunctionImpl<String(DialogFileOpen::*)() const>(&DialogFileOpen::getFilter));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)(const char*)>(&DialogFileOpen::setFile));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)(const String&)>(&DialogFileOpen::setFile));
					case 11: return FunctionPtr(new FunctionImpl<String(DialogFileOpen::*)() const>(&DialogFileOpen::getFile));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)(const DialogFileOpen::UpdateCallback&)>(&DialogFileOpen::setUpdateCallback));
					case 13: return FunctionPtr(new FunctionImpl<DialogFileOpen::UpdateCallback(DialogFileOpen::*)() const>(&DialogFileOpen::getUpdateCallback));
					case 14: return FunctionPtr(new FunctionImpl<DialogFileOpen::Result(DialogFileOpen::*)(DialogFileOpen::Flags)>(&DialogFileOpen::run, DialogFileOpen::DefaultFlags));
					case 15: return FunctionPtr(new FunctionImpl<DialogFileOpen(DialogFileOpen::*)() const>(&DialogFileOpen::clonePtr));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)()>(&DialogFileOpen::clearPtr));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(DialogFileOpen::*)()>(&DialogFileOpen::destroyPtr));
					case 18: return FunctionPtr(new FunctionImpl<DialogFileOpen&(DialogFileOpen::*)()>(&DialogFileOpen::acquirePtr));
					case 19: return FunctionPtr(new FunctionImpl<DialogFileOpen&(DialogFileOpen::*)()>(&DialogFileOpen::unacquirePtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(DialogFileOpen::*)() const>(&DialogFileOpen::isValidPtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(DialogFileOpen::*)() const>(&DialogFileOpen::isOwnerPtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(DialogFileOpen::*)() const>(&DialogFileOpen::isConstPtr));
					case 23: return FunctionPtr(new FunctionImpl<uint32_t(DialogFileOpen::*)() const>(&DialogFileOpen::getCountPtr));
					case 24: return FunctionPtr(new FunctionImpl<const void*(DialogFileOpen::*)() const>(&DialogFileOpen::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 2, 4, 6, 8 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 22, 94, 22, 22, 94, 94, 94 };
			static constexpr uint16_t constructor_arg_names[] = { 1949, 23, 1949, 23, 1949, 23, 1949, 23 };
			static constexpr uint16_t function_names[] = { 1975, 1976, 1977, 1969, 1969, 1970, 1334, 1334, 1336, 2754, 2754, 2755, 2072, 2074, 51, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 1, 1, 6, 6, 16, 6, 6, 16, 6, 6, 16, 6, 2075, 2751, 2753, 2753, 2753, 2753, 2753, 2753, 2753, 2753, 2753, 2753 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_types[] = { 1, 1, 22, 94, 22, 94, 22, 94, 2756, 2757 };
			static constexpr uint16_t function_arg_names[] = { 1973, 1974, 1949, 1949, 448, 448, 23, 23, 1162, 338 };
	};
	constexpr uint16_t ReflectionDialogFileOpen::constructor_bases[];
	constexpr uint16_t ReflectionDialogFileOpen::constructor_arg_types[];
	constexpr uint16_t ReflectionDialogFileOpen::constructor_arg_names[];
	constexpr uint16_t ReflectionDialogFileOpen::function_names[];
	constexpr uint16_t ReflectionDialogFileOpen::function_types[];
	constexpr uint16_t ReflectionDialogFileOpen::function_bases[];
	constexpr uint16_t ReflectionDialogFileOpen::function_arg_types[];
	constexpr uint16_t ReflectionDialogFileOpen::function_arg_names[];
	static ReflectionDialogFileOpen reflection_dialog_file_open;
	
	// Tellusim::DialogFileSave
	class ReflectionDialogFileSave : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return DialogFileSave::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<DialogFileSave, TypeList<const char*, const char*>>(nullptr, nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<DialogFileSave, TypeList<const String&, const char*>>({}, nullptr));
					case 2: return ConstructorPtr(new ConstructorImpl<DialogFileSave, TypeList<const char*, const String&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<DialogFileSave, TypeList<const String&, const String&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<DialogFileSave>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)(int32_t, int32_t)>(&DialogFileSave::setPosition));
					case 1: return FunctionPtr(new FunctionImpl<int32_t(DialogFileSave::*)() const>(&DialogFileSave::getPositionX));
					case 2: return FunctionPtr(new FunctionImpl<int32_t(DialogFileSave::*)() const>(&DialogFileSave::getPositionY));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)(const char*)>(&DialogFileSave::setTitle));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)(const String&)>(&DialogFileSave::setTitle));
					case 5: return FunctionPtr(new FunctionImpl<String(DialogFileSave::*)() const>(&DialogFileSave::getTitle));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)(const char*)>(&DialogFileSave::setFilter));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)(const String&)>(&DialogFileSave::setFilter));
					case 8: return FunctionPtr(new FunctionImpl<String(DialogFileSave::*)() const>(&DialogFileSave::getFilter));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)(const char*)>(&DialogFileSave::setFile));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)(const String&)>(&DialogFileSave::setFile));
					case 11: return FunctionPtr(new FunctionImpl<String(DialogFileSave::*)() const>(&DialogFileSave::getFile));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)(const DialogFileSave::UpdateCallback&)>(&DialogFileSave::setUpdateCallback));
					case 13: return FunctionPtr(new FunctionImpl<DialogFileSave::UpdateCallback(DialogFileSave::*)() const>(&DialogFileSave::getUpdateCallback));
					case 14: return FunctionPtr(new FunctionImpl<DialogFileSave::Result(DialogFileSave::*)(DialogFileSave::Flags)>(&DialogFileSave::run, DialogFileSave::DefaultFlags));
					case 15: return FunctionPtr(new FunctionImpl<DialogFileSave(DialogFileSave::*)() const>(&DialogFileSave::clonePtr));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)()>(&DialogFileSave::clearPtr));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(DialogFileSave::*)()>(&DialogFileSave::destroyPtr));
					case 18: return FunctionPtr(new FunctionImpl<DialogFileSave&(DialogFileSave::*)()>(&DialogFileSave::acquirePtr));
					case 19: return FunctionPtr(new FunctionImpl<DialogFileSave&(DialogFileSave::*)()>(&DialogFileSave::unacquirePtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(DialogFileSave::*)() const>(&DialogFileSave::isValidPtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(DialogFileSave::*)() const>(&DialogFileSave::isOwnerPtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(DialogFileSave::*)() const>(&DialogFileSave::isConstPtr));
					case 23: return FunctionPtr(new FunctionImpl<uint32_t(DialogFileSave::*)() const>(&DialogFileSave::getCountPtr));
					case 24: return FunctionPtr(new FunctionImpl<const void*(DialogFileSave::*)() const>(&DialogFileSave::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 2, 4, 6, 8 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 22, 94, 22, 22, 94, 94, 94 };
			static constexpr uint16_t constructor_arg_names[] = { 1949, 23, 1949, 23, 1949, 23, 1949, 23 };
			static constexpr uint16_t function_names[] = { 1975, 1976, 1977, 1969, 1969, 1970, 1334, 1334, 1336, 2754, 2754, 2755, 2072, 2074, 51, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 1, 1, 6, 6, 16, 6, 6, 16, 6, 6, 16, 6, 2075, 2751, 2758, 2758, 2758, 2758, 2758, 2758, 2758, 2758, 2758, 2758 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 3, 4, 4, 5, 6, 6, 7, 8, 8, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_types[] = { 1, 1, 22, 94, 22, 94, 22, 94, 2759, 2760 };
			static constexpr uint16_t function_arg_names[] = { 1973, 1974, 1949, 1949, 448, 448, 23, 23, 1162, 338 };
	};
	constexpr uint16_t ReflectionDialogFileSave::constructor_bases[];
	constexpr uint16_t ReflectionDialogFileSave::constructor_arg_types[];
	constexpr uint16_t ReflectionDialogFileSave::constructor_arg_names[];
	constexpr uint16_t ReflectionDialogFileSave::function_names[];
	constexpr uint16_t ReflectionDialogFileSave::function_types[];
	constexpr uint16_t ReflectionDialogFileSave::function_bases[];
	constexpr uint16_t ReflectionDialogFileSave::function_arg_types[];
	constexpr uint16_t ReflectionDialogFileSave::function_arg_names[];
	static ReflectionDialogFileSave reflection_dialog_file_save;
	
	// Tellusim::DialogDirectory
	class ReflectionDialogDirectory : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return DialogDirectory::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<DialogDirectory, TypeList<const char*, const char*>>(nullptr, nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<DialogDirectory, TypeList<const String&, const char*>>({}, nullptr));
					case 2: return ConstructorPtr(new ConstructorImpl<DialogDirectory, TypeList<const char*, const String&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<DialogDirectory, TypeList<const String&, const String&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<DialogDirectory>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(DialogDirectory::*)(int32_t, int32_t)>(&DialogDirectory::setPosition));
					case 1: return FunctionPtr(new FunctionImpl<int32_t(DialogDirectory::*)() const>(&DialogDirectory::getPositionX));
					case 2: return FunctionPtr(new FunctionImpl<int32_t(DialogDirectory::*)() const>(&DialogDirectory::getPositionY));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(DialogDirectory::*)(const char*)>(&DialogDirectory::setTitle));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(DialogDirectory::*)(const String&)>(&DialogDirectory::setTitle));
					case 5: return FunctionPtr(new FunctionImpl<String(DialogDirectory::*)() const>(&DialogDirectory::getTitle));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(DialogDirectory::*)(const char*)>(&DialogDirectory::setDirectory));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(DialogDirectory::*)(const String&)>(&DialogDirectory::setDirectory));
					case 8: return FunctionPtr(new FunctionImpl<String(DialogDirectory::*)() const>(&DialogDirectory::getDirectory));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(DialogDirectory::*)(const DialogDirectory::UpdateCallback&)>(&DialogDirectory::setUpdateCallback));
					case 10: return FunctionPtr(new FunctionImpl<DialogDirectory::UpdateCallback(DialogDirectory::*)() const>(&DialogDirectory::getUpdateCallback));
					case 11: return FunctionPtr(new FunctionImpl<DialogDirectory::Result(DialogDirectory::*)(DialogDirectory::Flags)>(&DialogDirectory::run, DialogDirectory::DefaultFlags));
					case 12: return FunctionPtr(new FunctionImpl<DialogDirectory(DialogDirectory::*)() const>(&DialogDirectory::clonePtr));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(DialogDirectory::*)()>(&DialogDirectory::clearPtr));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(DialogDirectory::*)()>(&DialogDirectory::destroyPtr));
					case 15: return FunctionPtr(new FunctionImpl<DialogDirectory&(DialogDirectory::*)()>(&DialogDirectory::acquirePtr));
					case 16: return FunctionPtr(new FunctionImpl<DialogDirectory&(DialogDirectory::*)()>(&DialogDirectory::unacquirePtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(DialogDirectory::*)() const>(&DialogDirectory::isValidPtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(DialogDirectory::*)() const>(&DialogDirectory::isOwnerPtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(DialogDirectory::*)() const>(&DialogDirectory::isConstPtr));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(DialogDirectory::*)() const>(&DialogDirectory::getCountPtr));
					case 21: return FunctionPtr(new FunctionImpl<const void*(DialogDirectory::*)() const>(&DialogDirectory::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 2, 4, 6, 8 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 22, 94, 22, 22, 94, 94, 94 };
			static constexpr uint16_t constructor_arg_names[] = { 1949, 23, 1949, 23, 1949, 23, 1949, 23 };
			static constexpr uint16_t function_names[] = { 1975, 1976, 1977, 1969, 1969, 1970, 2762, 2762, 2763, 2072, 2074, 51, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 1, 1, 6, 6, 16, 6, 6, 16, 6, 2075, 2751, 2761, 2761, 2761, 2761, 2761, 2761, 2761, 2761, 2761, 2761 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 };
			static constexpr uint16_t function_arg_types[] = { 1, 1, 22, 94, 22, 94, 2764, 2765 };
			static constexpr uint16_t function_arg_names[] = { 1973, 1974, 1949, 1949, 23, 23, 1162, 338 };
	};
	constexpr uint16_t ReflectionDialogDirectory::constructor_bases[];
	constexpr uint16_t ReflectionDialogDirectory::constructor_arg_types[];
	constexpr uint16_t ReflectionDialogDirectory::constructor_arg_names[];
	constexpr uint16_t ReflectionDialogDirectory::function_names[];
	constexpr uint16_t ReflectionDialogDirectory::function_types[];
	constexpr uint16_t ReflectionDialogDirectory::function_bases[];
	constexpr uint16_t ReflectionDialogDirectory::function_arg_types[];
	constexpr uint16_t ReflectionDialogDirectory::function_arg_names[];
	static ReflectionDialogDirectory reflection_dialog_directory;
	
	// Tellusim::DialogProgress
	class ReflectionDialogProgress : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return DialogProgress::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<DialogProgress, TypeList<const char*, const char*>>(nullptr, nullptr));
					case 1: return ConstructorPtr(new ConstructorImpl<DialogProgress, TypeList<const String&, const char*>>({}, nullptr));
					case 2: return ConstructorPtr(new ConstructorImpl<DialogProgress, TypeList<const char*, const String&>>());
					case 3: return ConstructorPtr(new ConstructorImpl<DialogProgress, TypeList<const String&, const String&>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<DialogProgress>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(DialogProgress::*)(int32_t, int32_t)>(&DialogProgress::setPosition));
					case 1: return FunctionPtr(new FunctionImpl<int32_t(DialogProgress::*)() const>(&DialogProgress::getPositionX));
					case 2: return FunctionPtr(new FunctionImpl<int32_t(DialogProgress::*)() const>(&DialogProgress::getPositionY));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(DialogProgress::*)(const char*)>(&DialogProgress::setTitle));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(DialogProgress::*)(const String&)>(&DialogProgress::setTitle));
					case 5: return FunctionPtr(new FunctionImpl<String(DialogProgress::*)() const>(&DialogProgress::getTitle));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(DialogProgress::*)(const char*)>(&DialogProgress::setMessage));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(DialogProgress::*)(const String&)>(&DialogProgress::setMessage));
					case 8: return FunctionPtr(new FunctionImpl<String(DialogProgress::*)() const>(&DialogProgress::getMessage));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(DialogProgress::*)(uint32_t)>(&DialogProgress::setProgress));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(DialogProgress::*)() const>(&DialogProgress::getProgress));
					case 11: return FunctionPtr(new FunctionImpl<DialogProgress::Result(DialogProgress::*)(DialogProgress::Flags)>(&DialogProgress::run, DialogProgress::DefaultFlags));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(DialogProgress::*)()>(&DialogProgress::close));
					case 13: return FunctionPtr(new FunctionImpl<DialogProgress(DialogProgress::*)() const>(&DialogProgress::clonePtr));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(DialogProgress::*)()>(&DialogProgress::clearPtr));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(DialogProgress::*)()>(&DialogProgress::destroyPtr));
					case 16: return FunctionPtr(new FunctionImpl<DialogProgress&(DialogProgress::*)()>(&DialogProgress::acquirePtr));
					case 17: return FunctionPtr(new FunctionImpl<DialogProgress&(DialogProgress::*)()>(&DialogProgress::unacquirePtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(DialogProgress::*)() const>(&DialogProgress::isValidPtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(DialogProgress::*)() const>(&DialogProgress::isOwnerPtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(DialogProgress::*)() const>(&DialogProgress::isConstPtr));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(DialogProgress::*)() const>(&DialogProgress::getCountPtr));
					case 22: return FunctionPtr(new FunctionImpl<const void*(DialogProgress::*)() const>(&DialogProgress::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 2, 4, 6, 8 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 22, 94, 22, 22, 94, 94, 94 };
			static constexpr uint16_t constructor_arg_names[] = { 1949, 2747, 1949, 2747, 1949, 2747, 1949, 2747 };
			static constexpr uint16_t function_names[] = { 1975, 1976, 1977, 1969, 1969, 1970, 2748, 2748, 2749, 2767, 2769, 51, 189, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 1, 1, 6, 6, 16, 6, 6, 16, 6, 10, 2751, 6, 2766, 2766, 2766, 2766, 2766, 2766, 2766, 2766, 2766, 2766 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 3, 4, 4, 5, 6, 6, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8 };
			static constexpr uint16_t function_arg_types[] = { 1, 1, 22, 94, 22, 94, 10, 2770 };
			static constexpr uint16_t function_arg_names[] = { 1973, 1974, 1949, 1949, 2747, 2747, 2768, 338 };
	};
	constexpr uint16_t ReflectionDialogProgress::constructor_bases[];
	constexpr uint16_t ReflectionDialogProgress::constructor_arg_types[];
	constexpr uint16_t ReflectionDialogProgress::constructor_arg_names[];
	constexpr uint16_t ReflectionDialogProgress::function_names[];
	constexpr uint16_t ReflectionDialogProgress::function_types[];
	constexpr uint16_t ReflectionDialogProgress::function_bases[];
	constexpr uint16_t ReflectionDialogProgress::function_arg_types[];
	constexpr uint16_t ReflectionDialogProgress::function_arg_names[];
	static ReflectionDialogProgress reflection_dialog_progress;
	
	// Tellusim::DialogColor
	class ReflectionDialogColor : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return DialogColor::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<DialogColor, TypeList<const char*, const Color&>>(nullptr, Color::zero));
					case 1: return ConstructorPtr(new ConstructorImpl<DialogColor, TypeList<const String&, const Color&>>({}, Color::zero));
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<DialogColor>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(DialogColor::*)(int32_t, int32_t)>(&DialogColor::setPosition));
					case 1: return FunctionPtr(new FunctionImpl<int32_t(DialogColor::*)() const>(&DialogColor::getPositionX));
					case 2: return FunctionPtr(new FunctionImpl<int32_t(DialogColor::*)() const>(&DialogColor::getPositionY));
					case 3: return FunctionPtr(new FunctionVoidImpl<void(DialogColor::*)(const char*)>(&DialogColor::setTitle));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(DialogColor::*)(const String&)>(&DialogColor::setTitle));
					case 5: return FunctionPtr(new FunctionImpl<String(DialogColor::*)() const>(&DialogColor::getTitle));
					case 6: return FunctionPtr(new FunctionVoidImpl<void(DialogColor::*)(const Color&, bool)>(&DialogColor::setColor, {}, false));
					case 7: return FunctionPtr(new FunctionImpl<const Color&(DialogColor::*)() const>(&DialogColor::getColor));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(DialogColor::*)(const DialogColor::ChangedCallback&)>(&DialogColor::setChangedCallback));
					case 9: return FunctionPtr(new FunctionImpl<DialogColor::ChangedCallback(DialogColor::*)() const>(&DialogColor::getChangedCallback));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(DialogColor::*)(const DialogColor::UpdateCallback&)>(&DialogColor::setUpdateCallback));
					case 11: return FunctionPtr(new FunctionImpl<DialogColor::UpdateCallback(DialogColor::*)() const>(&DialogColor::getUpdateCallback));
					case 12: return FunctionPtr(new FunctionImpl<DialogColor::Result(DialogColor::*)(DialogColor::Flags)>(&DialogColor::run, DialogColor::DefaultFlags));
					case 13: return FunctionPtr(new FunctionImpl<DialogColor(DialogColor::*)() const>(&DialogColor::clonePtr));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(DialogColor::*)()>(&DialogColor::clearPtr));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(DialogColor::*)()>(&DialogColor::destroyPtr));
					case 16: return FunctionPtr(new FunctionImpl<DialogColor&(DialogColor::*)()>(&DialogColor::acquirePtr));
					case 17: return FunctionPtr(new FunctionImpl<DialogColor&(DialogColor::*)()>(&DialogColor::unacquirePtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(DialogColor::*)() const>(&DialogColor::isValidPtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(DialogColor::*)() const>(&DialogColor::isOwnerPtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(DialogColor::*)() const>(&DialogColor::isConstPtr));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(DialogColor::*)() const>(&DialogColor::getCountPtr));
					case 22: return FunctionPtr(new FunctionImpl<const void*(DialogColor::*)() const>(&DialogColor::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 2, 4 };
			static constexpr uint16_t constructor_arg_types[] = { 22, 637, 94, 637 };
			static constexpr uint16_t constructor_arg_names[] = { 1949, 638, 1949, 638 };
			static constexpr uint16_t function_names[] = { 1975, 1976, 1977, 1969, 1969, 1970, 2131, 2133, 2555, 2557, 2072, 2074, 51, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 1, 1, 6, 6, 16, 6, 654, 6, 2558, 6, 2075, 2751, 2771, 2771, 2771, 2771, 2771, 2771, 2771, 2771, 2771, 2771 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 3, 4, 4, 6, 6, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9 };
			static constexpr uint16_t function_arg_types[] = { 1, 1, 22, 94, 637, 21, 2772, 2773, 2774 };
			static constexpr uint16_t function_arg_names[] = { 1973, 1974, 1949, 1949, 638, 225, 1162, 1162, 338 };
	};
	constexpr uint16_t ReflectionDialogColor::constructor_bases[];
	constexpr uint16_t ReflectionDialogColor::constructor_arg_types[];
	constexpr uint16_t ReflectionDialogColor::constructor_arg_names[];
	constexpr uint16_t ReflectionDialogColor::function_names[];
	constexpr uint16_t ReflectionDialogColor::function_types[];
	constexpr uint16_t ReflectionDialogColor::function_bases[];
	constexpr uint16_t ReflectionDialogColor::function_arg_types[];
	constexpr uint16_t ReflectionDialogColor::function_arg_names[];
	static ReflectionDialogColor reflection_dialog_color;
	
	// Tellusim::DialogMenu
	class ReflectionDialogMenu : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return DialogMenu::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<DialogMenu, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<DialogMenu>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(int32_t, int32_t)>(&DialogMenu::setPosition));
					case 1: return FunctionPtr(new FunctionImpl<int32_t(DialogMenu::*)() const>(&DialogMenu::getPositionX));
					case 2: return FunctionPtr(new FunctionImpl<int32_t(DialogMenu::*)() const>(&DialogMenu::getPositionY));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)() const>(&DialogMenu::getNumItems));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(uint32_t, const char*)>(&DialogMenu::setItemText));
					case 5: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(uint32_t, const String&)>(&DialogMenu::setItemText));
					case 6: return FunctionPtr(new FunctionImpl<String(DialogMenu::*)(uint32_t) const>(&DialogMenu::getItemText));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(uint32_t, const char*)>(&DialogMenu::setItemKey));
					case 8: return FunctionPtr(new FunctionImpl<String(DialogMenu::*)(uint32_t) const>(&DialogMenu::getItemKey));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(uint32_t, const Image&)>(&DialogMenu::setItemImage));
					case 10: return FunctionPtr(new FunctionImpl<Image(DialogMenu::*)(uint32_t) const>(&DialogMenu::getItemImage));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(uint32_t, bool, bool)>(&DialogMenu::setItemChecked, {}, {}, false));
					case 12: return FunctionPtr(new FunctionImpl<bool(DialogMenu::*)(uint32_t) const>(&DialogMenu::isItemChecked));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(uint32_t, bool)>(&DialogMenu::setItemEnabled));
					case 14: return FunctionPtr(new FunctionImpl<bool(DialogMenu::*)(uint32_t) const>(&DialogMenu::isItemEnabled));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(uint32_t, bool)>(&DialogMenu::setItemHidden));
					case 16: return FunctionPtr(new FunctionImpl<bool(DialogMenu::*)(uint32_t) const>(&DialogMenu::isItemHidden));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(uint32_t, uint32_t)>(&DialogMenu::setItemsGroup));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(uint32_t) const>(&DialogMenu::getItemGroupIndex));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(uint32_t) const>(&DialogMenu::getItemGroupSize));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const char*, const char*)>(&DialogMenu::addItem, {}, nullptr));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const String&, const char*)>(&DialogMenu::addItem, {}, nullptr));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const char*, const Image&, const char*)>(&DialogMenu::addItem, {}, Image::null, nullptr));
					case 23: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const String&, const Image&, const char*)>(&DialogMenu::addItem, {}, Image::null, nullptr));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const char*, const DialogMenu::ClickedCallback&, const char*)>(&DialogMenu::addItem, {}, {}, nullptr));
					case 25: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const String&, const DialogMenu::ClickedCallback&, const char*)>(&DialogMenu::addItem, {}, {}, nullptr));
					case 26: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const char*, const Image&, const DialogMenu::ClickedCallback&, const char*)>(&DialogMenu::addItem, {}, Image::null, {}, nullptr));
					case 27: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const String&, const Image&, const DialogMenu::ClickedCallback&, const char*)>(&DialogMenu::addItem, {}, Image::null, {}, nullptr));
					case 28: return FunctionPtr(new FunctionImpl<DialogMenu::ClickedCallback(DialogMenu::*)(uint32_t) const>(&DialogMenu::getItemClickedCallback));
					case 29: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const char*, bool, const DialogMenu::ChangedCallback&, const char*)>(&DialogMenu::addItem, {}, {}, {}, nullptr));
					case 30: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const String&, bool, const DialogMenu::ChangedCallback&, const char*)>(&DialogMenu::addItem, {}, {}, {}, nullptr));
					case 31: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const char*, const Image&, bool, const DialogMenu::ChangedCallback&, const char*)>(&DialogMenu::addItem, {}, Image::null, {}, {}, nullptr));
					case 32: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)(const String&, const Image&, bool, const DialogMenu::ChangedCallback&, const char*)>(&DialogMenu::addItem, {}, Image::null, {}, {}, nullptr));
					case 33: return FunctionPtr(new FunctionImpl<DialogMenu::ChangedCallback(DialogMenu::*)(uint32_t) const>(&DialogMenu::getItemChangedCallback));
					case 34: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)(const DialogMenu::UpdateCallback&)>(&DialogMenu::setUpdateCallback));
					case 35: return FunctionPtr(new FunctionImpl<DialogMenu::UpdateCallback(DialogMenu::*)() const>(&DialogMenu::getUpdateCallback));
					case 36: return FunctionPtr(new FunctionImpl<DialogMenu::Result(DialogMenu::*)(DialogMenu::Flags)>(&DialogMenu::run, DialogMenu::DefaultFlags));
					case 37: return FunctionPtr(new FunctionImpl<DialogMenu(DialogMenu::*)() const>(&DialogMenu::clonePtr));
					case 38: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)()>(&DialogMenu::clearPtr));
					case 39: return FunctionPtr(new FunctionVoidImpl<void(DialogMenu::*)()>(&DialogMenu::destroyPtr));
					case 40: return FunctionPtr(new FunctionImpl<DialogMenu&(DialogMenu::*)()>(&DialogMenu::acquirePtr));
					case 41: return FunctionPtr(new FunctionImpl<DialogMenu&(DialogMenu::*)()>(&DialogMenu::unacquirePtr));
					case 42: return FunctionPtr(new FunctionImpl<bool(DialogMenu::*)() const>(&DialogMenu::isValidPtr));
					case 43: return FunctionPtr(new FunctionImpl<bool(DialogMenu::*)() const>(&DialogMenu::isOwnerPtr));
					case 44: return FunctionPtr(new FunctionImpl<bool(DialogMenu::*)() const>(&DialogMenu::isConstPtr));
					case 45: return FunctionPtr(new FunctionImpl<uint32_t(DialogMenu::*)() const>(&DialogMenu::getCountPtr));
					case 46: return FunctionPtr(new FunctionImpl<const void*(DialogMenu::*)() const>(&DialogMenu::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1975, 1976, 1977, 2540, 2545, 2545, 2546, 2776, 2777, 2778, 2779, 2780, 2781, 2782, 2783, 2672, 2673, 2784, 2785, 2786, 2537, 2537, 2537, 2537, 2537, 2537, 2537, 2537, 2788, 2537, 2537, 2537, 2537, 2790, 2072, 2074, 51, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 1, 1, 10, 6, 6, 16, 6, 16, 6, 336, 6, 21, 6, 21, 6, 21, 6, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 2453, 10, 10, 10, 10, 2558, 6, 2075, 2751, 2775, 2775, 2775, 2775, 2775, 2775, 2775, 2775, 2775, 2775 };
			static constexpr uint16_t function_bases[] = { 0, 2, 2, 2, 2, 4, 6, 7, 9, 10, 12, 13, 16, 17, 19, 20, 22, 23, 25, 26, 27, 29, 31, 34, 37, 40, 43, 47, 51, 52, 56, 60, 65, 70, 71, 72, 72, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73, 73 };
			static constexpr uint16_t function_arg_types[] = { 1, 1, 10, 22, 10, 94, 10, 10, 22, 10, 10, 425, 10, 10, 21, 21, 10, 10, 21, 10, 10, 21, 10, 10, 10, 10, 10, 22, 22, 94, 22, 22, 425, 22, 94, 425, 22, 22, 2787, 22, 94, 2787, 22, 22, 425, 2787, 22, 94, 425, 2787, 22, 10, 22, 21, 2789, 22, 94, 21, 2789, 22, 22, 425, 21, 2789, 22, 94, 425, 21, 2789, 22, 10, 2791, 2792 };
			static constexpr uint16_t function_arg_names[] = { 1973, 1974, 274, 2086, 274, 2086, 274, 274, 2042, 274, 274, 450, 274, 274, 2515, 225, 274, 274, 1309, 274, 274, 1957, 274, 274, 87, 274, 274, 2086, 2042, 2086, 2042, 2086, 450, 2042, 2086, 450, 2042, 2086, 1162, 2042, 2086, 1162, 2042, 2086, 450, 1162, 2042, 2086, 450, 1162, 2042, 274, 2086, 2515, 1162, 2042, 2086, 2515, 1162, 2042, 2086, 450, 2515, 1162, 2042, 2086, 450, 2515, 1162, 2042, 274, 1162, 338 };
	};
	constexpr uint16_t ReflectionDialogMenu::constructor_bases[];
	constexpr uint16_t ReflectionDialogMenu::constructor_arg_types[];
	constexpr uint16_t ReflectionDialogMenu::constructor_arg_names[];
	constexpr uint16_t ReflectionDialogMenu::function_names[];
	constexpr uint16_t ReflectionDialogMenu::function_types[];
	constexpr uint16_t ReflectionDialogMenu::function_bases[];
	constexpr uint16_t ReflectionDialogMenu::function_arg_types[];
	constexpr uint16_t ReflectionDialogMenu::function_arg_names[];
	static ReflectionDialogMenu reflection_dialog_menu;
	
	// Tellusim::CubeFilter
	class ReflectionCubeFilter : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return CubeFilter::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<CubeFilter, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<CubeFilter>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(CubeFilter::*)()>(&CubeFilter::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)(CubeFilter::Mode) const>(&CubeFilter::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(CubeFilter::*)() const>(&CubeFilter::getGroupSize));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(CubeFilter::*)() const>(&CubeFilter::getMaxOrder));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(CubeFilter::*)() const>(&CubeFilter::getMaxSize));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(CubeFilter::*)() const>(&CubeFilter::getHarmonics));
					case 6: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)(const Device&, CubeFilter::Mode, uint32_t, uint32_t, uint32_t)>(&CubeFilter::create, Device::null, (CubeFilter::Mode)0, 3, 1024, 256));
					case 7: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)(const Device&, CubeFilter::Flags, uint32_t, uint32_t, uint32_t)>(&CubeFilter::create, Device::null, (CubeFilter::Flags)0, 3, 1024, 256));
					case 8: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)(Compute&, Buffer&, uint32_t, Texture&, const Slice&) const>(&CubeFilter::dispatch));
					case 9: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)(Compute&, Buffer&, uint32_t, Texture&) const>(&CubeFilter::dispatch));
					case 10: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)(Compute&, Texture&, const Slice&, Buffer&, uint32_t) const>(&CubeFilter::dispatch));
					case 11: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)(Compute&, Texture&, Buffer&, uint32_t) const>(&CubeFilter::dispatch));
					case 12: return FunctionPtr(new FunctionImpl<CubeFilter(CubeFilter::*)() const>(&CubeFilter::clonePtr));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(CubeFilter::*)()>(&CubeFilter::clearPtr));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(CubeFilter::*)()>(&CubeFilter::destroyPtr));
					case 15: return FunctionPtr(new FunctionImpl<CubeFilter&(CubeFilter::*)()>(&CubeFilter::acquirePtr));
					case 16: return FunctionPtr(new FunctionImpl<CubeFilter&(CubeFilter::*)()>(&CubeFilter::unacquirePtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)() const>(&CubeFilter::isValidPtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)() const>(&CubeFilter::isOwnerPtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(CubeFilter::*)() const>(&CubeFilter::isConstPtr));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(CubeFilter::*)() const>(&CubeFilter::getCountPtr));
					case 21: return FunctionPtr(new FunctionImpl<const void*(CubeFilter::*)() const>(&CubeFilter::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 2795, 2796, 2797, 2798, 24, 24, 1113, 1113, 1113, 1113, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 10, 10, 10, 10, 21, 21, 21, 21, 21, 21, 2793, 2793, 2793, 2793, 2793, 2793, 2793, 2793, 2793, 2793 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 1, 1, 6, 11, 16, 20, 25, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 };
			static constexpr uint16_t function_arg_types[] = { 2794, 2099, 2794, 10, 10, 10, 2099, 2800, 10, 10, 10, 2801, 1005, 10, 994, 405, 2801, 1005, 10, 994, 2801, 994, 405, 1005, 10, 2801, 994, 1005, 10 };
			static constexpr uint16_t function_arg_names[] = { 185, 28, 185, 2127, 87, 2799, 28, 338, 2127, 87, 2799, 2802, 915, 78, 995, 406, 2802, 915, 78, 995, 2802, 995, 406, 915, 78, 2802, 995, 915, 78 };
	};
	constexpr uint16_t ReflectionCubeFilter::constructor_bases[];
	constexpr uint16_t ReflectionCubeFilter::constructor_arg_types[];
	constexpr uint16_t ReflectionCubeFilter::constructor_arg_names[];
	constexpr uint16_t ReflectionCubeFilter::function_names[];
	constexpr uint16_t ReflectionCubeFilter::function_types[];
	constexpr uint16_t ReflectionCubeFilter::function_bases[];
	constexpr uint16_t ReflectionCubeFilter::function_arg_types[];
	constexpr uint16_t ReflectionCubeFilter::function_arg_names[];
	static ReflectionCubeFilter reflection_cube_filter;
	
	// Tellusim::DecoderJPEG
	class ReflectionDecoderJPEG : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return DecoderJPEG::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<DecoderJPEG, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<DecoderJPEG>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(DecoderJPEG::*)()>(&DecoderJPEG::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)(DecoderJPEG::Mode) const>(&DecoderJPEG::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::Mode)>(&DecoderJPEG::isYUV));
					case 3: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)(const Device&, DecoderJPEG::Mode)>(&DecoderJPEG::create));
					case 4: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)(const Device&, DecoderJPEG::Flags)>(&DecoderJPEG::create));
					case 5: return FunctionPtr(new FunctionImpl<bool(const char*, Image&, DecoderJPEG::Mode&, Size&)>(&DecoderJPEG::load));
					case 6: return FunctionPtr(new FunctionImpl<bool(Stream&, Image&, DecoderJPEG::Mode&, Size&)>(&DecoderJPEG::load));
					case 7: return FunctionPtr(new FunctionImpl<Texture(DecoderJPEG::*)(const Device&, const char*, Texture::Flags) const>(&DecoderJPEG::loadTexture, Device::null, {}, Texture::DefaultFlags));
					case 8: return FunctionPtr(new FunctionImpl<Texture(DecoderJPEG::*)(const Device&, Stream&, Texture::Flags) const>(&DecoderJPEG::loadTexture, Device::null, Stream::null, Texture::DefaultFlags));
					case 9: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)(Compute&, DecoderJPEG::Mode, Texture&, Texture&, const Slice&, const Slice&) const>(&DecoderJPEG::dispatch));
					case 10: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)(Compute&, DecoderJPEG::Mode, Texture&, Texture&, const Slice&) const>(&DecoderJPEG::dispatch));
					case 11: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)(Compute&, DecoderJPEG::Mode, Texture&, Texture&) const>(&DecoderJPEG::dispatch));
					case 12: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)(Compute&, DecoderJPEG::Mode, Texture&, Texture&, const Slice&, const Slice&) const>(&DecoderJPEG::dispatchYUV));
					case 13: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)(Compute&, DecoderJPEG::Mode, Texture&, Texture&, const Slice&) const>(&DecoderJPEG::dispatchYUV));
					case 14: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)(Compute&, DecoderJPEG::Mode, Texture&, Texture&) const>(&DecoderJPEG::dispatchYUV));
					case 15: return FunctionPtr(new FunctionImpl<DecoderJPEG(DecoderJPEG::*)() const>(&DecoderJPEG::clonePtr));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(DecoderJPEG::*)()>(&DecoderJPEG::clearPtr));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(DecoderJPEG::*)()>(&DecoderJPEG::destroyPtr));
					case 18: return FunctionPtr(new FunctionImpl<DecoderJPEG&(DecoderJPEG::*)()>(&DecoderJPEG::acquirePtr));
					case 19: return FunctionPtr(new FunctionImpl<DecoderJPEG&(DecoderJPEG::*)()>(&DecoderJPEG::unacquirePtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)() const>(&DecoderJPEG::isValidPtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)() const>(&DecoderJPEG::isOwnerPtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(DecoderJPEG::*)() const>(&DecoderJPEG::isConstPtr));
					case 23: return FunctionPtr(new FunctionImpl<uint32_t(DecoderJPEG::*)() const>(&DecoderJPEG::getCountPtr));
					case 24: return FunctionPtr(new FunctionImpl<const void*(DecoderJPEG::*)() const>(&DecoderJPEG::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 2805, 24, 24, 221, 221, 1563, 1563, 1113, 1113, 1113, 2809, 2809, 2809, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 21, 21, 21, 21, 1377, 1377, 21, 21, 21, 21, 21, 21, 2803, 2803, 2803, 2803, 2803, 2803, 2803, 2803, 2803, 2803 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 2, 4, 6, 10, 14, 17, 20, 26, 31, 35, 41, 46, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50, 50 };
			static constexpr uint16_t function_arg_types[] = { 2804, 2804, 2099, 2804, 2099, 2806, 22, 1601, 2807, 2808, 145, 1601, 2807, 2808, 2099, 22, 1379, 2099, 145, 1379, 2801, 2804, 994, 994, 405, 405, 2801, 2804, 994, 994, 405, 2801, 2804, 994, 994, 2801, 2804, 994, 994, 405, 405, 2801, 2804, 994, 994, 405, 2801, 2804, 994, 994 };
			static constexpr uint16_t function_arg_names[] = { 185, 185, 28, 185, 28, 338, 23, 450, 185, 87, 222, 450, 185, 87, 28, 23, 338, 28, 222, 338, 2802, 185, 86, 90, 435, 436, 2802, 185, 86, 90, 436, 2802, 185, 86, 90, 2802, 185, 86, 90, 435, 436, 2802, 185, 86, 90, 436, 2802, 185, 86, 90 };
	};
	constexpr uint16_t ReflectionDecoderJPEG::constructor_bases[];
	constexpr uint16_t ReflectionDecoderJPEG::constructor_arg_types[];
	constexpr uint16_t ReflectionDecoderJPEG::constructor_arg_names[];
	constexpr uint16_t ReflectionDecoderJPEG::function_names[];
	constexpr uint16_t ReflectionDecoderJPEG::function_types[];
	constexpr uint16_t ReflectionDecoderJPEG::function_bases[];
	constexpr uint16_t ReflectionDecoderJPEG::function_arg_types[];
	constexpr uint16_t ReflectionDecoderJPEG::function_arg_names[];
	static ReflectionDecoderJPEG reflection_decoder_jpeg;
	
	// Tellusim::EncoderBC15
	class ReflectionEncoderBC15 : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return EncoderBC15::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<EncoderBC15, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<EncoderBC15>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(EncoderBC15::*)()>(&EncoderBC15::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(EncoderBC15::*)(EncoderBC15::Mode) const>(&EncoderBC15::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<bool(EncoderBC15::*)(const Device&, EncoderBC15::Mode)>(&EncoderBC15::create));
					case 3: return FunctionPtr(new FunctionImpl<bool(EncoderBC15::*)(const Device&, EncoderBC15::Flags)>(&EncoderBC15::create));
					case 4: return FunctionPtr(new FunctionImpl<bool(EncoderBC15::*)(Compute&, EncoderBC15::Mode, Texture&, Texture&, const Slice&, const Slice&) const>(&EncoderBC15::dispatch));
					case 5: return FunctionPtr(new FunctionImpl<bool(EncoderBC15::*)(Compute&, EncoderBC15::Mode, Texture&, Texture&, const Slice&) const>(&EncoderBC15::dispatch));
					case 6: return FunctionPtr(new FunctionImpl<bool(EncoderBC15::*)(Compute&, EncoderBC15::Mode, Texture&, Texture&) const>(&EncoderBC15::dispatch));
					case 7: return FunctionPtr(new FunctionImpl<EncoderBC15(EncoderBC15::*)() const>(&EncoderBC15::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(EncoderBC15::*)()>(&EncoderBC15::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(EncoderBC15::*)()>(&EncoderBC15::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<EncoderBC15&(EncoderBC15::*)()>(&EncoderBC15::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<EncoderBC15&(EncoderBC15::*)()>(&EncoderBC15::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(EncoderBC15::*)() const>(&EncoderBC15::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(EncoderBC15::*)() const>(&EncoderBC15::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(EncoderBC15::*)() const>(&EncoderBC15::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(EncoderBC15::*)() const>(&EncoderBC15::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(EncoderBC15::*)() const>(&EncoderBC15::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 24, 24, 1113, 1113, 1113, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 21, 21, 21, 21, 2810, 2810, 2810, 2810, 2810, 2810, 2810, 2810, 2810, 2810 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 3, 5, 11, 16, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20 };
			static constexpr uint16_t function_arg_types[] = { 2811, 2099, 2811, 2099, 2812, 2801, 2811, 994, 994, 405, 405, 2801, 2811, 994, 994, 405, 2801, 2811, 994, 994 };
			static constexpr uint16_t function_arg_names[] = { 185, 28, 185, 28, 338, 2802, 185, 86, 90, 435, 436, 2802, 185, 86, 90, 436, 2802, 185, 86, 90 };
	};
	constexpr uint16_t ReflectionEncoderBC15::constructor_bases[];
	constexpr uint16_t ReflectionEncoderBC15::constructor_arg_types[];
	constexpr uint16_t ReflectionEncoderBC15::constructor_arg_names[];
	constexpr uint16_t ReflectionEncoderBC15::function_names[];
	constexpr uint16_t ReflectionEncoderBC15::function_types[];
	constexpr uint16_t ReflectionEncoderBC15::function_bases[];
	constexpr uint16_t ReflectionEncoderBC15::function_arg_types[];
	constexpr uint16_t ReflectionEncoderBC15::function_arg_names[];
	static ReflectionEncoderBC15 reflection_encoder_bc15;
	
	// Tellusim::EncoderBC67
	class ReflectionEncoderBC67 : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return EncoderBC67::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<EncoderBC67, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<EncoderBC67>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(EncoderBC67::*)()>(&EncoderBC67::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(EncoderBC67::*)(EncoderBC67::Mode) const>(&EncoderBC67::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<bool(EncoderBC67::*)(const Device&, EncoderBC67::Mode)>(&EncoderBC67::create));
					case 3: return FunctionPtr(new FunctionImpl<bool(EncoderBC67::*)(const Device&, EncoderBC67::Flags)>(&EncoderBC67::create));
					case 4: return FunctionPtr(new FunctionImpl<bool(EncoderBC67::*)(Compute&, EncoderBC67::Mode, Texture&, Texture&, const Slice&, const Slice&, uint32_t) const>(&EncoderBC67::dispatch, Compute::null, (EncoderBC67::Mode)0, Texture::null, Texture::null, {}, {}, 4));
					case 5: return FunctionPtr(new FunctionImpl<bool(EncoderBC67::*)(Compute&, EncoderBC67::Mode, Texture&, Texture&, const Slice&, uint32_t) const>(&EncoderBC67::dispatch, Compute::null, (EncoderBC67::Mode)0, Texture::null, Texture::null, {}, 4));
					case 6: return FunctionPtr(new FunctionImpl<bool(EncoderBC67::*)(Compute&, EncoderBC67::Mode, Texture&, Texture&, uint32_t) const>(&EncoderBC67::dispatch, Compute::null, (EncoderBC67::Mode)0, Texture::null, Texture::null, 4));
					case 7: return FunctionPtr(new FunctionImpl<EncoderBC67(EncoderBC67::*)() const>(&EncoderBC67::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(EncoderBC67::*)()>(&EncoderBC67::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(EncoderBC67::*)()>(&EncoderBC67::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<EncoderBC67&(EncoderBC67::*)()>(&EncoderBC67::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<EncoderBC67&(EncoderBC67::*)()>(&EncoderBC67::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(EncoderBC67::*)() const>(&EncoderBC67::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(EncoderBC67::*)() const>(&EncoderBC67::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(EncoderBC67::*)() const>(&EncoderBC67::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(EncoderBC67::*)() const>(&EncoderBC67::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(EncoderBC67::*)() const>(&EncoderBC67::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 24, 24, 1113, 1113, 1113, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 21, 21, 21, 21, 2813, 2813, 2813, 2813, 2813, 2813, 2813, 2813, 2813, 2813 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 3, 5, 12, 18, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23 };
			static constexpr uint16_t function_arg_types[] = { 2814, 2099, 2814, 2099, 2815, 2801, 2814, 994, 994, 405, 405, 10, 2801, 2814, 994, 994, 405, 10, 2801, 2814, 994, 994, 10 };
			static constexpr uint16_t function_arg_names[] = { 185, 28, 185, 28, 338, 2802, 185, 86, 90, 435, 436, 2816, 2802, 185, 86, 90, 436, 2816, 2802, 185, 86, 90, 2816 };
	};
	constexpr uint16_t ReflectionEncoderBC67::constructor_bases[];
	constexpr uint16_t ReflectionEncoderBC67::constructor_arg_types[];
	constexpr uint16_t ReflectionEncoderBC67::constructor_arg_names[];
	constexpr uint16_t ReflectionEncoderBC67::function_names[];
	constexpr uint16_t ReflectionEncoderBC67::function_types[];
	constexpr uint16_t ReflectionEncoderBC67::function_bases[];
	constexpr uint16_t ReflectionEncoderBC67::function_arg_types[];
	constexpr uint16_t ReflectionEncoderBC67::function_arg_names[];
	static ReflectionEncoderBC67 reflection_encoder_bc67;
	
	// Tellusim::EncoderASTC
	class ReflectionEncoderASTC : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return EncoderASTC::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<EncoderASTC, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<EncoderASTC>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(EncoderASTC::*)()>(&EncoderASTC::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(EncoderASTC::*)(EncoderASTC::Mode) const>(&EncoderASTC::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<bool(EncoderASTC::*)(const Device&, EncoderASTC::Mode)>(&EncoderASTC::create));
					case 3: return FunctionPtr(new FunctionImpl<bool(EncoderASTC::*)(const Device&, EncoderASTC::Flags)>(&EncoderASTC::create));
					case 4: return FunctionPtr(new FunctionImpl<bool(EncoderASTC::*)(Compute&, EncoderASTC::Mode, Texture&, Texture&, const Slice&, const Slice&, uint32_t) const>(&EncoderASTC::dispatch, Compute::null, (EncoderASTC::Mode)0, Texture::null, Texture::null, {}, {}, 4));
					case 5: return FunctionPtr(new FunctionImpl<bool(EncoderASTC::*)(Compute&, EncoderASTC::Mode, Texture&, Texture&, const Slice&, uint32_t) const>(&EncoderASTC::dispatch, Compute::null, (EncoderASTC::Mode)0, Texture::null, Texture::null, {}, 4));
					case 6: return FunctionPtr(new FunctionImpl<bool(EncoderASTC::*)(Compute&, EncoderASTC::Mode, Texture&, Texture&, uint32_t) const>(&EncoderASTC::dispatch, Compute::null, (EncoderASTC::Mode)0, Texture::null, Texture::null, 4));
					case 7: return FunctionPtr(new FunctionImpl<EncoderASTC(EncoderASTC::*)() const>(&EncoderASTC::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(EncoderASTC::*)()>(&EncoderASTC::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(EncoderASTC::*)()>(&EncoderASTC::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<EncoderASTC&(EncoderASTC::*)()>(&EncoderASTC::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<EncoderASTC&(EncoderASTC::*)()>(&EncoderASTC::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(EncoderASTC::*)() const>(&EncoderASTC::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(EncoderASTC::*)() const>(&EncoderASTC::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(EncoderASTC::*)() const>(&EncoderASTC::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(EncoderASTC::*)() const>(&EncoderASTC::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(EncoderASTC::*)() const>(&EncoderASTC::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 24, 24, 1113, 1113, 1113, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 21, 21, 21, 21, 2817, 2817, 2817, 2817, 2817, 2817, 2817, 2817, 2817, 2817 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 3, 5, 12, 18, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23 };
			static constexpr uint16_t function_arg_types[] = { 2818, 2099, 2818, 2099, 2819, 2801, 2818, 994, 994, 405, 405, 10, 2801, 2818, 994, 994, 405, 10, 2801, 2818, 994, 994, 10 };
			static constexpr uint16_t function_arg_names[] = { 185, 28, 185, 28, 338, 2802, 185, 86, 90, 435, 436, 2816, 2802, 185, 86, 90, 436, 2816, 2802, 185, 86, 90, 2816 };
	};
	constexpr uint16_t ReflectionEncoderASTC::constructor_bases[];
	constexpr uint16_t ReflectionEncoderASTC::constructor_arg_types[];
	constexpr uint16_t ReflectionEncoderASTC::constructor_arg_names[];
	constexpr uint16_t ReflectionEncoderASTC::function_names[];
	constexpr uint16_t ReflectionEncoderASTC::function_types[];
	constexpr uint16_t ReflectionEncoderASTC::function_bases[];
	constexpr uint16_t ReflectionEncoderASTC::function_arg_types[];
	constexpr uint16_t ReflectionEncoderASTC::function_arg_names[];
	static ReflectionEncoderASTC reflection_encoder_astc;
	
	// Tellusim::MeshModel
	class ReflectionMeshModel : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return MeshModel::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<MeshModel, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<MeshModel>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)()>(&MeshModel::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(MeshModel::*)() const>(&MeshModel::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<MeshModel::Flags(MeshModel::*)() const>(&MeshModel::getFlags));
					case 3: return FunctionPtr(new FunctionImpl<bool(MeshModel::*)(MeshModel::Flags) const>(&MeshModel::hasFlag));
					case 4: return FunctionPtr(new FunctionImpl<bool(MeshModel::*)(MeshModel::Flags) const>(&MeshModel::hasFlags));
					case 5: return FunctionPtr(new FunctionImpl<bool(MeshModel::*)(const Device&, const Pipeline&, const char*, MeshModel::Flags, Async*)>(&MeshModel::load, Device::null, Pipeline::null, {}, MeshModel::DefaultFlags, nullptr));
					case 6: return FunctionPtr(new FunctionImpl<bool(MeshModel::*)(const Device&, const Pipeline&, Stream&, MeshModel::Flags, Async*)>(&MeshModel::load, Device::null, Pipeline::null, Stream::null, MeshModel::DefaultFlags, nullptr));
					case 7: return FunctionPtr(new FunctionImpl<bool(MeshModel::*)(const Device&, const Pipeline&, const char*, MeshModel::Flags)>(&MeshModel::create, Device::null, Pipeline::null, {}, MeshModel::DefaultFlags));
					case 8: return FunctionPtr(new FunctionImpl<bool(MeshModel::*)(const Device&, const Pipeline&, const Mesh&, MeshModel::Flags)>(&MeshModel::create, Device::null, Pipeline::null, Mesh::null, MeshModel::DefaultFlags));
					case 9: return FunctionPtr(new FunctionImpl<bool(MeshModel::*)(const Device&, const Pipeline&, const MeshGeometry&, MeshModel::Flags)>(&MeshModel::create, Device::null, Pipeline::null, MeshGeometry::null, MeshModel::DefaultFlags));
					case 10: return FunctionPtr(new FunctionImpl<bool(MeshModel::*)(const Device&, const Pipeline&, const Array<MeshGeometry>&, MeshModel::Flags)>(&MeshModel::create, Device::null, Pipeline::null, {}, MeshModel::DefaultFlags));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)(const MeshModel::CreateCallback&)>(&MeshModel::setVertexBufferCallback));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)(const MeshModel::CreateCallback&)>(&MeshModel::setIndexBufferCallback));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)(const MeshModel::CreateCallback&)>(&MeshModel::setMeshBufferCallback));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)(Command&, uint32_t, const Pipeline*) const>(&MeshModel::setBuffers, Command::null, 0, nullptr));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)(Command&) const>(&MeshModel::draw));
					case 16: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)(Command&, uint32_t) const>(&MeshModel::draw));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)(Command&, uint32_t, uint32_t) const>(&MeshModel::draw));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)(Command&, uint32_t, uint32_t, uint32_t) const>(&MeshModel::drawInstanced, Command::null, {}, {}, 0));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(MeshModel::*)(Command&, uint32_t, uint32_t, uint32_t, uint32_t) const>(&MeshModel::drawInstanced));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)() const>(&MeshModel::getNumVertices));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)() const>(&MeshModel::getNumVertexBuffers));
					case 22: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t) const>(&MeshModel::getVertexBufferStride));
					case 23: return FunctionPtr(new FunctionImpl<size_t(MeshModel::*)(uint32_t) const>(&MeshModel::getVertexBufferOffset));
					case 24: return FunctionPtr(new FunctionImpl<Buffer(MeshModel::*)() const>(&MeshModel::getVertexBuffer));
					case 25: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)() const>(&MeshModel::getNumIndices));
					case 26: return FunctionPtr(new FunctionImpl<Format(MeshModel::*)() const>(&MeshModel::getIndexFormat));
					case 27: return FunctionPtr(new FunctionImpl<Buffer(MeshModel::*)() const>(&MeshModel::getIndexBuffer));
					case 28: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)() const>(&MeshModel::getNumMeshlets));
					case 29: return FunctionPtr(new FunctionImpl<Buffer(MeshModel::*)() const>(&MeshModel::getMeshletBuffer));
					case 30: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)() const>(&MeshModel::getNumGeometries));
					case 31: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t) const>(&MeshModel::getNumGeometryIndices));
					case 32: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t) const>(&MeshModel::getNumGeometryVertices));
					case 33: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t) const>(&MeshModel::getNumGeometryMeshlets));
					case 34: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t) const>(&MeshModel::getGeometryBaseIndex));
					case 35: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t) const>(&MeshModel::getGeometryBaseVertex));
					case 36: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t) const>(&MeshModel::getGeometryBaseMeshlet));
					case 37: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t) const>(&MeshModel::getNumMaterials));
					case 38: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t, uint32_t) const>(&MeshModel::getNumMaterialIndices));
					case 39: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t, uint32_t) const>(&MeshModel::getNumMaterialVertices));
					case 40: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t, uint32_t) const>(&MeshModel::getNumMaterialMeshlets));
					case 41: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t, uint32_t) const>(&MeshModel::getMaterialBaseIndex));
					case 42: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t, uint32_t) const>(&MeshModel::getMaterialBaseVertex));
					case 43: return FunctionPtr(new FunctionImpl<uint32_t(MeshModel::*)(uint32_t, uint32_t) const>(&MeshModel::getMaterialBaseMeshlet));
					case 44: return FunctionPtr(new FunctionImpl<size_t(MeshModel::*)() const>(&MeshModel::getMemory));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 906, 907, 908, 221, 221, 24, 24, 24, 24, 2825, 2827, 2828, 2829, 2100, 2100, 2100, 2831, 2831, 1448, 2832, 2833, 2834, 1451, 674, 1455, 1456, 2835, 2836, 490, 2837, 2838, 2839, 2840, 2841, 2842, 708, 2843, 2844, 2845, 2846, 2847, 2848, 453 };
			static constexpr uint16_t function_types[] = { 6, 21, 642, 21, 21, 21, 21, 21, 21, 21, 21, 6, 6, 6, 6, 6, 6, 6, 6, 6, 10, 10, 10, 74, 902, 10, 340, 902, 10, 902, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 74 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 1, 2, 7, 12, 16, 20, 24, 28, 29, 30, 31, 34, 35, 37, 40, 44, 49, 49, 49, 50, 51, 51, 51, 51, 51, 51, 51, 51, 52, 53, 54, 55, 56, 57, 58, 60, 62, 64, 66, 68, 70, 70 };
			static constexpr uint16_t function_arg_types[] = { 2821, 2821, 2099, 1586, 22, 2821, 417, 2099, 1586, 145, 2821, 417, 2099, 1586, 22, 2821, 2099, 1586, 2822, 2821, 2099, 1586, 489, 2821, 2099, 1586, 2823, 2821, 2826, 2826, 2826, 2101, 10, 2830, 2101, 2101, 10, 2101, 10, 10, 2101, 10, 10, 10, 2101, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 338, 338, 28, 969, 23, 338, 418, 28, 969, 222, 338, 418, 28, 969, 23, 338, 28, 969, 456, 338, 28, 969, 484, 338, 28, 969, 2824, 338, 1162, 1162, 1162, 188, 274, 969, 188, 188, 484, 188, 484, 630, 188, 484, 1064, 1065, 188, 484, 630, 1064, 1065, 274, 274, 484, 484, 484, 484, 484, 484, 484, 484, 630, 484, 630, 484, 630, 484, 630, 484, 630, 484, 630 };
	};
	constexpr uint16_t ReflectionMeshModel::constructor_bases[];
	constexpr uint16_t ReflectionMeshModel::constructor_arg_types[];
	constexpr uint16_t ReflectionMeshModel::constructor_arg_names[];
	constexpr uint16_t ReflectionMeshModel::function_names[];
	constexpr uint16_t ReflectionMeshModel::function_types[];
	constexpr uint16_t ReflectionMeshModel::function_bases[];
	constexpr uint16_t ReflectionMeshModel::function_arg_types[];
	constexpr uint16_t ReflectionMeshModel::function_arg_names[];
	static ReflectionMeshModel reflection_mesh_model;
	
	// Tellusim::SeparableFilter
	class ReflectionSeparableFilter : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return SeparableFilter::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<SeparableFilter, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<SeparableFilter>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)()>(&SeparableFilter::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(SeparableFilter::*)(Format, uint32_t) const>(&SeparableFilter::isCreated));
					case 2: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)(SeparableFilter::Mode, const char*)>(&SeparableFilter::setInputSource));
					case 3: return FunctionPtr(new FunctionImpl<String(SeparableFilter::*)(SeparableFilter::Mode) const>(&SeparableFilter::getInputSource));
					case 4: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)(SeparableFilter::Mode, const char*)>(&SeparableFilter::setOutputSource));
					case 5: return FunctionPtr(new FunctionImpl<String(SeparableFilter::*)(SeparableFilter::Mode) const>(&SeparableFilter::getOutputSource));
					case 6: return FunctionPtr(new FunctionImpl<bool(SeparableFilter::*)(const Device&, Format, uint32_t, SeparableFilter::Flags)>(&SeparableFilter::create, Device::null, (Format)0, {}, SeparableFilter::DefaultFlags));
					case 7: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)(SeparableFilter::Mode, const Array<Vector4f>&, bool)>(&SeparableFilter::setWeights, (SeparableFilter::Mode)0, {}, false));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)(SeparableFilter::Mode, const Array<float32_t>&, bool)>(&SeparableFilter::setWeights, (SeparableFilter::Mode)0, {}, false));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)(uint32_t, const Vector4f&)>(&SeparableFilter::setGaussianWeights));
					case 10: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)(uint32_t, float32_t)>(&SeparableFilter::setGaussianWeights));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)(uint32_t)>(&SeparableFilter::setSobelXWeights));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)(uint32_t)>(&SeparableFilter::setSobelYWeights));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)(uint32_t)>(&SeparableFilter::setBoxWeights));
					case 14: return FunctionPtr(new FunctionImpl<bool(SeparableFilter::*)(Compute&, SeparableFilter::Mode, uint32_t, Texture&, Texture&, const Slice&, const Slice&, const Vector4f&) const>(&SeparableFilter::dispatch, Compute::null, (SeparableFilter::Mode)0, {}, Texture::null, Texture::null, {}, {}, Vector4f::zero));
					case 15: return FunctionPtr(new FunctionImpl<bool(SeparableFilter::*)(Compute&, SeparableFilter::Mode, uint32_t, Texture&, Texture&, const Slice&, const Vector4f&) const>(&SeparableFilter::dispatch, Compute::null, (SeparableFilter::Mode)0, {}, Texture::null, Texture::null, {}, Vector4f::zero));
					case 16: return FunctionPtr(new FunctionImpl<bool(SeparableFilter::*)(Compute&, SeparableFilter::Mode, uint32_t, Texture&, Texture&, const Vector4f&) const>(&SeparableFilter::dispatch, Compute::null, (SeparableFilter::Mode)0, {}, Texture::null, Texture::null, Vector4f::zero));
					case 17: return FunctionPtr(new FunctionImpl<SeparableFilter(SeparableFilter::*)() const>(&SeparableFilter::clonePtr));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)()>(&SeparableFilter::clearPtr));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(SeparableFilter::*)()>(&SeparableFilter::destroyPtr));
					case 20: return FunctionPtr(new FunctionImpl<SeparableFilter&(SeparableFilter::*)()>(&SeparableFilter::acquirePtr));
					case 21: return FunctionPtr(new FunctionImpl<SeparableFilter&(SeparableFilter::*)()>(&SeparableFilter::unacquirePtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(SeparableFilter::*)() const>(&SeparableFilter::isValidPtr));
					case 23: return FunctionPtr(new FunctionImpl<bool(SeparableFilter::*)() const>(&SeparableFilter::isOwnerPtr));
					case 24: return FunctionPtr(new FunctionImpl<bool(SeparableFilter::*)() const>(&SeparableFilter::isConstPtr));
					case 25: return FunctionPtr(new FunctionImpl<uint32_t(SeparableFilter::*)() const>(&SeparableFilter::getCountPtr));
					case 26: return FunctionPtr(new FunctionImpl<const void*(SeparableFilter::*)() const>(&SeparableFilter::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 2850, 2852, 2853, 2854, 24, 2856, 2856, 2861, 2861, 2863, 2864, 2865, 1113, 1113, 1113, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 6, 16, 6, 16, 21, 6, 6, 6, 6, 6, 6, 6, 21, 21, 21, 2849, 2849, 2849, 2849, 2849, 2849, 2849, 2849, 2849, 2849 };
			static constexpr uint16_t function_bases[] = { 0, 0, 2, 4, 5, 7, 8, 12, 15, 18, 20, 22, 23, 24, 25, 33, 40, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 46 };
			static constexpr uint16_t function_arg_types[] = { 340, 10, 2851, 22, 2851, 2851, 22, 2851, 2099, 340, 10, 2855, 2851, 2857, 21, 2851, 2860, 21, 10, 519, 10, 123, 10, 10, 10, 2801, 2851, 10, 994, 994, 405, 405, 519, 2801, 2851, 10, 994, 994, 405, 519, 2801, 2851, 10, 994, 994, 519 };
			static constexpr uint16_t function_arg_names[] = { 96, 87, 185, 90, 185, 185, 90, 185, 28, 96, 87, 338, 185, 2858, 2859, 185, 2858, 2859, 87, 2862, 87, 2862, 87, 87, 87, 2802, 185, 87, 86, 90, 435, 436, 877, 2802, 185, 87, 86, 90, 436, 877, 2802, 185, 87, 86, 90, 877 };
	};
	constexpr uint16_t ReflectionSeparableFilter::constructor_bases[];
	constexpr uint16_t ReflectionSeparableFilter::constructor_arg_types[];
	constexpr uint16_t ReflectionSeparableFilter::constructor_arg_names[];
	constexpr uint16_t ReflectionSeparableFilter::function_names[];
	constexpr uint16_t ReflectionSeparableFilter::function_types[];
	constexpr uint16_t ReflectionSeparableFilter::function_bases[];
	constexpr uint16_t ReflectionSeparableFilter::function_arg_types[];
	constexpr uint16_t ReflectionSeparableFilter::function_arg_names[];
	static ReflectionSeparableFilter reflection_separable_filter;
	
	// Tellusim::PrefixScan
	class ReflectionPrefixScan : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return PrefixScan::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<PrefixScan, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<PrefixScan>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(PrefixScan::*)()>(&PrefixScan::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)(PrefixScan::Flags) const>(&PrefixScan::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(PrefixScan::*)() const>(&PrefixScan::getGroupSize));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(PrefixScan::*)() const>(&PrefixScan::getScanElements));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(PrefixScan::*)() const>(&PrefixScan::getMaxElements));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(PrefixScan::*)() const>(&PrefixScan::getMaxRegions));
					case 6: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)(const Device&, PrefixScan::Mode, uint32_t, uint32_t, Async*)>(&PrefixScan::create, Device::null, (PrefixScan::Mode)0, 256, 1, nullptr));
					case 7: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)(const Device&, PrefixScan::Flags, uint32_t, uint32_t, Async*)>(&PrefixScan::create, Device::null, (PrefixScan::Flags)0, 256, 1, nullptr));
					case 8: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)(Compute&, Buffer&, uint32_t, uint32_t)>(&PrefixScan::dispatch));
					case 9: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)(Compute&, Buffer&, uint32_t, const uint32_t*, const uint32_t*, PrefixScan::Flags)>(&PrefixScan::dispatch, Compute::null, Buffer::null, {}, {}, {}, PrefixScan::FlagNone));
					case 10: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)(Compute&, Buffer&, Buffer&, uint32_t, PrefixScan::Flags, uint32_t)>(&PrefixScan::dispatchIndirect, Compute::null, Buffer::null, Buffer::null, {}, PrefixScan::FlagNone, Maxu32));
					case 11: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)(Compute&, Buffer&, uint32_t, Buffer&, uint32_t, PrefixScan::Flags, uint32_t)>(&PrefixScan::dispatchIndirect, Compute::null, Buffer::null, {}, Buffer::null, {}, PrefixScan::FlagNone, Maxu32));
					case 12: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)(Compute&, Buffer&, Buffer&, Buffer&, uint32_t, uint32_t, PrefixScan::Flags, uint32_t)>(&PrefixScan::dispatchIndirect, Compute::null, Buffer::null, Buffer::null, Buffer::null, {}, {}, PrefixScan::FlagNone, Maxu32));
					case 13: return FunctionPtr(new FunctionImpl<PrefixScan(PrefixScan::*)() const>(&PrefixScan::clonePtr));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(PrefixScan::*)()>(&PrefixScan::clearPtr));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(PrefixScan::*)()>(&PrefixScan::destroyPtr));
					case 16: return FunctionPtr(new FunctionImpl<PrefixScan&(PrefixScan::*)()>(&PrefixScan::acquirePtr));
					case 17: return FunctionPtr(new FunctionImpl<PrefixScan&(PrefixScan::*)()>(&PrefixScan::unacquirePtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)() const>(&PrefixScan::isValidPtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)() const>(&PrefixScan::isOwnerPtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(PrefixScan::*)() const>(&PrefixScan::isConstPtr));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(PrefixScan::*)() const>(&PrefixScan::getCountPtr));
					case 22: return FunctionPtr(new FunctionImpl<const void*(PrefixScan::*)() const>(&PrefixScan::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 2795, 2868, 2869, 2870, 24, 24, 1113, 1113, 1115, 1115, 1115, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 10, 10, 10, 10, 21, 21, 21, 21, 21, 21, 21, 2866, 2866, 2866, 2866, 2866, 2866, 2866, 2866, 2866, 2866 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 1, 1, 6, 11, 15, 21, 27, 34, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42 };
			static constexpr uint16_t function_arg_types[] = { 2867, 2099, 2871, 10, 10, 417, 2099, 2867, 10, 10, 417, 2801, 1005, 10, 10, 2801, 1005, 10, 880, 880, 2867, 2801, 1005, 1005, 10, 2867, 10, 2801, 1005, 10, 1005, 10, 2867, 10, 2801, 1005, 1005, 1005, 10, 10, 2867, 10 };
			static constexpr uint16_t function_arg_names[] = { 338, 28, 185, 2799, 1604, 418, 28, 338, 2799, 1604, 418, 2802, 167, 78, 87, 2802, 167, 2872, 1010, 2873, 338, 2802, 167, 1113, 78, 338, 2874, 2802, 167, 2872, 1113, 78, 338, 2874, 2802, 167, 2872, 1113, 2875, 2876, 338, 2874 };
	};
	constexpr uint16_t ReflectionPrefixScan::constructor_bases[];
	constexpr uint16_t ReflectionPrefixScan::constructor_arg_types[];
	constexpr uint16_t ReflectionPrefixScan::constructor_arg_names[];
	constexpr uint16_t ReflectionPrefixScan::function_names[];
	constexpr uint16_t ReflectionPrefixScan::function_types[];
	constexpr uint16_t ReflectionPrefixScan::function_bases[];
	constexpr uint16_t ReflectionPrefixScan::function_arg_types[];
	constexpr uint16_t ReflectionPrefixScan::function_arg_names[];
	static ReflectionPrefixScan reflection_prefix_scan;
	
	// Tellusim::RadixSort
	class ReflectionRadixSort : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return RadixSort::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<RadixSort, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<RadixSort>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(RadixSort::*)()>(&RadixSort::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)(RadixSort::Flags) const>(&RadixSort::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(RadixSort::*)() const>(&RadixSort::getDataSize));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(RadixSort::*)() const>(&RadixSort::getGroupSize));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(RadixSort::*)() const>(&RadixSort::getSortElements));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(RadixSort::*)() const>(&RadixSort::getUpdateElements));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(RadixSort::*)() const>(&RadixSort::getMaxElements));
					case 7: return FunctionPtr(new FunctionImpl<uint32_t(RadixSort::*)() const>(&RadixSort::getMaxRegions));
					case 8: return FunctionPtr(new FunctionImpl<PrefixScan(RadixSort::*)() const>(&RadixSort::getPrefixScan));
					case 9: return FunctionPtr(new FunctionImpl<Buffer(RadixSort::*)() const>(&RadixSort::getDataBuffer));
					case 10: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)(const Device&, RadixSort::Mode, PrefixScan&, uint32_t, uint32_t, uint32_t, Async*)>(&RadixSort::create, Device::null, (RadixSort::Mode)0, PrefixScan::null, {}, 256, 1, nullptr));
					case 11: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)(const Device&, RadixSort::Flags, PrefixScan&, uint32_t, uint32_t, uint32_t, Async*)>(&RadixSort::create, Device::null, (RadixSort::Flags)0, PrefixScan::null, {}, 256, 1, nullptr));
					case 12: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)(Compute&, Buffer&, uint32_t, uint32_t, uint32_t, RadixSort::Flags, uint32_t)>(&RadixSort::dispatch, Compute::null, Buffer::null, {}, {}, {}, RadixSort::FlagNone, 32));
					case 13: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)(Compute&, Buffer&, uint32_t, const uint32_t*, const uint32_t*, const uint32_t*, RadixSort::Flags, uint32_t)>(&RadixSort::dispatch, Compute::null, Buffer::null, {}, {}, {}, {}, RadixSort::FlagNone, 32));
					case 14: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)(Compute&, Buffer&, Buffer&, uint32_t, RadixSort::Flags, uint32_t, uint32_t)>(&RadixSort::dispatchIndirect, Compute::null, Buffer::null, Buffer::null, {}, RadixSort::FlagNone, 32, Maxu32));
					case 15: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)(Compute&, Buffer&, uint32_t, Buffer&, uint32_t, RadixSort::Flags, uint32_t, uint32_t)>(&RadixSort::dispatchIndirect, Compute::null, Buffer::null, {}, Buffer::null, {}, RadixSort::FlagNone, 32, Maxu32));
					case 16: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)(Compute&, Buffer&, Buffer&, Buffer&, uint32_t, uint32_t, RadixSort::Flags, uint32_t, uint32_t)>(&RadixSort::dispatchIndirect, Compute::null, Buffer::null, Buffer::null, Buffer::null, {}, {}, RadixSort::FlagNone, 32, Maxu32));
					case 17: return FunctionPtr(new FunctionImpl<RadixSort(RadixSort::*)() const>(&RadixSort::clonePtr));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(RadixSort::*)()>(&RadixSort::clearPtr));
					case 19: return FunctionPtr(new FunctionVoidImpl<void(RadixSort::*)()>(&RadixSort::destroyPtr));
					case 20: return FunctionPtr(new FunctionImpl<RadixSort&(RadixSort::*)()>(&RadixSort::acquirePtr));
					case 21: return FunctionPtr(new FunctionImpl<RadixSort&(RadixSort::*)()>(&RadixSort::unacquirePtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)() const>(&RadixSort::isValidPtr));
					case 23: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)() const>(&RadixSort::isOwnerPtr));
					case 24: return FunctionPtr(new FunctionImpl<bool(RadixSort::*)() const>(&RadixSort::isConstPtr));
					case 25: return FunctionPtr(new FunctionImpl<uint32_t(RadixSort::*)() const>(&RadixSort::getCountPtr));
					case 26: return FunctionPtr(new FunctionImpl<const void*(RadixSort::*)() const>(&RadixSort::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 411, 2795, 2879, 2880, 2869, 2870, 2881, 2882, 24, 24, 1113, 1113, 1115, 1115, 1115, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 10, 10, 10, 10, 10, 10, 2866, 902, 21, 21, 21, 21, 21, 21, 21, 2877, 2877, 2877, 2877, 2877, 2877, 2877, 2877, 2877, 2877 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 8, 15, 22, 30, 37, 45, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54, 54 };
			static constexpr uint16_t function_arg_types[] = { 2878, 2099, 2883, 2884, 10, 10, 10, 417, 2099, 2878, 2884, 10, 10, 10, 417, 2801, 1005, 10, 10, 10, 2878, 10, 2801, 1005, 10, 880, 880, 880, 2878, 10, 2801, 1005, 1005, 10, 2878, 10, 10, 2801, 1005, 10, 1005, 10, 2878, 10, 10, 2801, 1005, 1005, 1005, 10, 10, 2878, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 338, 28, 185, 2885, 87, 2799, 1604, 418, 28, 338, 2885, 87, 2799, 1604, 418, 2802, 167, 2886, 2887, 87, 338, 2888, 2802, 167, 2872, 2889, 2890, 2873, 338, 2888, 2802, 167, 1113, 78, 338, 2888, 2874, 2802, 167, 2872, 1113, 78, 338, 2888, 2874, 2802, 167, 2872, 1113, 2875, 2876, 338, 2888, 2874 };
	};
	constexpr uint16_t ReflectionRadixSort::constructor_bases[];
	constexpr uint16_t ReflectionRadixSort::constructor_arg_types[];
	constexpr uint16_t ReflectionRadixSort::constructor_arg_names[];
	constexpr uint16_t ReflectionRadixSort::function_names[];
	constexpr uint16_t ReflectionRadixSort::function_types[];
	constexpr uint16_t ReflectionRadixSort::function_bases[];
	constexpr uint16_t ReflectionRadixSort::function_arg_types[];
	constexpr uint16_t ReflectionRadixSort::function_arg_names[];
	static ReflectionRadixSort reflection_radix_sort;
	
	// Tellusim::BitonicSort
	class ReflectionBitonicSort : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return BitonicSort::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<BitonicSort, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<BitonicSort>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(BitonicSort::*)()>(&BitonicSort::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)(BitonicSort::Flags) const>(&BitonicSort::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(BitonicSort::*)() const>(&BitonicSort::getDataSize));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(BitonicSort::*)() const>(&BitonicSort::getGroupSize));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(BitonicSort::*)() const>(&BitonicSort::getSortElements));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(BitonicSort::*)() const>(&BitonicSort::getMaxRegions));
					case 6: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)(const Device&, BitonicSort::Mode, uint32_t, uint32_t, uint32_t, Async*)>(&BitonicSort::create, Device::null, (BitonicSort::Mode)0, {}, 256, 1, nullptr));
					case 7: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)(const Device&, BitonicSort::Flags, uint32_t, uint32_t, uint32_t, Async*)>(&BitonicSort::create, Device::null, (BitonicSort::Flags)0, {}, 256, 1, nullptr));
					case 8: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)(Compute&, Buffer&, uint32_t, uint32_t, uint32_t, BitonicSort::Flags)>(&BitonicSort::dispatch, Compute::null, Buffer::null, {}, {}, {}, BitonicSort::FlagNone));
					case 9: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)(Compute&, Buffer&, uint32_t, const uint32_t*, const uint32_t*, const uint32_t*, BitonicSort::Flags)>(&BitonicSort::dispatch, Compute::null, Buffer::null, {}, {}, {}, {}, BitonicSort::FlagNone));
					case 10: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)(Compute&, Buffer&, Buffer&, uint32_t, BitonicSort::Flags)>(&BitonicSort::dispatchIndirect, Compute::null, Buffer::null, Buffer::null, {}, BitonicSort::FlagNone));
					case 11: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)(Compute&, Buffer&, uint32_t, Buffer&, uint32_t, BitonicSort::Flags)>(&BitonicSort::dispatchIndirect, Compute::null, Buffer::null, {}, Buffer::null, {}, BitonicSort::FlagNone));
					case 12: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)(Compute&, Buffer&, Buffer&, Buffer&, uint32_t, uint32_t, BitonicSort::Flags)>(&BitonicSort::dispatchIndirect, Compute::null, Buffer::null, Buffer::null, Buffer::null, {}, {}, BitonicSort::FlagNone));
					case 13: return FunctionPtr(new FunctionImpl<BitonicSort(BitonicSort::*)() const>(&BitonicSort::clonePtr));
					case 14: return FunctionPtr(new FunctionVoidImpl<void(BitonicSort::*)()>(&BitonicSort::clearPtr));
					case 15: return FunctionPtr(new FunctionVoidImpl<void(BitonicSort::*)()>(&BitonicSort::destroyPtr));
					case 16: return FunctionPtr(new FunctionImpl<BitonicSort&(BitonicSort::*)()>(&BitonicSort::acquirePtr));
					case 17: return FunctionPtr(new FunctionImpl<BitonicSort&(BitonicSort::*)()>(&BitonicSort::unacquirePtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)() const>(&BitonicSort::isValidPtr));
					case 19: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)() const>(&BitonicSort::isOwnerPtr));
					case 20: return FunctionPtr(new FunctionImpl<bool(BitonicSort::*)() const>(&BitonicSort::isConstPtr));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(BitonicSort::*)() const>(&BitonicSort::getCountPtr));
					case 22: return FunctionPtr(new FunctionImpl<const void*(BitonicSort::*)() const>(&BitonicSort::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 411, 2795, 2879, 2870, 24, 24, 1113, 1113, 1115, 1115, 1115, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 10, 10, 10, 10, 21, 21, 21, 21, 21, 21, 21, 2891, 2891, 2891, 2891, 2891, 2891, 2891, 2891, 2891, 2891 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 1, 1, 7, 13, 19, 26, 31, 37, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44 };
			static constexpr uint16_t function_arg_types[] = { 2892, 2099, 2893, 10, 10, 10, 417, 2099, 2892, 10, 10, 10, 417, 2801, 1005, 10, 10, 10, 2892, 2801, 1005, 10, 880, 880, 880, 2892, 2801, 1005, 1005, 10, 2892, 2801, 1005, 10, 1005, 10, 2892, 2801, 1005, 1005, 1005, 10, 10, 2892 };
			static constexpr uint16_t function_arg_names[] = { 338, 28, 185, 87, 2799, 1604, 418, 28, 338, 87, 2799, 1604, 418, 2802, 167, 2886, 2887, 87, 338, 2802, 167, 2872, 2889, 2890, 2873, 338, 2802, 167, 1113, 78, 338, 2802, 167, 2872, 1113, 78, 338, 2802, 167, 2872, 1113, 2875, 2876, 338 };
	};
	constexpr uint16_t ReflectionBitonicSort::constructor_bases[];
	constexpr uint16_t ReflectionBitonicSort::constructor_arg_types[];
	constexpr uint16_t ReflectionBitonicSort::constructor_arg_names[];
	constexpr uint16_t ReflectionBitonicSort::function_names[];
	constexpr uint16_t ReflectionBitonicSort::function_types[];
	constexpr uint16_t ReflectionBitonicSort::function_bases[];
	constexpr uint16_t ReflectionBitonicSort::function_arg_types[];
	constexpr uint16_t ReflectionBitonicSort::function_arg_names[];
	static ReflectionBitonicSort reflection_bitonic_sort;
	
	// Tellusim::SpatialGrid
	class ReflectionSpatialGrid : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return SpatialGrid::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<SpatialGrid, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<SpatialGrid>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(SpatialGrid::*)()>(&SpatialGrid::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(SpatialGrid::*)() const>(&SpatialGrid::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(SpatialGrid::*)() const>(&SpatialGrid::getGroupSize));
					case 3: return FunctionPtr(new FunctionImpl<RadixSort(SpatialGrid::*)() const>(&SpatialGrid::getRadixSort));
					case 4: return FunctionPtr(new FunctionImpl<bool(SpatialGrid::*)(const Device&, RadixSort&, uint32_t)>(&SpatialGrid::create, Device::null, RadixSort::null, 256));
					case 5: return FunctionPtr(new FunctionImpl<bool(SpatialGrid::*)(Compute&, Buffer&, uint32_t, uint32_t, uint32_t)>(&SpatialGrid::dispatch, Compute::null, Buffer::null, {}, {}, 32));
					case 6: return FunctionPtr(new FunctionImpl<bool(SpatialGrid::*)(Compute&, Buffer&, Buffer&, uint32_t, uint32_t)>(&SpatialGrid::dispatchIndirect, Compute::null, Buffer::null, Buffer::null, {}, Maxu32));
					case 7: return FunctionPtr(new FunctionImpl<SpatialGrid(SpatialGrid::*)() const>(&SpatialGrid::clonePtr));
					case 8: return FunctionPtr(new FunctionVoidImpl<void(SpatialGrid::*)()>(&SpatialGrid::clearPtr));
					case 9: return FunctionPtr(new FunctionVoidImpl<void(SpatialGrid::*)()>(&SpatialGrid::destroyPtr));
					case 10: return FunctionPtr(new FunctionImpl<SpatialGrid&(SpatialGrid::*)()>(&SpatialGrid::acquirePtr));
					case 11: return FunctionPtr(new FunctionImpl<SpatialGrid&(SpatialGrid::*)()>(&SpatialGrid::unacquirePtr));
					case 12: return FunctionPtr(new FunctionImpl<bool(SpatialGrid::*)() const>(&SpatialGrid::isValidPtr));
					case 13: return FunctionPtr(new FunctionImpl<bool(SpatialGrid::*)() const>(&SpatialGrid::isOwnerPtr));
					case 14: return FunctionPtr(new FunctionImpl<bool(SpatialGrid::*)() const>(&SpatialGrid::isConstPtr));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(SpatialGrid::*)() const>(&SpatialGrid::getCountPtr));
					case 16: return FunctionPtr(new FunctionImpl<const void*(SpatialGrid::*)() const>(&SpatialGrid::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 2795, 2895, 24, 1113, 1115, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 10, 2877, 21, 21, 21, 2894, 2894, 2894, 2894, 2894, 2894, 2894, 2894, 2894, 2894 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 3, 8, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13 };
			static constexpr uint16_t function_arg_types[] = { 2099, 2896, 10, 2801, 1005, 10, 10, 10, 2801, 1005, 1005, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 28, 2897, 2799, 2802, 167, 78, 87, 2888, 2802, 167, 1113, 78, 2874 };
	};
	constexpr uint16_t ReflectionSpatialGrid::constructor_bases[];
	constexpr uint16_t ReflectionSpatialGrid::constructor_arg_types[];
	constexpr uint16_t ReflectionSpatialGrid::constructor_arg_names[];
	constexpr uint16_t ReflectionSpatialGrid::function_names[];
	constexpr uint16_t ReflectionSpatialGrid::function_types[];
	constexpr uint16_t ReflectionSpatialGrid::function_bases[];
	constexpr uint16_t ReflectionSpatialGrid::function_arg_types[];
	constexpr uint16_t ReflectionSpatialGrid::function_arg_names[];
	static ReflectionSpatialGrid reflection_spatial_grid;
	
	// Tellusim::SpatialTree
	class ReflectionSpatialTree : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return SpatialTree::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<SpatialTree, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<SpatialTree>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(SpatialTree::*)()>(&SpatialTree::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)(SpatialTree::Flags) const>(&SpatialTree::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(SpatialTree::*)() const>(&SpatialTree::getGroupSize));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(SpatialTree::*)() const>(&SpatialTree::getBoundsNodes));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(SpatialTree::*)() const>(&SpatialTree::getMaxNodes));
					case 5: return FunctionPtr(new FunctionImpl<uint32_t(SpatialTree::*)() const>(&SpatialTree::getMaxRegions));
					case 6: return FunctionPtr(new FunctionImpl<RadixSort(SpatialTree::*)() const>(&SpatialTree::getRadixSort));
					case 7: return FunctionPtr(new FunctionImpl<Buffer(SpatialTree::*)() const>(&SpatialTree::getHashBuffer));
					case 8: return FunctionPtr(new FunctionImpl<Buffer(SpatialTree::*)() const>(&SpatialTree::getParentsBuffer));
					case 9: return FunctionPtr(new FunctionImpl<Buffer(SpatialTree::*)() const>(&SpatialTree::getCounterBuffer));
					case 10: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)(const Device&, SpatialTree::Mode, RadixSort&, uint32_t, uint32_t, uint32_t, Async*)>(&SpatialTree::create, Device::null, (SpatialTree::Mode)0, RadixSort::null, {}, 256, 1, nullptr));
					case 11: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)(const Device&, SpatialTree::Flags, RadixSort&, uint32_t, uint32_t, uint32_t, Async*)>(&SpatialTree::create, Device::null, (SpatialTree::Flags)0, RadixSort::null, {}, 256, 1, nullptr));
					case 12: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)(Compute&, SpatialTree::Hash, Buffer&, uint32_t, uint32_t, SpatialTree::Flags)>(&SpatialTree::dispatch, Compute::null, (SpatialTree::Hash)0, Buffer::null, {}, {}, SpatialTree::FlagNone));
					case 13: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)(Compute&, SpatialTree::Hash, Buffer&, uint32_t, const uint32_t*, const uint32_t*, SpatialTree::Flags)>(&SpatialTree::dispatch, Compute::null, (SpatialTree::Hash)0, Buffer::null, {}, {}, {}, SpatialTree::FlagNone));
					case 14: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)(Compute&, SpatialTree::Hash, Buffer&, Buffer&, uint32_t, uint32_t)>(&SpatialTree::dispatchIndirect, Compute::null, (SpatialTree::Hash)0, Buffer::null, Buffer::null, {}, Maxu32));
					case 15: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)(Compute&, SpatialTree::Hash, Buffer&, uint32_t, Buffer&, uint32_t, uint32_t)>(&SpatialTree::dispatchIndirect, Compute::null, (SpatialTree::Hash)0, Buffer::null, {}, Buffer::null, {}, Maxu32));
					case 16: return FunctionPtr(new FunctionImpl<SpatialTree(SpatialTree::*)() const>(&SpatialTree::clonePtr));
					case 17: return FunctionPtr(new FunctionVoidImpl<void(SpatialTree::*)()>(&SpatialTree::clearPtr));
					case 18: return FunctionPtr(new FunctionVoidImpl<void(SpatialTree::*)()>(&SpatialTree::destroyPtr));
					case 19: return FunctionPtr(new FunctionImpl<SpatialTree&(SpatialTree::*)()>(&SpatialTree::acquirePtr));
					case 20: return FunctionPtr(new FunctionImpl<SpatialTree&(SpatialTree::*)()>(&SpatialTree::unacquirePtr));
					case 21: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)() const>(&SpatialTree::isValidPtr));
					case 22: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)() const>(&SpatialTree::isOwnerPtr));
					case 23: return FunctionPtr(new FunctionImpl<bool(SpatialTree::*)() const>(&SpatialTree::isConstPtr));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(SpatialTree::*)() const>(&SpatialTree::getCountPtr));
					case 25: return FunctionPtr(new FunctionImpl<const void*(SpatialTree::*)() const>(&SpatialTree::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 2795, 2900, 2901, 2870, 2895, 2902, 2903, 2904, 24, 24, 1113, 1113, 1115, 1115, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 10, 10, 10, 10, 2877, 902, 902, 902, 21, 21, 21, 21, 21, 21, 2898, 2898, 2898, 2898, 2898, 2898, 2898, 2898, 2898, 2898 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 8, 15, 21, 28, 34, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41, 41 };
			static constexpr uint16_t function_arg_types[] = { 2899, 2099, 2905, 2896, 10, 10, 10, 417, 2099, 2899, 2896, 10, 10, 10, 417, 2801, 2906, 1005, 10, 10, 2899, 2801, 2906, 1005, 10, 880, 880, 2899, 2801, 2906, 1005, 1005, 10, 10, 2801, 2906, 1005, 10, 1005, 10, 10 };
			static constexpr uint16_t function_arg_names[] = { 338, 28, 185, 2897, 87, 2799, 1604, 418, 28, 338, 2897, 87, 2799, 1604, 418, 2802, 180, 2907, 78, 87, 338, 2802, 180, 2907, 2872, 1010, 2873, 338, 2802, 180, 2907, 1113, 78, 2874, 2802, 180, 2907, 2872, 1113, 78, 2874 };
	};
	constexpr uint16_t ReflectionSpatialTree::constructor_bases[];
	constexpr uint16_t ReflectionSpatialTree::constructor_arg_types[];
	constexpr uint16_t ReflectionSpatialTree::constructor_arg_names[];
	constexpr uint16_t ReflectionSpatialTree::function_names[];
	constexpr uint16_t ReflectionSpatialTree::function_types[];
	constexpr uint16_t ReflectionSpatialTree::function_bases[];
	constexpr uint16_t ReflectionSpatialTree::function_arg_types[];
	constexpr uint16_t ReflectionSpatialTree::function_arg_names[];
	static ReflectionSpatialTree reflection_spatial_tree;
	
	// Tellusim::FourierTransform
	class ReflectionFourierTransform : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return FourierTransform::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<FourierTransform, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<FourierTransform>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(FourierTransform::*)()>(&FourierTransform::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)(FourierTransform::Mode) const>(&FourierTransform::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)(FourierTransform::Flags) const>(&FourierTransform::isCreated));
					case 3: return FunctionPtr(new FunctionImpl<uint32_t(FourierTransform::*)() const>(&FourierTransform::getMaxWidth));
					case 4: return FunctionPtr(new FunctionImpl<uint32_t(FourierTransform::*)() const>(&FourierTransform::getMaxHeight));
					case 5: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)(const Device&, FourierTransform::Mode, uint32_t, uint32_t, Async*)>(&FourierTransform::create, Device::null, (FourierTransform::Mode)0, {}, {}, nullptr));
					case 6: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)(const Device&, FourierTransform::Flags, uint32_t, uint32_t, Async*)>(&FourierTransform::create, Device::null, (FourierTransform::Flags)0, {}, {}, nullptr));
					case 7: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)(Compute&, FourierTransform::Mode, FourierTransform::Operation, Texture&, Texture&, const Slice&, const Slice&) const>(&FourierTransform::dispatch));
					case 8: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)(Compute&, FourierTransform::Mode, FourierTransform::Operation, Texture&, Texture&, const Slice&) const>(&FourierTransform::dispatch));
					case 9: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)(Compute&, FourierTransform::Mode, FourierTransform::Operation, Texture&, Texture&) const>(&FourierTransform::dispatch));
					case 10: return FunctionPtr(new FunctionImpl<FourierTransform(FourierTransform::*)() const>(&FourierTransform::clonePtr));
					case 11: return FunctionPtr(new FunctionVoidImpl<void(FourierTransform::*)()>(&FourierTransform::clearPtr));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(FourierTransform::*)()>(&FourierTransform::destroyPtr));
					case 13: return FunctionPtr(new FunctionImpl<FourierTransform&(FourierTransform::*)()>(&FourierTransform::acquirePtr));
					case 14: return FunctionPtr(new FunctionImpl<FourierTransform&(FourierTransform::*)()>(&FourierTransform::unacquirePtr));
					case 15: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)() const>(&FourierTransform::isValidPtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)() const>(&FourierTransform::isOwnerPtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(FourierTransform::*)() const>(&FourierTransform::isConstPtr));
					case 18: return FunctionPtr(new FunctionImpl<uint32_t(FourierTransform::*)() const>(&FourierTransform::getCountPtr));
					case 19: return FunctionPtr(new FunctionImpl<const void*(FourierTransform::*)() const>(&FourierTransform::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 904, 2911, 2912, 24, 24, 1113, 1113, 1113, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 10, 10, 21, 21, 21, 21, 21, 2908, 2908, 2908, 2908, 2908, 2908, 2908, 2908, 2908, 2908 };
			static constexpr uint16_t function_bases[] = { 0, 0, 1, 2, 2, 2, 7, 12, 19, 25, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30, 30 };
			static constexpr uint16_t function_arg_types[] = { 2909, 2910, 2099, 2909, 10, 10, 417, 2099, 2910, 10, 10, 417, 2801, 2909, 2913, 994, 994, 405, 405, 2801, 2909, 2913, 994, 994, 405, 2801, 2909, 2913, 994, 994 };
			static constexpr uint16_t function_arg_names[] = { 185, 338, 28, 185, 30, 31, 418, 28, 338, 30, 31, 418, 2802, 185, 1501, 86, 90, 435, 436, 2802, 185, 1501, 86, 90, 436, 2802, 185, 1501, 86, 90 };
	};
	constexpr uint16_t ReflectionFourierTransform::constructor_bases[];
	constexpr uint16_t ReflectionFourierTransform::constructor_arg_types[];
	constexpr uint16_t ReflectionFourierTransform::constructor_arg_names[];
	constexpr uint16_t ReflectionFourierTransform::function_names[];
	constexpr uint16_t ReflectionFourierTransform::function_types[];
	constexpr uint16_t ReflectionFourierTransform::function_bases[];
	constexpr uint16_t ReflectionFourierTransform::function_arg_types[];
	constexpr uint16_t ReflectionFourierTransform::function_arg_names[];
	static ReflectionFourierTransform reflection_fourier_transform;
	
	// Tellusim::TensorGraph
	class ReflectionTensorGraph : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return TensorGraph::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<TensorGraph, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<TensorGraph>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionVoidImpl<void(TensorGraph::*)()>(&TensorGraph::clear));
					case 1: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)() const>(&TensorGraph::isCreated));
					case 2: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)(const Device&, TensorGraph::Flags, TensorGraph::Masks, Async*)>(&TensorGraph::create, Device::null, TensorGraph::FlagsAll, TensorGraph::MasksAll, nullptr));
					case 3: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)(Compute&, TensorGraph::Operation, const Tensor&, TensorGraph::Flags) const>(&TensorGraph::dispatch, Compute::null, (TensorGraph::Operation)0, {}, TensorGraph::FlagNone));
					case 4: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)(Compute&, TensorGraph::Operation, Tensor&, const Tensor&, TensorGraph::Flags) const>(&TensorGraph::dispatch, Compute::null, (TensorGraph::Operation)0, {}, {}, TensorGraph::FlagNone));
					case 5: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)(Compute&, TensorGraph::Operation, Tensor&, const Tensor&, const Tensor&, TensorGraph::Flags) const>(&TensorGraph::dispatch, Compute::null, (TensorGraph::Operation)0, {}, {}, {}, TensorGraph::FlagNone));
					case 6: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)(Compute&, TensorGraph::Operation, Tensor&, const Tensor&, const Tensor&, const Tensor&, TensorGraph::Flags) const>(&TensorGraph::dispatch, Compute::null, (TensorGraph::Operation)0, {}, {}, {}, {}, TensorGraph::FlagNone));
					case 7: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)(Compute&, const Tensor&, Texture&, const Region&, const Slice&) const>(&TensorGraph::dispatch, Compute::null, {}, Texture::null, {}, Slice()));
					case 8: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)(Compute&, const Tensor&, Texture&, const Slice&) const>(&TensorGraph::dispatch, Compute::null, {}, Texture::null, Slice()));
					case 9: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)(Compute&, Texture&, const Tensor&, const Region&, const Slice&) const>(&TensorGraph::dispatch, Compute::null, Texture::null, {}, {}, Slice()));
					case 10: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)(Compute&, Texture&, const Tensor&, const Slice&) const>(&TensorGraph::dispatch, Compute::null, Texture::null, {}, Slice()));
					case 11: return FunctionPtr(new FunctionImpl<TensorGraph(TensorGraph::*)() const>(&TensorGraph::clonePtr));
					case 12: return FunctionPtr(new FunctionVoidImpl<void(TensorGraph::*)()>(&TensorGraph::clearPtr));
					case 13: return FunctionPtr(new FunctionVoidImpl<void(TensorGraph::*)()>(&TensorGraph::destroyPtr));
					case 14: return FunctionPtr(new FunctionImpl<TensorGraph&(TensorGraph::*)()>(&TensorGraph::acquirePtr));
					case 15: return FunctionPtr(new FunctionImpl<TensorGraph&(TensorGraph::*)()>(&TensorGraph::unacquirePtr));
					case 16: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)() const>(&TensorGraph::isValidPtr));
					case 17: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)() const>(&TensorGraph::isOwnerPtr));
					case 18: return FunctionPtr(new FunctionImpl<bool(TensorGraph::*)() const>(&TensorGraph::isConstPtr));
					case 19: return FunctionPtr(new FunctionImpl<uint32_t(TensorGraph::*)() const>(&TensorGraph::getCountPtr));
					case 20: return FunctionPtr(new FunctionImpl<const void*(TensorGraph::*)() const>(&TensorGraph::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 5, 904, 24, 1113, 1113, 1113, 1113, 1113, 1113, 1113, 1113, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 6, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 2914, 2914, 2914, 2914, 2914, 2914, 2914, 2914, 2914, 2914 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 4, 8, 13, 19, 26, 31, 35, 40, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44, 44 };
			static constexpr uint16_t function_arg_types[] = { 2099, 2915, 2916, 417, 2801, 2918, 2919, 2915, 2801, 2918, 2920, 2919, 2915, 2801, 2918, 2920, 2919, 2919, 2915, 2801, 2918, 2920, 2919, 2919, 2919, 2915, 2801, 2919, 994, 429, 405, 2801, 2919, 994, 405, 2801, 994, 2919, 429, 405, 2801, 994, 2919, 405 };
			static constexpr uint16_t function_arg_names[] = { 28, 338, 2917, 418, 2802, 1501, 86, 338, 2802, 1501, 86, 2921, 338, 2802, 1501, 86, 2921, 2922, 338, 2802, 1501, 86, 2921, 2922, 2923, 338, 2802, 86, 90, 430, 406, 2802, 86, 90, 406, 2802, 86, 90, 430, 406, 2802, 86, 90, 406 };
	};
	constexpr uint16_t ReflectionTensorGraph::constructor_bases[];
	constexpr uint16_t ReflectionTensorGraph::constructor_arg_types[];
	constexpr uint16_t ReflectionTensorGraph::constructor_arg_names[];
	constexpr uint16_t ReflectionTensorGraph::function_names[];
	constexpr uint16_t ReflectionTensorGraph::function_types[];
	constexpr uint16_t ReflectionTensorGraph::function_bases[];
	constexpr uint16_t ReflectionTensorGraph::function_arg_types[];
	constexpr uint16_t ReflectionTensorGraph::function_arg_names[];
	static ReflectionTensorGraph reflection_tensor_graph;
	
	// Tellusim::Desktop
	class ReflectionDesktop : public ReflectionImpl {
		public:
			virtual const char *getName() const {
				return Desktop::getClassNamePtr();
			}
			virtual const Reflection *getBase() const {
				return nullptr;
			}
			virtual uint32_t getNumConstructors() const {
				return TS_COUNTOF(constructor_bases) - 1;
			}
			virtual uint32_t getNumConstructorArgs(uint32_t index) const {
				return constructor_bases[index + 1] - constructor_bases[index];
			}
			virtual const char *getConstructorArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_types[constructor_bases[index] + arg]];
			}
			virtual const char *getConstructorArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[constructor_arg_names[constructor_bases[index] + arg]];
			}
			virtual ConstructorPtr getConstructor(uint32_t index) const {
				switch(index) {
					case 0: return ConstructorPtr(new ConstructorImpl<Desktop, TypeList<>>());
				}
				return ReflectionImpl::getConstructor(index);
			}
			virtual DestructorPtr getDestructor() const {
				return DestructorPtr(new DestructorImpl<Desktop>());
			}
			virtual uint32_t getNumFunctions() const {
				return TS_COUNTOF(function_bases) - 1;
			}
			virtual const char *getFunctionName(uint32_t index) const {
				return reflection_names[function_names[index]];
			}
			virtual const char *getFunctionType(uint32_t index) const {
				return reflection_names[function_types[index]];
			}
			virtual uint32_t getNumFunctionArgs(uint32_t index) const {
				return function_bases[index + 1] - function_bases[index];
			}
			virtual const char *getFunctionArgType(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_types[function_bases[index] + arg]];
			}
			virtual const char *getFunctionArgName(uint32_t index, uint32_t arg) const {
				return reflection_names[function_arg_names[function_bases[index] + arg]];
			}
			virtual FunctionPtr getFunction(uint32_t index) const {
				switch(index) {
					case 0: return FunctionPtr(new FunctionImpl<bool(Desktop::*)()>(&Desktop::update));
					case 1: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)() const>(&Desktop::getWidth));
					case 2: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)() const>(&Desktop::getHeight));
					case 3: return FunctionPtr(new FunctionImpl<int32_t(Desktop::*)() const>(&Desktop::getPositionX));
					case 4: return FunctionPtr(new FunctionImpl<int32_t(Desktop::*)() const>(&Desktop::getPositionY));
					case 5: return FunctionPtr(new FunctionImpl<float32_t(Desktop::*)() const>(&Desktop::getScale));
					case 6: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)() const>(&Desktop::getNumScreens));
					case 7: return FunctionPtr(new FunctionImpl<String(Desktop::*)(uint32_t) const>(&Desktop::getScreenName));
					case 8: return FunctionPtr(new FunctionImpl<String(Desktop::*)(uint32_t) const>(&Desktop::getScreenDevice));
					case 9: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(uint32_t) const>(&Desktop::getScreenWidth));
					case 10: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(uint32_t) const>(&Desktop::getScreenHeight));
					case 11: return FunctionPtr(new FunctionImpl<int32_t(Desktop::*)(uint32_t) const>(&Desktop::getScreenPositionX));
					case 12: return FunctionPtr(new FunctionImpl<int32_t(Desktop::*)(uint32_t) const>(&Desktop::getScreenPositionY));
					case 13: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(uint32_t) const>(&Desktop::getScreenFrequency));
					case 14: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(uint32_t) const>(&Desktop::getNumModes));
					case 15: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(uint32_t, uint32_t) const>(&Desktop::getModeWidth));
					case 16: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(uint32_t, uint32_t) const>(&Desktop::getModeHeight));
					case 17: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(uint32_t, uint32_t, uint32_t) const>(&Desktop::getModeIndex));
					case 18: return FunctionPtr(new FunctionImpl<bool(Desktop::*)(uint32_t, uint32_t, uint32_t)>(&Desktop::setMode));
					case 19: return FunctionPtr(new FunctionImpl<bool(Desktop::*)(uint32_t)>(&Desktop::restoreMode));
					case 20: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(uint32_t) const>(&Desktop::getWidth));
					case 21: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(uint32_t) const>(&Desktop::getHeight));
					case 22: return FunctionPtr(new FunctionImpl<int32_t(Desktop::*)(uint32_t) const>(&Desktop::getPositionX));
					case 23: return FunctionPtr(new FunctionImpl<int32_t(Desktop::*)(uint32_t) const>(&Desktop::getPositionY));
					case 24: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)(int32_t, int32_t) const>(&Desktop::getScreenIndex));
					case 25: return FunctionPtr(new FunctionImpl<bool(Desktop::*)(int32_t, int32_t) const>(&Desktop::setMouse));
					case 26: return FunctionPtr(new FunctionImpl<bool(Desktop::*)(int32_t&, int32_t&) const>(&Desktop::getMouse));
					case 27: return FunctionPtr(new FunctionImpl<Desktop(Desktop::*)() const>(&Desktop::clonePtr));
					case 28: return FunctionPtr(new FunctionVoidImpl<void(Desktop::*)()>(&Desktop::clearPtr));
					case 29: return FunctionPtr(new FunctionVoidImpl<void(Desktop::*)()>(&Desktop::destroyPtr));
					case 30: return FunctionPtr(new FunctionImpl<Desktop&(Desktop::*)()>(&Desktop::acquirePtr));
					case 31: return FunctionPtr(new FunctionImpl<Desktop&(Desktop::*)()>(&Desktop::unacquirePtr));
					case 32: return FunctionPtr(new FunctionImpl<bool(Desktop::*)() const>(&Desktop::isValidPtr));
					case 33: return FunctionPtr(new FunctionImpl<bool(Desktop::*)() const>(&Desktop::isOwnerPtr));
					case 34: return FunctionPtr(new FunctionImpl<bool(Desktop::*)() const>(&Desktop::isConstPtr));
					case 35: return FunctionPtr(new FunctionImpl<uint32_t(Desktop::*)() const>(&Desktop::getCountPtr));
					case 36: return FunctionPtr(new FunctionImpl<const void*(Desktop::*)() const>(&Desktop::getInternalPtr));
				}
				return ReflectionImpl::getFunction(index);
			}
		private:
			static constexpr uint16_t constructor_bases[] = { 0, 0 };
			static constexpr uint16_t constructor_arg_types[] = { 0 };
			static constexpr uint16_t constructor_arg_names[] = { 0 };
			static constexpr uint16_t function_names[] = { 1083, 11, 12, 1976, 1977, 761, 2925, 2926, 2927, 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2114, 2937, 11, 12, 1976, 1977, 2938, 1980, 2383, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67 };
			static constexpr uint16_t function_types[] = { 21, 10, 10, 1, 1, 123, 10, 16, 16, 10, 10, 1, 1, 10, 10, 10, 10, 10, 21, 21, 10, 10, 1, 1, 10, 21, 21, 2924, 2924, 2924, 2924, 2924, 2924, 2924, 2924, 2924, 2924 };
			static constexpr uint16_t function_bases[] = { 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 15, 18, 19, 20, 21, 22, 23, 25, 27, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 };
			static constexpr uint16_t function_arg_types[] = { 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1, 1, 1, 1, 2939, 2939 };
			static constexpr uint16_t function_arg_names[] = { 274, 274, 274, 274, 274, 274, 274, 274, 274, 185, 274, 185, 274, 30, 31, 274, 30, 31, 274, 274, 274, 274, 274, 1973, 1974, 1973, 1974, 1973, 1974 };
	};
	constexpr uint16_t ReflectionDesktop::constructor_bases[];
	constexpr uint16_t ReflectionDesktop::constructor_arg_types[];
	constexpr uint16_t ReflectionDesktop::constructor_arg_names[];
	constexpr uint16_t ReflectionDesktop::function_names[];
	constexpr uint16_t ReflectionDesktop::function_types[];
	constexpr uint16_t ReflectionDesktop::function_bases[];
	constexpr uint16_t ReflectionDesktop::function_arg_types[];
	constexpr uint16_t ReflectionDesktop::function_arg_names[];
	static ReflectionDesktop reflection_desktop;
	
	// Tellusim::Reflection
	static SpinLock reflection_lock;
	static Map<const char*, Reflection*> reflection_instances;
	const Reflection *Reflection::get(const char *name) {
		AtomicLock atomic(reflection_lock);
		if(!reflection_instances) reflection_instances = {
			{ App::getClassNamePtr(), &reflection_app },
			{ Async::getClassNamePtr(), &reflection_async },
			{ Stream::getClassNamePtr(), &reflection_stream },
			{ Blob::getClassNamePtr(), &reflection_blob },
			{ File::getClassNamePtr(), &reflection_file },
			{ Socket::getClassNamePtr(), &reflection_socket },
			{ SocketSSL::getClassNamePtr(), &reflection_socket_ssl },
			{ Source::getClassNamePtr(), &reflection_source },
			{ Date::getClassNamePtr(), &reflection_date },
			{ Info::getClassNamePtr(), &reflection_info },
			{ Directory::getClassNamePtr(), &reflection_directory },
			{ Archive::getClassNamePtr(), &reflection_archive },
			{ Image::getClassNamePtr(), &reflection_image },
			{ MeshNode::getClassNamePtr(), &reflection_mesh_node },
			{ MeshIndices::getClassNamePtr(), &reflection_mesh_indices },
			{ MeshAttribute::getClassNamePtr(), &reflection_mesh_attribute },
			{ MeshJoint::getClassNamePtr(), &reflection_mesh_joint },
			{ MeshMaterial::getClassNamePtr(), &reflection_mesh_material },
			{ MeshGeometry::getClassNamePtr(), &reflection_mesh_geometry },
			{ MeshTransform::getClassNamePtr(), &reflection_mesh_transform },
			{ MeshAnimation::getClassNamePtr(), &reflection_mesh_animation },
			{ MeshAttachment::getClassNamePtr(), &reflection_mesh_attachment },
			{ Mesh::getClassNamePtr(), &reflection_mesh },
			{ Json::getClassNamePtr(), &reflection_json },
			{ Xml::getClassNamePtr(), &reflection_xml },
			{ Buffer::getClassNamePtr(), &reflection_buffer },
			{ BufferTable::getClassNamePtr(), &reflection_buffer_table },
			{ D3D12Buffer::getClassNamePtr(), &reflection_d3d12_buffer },
			{ D3D11Buffer::getClassNamePtr(), &reflection_d3d11_buffer },
			{ MTLBuffer::getClassNamePtr(), &reflection_mtl_buffer },
			{ VKBuffer::getClassNamePtr(), &reflection_vk_buffer },
			{ GLBuffer::getClassNamePtr(), &reflection_gl_buffer },
			{ GLESBuffer::getClassNamePtr(), &reflection_gles_buffer },
			{ CUBuffer::getClassNamePtr(), &reflection_cu_buffer },
			{ HIPBuffer::getClassNamePtr(), &reflection_hip_buffer },
			{ FUBuffer::getClassNamePtr(), &reflection_fu_buffer },
			{ Command::getClassNamePtr(), &reflection_command },
			{ D3D12Command::getClassNamePtr(), &reflection_d3d12_command },
			{ MTLCommand::getClassNamePtr(), &reflection_mtl_command },
			{ VKCommand::getClassNamePtr(), &reflection_vk_command },
			{ FUCommand::getClassNamePtr(), &reflection_fu_command },
			{ Compute::getClassNamePtr(), &reflection_compute },
			{ D3D12Compute::getClassNamePtr(), &reflection_d3d12_compute },
			{ MTLCompute::getClassNamePtr(), &reflection_mtl_compute },
			{ VKCompute::getClassNamePtr(), &reflection_vk_compute },
			{ FUCompute::getClassNamePtr(), &reflection_fu_compute },
			{ Context::getClassNamePtr(), &reflection_context },
			{ D3D12Context::getClassNamePtr(), &reflection_d3d12_context },
			{ D3D11Context::getClassNamePtr(), &reflection_d3d11_context },
			{ MTLContext::getClassNamePtr(), &reflection_mtl_context },
			{ VKContext::getClassNamePtr(), &reflection_vk_context },
			{ GLContext::getClassNamePtr(), &reflection_gl_context },
			{ GLESContext::getClassNamePtr(), &reflection_gles_context },
			{ WGContext::getClassNamePtr(), &reflection_wg_context },
			{ CUContext::getClassNamePtr(), &reflection_cu_context },
			{ HIPContext::getClassNamePtr(), &reflection_hip_context },
			{ Query::getClassNamePtr(), &reflection_query },
			{ FUQuery::getClassNamePtr(), &reflection_fu_query },
			{ Fence::getClassNamePtr(), &reflection_fence },
			{ VKFence::getClassNamePtr(), &reflection_vk_fence },
			{ FUFence::getClassNamePtr(), &reflection_fu_fence },
			{ Shader::getClassNamePtr(), &reflection_shader },
			{ ShaderCompiler::getClassNamePtr(), &reflection_shader_compiler },
			{ D3D12Shader::getClassNamePtr(), &reflection_d3d12_shader },
			{ D3D11Shader::getClassNamePtr(), &reflection_d3d11_shader },
			{ MTLShader::getClassNamePtr(), &reflection_mtl_shader },
			{ VKShader::getClassNamePtr(), &reflection_vk_shader },
			{ GLShader::getClassNamePtr(), &reflection_gl_shader },
			{ GLESShader::getClassNamePtr(), &reflection_gles_shader },
			{ CUShader::getClassNamePtr(), &reflection_cu_shader },
			{ HIPShader::getClassNamePtr(), &reflection_hip_shader },
			{ FUShader::getClassNamePtr(), &reflection_fu_shader },
			{ Sampler::getClassNamePtr(), &reflection_sampler },
			{ MTLSampler::getClassNamePtr(), &reflection_mtl_sampler },
			{ FUSampler::getClassNamePtr(), &reflection_fu_sampler },
			{ Texture::getClassNamePtr(), &reflection_texture },
			{ TextureTable::getClassNamePtr(), &reflection_texture_table },
			{ D3D12Texture::getClassNamePtr(), &reflection_d3d12_texture },
			{ D3D11Texture::getClassNamePtr(), &reflection_d3d11_texture },
			{ MTLTexture::getClassNamePtr(), &reflection_mtl_texture },
			{ VKTexture::getClassNamePtr(), &reflection_vk_texture },
			{ GLTexture::getClassNamePtr(), &reflection_gl_texture },
			{ GLESTexture::getClassNamePtr(), &reflection_gles_texture },
			{ CUTexture::getClassNamePtr(), &reflection_cu_texture },
			{ HIPTexture::getClassNamePtr(), &reflection_hip_texture },
			{ FUTexture::getClassNamePtr(), &reflection_fu_texture },
			{ Tracing::getClassNamePtr(), &reflection_tracing },
			{ D3D12Tracing::getClassNamePtr(), &reflection_d3d12_tracing },
			{ MTLTracing::getClassNamePtr(), &reflection_mtl_tracing },
			{ VKTracing::getClassNamePtr(), &reflection_vk_tracing },
			{ FUTracing::getClassNamePtr(), &reflection_fu_tracing },
			{ Target::getClassNamePtr(), &reflection_target },
			{ D3D12Target::getClassNamePtr(), &reflection_d3d12_target },
			{ D3D11Target::getClassNamePtr(), &reflection_d3d11_target },
			{ MTLTarget::getClassNamePtr(), &reflection_mtl_target },
			{ VKTarget::getClassNamePtr(), &reflection_vk_target },
			{ GLTarget::getClassNamePtr(), &reflection_gl_target },
			{ GLESTarget::getClassNamePtr(), &reflection_gles_target },
			{ FUTarget::getClassNamePtr(), &reflection_fu_target },
			{ Device::getClassNamePtr(), &reflection_device },
			{ D3D12Device::getClassNamePtr(), &reflection_d3d12_device },
			{ D3D11Device::getClassNamePtr(), &reflection_d3d11_device },
			{ MTLDevice::getClassNamePtr(), &reflection_mtl_device },
			{ VKDevice::getClassNamePtr(), &reflection_vk_device },
			{ FUDevice::getClassNamePtr(), &reflection_fu_device },
			{ Kernel::getClassNamePtr(), &reflection_kernel },
			{ D3D12Kernel::getClassNamePtr(), &reflection_d3d12_kernel },
			{ MTLKernel::getClassNamePtr(), &reflection_mtl_kernel },
			{ FUKernel::getClassNamePtr(), &reflection_fu_kernel },
			{ Pipeline::getClassNamePtr(), &reflection_pipeline },
			{ D3D12Pipeline::getClassNamePtr(), &reflection_d3d12_pipeline },
			{ MTLPipeline::getClassNamePtr(), &reflection_mtl_pipeline },
			{ FUPipeline::getClassNamePtr(), &reflection_fu_pipeline },
			{ Traversal::getClassNamePtr(), &reflection_traversal },
			{ D3D12Traversal::getClassNamePtr(), &reflection_d3d12_traversal },
			{ FUTraversal::getClassNamePtr(), &reflection_fu_traversal },
			{ Surface::getClassNamePtr(), &reflection_surface },
			{ D3D12Surface::getClassNamePtr(), &reflection_d3d12_surface },
			{ D3D11Surface::getClassNamePtr(), &reflection_d3d11_surface },
			{ MTLSurface::getClassNamePtr(), &reflection_mtl_surface },
			{ VKSurface::getClassNamePtr(), &reflection_vk_surface },
			{ GLSurface::getClassNamePtr(), &reflection_gl_surface },
			{ GLESSurface::getClassNamePtr(), &reflection_gles_surface },
			{ Window::getClassNamePtr(), &reflection_window },
			{ Font::getClassNamePtr(), &reflection_font },
			{ CanvasElement::getClassNamePtr(), &reflection_canvas_element },
			{ CanvasText::getClassNamePtr(), &reflection_canvas_text },
			{ CanvasMesh::getClassNamePtr(), &reflection_canvas_mesh },
			{ CanvasRect::getClassNamePtr(), &reflection_canvas_rect },
			{ CanvasTriangle::getClassNamePtr(), &reflection_canvas_triangle },
			{ CanvasEllipse::getClassNamePtr(), &reflection_canvas_ellipse },
			{ CanvasShape::getClassNamePtr(), &reflection_canvas_shape },
			{ CanvasStrip::getClassNamePtr(), &reflection_canvas_strip },
			{ Canvas::getClassNamePtr(), &reflection_canvas },
			{ Control::getClassNamePtr(), &reflection_control },
			{ ControlRoot::getClassNamePtr(), &reflection_control_root },
			{ ControlText::getClassNamePtr(), &reflection_control_text },
			{ ControlRect::getClassNamePtr(), &reflection_control_rect },
			{ ControlGrid::getClassNamePtr(), &reflection_control_grid },
			{ ControlGroup::getClassNamePtr(), &reflection_control_group },
			{ ControlPanel::getClassNamePtr(), &reflection_control_panel },
			{ ControlDialog::getClassNamePtr(), &reflection_control_dialog },
			{ ControlWindow::getClassNamePtr(), &reflection_control_window },
			{ ControlCheck::getClassNamePtr(), &reflection_control_check },
			{ ControlCombo::getClassNamePtr(), &reflection_control_combo },
			{ ControlButton::getClassNamePtr(), &reflection_control_button },
			{ ControlSlider::getClassNamePtr(), &reflection_control_slider },
			{ ControlScroll::getClassNamePtr(), &reflection_control_scroll },
			{ ControlSplit::getClassNamePtr(), &reflection_control_split },
			{ ControlArea::getClassNamePtr(), &reflection_control_area },
			{ ControlTree::getClassNamePtr(), &reflection_control_tree },
			{ ControlEdit::getClassNamePtr(), &reflection_control_edit },
			{ DialogMessage::getClassNamePtr(), &reflection_dialog_message },
			{ DialogFileOpen::getClassNamePtr(), &reflection_dialog_file_open },
			{ DialogFileSave::getClassNamePtr(), &reflection_dialog_file_save },
			{ DialogDirectory::getClassNamePtr(), &reflection_dialog_directory },
			{ DialogProgress::getClassNamePtr(), &reflection_dialog_progress },
			{ DialogColor::getClassNamePtr(), &reflection_dialog_color },
			{ DialogMenu::getClassNamePtr(), &reflection_dialog_menu },
			{ CubeFilter::getClassNamePtr(), &reflection_cube_filter },
			{ DecoderJPEG::getClassNamePtr(), &reflection_decoder_jpeg },
			{ EncoderBC15::getClassNamePtr(), &reflection_encoder_bc15 },
			{ EncoderBC67::getClassNamePtr(), &reflection_encoder_bc67 },
			{ EncoderASTC::getClassNamePtr(), &reflection_encoder_astc },
			{ MeshModel::getClassNamePtr(), &reflection_mesh_model },
			{ SeparableFilter::getClassNamePtr(), &reflection_separable_filter },
			{ PrefixScan::getClassNamePtr(), &reflection_prefix_scan },
			{ RadixSort::getClassNamePtr(), &reflection_radix_sort },
			{ BitonicSort::getClassNamePtr(), &reflection_bitonic_sort },
			{ SpatialGrid::getClassNamePtr(), &reflection_spatial_grid },
			{ SpatialTree::getClassNamePtr(), &reflection_spatial_tree },
			{ FourierTransform::getClassNamePtr(), &reflection_fourier_transform },
			{ TensorGraph::getClassNamePtr(), &reflection_tensor_graph },
			{ Desktop::getClassNamePtr(), &reflection_desktop },
		};
		auto it = reflection_instances.find(name);
		if(!it) it = reflection_instances.find(String(name));
		if(it) return it->data;
		TS_LOGF(Error, "Reflection::get(): can't find \"%s\"\n", name);
		return nullptr;
	}
}
