vgpu

package

Go to main page

Versions in this module

v0

v0.3.2

Aug 17, 2024

Changes in this version

type Types

+ const Depth24Stencil8

+ const UndefinedType

v0.3.1

Aug 2, 2024

v0.3.0

Jul 24, 2024

v0.2.3

Jul 16, 2024

v0.2.2

Jul 14, 2024

v0.2.1

Jul 14, 2024

v0.2.0

Jun 20, 2024

Changes in this version

type VarSet

+ NTextures int

type Vars

+ NTextures int

v0.1.4

Jun 1, 2024

v0.1.3

May 5, 2024

v0.1.2

May 1, 2024

v0.1.1

May 1, 2024

v0.1.0

Apr 14, 2024

v0.0.10

Apr 14, 2024

Changes in this version

+ func ImageSRGBFromLinear(img *image.RGBA) *image.RGBA

+ func SRGBFromLinear(rl, gl, bl float32) (r, g, b float32)

+ func SRGBFromLinearComp(lin float32) float32

+ func SetImageSRGBFromLinear(img *image.RGBA)

type BuffTypes

+ const VtxIndexBuff

type GPU

+ GPUProperties vk.PhysicalDeviceProperties

+ MemoryProperties vk.PhysicalDeviceMemoryProperties

+ func (gp *GPU) PropertiesString(print bool) string

type Image

+ func (im *Image) ConfigValueHost(buff *MemBuff, buffPtr unsafe.Pointer, offset int)

+ func (im *Image) IsValue() bool

type ImageFlags

+ const ImageIsValue

type MemReg

+ BuffIndex int

type Memory

+ func (mm *Memory) CmdTransferRegsFromGPU(cmd vk.CommandBuffer, buff *MemBuff, regs []MemReg)

+ func (mm *Memory) CmdTransferStorageBuffRegsFromGPU(cmd vk.CommandBuffer, buff *MemBuff, buffIndex int, regs []MemReg)

+ func (mm *Memory) CmdTransferStorageRegsFromGPU(cmd vk.CommandBuffer, regs []MemReg)

+ func (mm *Memory) SyncRegionValueIndex(set int, varNm string, valIndex int) (MemReg, error)

+ func (mm *Memory) SyncRegionValueName(set int, varNm, valNm string) (MemReg, error)

+ func (mm *Memory) SyncStorageRegionsFromGPU(regs ...MemReg)

+ func (mm *Memory) SyncValueIndexFromGPU(set int, varNm string, valIndex int) error

+ func (mm *Memory) SyncValueNameFromGPU(set int, varNm, valNm string) error

+ func (mm *Memory) SyncValuesTextures(buff *MemBuff)

+ func (mm *Memory) TransferAllValuesTextures(buff *MemBuff)

+ func (mm *Memory) TransferImagesFromGPU(buff vk.Buffer, imgs ...*Image)

+ func (mm *Memory) TransferRegsFromGPU(regs []MemReg)

+ func (mm *Memory) TransferStorageRegsFromGPU(regs []MemReg)

type Render

+ ClearValues []vk.ClearValue

type System

+ func (sy *System) CmdBindTextureVarIndex(cmd vk.CommandBuffer, setIndex int, varNm string, valIndex int) (txIndex, descIndex int, switched bool, err error)

+ func (sy *System) ComputeCopyFromGPU(cmd vk.CommandBuffer, regs ...MemReg)

type Types

+ const Float32Matrix3

+ const Float32Matrix4

+ const Float32Vector2

+ const Float32Vector3

+ const Float32Vector4

+ const Float64Vector2

+ const Float64Vector3

+ const Float64Vector4

+ const Int32Vector2

+ const Int32Vector4

+ const Uint32Vector2

+ const Uint32Vector4

+ type Value struct

+ AllocSize int

+ ElSize int

+ Flags ValueFlags

+ Index int

+ MemPtr unsafe.Pointer

+ N int

+ Name string

+ Offset int

+ Texture *Texture

+ func (vl *Value) AllocHost(vr *Var, buff *MemBuff, buffPtr unsafe.Pointer, offset int) int

+ func (vl *Value) Bytes() []byte

+ func (vl *Value) ClearMod()

+ func (vl *Value) CopyFromBytes(srcPtr unsafe.Pointer)

+ func (vl *Value) CopyToBytes(srcPtr unsafe.Pointer)

+ func (vl *Value) Floats32() math32.ArrayF32

+ func (vl *Value) Free()

+ func (vl *Value) HasFlag(flag ValueFlags) bool

+ func (vl *Value) Init(gp *GPU, vr *Var, idx int)

+ func (vl *Value) IsMod() bool

+ func (vl *Value) MemReg(vr *Var) MemReg

+ func (vl *Value) MemSize(vr *Var) int

+ func (vl *Value) PaddedArrayCheck() error

+ func (vl *Value) SetFlag(on bool, flag ...enums.BitFlag)

+ func (vl *Value) SetGoImage(img image.Image, layer int, flipY bool) error

+ func (vl *Value) SetMod()

+ func (vl *Value) UInts32() math32.ArrayU32

+ type ValueFlags int64

+ const ValueFlagsN

+ const ValueMod

+ const ValuePaddedArray

+ const ValueTextureOwns

+ func ValueFlagsValues() []ValueFlags

+ func (i *ValueFlags) SetFlag(on bool, f ...enums.BitFlag)

+ func (i *ValueFlags) SetInt64(in int64)

+ func (i *ValueFlags) SetString(s string) error

+ func (i *ValueFlags) SetStringOr(s string) error

+ func (i *ValueFlags) UnmarshalText(text []byte) error

+ func (i ValueFlags) BitIndexString() string

+ func (i ValueFlags) Desc() string

+ func (i ValueFlags) HasFlag(f enums.BitFlag) bool

+ func (i ValueFlags) Int64() int64

+ func (i ValueFlags) MarshalText() ([]byte, error)

+ func (i ValueFlags) String() string

+ func (i ValueFlags) Values() []enums.Enum

+ type Values struct

+ GpTexValues []*Value

+ NameMap map[string]*Value

+ TexSzAlloc szalloc.SzAlloc

+ Values []*Value

+ func (vs *Values) ActiveValues() []*Value

+ func (vs *Values) AllocHost(vr *Var, buff *MemBuff, offset int) int

+ func (vs *Values) AllocTexBySize(gp *GPU, vr *Var)

+ func (vs *Values) AllocTextures(mm *Memory)

+ func (vs *Values) ConfigValues(gp *GPU, dev vk.Device, vr *Var, nvals int) bool

+ func (vs *Values) Destroy()

+ func (vs *Values) Free()

+ func (vs *Values) MemSize(vr *Var, alignBytes int) int

+ func (vs *Values) ModRegs(vr *Var) []MemReg

+ func (vs *Values) SetGoImage(idx int, img image.Image, flipy bool)

+ func (vs *Values) SetName(idx int, name string) (*Value, error)

+ func (vs *Values) ValueByIndexTry(idx int) (*Value, error)

+ func (vs *Values) ValueByNameTry(name string) (*Value, error)

type Var

+ BindValueIndex []int

+ DynOffIndex int

+ Values Values

+ func (vr *Var) BindValue(descIndex int) (*Value, error)

+ func (vr *Var) TextureValidIndex(stIndex, idx int) int

+ func (vr *Var) ValuesMemSize(alignBytes int) int

type VarList

+ func (vs *VarList) ValueByIndexTry(varName string, valIndex int) (*Var, *Value, error)

+ func (vs *VarList) ValueByNameTry(varName, valName string) (*Var, *Value, error)

type VarSet

+ NValuesPer int

+ func (st *VarSet) BindDynValue(vs *Vars, vr *Var, vl *Value) error

