vkx

package
v0.0.0-...-1b23d78 Latest Latest
Warning

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

 Go to latest Published: Oct 23, 2019 License: MIT Imports: 25 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	MaxTimestamp = 0x7FFFFFFFFFFFFFFF
	MaxCycleTime = 0x00FFFFFF // 24 bit
)
View Source 
const (
	Version = 1

	DefaultVulkanVersion = vk.API_VERSION_1_1
)

Variables

View Source 
var (
	DefaultAllocator *vk.AllocationCallbacks
)

Functions

func CycleTime 

func CycleTime() uint32

func CycleTimeFloat 

func CycleTimeFloat() float32

func DefaultDebugReportCallback 

func DefaultDebugReportCallback() vk.PfnDebugReportCallbackEXT

func EnumerateExtensions 

func EnumerateExtensions(forLayer string) (m map[string]uint32, err error)

func EnumerateLayers 

func EnumerateLayers() (m map[string]uint32, err error)

func SyncTime 

func SyncTime() time.Time

func Timestamp 

func Timestamp() int64

Timestamp in miliseconds

func ToSysTime 

func ToSysTime(ms int64) time.Time

func ToTimestamp 

func ToTimestamp(t time.Time) int64

Types

type BufferMemory 

type BufferMemory struct {
	Handle vk.Buffer
	Memory vk.DeviceMemory
	Device *Device
}

func (*BufferMemory) Close 

func (vb *BufferMemory) Close() error

func (*BufferMemory) FillMemory 

func (vb *BufferMemory) FillMemory(offset, size uint64, flags vk.MemoryMapFlags, pSrc unsafe.Pointer) error

func (*BufferMemory) MapMemory 

func (vb *BufferMemory) MapMemory(offset, size uint64, flags vk.MemoryMapFlags) (addr unsafe.Pointer, err error)

func (*BufferMemory) UnmapMemory 

func (vb *BufferMemory) UnmapMemory()

type ClearValues 

type ClearValues struct {
	// contains filtered or unexported fields
}

func (ClearValues) Count 

func (cvs ClearValues) Count() int

func (*ClearValues) Free 

func (cvs *ClearValues) Free()

func (ClearValues) Get 

func (cvs ClearValues) Get(i int) *vk.ClearValue

func (ClearValues) Ptr 

func (cvs ClearValues) Ptr() *vk.ClearValue

func (*ClearValues) SetCount 

func (cvs *ClearValues) SetCount(n int)

type CommandBuffer 

type CommandBuffer struct {
	Handle   vk.CommandBuffer
	Instance *Instance    // for vkCmdXXX commands
	Pool     *CommandPool // for free
}

func (CommandBuffer) AllocTempHandle 

func (cb CommandBuffer) AllocTempHandle() *vk.CommandBuffer

func (CommandBuffer) Begin 

func (cb CommandBuffer) Begin(flags vk.CommandBufferUsageFlags) error

func (CommandBuffer) BeginRenderPass 

func (cb CommandBuffer) BeginRenderPass(pBeginInfo *vk.RenderPassBeginInfo, subpassContents vk.SubpassContents)

func (CommandBuffer) BindDescriptorSets 

func (cb CommandBuffer) BindDescriptorSets(pipelineBindPoint vk.PipelineBindPoint, layout vk.PipelineLayout,
	firstSet, descriptorSetCount uint32, pDescriptorSets *vk.DescriptorSet, dynamicOffsetCount uint32, pDynamicOffsets *uint32)

func (CommandBuffer) BindPipeline 

func (cb CommandBuffer) BindPipeline(pipelineBindPoint vk.PipelineBindPoint, pipeline vk.Pipeline)

func (CommandBuffer) BindVertexBuffers 

func (cb CommandBuffer) BindVertexBuffers(firstBinding, bindingCount uint32, pBuffers *vk.Buffer, pOffsets *vk.DeviceSize)

func (CommandBuffer) ClearAttachments 

func (cb CommandBuffer) ClearAttachments(attachmentCount uint32, pAttachments *vk.ClearAttachment, rectCount uint32, pRects *vk.ClearRect)

func (CommandBuffer) ClearColorImage 

func (cb CommandBuffer) ClearColorImage(image vk.Image, imageLayout vk.ImageLayout,
	pColor *vk.ClearColorValue, rangeCount uint32, pRanges *vk.ImageSubresourceRange)