+ func (st *VarSet) BindDynValueIndex(vs *Vars, varNm string, valIndex int) error

+ func (st *VarSet) BindDynValueName(vs *Vars, varNm, valNm string) error

+ func (st *VarSet) BindDynValuesAllIndex(vs *Vars, idx int)

+ func (st *VarSet) ConfigValues(nvals int)

+ func (st *VarSet) TextureGroupSizeIndexes(vs *Vars, varNm string, valIndex int) *szalloc.Indexes

type Vars

+ BindDescIndex int

+ VkWriteValues []vk.WriteDescriptorSet

+ func (vs *Vars) BindDynValuesAllIndex(idx int)

+ func (vs *Vars) BindDynamicValue(set int, vr *Var, vl *Value) error

+ func (vs *Vars) BindDynamicValueIndex(set int, varNm string, valIndex int) error

+ func (vs *Vars) BindDynamicValueName(set int, varNm, valNm string) error

+ func (vs *Vars) BindVertexValueIndex(varNm string, valIndex int) error

+ func (vs *Vars) BindVertexValueName(varNm, valNm string) error

+ func (vs *Vars) TextureGroupSizeIndexes(set int, varNm string, valIndex int) *szalloc.Indexes

+ func (vs *Vars) ValueByIndexTry(set int, varName string, valIndex int) (*Var, *Value, error)

+ func (vs *Vars) ValueByNameTry(set int, varName, valName string) (*Var, *Value, error)

v0.0.9

Mar 20, 2024

v0.0.8

Mar 19, 2024

v0.0.7

Mar 1, 2024

v0.0.6

Feb 21, 2024

Changes in this version

type Surface

+ NeedsConfig bool

v0.0.5

Feb 18, 2024

v0.0.4

Feb 5, 2024

v0.0.3

Jan 25, 2024

v0.0.2

Jan 17, 2024

Changes in this version

+ const ByteCopyMemoryLimit

+ const CCW

+ const CW

+ const CullBack

+ const CullFront

+ const FlipY

+ const LineList

+ const LineListWithAdjacency

+ const LineStrip

+ const LineStripWithAdjacency

+ const MaxImageLayers

+ const MaxTexturesPerSet

+ const NoFlipY

+ const PatchList

+ const PointList

+ const PushSet

+ const TriangleFan

+ const TriangleList

+ const TriangleListWithAdjacency

+ const TriangleStrip

+ const TriangleStripWithAdjacency

+ const VertexSet

+ var BuffUsages = map[BuffTypes]vk.BufferUsageFlagBits

+ var Debug = false

+ var FormatSizes = map[vk.Format]int

+ var ImageFormatNames = map[vk.Format]string

+ var RoleBuffers = map[VarRoles]BuffTypes

+ var RoleDescriptors = map[VarRoles]vk.DescriptorType

+ var ShaderPipelineFlags = map[ShaderTypes]vk.PipelineStageFlagBits

+ var ShaderStageFlags = map[ShaderTypes]vk.ShaderStageFlagBits

+ var StaticRoleDescriptors = map[VarRoles]vk.DescriptorType

+ var VulkanBorderColors = map[BorderColors]vk.BorderColor

+ var VulkanSamplerModes = map[SamplerModes]vk.SamplerAddressMode

+ var VulkanTypes = map[Types]vk.Format

+ func AllocBuffMem(gp *GPU, dev vk.Device, buffer vk.Buffer, props vk.MemoryPropertyFlagBits) vk.DeviceMemory

+ func CheckErr(err *error)

+ func CheckExisting(actual, required []string) (existing []string, missing int)

+ func CleanString(s string) string

+ func CmdBegin(cmd vk.CommandBuffer)

+ func CmdBeginOneTime(cmd vk.CommandBuffer)

+ func CmdEnd(cmd vk.CommandBuffer)

+ func CmdEndSubmitWait(cmd vk.CommandBuffer, dev *Device)

+ func CmdReset(cmd vk.CommandBuffer)

+ func CmdResetBegin(cmd vk.CommandBuffer)

+ func CmdSubmit(cmd vk.CommandBuffer, dev *Device)

+ func CmdSubmitFence(cmd vk.CommandBuffer, dev *Device, fence vk.Fence)

+ func CmdSubmitSignal(cmd vk.CommandBuffer, dev *Device, signal vk.Semaphore, fence vk.Fence)

+ func CmdSubmitWait(cmd vk.CommandBuffer, dev *Device)

+ func CmdSubmitWaitSignal(cmd vk.CommandBuffer, dev *Device, wait, signal vk.Semaphore, fence vk.Fence)

+ func CmdWait(dev *Device)

+ func DestroyBuffer(dev vk.Device, buff *vk.Buffer)

+ func DeviceExts(gpu vk.PhysicalDevice) (names []string, err error)

+ func FindRequiredMemoryType(props vk.PhysicalDeviceMemoryProperties, ...) (uint32, bool)

+ func FindRequiredMemoryTypeFallback(props vk.PhysicalDeviceMemoryProperties, ...) (uint32, bool)

+ func FindString(str string, strs []string) int

+ func FreeBuffMem(dev vk.Device, memory *vk.DeviceMemory)

+ func HasAllStrings(s string, strs []string) bool

+ func IfPanic(err error, finalizers ...func())

+ func ImageSRGBFmLinear(img *image.RGBA) *image.RGBA

+ func ImageSRGBToLinear(img *image.RGBA) *image.RGBA

+ func ImageToRGBA(img image.Image) *image.RGBA

+ func ImgCompToUint8(val float32) uint8

+ func Init() error — darwin/amd64, linux/amd64, windows/amd64

+ func InitNoDisplay() error

+ func InstanceExts() (names []string, err error)

+ func IsError(ret vk.Result) bool

+ func MapMemory(dev vk.Device, mem vk.DeviceMemory, size int) unsafe.Pointer

+ func MapMemoryAll(dev vk.Device, mem vk.DeviceMemory) unsafe.Pointer

+ func MemSizeAlign(size, align int) int

+ func NDescForTextures(nvals int) int

+ func NewBuffer(dev vk.Device, size int, usage vk.BufferUsageFlagBits) vk.Buffer

+ func NewError(ret vk.Result) error

+ func NewEvent(dev vk.Device) vk.Event

+ func NewFence(dev vk.Device) vk.Fence

+ func NewSemaphore(dev vk.Device) vk.Semaphore

+ func NoDisplayGPU(nm string) (*GPU, *Device, error)

+ func PlatformDefaults(gp *GPU) — darwin/amd64, linux/amd64, windows/amd64

+ func SRGBFmLinear(rl, gl, bl float32) (r, g, b float32)

+ func SRGBFmLinearComp(lin float32) float32

+ func SRGBToLinear(r, g, b float32) (rl, gl, bl float32)

+ func SRGBToLinearComp(srgb float32) float32

+ func SafeString(s string) string

+ func SafeStrings(list []string) []string

+ func SetImageSRGBFmLinear(img *image.RGBA)

+ func SetImageSRGBToLinear(img *image.RGBA)

+ func SliceUint32(data []byte) []uint32

+ func Terminate() — darwin/amd64, linux/amd64, windows/amd64

+ func ValidationLayers() (names []string, err error)

+ func Warps(n, threads int) int

+ type BorderColors int32

+ const BorderBlack

+ const BorderColorsN

+ const BorderTrans

+ const BorderWhite

+ func BorderColorsValues() []BorderColors

+ func (bc BorderColors) VkColor() vk.BorderColor

+ func (i *BorderColors) SetInt64(in int64)

+ func (i *BorderColors) SetString(s string) error

+ func (i *BorderColors) UnmarshalText(text []byte) error

+ func (i BorderColors) Desc() string

+ func (i BorderColors) Int64() int64

+ func (i BorderColors) IsValid() bool

+ func (i BorderColors) MarshalText() ([]byte, error)

+ func (i BorderColors) String() string

+ func (i BorderColors) Values() []enums.Enum

+ type BuffTypes int32

+ const BuffTypesN

+ const StorageBuff

+ const TextureBuff

+ const UniformBuff

+ const VtxIdxBuff

+ func BuffTypesValues() []BuffTypes

+ func (bt BuffTypes) AlignBytes(gp *GPU) int

+ func (bt BuffTypes) IsReadOnly() bool

+ func (i *BuffTypes) SetInt64(in int64)

+ func (i *BuffTypes) SetString(s string) error

+ func (i *BuffTypes) UnmarshalText(text []byte) error

+ func (i BuffTypes) Desc() string

+ func (i BuffTypes) Int64() int64

+ func (i BuffTypes) IsValid() bool

+ func (i BuffTypes) MarshalText() ([]byte, error)

+ func (i BuffTypes) String() string

+ func (i BuffTypes) Values() []enums.Enum

+ type CPUOptions int32

+ const CPUOptionsN

+ const OptAlphaToOne

+ const OptDepthBiasClamp

+ const OptDepthBounds

+ const OptDepthClamp

+ const OptDrawIndirectFirstInstance

+ const OptDualSrcBlend

+ const OptFillModeNonSolid

+ const OptFragmentStoresAndAtomics

+ const OptFullDrawIndexUint32

+ const OptGeometryShader

+ const OptImageCubeArray

+ const OptIndependentBlend

+ const OptInheritedQueries

+ const OptLargePoints

+ const OptLogicOp

+ const OptMultiDrawIndirect

+ const OptMultiViewport

+ const OptOcclusionQueryPrecise

+ const OptPipelineStatisticsQuery

+ const OptRobustBufferAccess

+ const OptSampleRateShading

+ const OptSamplerAnisotropy

+ const OptShaderClipDistance

+ const OptShaderCullDistance

+ const OptShaderFloat64

+ const OptShaderImageGatherExtended

+ const OptShaderInt16

+ const OptShaderInt64

+ const OptShaderResourceMinLod

+ const OptShaderResourceResidency

+ const OptShaderSampledImageArrayDynamicIndexing

+ const OptShaderStorageBufferArrayDynamicIndexing

+ const OptShaderStorageImageArrayDynamicIndexing

+ const OptShaderStorageImageExtendedFormats

+ const OptShaderStorageImageMultisample

+ const OptShaderStorageImageReadWithoutFormat

+ const OptShaderStorageImageWriteWithoutFormat

+ const OptShaderTessellationAndGeometryPointSize

+ const OptShaderUniformBufferArrayDynamicIndexing

+ const OptSparseBinding

+ const OptSparseResidency16Samples

+ const OptSparseResidency2Samples

+ const OptSparseResidency4Samples

+ const OptSparseResidency8Samples

+ const OptSparseResidencyAliased

+ const OptSparseResidencyBuffer

+ const OptSparseResidencyImage2D

+ const OptSparseResidencyImage3D

+ const OptTessellationShader

+ const OptTextureCompressionASTC_LDR

+ const OptTextureCompressionBC

+ const OptTextureCompressionETC2

+ const OptVariableMultisampleRate

+ const OptVertexPipelineStoresAndAtomics

+ const OptWideLines

+ func CPUOptionsValues() []CPUOptions

+ func (i *CPUOptions) SetInt64(in int64)

+ func (i *CPUOptions) SetString(s string) error

+ func (i *CPUOptions) UnmarshalText(text []byte) error

+ func (i CPUOptions) Desc() string

+ func (i CPUOptions) Int64() int64

+ func (i CPUOptions) IsValid() bool

+ func (i CPUOptions) MarshalText() ([]byte, error)

+ func (i CPUOptions) String() string

+ func (i CPUOptions) Values() []enums.Enum

+ type CmdPool struct

+ Buff vk.CommandBuffer

+ Pool vk.CommandPool

+ func (cp *CmdPool) BeginCmd() vk.CommandBuffer

+ func (cp *CmdPool) BeginCmdOneTime() vk.CommandBuffer

+ func (cp *CmdPool) ConfigResettable(dv *Device)

+ func (cp *CmdPool) ConfigTransient(dv *Device)

+ func (cp *CmdPool) Destroy(dev vk.Device)

+ func (cp *CmdPool) EndCmd()

+ func (cp *CmdPool) EndSubmitWait(dev *Device)

+ func (cp *CmdPool) EndSubmitWaitFree(dev *Device)

+ func (cp *CmdPool) FreeBuffer(dev *Device)

+ func (cp *CmdPool) NewBuffer(dv *Device) vk.CommandBuffer

+ func (cp *CmdPool) Reset()

+ func (cp *CmdPool) Submit(dev *Device)

+ func (cp *CmdPool) SubmitWait(dev *Device)

+ type Device struct

+ Device vk.Device

+ Queue vk.Queue

+ QueueIndex uint32

+ func NewGraphicsDevice(gp *GPU) (*Device, error)

+ func (dv *Device) Destroy()

+ func (dv *Device) DeviceWaitIdle()

+ func (dv *Device) FindQueue(gp *GPU, flags vk.QueueFlagBits) error

+ func (dv *Device) Init(gp *GPU, flags vk.QueueFlagBits) error

+ func (dv *Device) MakeDevice(gp *GPU)

+ type Framebuffer struct

+ Format ImageFormat

+ Framebuffer vk.Framebuffer

+ HasCleared bool

+ Image Image

+ Render *Render

+ func (fb *Framebuffer) Config()

+ func (fb *Framebuffer) ConfigRender(rp *Render)

+ func (fb *Framebuffer) ConfigRenderImage(gp *GPU, dev vk.Device, fmt ImageFormat)

+ func (fb *Framebuffer) ConfigSurfaceImage(gp *GPU, dev vk.Device, fmt ImageFormat, img vk.Image)

+ func (fb *Framebuffer) CopyToImage(toImg *Image, dev vk.Device, cmd vk.CommandBuffer)

+ func (fb *Framebuffer) Destroy()

+ func (fb *Framebuffer) DestroyFrame()

+ func (fb *Framebuffer) GrabImage(dev vk.Device, cmd vk.CommandBuffer)

+ type GPU struct

+ APIVersion vk.Version

+ AppName string

+ AppVersion vk.Version

+ Compute bool

+ DebugCallback vk.DebugReportCallback

+ DeviceExts []string

+ DeviceFeaturesNeeded *vk.PhysicalDeviceVulkan12Features

+ DeviceName string

+ EnabledOpts GPUOpts

+ GPU vk.PhysicalDevice

+ GPUFeats vk.PhysicalDeviceFeatures

+ GPUProps vk.PhysicalDeviceProperties

+ Instance vk.Instance

+ InstanceExts []string

+ MaxComputeWorkGroupCount1D int

+ MemoryProps vk.PhysicalDeviceMemoryProperties

+ UserOpts *GPUOpts

+ ValidationLayers []string

+ func NewComputeGPU() *GPU

+ func NewGPU() *GPU

+ func (gp *GPU) AddDeviceExt(ext ...string) bool

+ func (gp *GPU) AddInstanceExt(ext ...string) bool

+ func (gp *GPU) AddValidationLayer(ext string) bool

+ func (gp *GPU) CheckGPUOpts(feats *vk.PhysicalDeviceFeatures, opts *GPUOpts, report bool) bool

+ func (gp *GPU) Config(name string, opts ...*GPUOpts) error

+ func (gp *GPU) Defaults(graphics bool)