func (CommandBuffer) CopyBuffer 

func (cb CommandBuffer) CopyBuffer(srcBuffer, dstBuffer vk.Buffer, regionCount uint32, pRegions *vk.BufferCopy)

func (CommandBuffer) CopyBufferToImage 

func (cb CommandBuffer) CopyBufferToImage(srcBuffer vk.Buffer, dstImage vk.Image, dstImageLayout vk.ImageLayout, regionCount uint32, pRegions *vk.BufferImageCopy)

func (CommandBuffer) Draw 

func (cb CommandBuffer) Draw(vertexCount, instanceCount, firstVertex, firstInstance uint32)

func (CommandBuffer) DrawIndexed 

func (cb CommandBuffer) DrawIndexed(indexCount, instanceCount, firstIndex uint32, vertexOffset int32, firstInstance uint32)

func (CommandBuffer) End 

func (cb CommandBuffer) End() error

func (CommandBuffer) EndRenderPass 

func (cb CommandBuffer) EndRenderPass()

func (*CommandBuffer) Free 

func (cb *CommandBuffer) Free()

func (CommandBuffer) FreeTempHandle 

func (cb CommandBuffer) FreeTempHandle(tmpHandle *vk.CommandBuffer)

func (CommandBuffer) PipelineBarrier 

func (cb CommandBuffer) PipelineBarrier(srcStageMask, dstStageMask vk.PipelineStageFlags, dependencyFlags vk.DependencyFlags,
	memoryBarrierCount uint32, pMemoryBarriers *vk.MemoryBarrier, bufferMemoryBarrierCount uint32, pBufferMemoryBarriers *vk.BufferMemoryBarrier,
	imageMemoryBarrierCount uint32, pImageMemoryBarriers *vk.ImageMemoryBarrier)

func (CommandBuffer) PushConstants 

func (cb CommandBuffer) PushConstants(layout vk.PipelineLayout, stageFlags vk.ShaderStageFlags, offset, size uint32, pValues unsafe.Pointer)

func (*CommandBuffer) Reset 

func (cb *CommandBuffer) Reset(flags vk.CommandBufferResetFlags)

func (CommandBuffer) Submit 

func (cmd CommandBuffer) Submit(queue vk.Queue) error

func (CommandBuffer) TransitionImageLayout 

func (cb CommandBuffer) TransitionImageLayout(image vk.Image, format vk.Format, oldLayout vk.ImageLayout, newLayout vk.ImageLayout)

type CommandPool 

type CommandPool struct {
	Handle vk.CommandPool
	Device *Device
}

func (*CommandPool) Allocate 

func (pool *CommandPool) Allocate(lvl vk.CommandBufferLevel) (cb CommandBuffer, err error)

func (*CommandPool) BeginOneShot 

func (pool *CommandPool) BeginOneShot(lvl vk.CommandBufferLevel, flags vk.CommandBufferUsageFlags) (cb CommandBuffer, err error)

func (*CommandPool) Close 

func (cp *CommandPool) Close() error

type CorePfns 