+ func (gp *GPU) Destroy()

+ func (gp *GPU) GetDeviceName(props *vk.PhysicalDeviceProperties, idx int) string

+ func (gp *GPU) NewComputeSystem(name string) *System

+ func (gp *GPU) NewGraphicsSystem(name string, dev *Device) *System

+ func (gp *GPU) PropsString(print bool) string

+ func (gp *GPU) SelectGPU(gpus []vk.PhysicalDevice, gpuCount int) int

+ func (gp *GPU) SetGPUOpts(feats *vk.PhysicalDeviceFeatures, opts GPUOpts)

+ type GPUOpts map[CPUOptions]OptionStates

+ var DefaultOpts *GPUOpts

+ func NewRequiredOpts(opts ...CPUOptions) GPUOpts

+ func (co *GPUOpts) Add(opt CPUOptions, state OptionStates)

+ func (co *GPUOpts) CopyFrom(fm *GPUOpts)

+ func (co *GPUOpts) Init()

+ func (co *GPUOpts) State(opt CPUOptions) OptionStates

+ type HostImage struct

+ Buff vk.Buffer

+ Mem vk.DeviceMemory

+ Offset int

+ Ptr unsafe.Pointer

+ Size int

+ func (hi *HostImage) Pixels() []byte

+ func (hi *HostImage) SetNil()

+ type Image struct

+ Dev vk.Device

+ Flags ImageFlags

+ Format ImageFormat

+ GPU *GPU

+ Host HostImage

+ Image vk.Image

+ Mem vk.DeviceMemory

+ Name string

+ View vk.ImageView

+ func (im *Image) AllocHost()

+ func (im *Image) AllocImage()

+ func (im *Image) ConfigDepth(gp *GPU, dev vk.Device, depthType Types, imgFmt *ImageFormat)

+ func (im *Image) ConfigDepthView()

+ func (im *Image) ConfigFramebuffer(gp *GPU, dev vk.Device, imgFmt *ImageFormat)

+ func (im *Image) ConfigGoImage(sz image.Point, layers int)

+ func (im *Image) ConfigMulti(gp *GPU, dev vk.Device, imgFmt *ImageFormat)

+ func (im *Image) ConfigStdView()

+ func (im *Image) ConfigValHost(buff *MemBuff, buffPtr unsafe.Pointer, offset int)

+ func (im *Image) CopyImageRec() vk.ImageCopy

+ func (im *Image) CopyRec() vk.BufferImageCopy

+ func (im *Image) Destroy()

+ func (im *Image) DestroyView()

+ func (im *Image) DevGoImage() (*image.RGBA, error)

+ func (im *Image) DevGoImageCopy(rgba *image.RGBA) error

+ func (im *Image) FreeHost()

+ func (im *Image) FreeImage()

+ func (im *Image) GoImage(layer int) (*image.RGBA, error)

+ func (im *Image) HasFlag(flag ImageFlags) bool

+ func (im *Image) HostPixels(layer int) []byte

+ func (im *Image) IsActive() bool

+ func (im *Image) IsHostActive() bool

+ func (im *Image) IsHostOwner() bool

+ func (im *Image) IsImageOwner() bool

+ func (im *Image) IsVal() bool

+ func (im *Image) SetFlag(on bool, flag ...enums.BitFlag)

+ func (im *Image) SetGoImage(img image.Image, layer int, flipY bool) error

+ func (im *Image) SetNil()

+ func (im *Image) SetSize(size image.Point) bool

+ func (im *Image) SetVkImage(gp *GPU, dev vk.Device, img vk.Image)

+ func (im *Image) Transition(cmd vk.CommandBuffer, format vk.Format, oldLayout, newLayout vk.ImageLayout, ...)

+ func (im *Image) TransitionDstToGeneral(cmd vk.CommandBuffer)

+ func (im *Image) TransitionDstToShader(cmd vk.CommandBuffer)

+ func (im *Image) TransitionForDst(cmd vk.CommandBuffer, srcStage vk.PipelineStageFlagBits)

+ func (im *Image) UnmapDev()

+ type ImageFlags int64

+ const DepthImage

+ const FramebufferImage

+ const ImageActive

+ const ImageFlagsN

+ const ImageHostActive

+ const ImageIsVal

+ const ImageOnHostOnly

+ const ImageOwnsHost

+ const ImageOwnsImage

+ func ImageFlagsValues() []ImageFlags

+ func (i *ImageFlags) SetFlag(on bool, f ...enums.BitFlag)

+ func (i *ImageFlags) SetInt64(in int64)

+ func (i *ImageFlags) SetString(s string) error

+ func (i *ImageFlags) SetStringOr(s string) error

+ func (i *ImageFlags) UnmarshalText(text []byte) error

+ func (i ImageFlags) BitIndexString() string

+ func (i ImageFlags) Desc() string

+ func (i ImageFlags) HasFlag(f enums.BitFlag) bool

+ func (i ImageFlags) Int64() int64

+ func (i ImageFlags) IsValid() bool

+ func (i ImageFlags) MarshalText() ([]byte, error)

+ func (i ImageFlags) String() string

+ func (i ImageFlags) Values() []enums.Enum

+ type ImageFormat struct

+ Format vk.Format

+ Layers int

+ Samples vk.SampleCountFlagBits

+ Size image.Point

+ func NewImageFormat(width, height, layers int) *ImageFormat

+ func (im *ImageFormat) Aspect() float32

+ func (im *ImageFormat) Bounds() image.Rectangle

+ func (im *ImageFormat) BytesPerPixel() int

+ func (im *ImageFormat) Defaults()

+ func (im *ImageFormat) IsRGBAUnorm() bool

+ func (im *ImageFormat) IsStdRGBA() bool

+ func (im *ImageFormat) LayerByteSize() int

+ func (im *ImageFormat) NSamples() int

+ func (im *ImageFormat) Set(w, h int, ft vk.Format)

+ func (im *ImageFormat) SetFormat(ft Types)

+ func (im *ImageFormat) SetMultisample(nsamp int)

+ func (im *ImageFormat) SetSize(w, h int)

+ func (im *ImageFormat) Size32() (width, height uint32)

+ func (im *ImageFormat) Stride() int

+ func (im *ImageFormat) String() string

+ func (im *ImageFormat) TotalByteSize() int

+ type MemBuff struct

+ Active bool

+ AlignBytes int

+ Dev vk.Buffer

+ DevMem vk.DeviceMemory

+ GPU *GPU

+ Host vk.Buffer

+ HostMem vk.DeviceMemory

+ HostPtr unsafe.Pointer

+ Size int

+ Type BuffTypes

+ func (mb *MemBuff) AllocDev(dev vk.Device)

+ func (mb *MemBuff) AllocHost(dev vk.Device, bsz int) bool

+ func (mb *MemBuff) Free(dev vk.Device)

+ type MemReg struct

+ BuffIdx int

+ BuffType BuffTypes

+ Offset int

+ Size int

+ type Memory struct

+ Buffs [BuffTypesN]*MemBuff

+ CmdPool CmdPool

+ Device Device

+ GPU *GPU

+ StorageBuffs []*MemBuff

+ StorageMems []*VarMem

+ Vars Vars

+ func (mm *Memory) AllocBuffMem(buffer vk.Buffer, props vk.MemoryPropertyFlagBits) vk.DeviceMemory

+ func (mm *Memory) AllocDev()

+ func (mm *Memory) AllocDevBuff(bt BuffTypes)

+ func (mm *Memory) AllocHost()

+ func (mm *Memory) AllocHostBuff(bt BuffTypes)

+ func (mm *Memory) AllocHostStorageBuff()