type CorePfns struct {
	vk.PfnDestroyInstance
	vk.PfnGetDeviceProcAddr
	//vk.PfnEnumerateInstanceExtensionProperties
	vk.PfnDestroySurfaceKHR
	vk.PfnEnumeratePhysicalDevices

	vk.PfnGetPhysicalDeviceProperties
	vk.PfnEnumerateDeviceExtensionProperties
	vk.PfnGetPhysicalDeviceFeatures // TODO: vk.PfnGetPhysicalDeviceFeatures2
	vk.PfnGetPhysicalDeviceQueueFamilyProperties
	vk.PfnCreateDevice
	vk.PfnDestroyDevice
	vk.PfnCreatePipelineCache
	vk.PfnDestroyPipelineCache
	vk.PfnGetPipelineCacheData
	vk.PfnGetDeviceQueue
	vk.PfnGetPhysicalDeviceSurfaceCapabilitiesKHR
	vk.PfnGetPhysicalDeviceSurfaceFormatsKHR
	vk.PfnGetPhysicalDeviceSurfacePresentModesKHR
	vk.PfnGetPhysicalDeviceSurfaceSupportKHR
	vk.PfnCreateSwapchainKHR
	vk.PfnDestroySwapchainKHR
	vk.PfnGetSwapchainImagesKHR
	vk.PfnCreateImage
	vk.PfnDestroyImage
	vk.PfnCreateImageView
	vk.PfnDestroyImageView
	vk.PfnCreateShaderModule
	vk.PfnDestroyShaderModule

	vk.PfnCreatePipelineLayout
	vk.PfnDestroyPipelineLayout
	vk.PfnCreateGraphicsPipelines
	vk.PfnDestroyPipeline
	vk.PfnCreateRenderPass
	vk.PfnDestroyRenderPass
	vk.PfnCreateBuffer
	vk.PfnAllocateMemory
	vk.PfnBindBufferMemory
	vk.PfnBindImageMemory
	vk.PfnGetPhysicalDeviceMemoryProperties
	vk.PfnGetImageMemoryRequirements
	vk.PfnGetBufferMemoryRequirements
	vk.PfnDestroyBuffer
	vk.PfnFreeMemory
	vk.PfnMapMemory
	vk.PfnUnmapMemory
	vk.PfnCreateFramebuffer
	vk.PfnDestroyFramebuffer
	vk.PfnCreateDescriptorSetLayout
	vk.PfnDestroyDescriptorSetLayout
	vk.PfnCreateDescriptorPool
	vk.PfnDestroyDescriptorPool
	vk.PfnAllocateDescriptorSets
	vk.PfnUpdateDescriptorSets

	vk.PfnQueueSubmit
	vk.PfnQueuePresentKHR
	vk.PfnQueueWaitIdle
	vk.PfnAcquireNextImageKHR

	vk.PfnCreateCommandPool
	vk.PfnDestroyCommandPool
	vk.PfnAllocateCommandBuffers
	vk.PfnFreeCommandBuffers
	vk.PfnResetCommandBuffer
	vk.PfnBeginCommandBuffer
	vk.PfnEndCommandBuffer

	vk.PfnCmdBeginRenderPass
	vk.PfnCmdEndRenderPass
	vk.PfnCmdBindPipeline
	vk.PfnCmdBindVertexBuffers
	vk.PfnCmdDraw
	vk.PfnCmdCopyBuffer
	vk.PfnCmdBindDescriptorSets
	vk.PfnCmdDrawIndexed
	vk.PfnCmdCopyBufferToImage
	vk.PfnCmdPipelineBarrier
	vk.PfnCmdClearColorImage
	vk.PfnCmdClearAttachments
	vk.PfnCmdPushConstants

	vk.PfnCreateSemaphore
	vk.PfnDestroySemaphore
	vk.PfnCreateFence
	vk.PfnDestroyFence
	vk.PfnWaitForFences
	vk.PfnResetFences
	vk.PfnGetFenceStatus
	vk.PfnCreateSampler
	vk.PfnDestroySampler
}

type DebugPfns 

type DebugPfns struct {
	// TODO: vk.PfnDestroyDebugUtilsMessengerEXT
	// TODO: vk.PfnCreateDebugUtilsMessengerEXT
	vk.PfnCreateDebugReportCallbackEXT
	vk.PfnDestroyDebugReportCallbackEXT
}

type DescriptorBinding 

type DescriptorBinding = vk.DescriptorSetLayoutBinding

type DescriptorPool 

type DescriptorPool struct {
	Handle vk.DescriptorPool
	Device *Device
}

func (*DescriptorPool) AllocateDescriptorSets 

func (pool *DescriptorPool) AllocateDescriptorSets(layouts []vk.DescriptorSetLayout) (sets *DescriptorSets, err error)

func (*DescriptorPool) Close 

func (pool *DescriptorPool) Close() error

type DescriptorSetLayoutInfo 

type DescriptorSetLayoutInfo struct {
	Flags    vk.DescriptorSetLayoutCreateFlags
	Bindings []DescriptorBinding
}

type DescriptorSets 

type DescriptorSets struct {
	Sets   *vk.DescriptorSet
	Count  uint32
	Device *Device
}

func (*DescriptorSets) Close 

func (sets *DescriptorSets) Close() error

func (*DescriptorSets) GetVk 

func (sets *DescriptorSets) GetVk(i uint32) vk.DescriptorSet

func (*DescriptorSets) GetVkPtr 

func (sets *DescriptorSets) GetVkPtr(i uint32) *vk.DescriptorSet

type Device 

type Device struct {
	sync.Mutex
	Handle vk.Device

	CmdPoolShortLive *CommandPool
	CmdPoolLongLive  *CommandPool

	GraphicsQueue vk.Queue
	PresentQueue  vk.Queue

	Physical *PhysicalDevice
	Instance *Instance

	Shaders map[string]*ShaderModule

	PipelineCache vk.PipelineCache
}

func (*Device) Close 

func (dev *Device) Close() error

func (*Device) CreateBuffer 

func (dev *Device) CreateBuffer(size uint64, usage vk.BufferUsageFlags, memoryProperties vk.MemoryPropertyFlags) (vb *BufferMemory, err error)

func (*Device) CreateCommandPool 

func (dev *Device) CreateCommandPool(queueFamilyIndex uint32, flags vk.CommandPoolCreateFlags) (cp *CommandPool, err error)

func (*Device) CreateDescriptorPool 

func (dev *Device) CreateDescriptorPool(sizes []vk.DescriptorPoolSize, maxSets uint32) (*DescriptorPool, error)

func (*Device) CreateFence 

func (dev *Device) CreateFence(flags vk.FenceCreateFlags) (fen *Fence, err error)

func (*Device) CreateFontManager 

func (dev *Device) CreateFontManager(layouts []vk.DescriptorSetLayout) (fman *FontManager, err error)

func (*Device) CreateFramebuffer 

func (dev *Device) CreateFramebuffer(image vk.Image, pass vk.RenderPass, format vk.Format, extent vk.Extent2D) (fb *Framebuffer, err error)

func (*Device) CreateImage 

func (dev *Device) CreateImage(ci *vk.ImageCreateInfo, memoryProperties vk.MemoryPropertyFlags) (vb *ImageMemory, err error)

func (*Device) CreateImageView 

func (dev *Device) CreateImageView(image vk.Image, imageFormat vk.Format) (*ImageView, error)

func (*Device) CreatePipeline 

func (dev *Device) CreatePipeline(pipelineInfo PipelineInfo) (pl *Pipeline, err error)

func (*Device) CreatePipelineLayout 

func (dev *Device) CreatePipelineLayout(setLayouts []vk.DescriptorSetLayout, pushConstantRanges []vk.PushConstantRange) (layout vk.PipelineLayout, err error)

func (*Device) CreateRenderPass 

func (dev *Device) CreateRenderPass(renderPassInfo RenderPassInfo) (renderPass *RenderPass, err error)

func (*Device) CreateSemaphore 

func (dev *Device) CreateSemaphore(flags vk.SemaphoreCreateFlags) (sem *Semaphore, err error)

func (*Device) CreateTextureSampler 

func (dev *Device) CreateTextureSampler(samplerInfo vk.SamplerCreateInfo) (smplr *Sampler, err error)

func (*Device) GetQueue 

func (dev *Device) GetQueue(idxFamily uint32) vk.Queue

func (*Device) ResetFences 

func (dev *Device) ResetFences(fens []vk.Fence) error

func (*Device) TransitionImageLayout 

func (dev *Device) TransitionImageLayout(image vk.Image, format vk.Format, oldLayout vk.ImageLayout, newLayout vk.ImageLayout) (err error)

func (*Device) UpdateDescriptorSets 

func (dev *Device) UpdateDescriptorSets(writeCount uint32, pWrites *vk.WriteDescriptorSet, copyCount uint32, pCopies *vk.CopyDescriptorSet)

func (*Device) WaitFences 

func (dev *Device) WaitFences(fens []vk.Fence, waitAll bool, timeoutNsecs uint64) error

type Fence 

type Fence struct {
	Handle vk.Fence
	Device *Device
}

func (*Fence) Close 

func (fen *Fence) Close() error

func (*Fence) Reset 

func (fen *Fence) Reset() error

func (*Fence) Status 

func (fen *Fence) Status() vk.Result

func (*Fence) Wait 

func (fen *Fence) Wait(timeoutNsecs uint64) error

func (*Fence) WaitForever 

func (fen *Fence) WaitForever() error

type FontManager 

type FontManager struct {
	font.Manager
	Textures []*FontTexture
	Sampler  *Sampler

	Device *Device
	// contains filtered or unexported fields
}

func (*FontManager) Close 