+ func (mm *Memory) CmdTransferRegsFmGPU(cmd vk.CommandBuffer, buff *MemBuff, regs []MemReg)

+ func (mm *Memory) CmdTransferRegsToGPU(cmd vk.CommandBuffer, buff *MemBuff, regs []MemReg)

+ func (mm *Memory) CmdTransferStorageBuffRegsFmGPU(cmd vk.CommandBuffer, buff *MemBuff, buffIdx int, regs []MemReg)

+ func (mm *Memory) CmdTransferStorageBuffRegsToGPU(cmd vk.CommandBuffer, buff *MemBuff, buffIdx int, regs []MemReg)

+ func (mm *Memory) CmdTransferStorageRegsFmGPU(cmd vk.CommandBuffer, regs []MemReg)

+ func (mm *Memory) CmdTransferStorageRegsToGPU(cmd vk.CommandBuffer, regs []MemReg)

+ func (mm *Memory) Config(dev vk.Device)

+ func (mm *Memory) Deactivate()

+ func (mm *Memory) DeactivateBuff(bt BuffTypes)

+ func (mm *Memory) Destroy(dev vk.Device)

+ func (mm *Memory) Free() bool

+ func (mm *Memory) FreeBuff(bt BuffTypes) bool

+ func (mm *Memory) FreeBuffMem(memory *vk.DeviceMemory)

+ func (mm *Memory) Init(gp *GPU, device *Device)

+ func (mm *Memory) NewBuffer(size int, usage vk.BufferUsageFlagBits) vk.Buffer

+ func (mm *Memory) SyncRegionValIdx(set int, varNm string, valIdx int) (MemReg, error)

+ func (mm *Memory) SyncRegionValName(set int, varNm, valNm string) (MemReg, error)

+ func (mm *Memory) SyncStorageRegionsFmGPU(regs ...MemReg)

+ func (mm *Memory) SyncToGPU()

+ func (mm *Memory) SyncToGPUBuff(bt BuffTypes)

+ func (mm *Memory) SyncValIdxFmGPU(set int, varNm string, valIdx int) error

+ func (mm *Memory) SyncValNameFmGPU(set int, varNm, valNm string) error

+ func (mm *Memory) SyncValsTextures(buff *MemBuff)

+ func (mm *Memory) TransferAllValsTextures(buff *MemBuff)

+ func (mm *Memory) TransferImagesFmGPU(buff vk.Buffer, imgs ...*Image)

+ func (mm *Memory) TransferRegsFmGPU(regs []MemReg)

+ func (mm *Memory) TransferRegsToGPU(regs []MemReg)

+ func (mm *Memory) TransferStorageRegsFmGPU(regs []MemReg)

+ func (mm *Memory) TransferStorageRegsToGPU(regs []MemReg)

+ func (mm *Memory) TransferTexturesToGPU(buff vk.Buffer, imgs ...*Image)

+ func (mm *Memory) TransferToGPU()

+ func (mm *Memory) TransferToGPUBuff(bt BuffTypes)

+ type OptionStates int32

+ const Disabled

+ const Enabled

+ const OptionStatesN

+ const Optional

+ const Required

+ func OptionStatesValues() []OptionStates

+ func (i *OptionStates) SetInt64(in int64)

+ func (i *OptionStates) SetString(s string) error

+ func (i *OptionStates) UnmarshalText(text []byte) error

+ func (i OptionStates) Desc() string

+ func (i OptionStates) Int64() int64

+ func (i OptionStates) IsValid() bool

+ func (i OptionStates) MarshalText() ([]byte, error)

+ func (i OptionStates) String() string

+ func (i OptionStates) Values() []enums.Enum

+ type Pipeline struct

+ Name string

+ ShaderMap map[string]*Shader

+ Shaders []*Shader

+ Sys *System

+ VkCache vk.PipelineCache

+ VkConfig vk.GraphicsPipelineCreateInfo

+ VkPipeline vk.Pipeline

+ func (pl *Pipeline) AddShader(name string, typ ShaderTypes) *Shader

+ func (pl *Pipeline) AddShaderCode(name string, typ ShaderTypes, code []byte) *Shader

+ func (pl *Pipeline) AddShaderEmbed(name string, typ ShaderTypes, efs embed.FS, fname string) *Shader

+ func (pl *Pipeline) AddShaderFile(name string, typ ShaderTypes, fname string) *Shader

+ func (pl *Pipeline) BindDrawVertex(cmd vk.CommandBuffer, descIdx int)

+ func (pl *Pipeline) BindPipeline(cmd vk.CommandBuffer)

+ func (pl *Pipeline) ComputeDispatch(cmd vk.CommandBuffer, nx, ny, nz int)

+ func (pl *Pipeline) ComputeDispatch1D(cmd vk.CommandBuffer, n, threads int)

+ func (pl *Pipeline) Config()

+ func (pl *Pipeline) ConfigCompute()

+ func (pl *Pipeline) ConfigStages()

+ func (pl *Pipeline) Destroy()

+ func (pl *Pipeline) DestroyPipeline()

+ func (pl *Pipeline) Draw(cmd vk.CommandBuffer, vtxCount, instanceCount, firstVtx, firstInstance int)

+ func (pl *Pipeline) DrawVertex(cmd vk.CommandBuffer, descIdx int)

+ func (pl *Pipeline) FreeShaders()

+ func (pl *Pipeline) Init(sy *System)

+ func (pl *Pipeline) InitPipeline()

+ func (pl *Pipeline) Push(cmd vk.CommandBuffer, vr *Var, val unsafe.Pointer)

+ func (pl *Pipeline) SetColorBlend(alphaBlend bool)

+ func (pl *Pipeline) SetCullFace(back bool)

+ func (pl *Pipeline) SetDynamicState()

+ func (pl *Pipeline) SetFrontFace(ccw bool)

+ func (pl *Pipeline) SetGraphicsDefaults()

+ func (pl *Pipeline) SetLineWidth(lineWidth float32)

+ func (pl *Pipeline) SetRasterization(polygonMode vk.PolygonMode, cullMode vk.CullModeFlagBits, ...)

+ func (pl *Pipeline) SetTopology(topo Topologies, restartEnable bool)

+ func (pl *Pipeline) ShaderByName(name string) *Shader

+ func (pl *Pipeline) Vars() *Vars

+ type Render struct

+ ClearVals []vk.ClearValue

+ Depth Image

+ Dev vk.Device

+ Format ImageFormat

+ Grab Image

+ GrabDepth MemBuff

+ HasDepth bool

+ HasMulti bool

+ Multi Image

+ NotSurface bool

+ Sys *System

+ VkClearPass vk.RenderPass

+ VkLoadPass vk.RenderPass

+ func (rp *Render) BeginRenderPass(cmd vk.CommandBuffer, fr *Framebuffer)

+ func (rp *Render) BeginRenderPassImpl(cmd vk.CommandBuffer, fr *Framebuffer, clear bool)

+ func (rp *Render) BeginRenderPassNoClear(cmd vk.CommandBuffer, fr *Framebuffer)

+ func (rp *Render) Config(dev vk.Device, imgFmt *ImageFormat, depthFmt Types, notSurface bool)

+ func (rp *Render) ConfigGrab(dev vk.Device)

+ func (rp *Render) ConfigGrabDepth(dev vk.Device)

+ func (rp *Render) ConfigImpl(dev vk.Device, imgFmt *ImageFormat, depthFmt Types, clear bool) vk.RenderPass

+ func (rp *Render) DepthImageArray() ([]float32, error)

+ func (rp *Render) Destroy()

+ func (rp *Render) GrabDepthImage(dev vk.Device, cmd vk.CommandBuffer) error

+ func (rp *Render) SetClearColor(r, g, b, a float32)

+ func (rp *Render) SetClearDepthStencil(depth float32, stencil uint32)

+ func (rp *Render) SetSize(size image.Point)

+ type RenderFrame struct

+ Device Device

+ Format ImageFormat

+ Frames []*Framebuffer

+ GPU *GPU

+ ImageAcquired vk.Semaphore

+ NFrames int

+ OwnDevice bool

+ Render *Render

+ RenderDone vk.Semaphore

+ RenderFence vk.Fence

+ func NewRenderFrame(gp *GPU, dev *Device, size image.Point) *RenderFrame

+ func NewRenderFrameOwnDevice(gp *GPU, size image.Point) *RenderFrame

+ func (rf *RenderFrame) Config()

+ func (rf *RenderFrame) Defaults()

+ func (rf *RenderFrame) Destroy()

+ func (rf *RenderFrame) Free()

+ func (rf *RenderFrame) GrabDepthImage(cmd vk.CommandBuffer)

+ func (rf *RenderFrame) GrabImage(cmd vk.CommandBuffer, idx int)

+ func (rf *RenderFrame) Init(gp *GPU, makeDevice bool) error

+ func (rf *RenderFrame) ReConfig()

+ func (rf *RenderFrame) ReConfigFrames()

+ func (rf *RenderFrame) SetRender(rp *Render)

+ func (rf *RenderFrame) SetSize(size image.Point) bool

+ func (rf *RenderFrame) SubmitRender(cmd vk.CommandBuffer)

+ func (rf *RenderFrame) WaitForRender()

+ type Sampler struct

+ Border BorderColors

+ Name string

+ UMode SamplerModes

+ VMode SamplerModes

+ VkSampler vk.Sampler

+ WMode SamplerModes

+ func (sm *Sampler) Config(gp *GPU, dev vk.Device)

+ func (sm *Sampler) Defaults()

+ func (sm *Sampler) Destroy(dev vk.Device)

+ type SamplerModes int32

+ const ClampToBorder

+ const ClampToEdge

+ const MirrorClampToEdge

+ const MirroredRepeat

+ const Repeat

+ const SamplerModesN

+ func SamplerModesValues() []SamplerModes

+ func (i *SamplerModes) SetInt64(in int64)

+ func (i *SamplerModes) SetString(s string) error

+ func (i *SamplerModes) UnmarshalText(text []byte) error

+ func (i SamplerModes) Desc() string

+ func (i SamplerModes) Int64() int64

+ func (i SamplerModes) IsValid() bool

+ func (i SamplerModes) MarshalText() ([]byte, error)

+ func (i SamplerModes) String() string

+ func (i SamplerModes) Values() []enums.Enum

+ func (sm SamplerModes) VkMode() vk.SamplerAddressMode

+ type Shader struct

+ Name string

+ Type ShaderTypes

+ VkModule vk.ShaderModule

+ func (sh *Shader) Free(dev vk.Device)

+ func (sh *Shader) Init(name string, typ ShaderTypes)

+ func (sh *Shader) OpenCode(dev vk.Device, code []byte) error

+ func (sh *Shader) OpenFile(dev vk.Device, fname string) error

+ type ShaderTypes int32

+ const AllShaders

+ const ComputeShader

+ const FragmentShader

+ const GeometryShader

+ const TessCtrlShader

+ const TessEvalShader

+ const VertexShader

+ type StackFrame struct

+ File string

+ LineNumber int

+ Name string

+ Package string

+ ProgramCounter uintptr

+ func (frame *StackFrame) Func() *runtime.Func

+ func (frame *StackFrame) SourceLine() (string, error)

+ func (frame *StackFrame) String() string

+ type Surface struct

+ DesiredFormats []vk.Format

+ Device Device

+ Format ImageFormat

+ Frames []*Framebuffer

+ GPU *GPU

+ ImageAcquired vk.Semaphore

+ NFrames int

+ Render *Render

+ RenderDone vk.Semaphore

+ RenderFence vk.Fence

+ Surface vk.Surface

+ Swapchain vk.Swapchain

+ func NewSurface(gp *GPU, vsurf vk.Surface) *Surface

+ func (sf *Surface) AcquireNextImage() uint32

+ func (sf *Surface) ConfigSwapchain()

+ func (sf *Surface) Defaults()

+ func (sf *Surface) Destroy()

+ func (sf *Surface) FreeSwapchain()

+ func (sf *Surface) Init(gp *GPU, vs vk.Surface) error

+ func (sf *Surface) PresentImage(frameIdx uint32) error

+ func (sf *Surface) ReConfigFrames()

+ func (sf *Surface) ReConfigSwapchain()

+ func (sf *Surface) SetRender(rp *Render)

+ func (sf *Surface) SubmitRender(cmd vk.CommandBuffer)

+ type System struct

+ CmdBuffs map[string]vk.CommandBuffer

+ CmdPool CmdPool

+ Compute bool

+ Device Device

+ Events map[string]vk.Event

+ Fences map[string]vk.Fence

+ GPU *GPU

+ Mem Memory

+ Name string

+ PipelineMap map[string]*Pipeline

+ Pipelines []*Pipeline

+ Render Render

+ Semaphores map[string]vk.Semaphore

+ StaticVars bool

+ func (sy *System) AddPipeline(pl *Pipeline)

+ func (sy *System) BeginRenderPass(cmd vk.CommandBuffer, fr *Framebuffer, descIdx int)

+ func (sy *System) BeginRenderPassNoClear(cmd vk.CommandBuffer, fr *Framebuffer, descIdx int)

+ func (sy *System) CmdBindTextureVarIdx(cmd vk.CommandBuffer, setIdx int, varNm string, valIdx int) (txIdx, descIdx int, switched bool, err error)

+ func (sy *System) CmdBindVars(cmd vk.CommandBuffer, descIdx int)

+ func (sy *System) CmdBuffByNameTry(name string) (vk.CommandBuffer, error)

+ func (sy *System) CmdResetBindVars(cmd vk.CommandBuffer, descIdx int)

+ func (sy *System) CmdSubmitWait()

+ func (sy *System) ComputeCmdBuff() vk.CommandBuffer

+ func (sy *System) ComputeCmdEnd(cmd vk.CommandBuffer)

+ func (sy *System) ComputeCopyFmGPU(cmd vk.CommandBuffer, regs ...MemReg)

+ func (sy *System) ComputeCopyToGPU(cmd vk.CommandBuffer, regs ...MemReg)

+ func (sy *System) ComputeResetBegin(cmd vk.CommandBuffer)

+ func (sy *System) ComputeResetBindVars(cmd vk.CommandBuffer, descIdx int)

+ func (sy *System) ComputeSetEvent(cmd vk.CommandBuffer, event string) error

+ func (sy *System) ComputeSubmitSignal(cmd vk.CommandBuffer, signal, fence string) error

+ func (sy *System) ComputeSubmitWait(cmd vk.CommandBuffer)

+ func (sy *System) ComputeSubmitWaitSignal(cmd vk.CommandBuffer, wait, signal, fence string) error

+ func (sy *System) ComputeWait() error

+ func (sy *System) ComputeWaitEvents(cmd vk.CommandBuffer, event ...string) error

+ func (sy *System) ComputeWaitFence(fence string) error

+ func (sy *System) ComputeWaitMemHostToShader(cmd vk.CommandBuffer)

+ func (sy *System) ComputeWaitMemShaderToHost(cmd vk.CommandBuffer)

+ func (sy *System) ComputeWaitMemWriteRead(cmd vk.CommandBuffer)

+ func (sy *System) ComputeWaitMemoryBuff(cmd vk.CommandBuffer, buff *MemBuff)

+ func (sy *System) Config()