func (fman *FontManager) Close() error

func (*FontManager) MakeText 

func (fman *FontManager) MakeText(s string, fontName string, fontSize int) (text *Text, err error)

type FontTexture 

type FontTexture struct {
	Image *ImageMemory
	View  *ImageView
	Sets  *DescriptorSets

	Device *Device
}

func (*FontTexture) Close 

func (texture *FontTexture) Close() error

type FrameFlight 

type FrameFlight struct {
	Fence             *Fence
	SemRenderFinished *vk.Semaphore
	SemImageAvailable *vk.Semaphore
	PresentInfo       *vk.PresentInfoKHR
	SubmitInfo        *vk.SubmitInfo
	CommandBuffer     CommandBuffer // main command buffer for this flight
	// Sets2D            *DescriptorSets
	// Uni2DMat          *Uni2DMat
	Device  *Device
	Surface *Surface
}

func (*FrameFlight) Close 

func (frm *FrameFlight) Close() error

type Framebuffer 

type Framebuffer struct {
	Handle vk.Framebuffer

	FrameImage vk.Image
	FrameView  *ImageView

	Device *Device
}

func (*Framebuffer) Close 

func (fb *Framebuffer) Close() error

type ImageMemory 

type ImageMemory struct {
	Handle vk.Image
	Memory vk.DeviceMemory
	Device *Device
}

func (*ImageMemory) Close 

func (vb *ImageMemory) Close() error

func (*ImageMemory) FillMemory 

func (vb *ImageMemory) FillMemory(offset, size uint64, flags vk.MemoryMapFlags, pSrc unsafe.Pointer) error

func (*ImageMemory) MapMemory 

func (vb *ImageMemory) MapMemory(offset, size uint64, flags vk.MemoryMapFlags) (addr unsafe.Pointer, err error)

func (*ImageMemory) UnmapMemory 

func (vb *ImageMemory) UnmapMemory()

type ImageView 

type ImageView struct {
	Handle vk.ImageView
	Device *Device
}

func (*ImageView) Close 

func (view *ImageView) Close() error

type InputAssembly 

type InputAssembly struct {
	Flags    vk.PipelineInputAssemblyStateCreateFlags
	Topology vk.PrimitiveTopology
	Restart  bool
}

type Instance 

type Instance struct {
	Handle vk.Instance

	CorePfns
	SysPfns
	DebugPfns

	config.Options
	// contains filtered or unexported fields
}

func New 

func New(options config.Options) (inst *Instance, err error)

func (*Instance) AllocDispatchableHandle 

func (inst *Instance) AllocDispatchableHandle() *vk.DispatchableHandle

func (*Instance) AllocNonDispatchableHandle 

func (inst *Instance) AllocNonDispatchableHandle() *vk.NonDispatchableHandle

func (*Instance) Close 

func (inst *Instance) Close() error

func (*Instance) CreateSysSurface 

func (inst *Instance) CreateSysSurface(data SysSurfaceData) (vkSurface vk.SurfaceKHR, err error)

func (*Instance) EnumPhysicalDevices 

func (inst *Instance) EnumPhysicalDevices() (list []*PhysicalDevice, err error)

func (*Instance) FreeDispatchableHandle 

func (inst *Instance) FreeDispatchableHandle(p *vk.DispatchableHandle)

func (*Instance) FreeNonDispatchableHandle 

func (inst *Instance) FreeNonDispatchableHandle(p *vk.NonDispatchableHandle)

func (*Instance) LoadDeviceProc 

func (inst *Instance) LoadDeviceProc(device vk.Device, ppfn interface{}) error

func (*Instance) LoadVulkanProc 

func (inst *Instance) LoadVulkanProc(ppfn interface{}) error

type Mat3 

type Mat3 = calc.Mat3

Mat3 type

type Mat4 

type Mat4 = calc.Mat4

Mat4 type

type PhysicalDevice 

type PhysicalDevice struct {
	Handle vk.PhysicalDevice

	vk.PhysicalDeviceFeatures

	Instance *Instance
}

func (*PhysicalDevice) CreateLogicalDevice 

func (phy *PhysicalDevice) CreateLogicalDevice(opts *SurfaceProperties, exts []string) (*Device, error)

func (*PhysicalDevice) EnumerateExtensions 

func (phy *PhysicalDevice) EnumerateExtensions(layer string) (m map[string]uint32, err error)

func (*PhysicalDevice) Features 

func (phy *PhysicalDevice) Features() (x vk.PhysicalDeviceFeatures)

func (*PhysicalDevice) FindMemoryType 

func (phy *PhysicalDevice) FindMemoryType(typeFilter uint32, properties vk.MemoryPropertyFlags) uint32

func (*PhysicalDevice) FindQueueFamilies 

func (phy *PhysicalDevice) FindQueueFamilies(win vk.SurfaceKHR) (graphics, present int)

func (*PhysicalDevice) Name 

func (phy *PhysicalDevice) Name() (x string)

func (*PhysicalDevice) PipelineCacheUUID 

func (phy *PhysicalDevice) PipelineCacheUUID() (x uuid.UUID)

func (*PhysicalDevice) Properties 

func (phy *PhysicalDevice) Properties() (x vk.PhysicalDeviceProperties)

func (*PhysicalDevice) ResolveForSurface 

func (phy *PhysicalDevice) ResolveForSurface(sur vk.SurfaceKHR) (x uint32, ropts *SurfaceProperties)

func (*PhysicalDevice) String 

func (phy *PhysicalDevice) String() string

type Pipeline 

type Pipeline struct {
	Handle         vk.Pipeline
	PipelineLayout vk.PipelineLayout
	SetLayouts     []vk.DescriptorSetLayout
	Shaders        []*ShaderModule
	Device         *Device
	Instance       *Instance
}

func (*Pipeline) Close 

func (pl *Pipeline) Close() error

type PipelineColorBlendAttachmentState 

type PipelineColorBlendAttachmentState = vk.PipelineColorBlendAttachmentState

type PipelineInfo 

type PipelineInfo struct {
	Shaders              []string
	DescriptorSetLayouts []DescriptorSetLayoutInfo
	PushConstantRanges   []PushConstantRange
	Bindings             []VertexBinding
	Attributes           []VertexAttribute
	InputAssembly        InputAssembly
	Viewports            []Viewport
	Scissors             []vk.Rect2D
	Rasterization        RasterizationInfo
	ColorBlends          []PipelineColorBlendAttachmentState
	RenderPass           vk.RenderPass
	Subpass              uint32
}

type Point 

type Point = calc.Point2

Point type

type Pool 

type Pool struct {
	sync.Mutex

	Idle []interface{}

	New func() interface{}
}

func (*Pool) Get 

func (p *Pool) Get() (x interface{})

func (*Pool) Put 

func (p *Pool) Put(x interface{})

type PushConstantRange 

type PushConstantRange = vk.PushConstantRange

type Range 

type Range = calc.Range2

Range type

type RasterizationInfo 

type RasterizationInfo struct {
	Flags                   vk.PipelineRasterizationStateCreateFlags
	DepthClampEnable        bool
	RasterizerDiscardEnable bool
	PolygonMode             vk.PolygonMode
	CullMode                vk.CullModeFlags
	FrontFace               vk.FrontFace
	DepthBiasEnable         bool
	DepthBiasConstantFactor float32
	DepthBiasClamp          float32
	DepthBiasSlopeFactor    float32
	LineWidth               float32
}

type Rect 

type Rect = calc.Rect2

Rect type

type RenderPass 

type RenderPass struct {
	Handle vk.RenderPass
	Device *Device
}

func (*RenderPass) Close 

func (p *RenderPass) Close() error

type RenderPassInfo 

type RenderPassInfo struct {
	Flags          vk.RenderPassCreateFlags
	Attachments    []vk.AttachmentDescription
	Subpasses      []SubpassInfo
	SubpassDepends []vk.SubpassDependency
}

type Sampler 

type Sampler struct {
	Handle vk.Sampler
	Device *Device
}

func (*Sampler) Close 

func (smplr *Sampler) Close() error

type Semaphore 

type Semaphore struct {
	Handle vk.Semaphore
	Device *Device
}

func (*Semaphore) Close 

func (sem *Semaphore) Close() error

type ShaderModule 

type ShaderModule struct {
	Handle vk.ShaderModule

	Device *Device
	// contains filtered or unexported fields
}

func (*ShaderModule) Close 

func (sm *ShaderModule) Close() error

func (*ShaderModule) EntryPoint 

func (sm *ShaderModule) EntryPoint() string