+ func (sy *System) ConfigRender(imgFmt *ImageFormat, depthFmt Types)

+ func (sy *System) ConfigRenderNonSurface(imgFmt *ImageFormat, depthFmt Types)

+ func (sy *System) Destroy()

+ func (sy *System) EndRenderPass(cmd vk.CommandBuffer)

+ func (sy *System) EventByNameTry(name string) (vk.Event, error)

+ func (sy *System) FenceByNameTry(name string) (vk.Fence, error)

+ func (sy *System) InitCmd()

+ func (sy *System) InitCompute(gp *GPU, name string) error

+ func (sy *System) InitGraphics(gp *GPU, name string, dev *Device) error

+ func (sy *System) MemCmdEndSubmitWaitFree()

+ func (sy *System) MemCmdStart() vk.CommandBuffer

+ func (sy *System) NewCmdBuff(name string) vk.CommandBuffer

+ func (sy *System) NewComputePipelineEmbed(name string, efs embed.FS, fname string) *Pipeline

+ func (sy *System) NewEvent(name string) vk.Event

+ func (sy *System) NewFence(name string) vk.Fence

+ func (sy *System) NewPipeline(name string) *Pipeline

+ func (sy *System) NewSemaphore(name string) vk.Semaphore

+ func (sy *System) PipelineByNameTry(name string) (*Pipeline, error)

+ func (sy *System) ResetBeginRenderPass(cmd vk.CommandBuffer, fr *Framebuffer, descIdx int)

+ func (sy *System) ResetBeginRenderPassNoClear(cmd vk.CommandBuffer, fr *Framebuffer, descIdx int)

+ func (sy *System) SemaphoreByNameTry(name string) (vk.Semaphore, error)

+ func (sy *System) SetClearColor(r, g, b, a float32)

+ func (sy *System) SetClearDepthStencil(depth float32, stencil uint32)

+ func (sy *System) SetColorBlend(alphaBlend bool)

+ func (sy *System) SetCullFace(back bool)

+ func (sy *System) SetFrontFace(ccw bool)

+ func (sy *System) SetGraphicsDefaults()

+ func (sy *System) SetLineWidth(lineWidth float32)

+ func (sy *System) SetRasterization(polygonMode vk.PolygonMode, cullMode vk.CullModeFlagBits, ...)

+ func (sy *System) SetTopology(topo Topologies, restartEnable bool)

+ func (sy *System) Vars() *Vars

+ type Texture struct

+ func (tx *Texture) AllocTexture()

+ func (tx *Texture) Defaults()

+ func (tx *Texture) Destroy()

+ type Topologies int32

+ type Types int32

+ const Bool32

+ const Depth24Sten8

+ const Depth32

+ const Float32

+ const Float32Mat3

+ const Float32Mat4

+ const Float32Vec2

+ const Float32Vec3

+ const Float32Vec4

+ const Float64

+ const Float64Vec2

+ const Float64Vec3

+ const Float64Vec4

+ const ImageRGBA32

+ const Int16

+ const Int32

+ const Int32Vec2

+ const Int32Vec4

+ const Struct

+ const TypesN

+ const Uint16

+ const Uint32

+ const Uint32Vec2

+ const Uint32Vec4

+ const UndefType

+ func TypesValues() []Types

+ func (i *Types) SetInt64(in int64)

+ func (i *Types) SetString(s string) error

+ func (i *Types) UnmarshalText(text []byte) error

+ func (i Types) Desc() string

+ func (i Types) Int64() int64

+ func (i Types) IsValid() bool

+ func (i Types) MarshalText() ([]byte, error)

+ func (i Types) String() string

+ func (i Types) Values() []enums.Enum

+ func (tp Types) Bytes() int

+ func (tp Types) VkFormat() vk.Format

+ func (tp Types) VkIndexType() vk.IndexType

+ type Val struct

+ AllocSize int

+ ElSize int

+ Flags ValFlags

+ Idx int

+ MemPtr unsafe.Pointer

+ N int

+ Name string

+ Offset int

+ Texture *Texture

+ func (vl *Val) AllocHost(vr *Var, buff *MemBuff, buffPtr unsafe.Pointer, offset int) int

+ func (vl *Val) Bytes() []byte

+ func (vl *Val) ClearMod()

+ func (vl *Val) CopyFromBytes(srcPtr unsafe.Pointer)

+ func (vl *Val) CopyToBytes(srcPtr unsafe.Pointer)

+ func (vl *Val) Floats32() mat32.ArrayF32

+ func (vl *Val) Free()

+ func (vl *Val) HasFlag(flag ValFlags) bool

+ func (vl *Val) Init(gp *GPU, vr *Var, idx int)

+ func (vl *Val) IsMod() bool

+ func (vl *Val) MemReg(vr *Var) MemReg

+ func (vl *Val) MemSize(vr *Var) int

+ func (vl *Val) PaddedArrayCheck() error

+ func (vl *Val) SetFlag(on bool, flag ...enums.BitFlag)

+ func (vl *Val) SetGoImage(img image.Image, layer int, flipY bool) error

+ func (vl *Val) SetMod()

+ func (vl *Val) UInts32() mat32.ArrayU32

+ type ValFlags int64

+ const ValFlagsN

+ const ValMod

+ const ValPaddedArray

+ const ValTextureOwns

+ func ValFlagsValues() []ValFlags

+ func (i *ValFlags) SetFlag(on bool, f ...enums.BitFlag)

+ func (i *ValFlags) SetInt64(in int64)

+ func (i *ValFlags) SetString(s string) error

+ func (i *ValFlags) SetStringOr(s string) error

+ func (i *ValFlags) UnmarshalText(text []byte) error

+ func (i ValFlags) BitIndexString() string

+ func (i ValFlags) Desc() string

+ func (i ValFlags) HasFlag(f enums.BitFlag) bool

+ func (i ValFlags) Int64() int64

+ func (i ValFlags) IsValid() bool

+ func (i ValFlags) MarshalText() ([]byte, error)

+ func (i ValFlags) String() string

+ func (i ValFlags) Values() []enums.Enum

+ type Vals struct

+ GpTexVals []*Val

+ NameMap map[string]*Val

+ TexSzAlloc szalloc.SzAlloc

+ Vals []*Val

+ func (vs *Vals) ActiveVals() []*Val

+ func (vs *Vals) AllocHost(vr *Var, buff *MemBuff, offset int) int

+ func (vs *Vals) AllocTexBySize(gp *GPU, vr *Var)

+ func (vs *Vals) AllocTextures(mm *Memory)

+ func (vs *Vals) ConfigVals(gp *GPU, dev vk.Device, vr *Var, nvals int) bool

+ func (vs *Vals) Destroy()

+ func (vs *Vals) Free()

+ func (vs *Vals) MemSize(vr *Var, alignBytes int) int

+ func (vs *Vals) ModRegs(vr *Var) []MemReg

+ func (vs *Vals) SetGoImage(idx int, img image.Image, flipy bool)

+ func (vs *Vals) SetName(idx int, name string) (*Val, error)

+ func (vs *Vals) ValByIdxTry(idx int) (*Val, error)

+ func (vs *Vals) ValByNameTry(name string) (*Val, error)

+ type Var struct

+ ArrayN int

+ BindLoc int

+ BindValIdx []int

+ DynOffIdx int

+ Name string

+ Offset int

+ Role VarRoles

+ Set int

+ Shaders vk.ShaderStageFlagBits

+ SizeOf int

+ StorageBuff int

+ TextureOwns bool

+ Type Types

+ Vals Vals

+ func (vr *Var) AllocHost(buff *MemBuff, offset int) int

+ func (vr *Var) AllocTextures(mm *Memory)