type Size 

type Size = calc.Size2

Size type

type SubpassInfo 

type SubpassInfo struct {
	Flags                  vk.SubpassDescriptionFlags
	PipelineBindPoint      vk.PipelineBindPoint
	InputAttachments       []vk.AttachmentReference
	ColorAttachments       []vk.AttachmentReference
	ResolveAttachments     []vk.AttachmentReference
	DepthStencilAttachment *vk.AttachmentReference
	PreserveAttachments    []uint32
}

type Surface 

type Surface struct {
	Device  *Device
	Surface vk.SurfaceKHR

	*SurfaceProperties

	Swapchain *vk.SwapchainKHR

	Framebuffers []*Framebuffer

	FrameFlights []*FrameFlight

	CurrentFrame uint32

	UiRenderPass *RenderPass

	TextPipeline *Pipeline

	NeedRecreate bool
	// contains filtered or unexported fields
}

func (*Surface) AcquireNextImage 

func (sur *Surface) AcquireNextImage(timeoutNsec uint64, semaphore vk.Semaphore, fence vk.Fence) (imageIndex uint32, err error)

func (*Surface) Close 

func (sur *Surface) Close() error

func (*Surface) CreateFlight 

func (sur *Surface) CreateFlight() (frm *FrameFlight, err error)

func (*Surface) CreateFramebuffers 

func (sur *Surface) CreateFramebuffers(pass vk.RenderPass, format vk.Format, extent vk.Extent2D) (fbs []*Framebuffer, err error)

func (*Surface) Init 

func (sur *Surface) Init(self interface{}, inst *Instance, sys SysSurfaceData) (err error)

func (*Surface) InitTextPipleline 

func (sur *Surface) InitTextPipleline() (err error)

func (*Surface) InitUiRenderPass 

func (sur *Surface) InitUiRenderPass() (err error)

func (*Surface) OnCreateSurface 

func (sur *Surface) OnCreateSurface() error

func (*Surface) Pause 

func (sur *Surface) Pause()

func (*Surface) PauseDur 

func (sur *Surface) PauseDur(ms int64)

func (*Surface) Paused 

func (sur *Surface) Paused() bool

func (*Surface) Recreate 

func (sur *Surface) Recreate(self interface{}) (err error)

func (*Surface) Resume 

func (sur *Surface) Resume()

func (*Surface) WaitAllFences 

func (sur *Surface) WaitAllFences()

type SurfaceCapabilities 

type SurfaceCapabilities = vk.SurfaceCapabilitiesKHR

type SurfaceHandler 

type SurfaceHandler interface {
	OnCreateSurface() error
}

type SurfaceProperties 

type SurfaceProperties struct {
	SurfaceCapabilities

	SurfaceFormat vk.SurfaceFormatKHR
	ImageCount    uint32
	PresentMode   vk.PresentModeKHR

	GraphicsFamily uint32
	PresentFamily  uint32
}

type SysPfns 

type SysPfns struct {
	vk.PfnCreateXcbSurfaceKHR
	vk.PfnGetPhysicalDeviceXcbPresentationSupportKHR
}

type SysSurfaceData 

type SysSurfaceData struct {
	ID  uintptr
	Ctx uintptr
}

type Text 

type Text struct {
	*font.Text
	Uni2D
	VB       *BufferMemory
	NumVerts uint32
	// contains filtered or unexported fields
}

func (*Text) Close 

func (text *Text) Close() error

func (*Text) RecordCommands 

func (text *Text) RecordCommands(cb CommandBuffer, pl *Pipeline)

type Uni2D 

type Uni2D struct {
	M Mat3
	// contains filtered or unexported fields
}

type Uni3DMat 

type Uni3DMat struct {
	MP Mat4
	MV Mat4
	MM Mat4
}

type UniEnvBlock 

type UniEnvBlock struct {
	// time in secs
	T float32
}

type Vec2 

type Vec2 = calc.Vec2

Vec2 type

type Vec3 

type Vec3 = calc.Vec3

Vec3 type

type Vec4 

type Vec4 = calc.Vec4

Vec4 type

type VertexAttribute 

type VertexAttribute = vk.VertexInputAttributeDescription

type VertexBinding 

type VertexBinding = vk.VertexInputBindingDescription

type Viewport 

type Viewport = vk.Viewport

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.