+ func (vr *Var) BindVal(descIdx int) (*Val, error)

+ func (vr *Var) BuffType() BuffTypes

+ func (vr *Var) Free()

+ func (vr *Var) Init(name string, typ Types, arrayN int, role VarRoles, set int, ...)

+ func (vr *Var) MemSize() int

+ func (vr *Var) MemSizeStorage(mm *Memory, alignBytes int)

+ func (vr *Var) ModRegs() []MemReg

+ func (vr *Var) SetTextureDev(dev vk.Device)

+ func (vr *Var) String() string

+ func (vr *Var) TextureValidIdx(stIdx, idx int) int

+ func (vr *Var) ValsMemSize(alignBytes int) int

+ type VarList struct

+ VarMap map[string]*Var

+ Vars []*Var

+ func (vs *VarList) ValByIdxTry(varName string, valIdx int) (*Var, *Val, error)

+ func (vs *VarList) ValByNameTry(varName, valName string) (*Var, *Val, error)

+ func (vs *VarList) VarByNameTry(name string) (*Var, error)

+ type VarMem struct

+ Buff int

+ Offset int

+ Size int

+ Var *Var

+ type VarRoles int32

+ const Index

+ const Push

+ const Storage

+ const StorageImage

+ const StorageTexel

+ const TextureRole

+ const UndefVarRole

+ const Uniform

+ const UniformTexel

+ const VarRolesN

+ const Vertex

+ func VarRolesValues() []VarRoles

+ func (i *VarRoles) SetInt64(in int64)

+ func (i *VarRoles) SetString(s string) error

+ func (i *VarRoles) UnmarshalText(text []byte) error

+ func (i VarRoles) Desc() string

+ func (i VarRoles) Int64() int64

+ func (i VarRoles) IsValid() bool

+ func (i VarRoles) MarshalText() ([]byte, error)

+ func (i VarRoles) String() string

+ func (i VarRoles) Values() []enums.Enum

+ func (vr VarRoles) BuffType() BuffTypes

+ func (vr VarRoles) IsDynamic() bool

+ func (vr VarRoles) VkDescriptor() vk.DescriptorType

+ func (vr VarRoles) VkDescriptorStatic() vk.DescriptorType

+ type VarSet struct

+ NTextureDescs int

+ NValsPer int

+ ParentVars *Vars

+ RoleMap map[VarRoles][]*Var

+ Set int

+ VkDescSets []vk.DescriptorSet

+ VkLayout vk.DescriptorSetLayout

+ func (st *VarSet) Add(name string, typ Types, arrayN int, role VarRoles, shaders ...ShaderTypes) *Var

+ func (st *VarSet) AddStruct(name string, size int, arrayN int, role VarRoles, shaders ...ShaderTypes) *Var

+ func (st *VarSet) AddVar(vr *Var)

+ func (st *VarSet) BindDynVal(vs *Vars, vr *Var, vl *Val) error

+ func (st *VarSet) BindDynValIdx(vs *Vars, varNm string, valIdx int) error

+ func (st *VarSet) BindDynValName(vs *Vars, varNm, valNm string) error

+ func (st *VarSet) BindDynValsAllIdx(vs *Vars, idx int)

+ func (st *VarSet) BindDynVar(vs *Vars, vr *Var) error

+ func (st *VarSet) BindDynVarName(vs *Vars, varNm string) error

+ func (st *VarSet) BindDynVars(vs *Vars)

+ func (st *VarSet) BindStatVar(vs *Vars, vr *Var)

+ func (st *VarSet) BindStatVarName(vs *Vars, varNm string) error

+ func (st *VarSet) BindStatVars(vs *Vars)

+ func (st *VarSet) BindStatVarsAll(vs *Vars)

+ func (st *VarSet) Config(dev vk.Device) error

+ func (st *VarSet) ConfigVals(nvals int)

+ func (st *VarSet) DescLayout(dev vk.Device, vs *Vars)

+ func (st *VarSet) Destroy(dev vk.Device)

+ func (st *VarSet) DestroyLayout(dev vk.Device)

+ func (st *VarSet) TexGpSzIdxs(vs *Vars, varNm string, valIdx int) *szalloc.Idxs

+ func (st *VarSet) VkVertexConfig() *vk.PipelineVertexInputStateCreateInfo

+ func (vs *VarSet) VkPushConfig() []vk.PushConstantRange

+ type Vars struct

+ BindDescIdx int

+ DynOffs [][]uint32

+ HasPush bool

+ HasVertex bool

+ Mem *Memory

+ NDescs int

+ RoleMap map[VarRoles][]*Var

+ SetMap map[int]*VarSet

+ StaticVars bool

+ VkDescLayout vk.PipelineLayout

+ VkDescPool vk.DescriptorPool

+ VkDescSets [][]vk.DescriptorSet

+ VkWriteVals []vk.WriteDescriptorSet

+ func (vs *Vars) AddDynOff()

+ func (vs *Vars) AddPushSet() *VarSet

+ func (vs *Vars) AddSet() *VarSet

+ func (vs *Vars) AddVertexSet() *VarSet

+ func (vs *Vars) AllocHost(buff *MemBuff, offset int) int

+ func (vs *Vars) AllocTextures(mm *Memory)

+ func (vs *Vars) BindAllTextureVars(set int) error

+ func (vs *Vars) BindDynVal(set int, vr *Var, vl *Val) error

+ func (vs *Vars) BindDynValIdx(set int, varNm string, valIdx int) error

+ func (vs *Vars) BindDynValName(set int, varNm, valNm string) error

+ func (vs *Vars) BindDynValsAllIdx(idx int)

+ func (vs *Vars) BindDynVarName(set int, varNm string) error

+ func (vs *Vars) BindDynVars(set int) error

+ func (vs *Vars) BindDynVarsAll()

+ func (vs *Vars) BindStatVarName(set int, varNm string) error

+ func (vs *Vars) BindStatVars(set int) error

+ func (vs *Vars) BindStatVarsAll()

+ func (vs *Vars) BindVarsEnd()

+ func (vs *Vars) BindVarsStart(descIdx int)

+ func (vs *Vars) BindVertexValIdx(varNm string, valIdx int) error

+ func (vs *Vars) BindVertexValName(varNm, valNm string) error

+ func (vs *Vars) Config() error

+ func (vs *Vars) DescLayout(dev vk.Device)

+ func (vs *Vars) Destroy(dev vk.Device)

+ func (vs *Vars) Free(buff *MemBuff)

+ func (vs *Vars) MemSize(buff *MemBuff) int

+ func (vs *Vars) MemSizeStorage(mm *Memory, alignBytes int)

+ func (vs *Vars) ModRegs(bt BuffTypes) []MemReg

+ func (vs *Vars) ModRegsStorage(bufIdx int, buff *MemBuff) []MemReg

+ func (vs *Vars) NSets() int

+ func (vs *Vars) PushSet() *VarSet

+ func (vs *Vars) SetTry(set int) (*VarSet, error)

+ func (vs *Vars) StartSet() int

+ func (vs *Vars) StringDoc() string

+ func (vs *Vars) TexGpSzIdxs(set int, varNm string, valIdx int) *szalloc.Idxs

+ func (vs *Vars) ValByIdxTry(set int, varName string, valIdx int) (*Var, *Val, error)

+ func (vs *Vars) ValByNameTry(set int, varName, valName string) (*Var, *Val, error)

+ func (vs *Vars) VarByNameTry(set int, name string) (*Var, error)

+ func (vs *Vars) VertexSet() *VarSet

+ func (vs *Vars) VkPushConfig() []vk.PushConstantRange

+ func (vs *Vars) VkVertexConfig() *vk.PipelineVertexInputStateCreateInfo

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL