deferred

Documentation

Index

• Constants
• func GetFrameLayout(ctx vk.APIContext, dev *vk.Device) *vk.DescriptorLayout
• type DeferredFrame
  • func (d *DeferredFrame) AddEnvironment(SPH [9]mgl32.Vec4, ubfImage vmodel.ImageIndex, pi *vscene.ProcessInfo)
  • func (d *DeferredFrame) AddFrameImage(view *vk.ImageView, sampler *vk.Sampler) (imageIndex vmodel.ImageIndex)
  • func (d *DeferredFrame) BindDeferredFrame() *vk.DescriptorSet
  • func (d *DeferredFrame) GetCache() *vk.RenderCache
  • func (d *DeferredFrame) GetRenderer() vmodel.Renderer
  • func (f *DeferredFrame) GetSimpleFrame() *vscene.SimpleFrame
• type DeferredLayout
• type DrawFrame
• type DrawLights
  • func (dl *DrawLights) AddLight(standard vscene.Light, special interface{})
  • func (dl *DrawLights) Begin() (atEnd func())
  • func (dl *DrawLights) GetCache() *vk.RenderCache
• type LightsFrame
• type Probe
• type Renderer
  • func NewRenderer() *Renderer
  • func (f *Renderer) Dispose()
  • func (r *Renderer) GetPerRenderer(key vk.Key, ctor func(ctx vk.APIContext) interface{}) interface{}
  • func (f *Renderer) GetRenderPass() vk.RenderPass
  • func (f *Renderer) Render(camera vscene.Camera, sc *vscene.Scene, rc *vk.RenderCache, ...)
  • func (f *Renderer) RenderView(camera vscene.Camera, sc *vscene.Scene, rc *vk.RenderCache, ...)
  • func (f *Renderer) SetTimedOutput(output func(started time.Time, gpuTimes []float64))
  • func (f *Renderer) Setup(ctx vk.APIContext, dev *vk.Device, mainImage vk.ImageDescription, images int)

Constants

const (
	MAX_PROBES = 16
	MAX_LIGHTS = 64
)

const LAYER3DSplit = vscene.LAYER3D + 1

const ShadowPoints = 1024 * 1024

Functions

func GetFrameLayout

func GetFrameLayout(ctx vk.APIContext, dev *vk.Device) *vk.DescriptorLayout

Types

type DeferredFrame

type DeferredFrame struct {
	DrawPhase   DrawFrame
	LightsFrame LightsFrame
	// contains filtered or unexported fields
}

func (*DeferredFrame) AddEnvironment

func (d *DeferredFrame) AddEnvironment(SPH [9]mgl32.Vec4, ubfImage vmodel.ImageIndex, pi *vscene.ProcessInfo)

func (*DeferredFrame) AddFrameImage

func (d *DeferredFrame) AddFrameImage(view *vk.ImageView, sampler *vk.Sampler) (imageIndex vmodel.ImageIndex)

func (*DeferredFrame) BindDeferredFrame

func (d *DeferredFrame) BindDeferredFrame() *vk.DescriptorSet

func (*DeferredFrame) GetCache

func (d *DeferredFrame) GetCache() *vk.RenderCache

func (*DeferredFrame) GetRenderer

func (d *DeferredFrame) GetRenderer() vmodel.Renderer

func (*DeferredFrame) GetSimpleFrame

func (f *DeferredFrame) GetSimpleFrame() *vscene.SimpleFrame

type DeferredLayout

type DeferredLayout interface {
	// Bind frame and return descriptor set containing frames UBF and textures
	BindDeferredFrame() *vk.DescriptorSet
}

DeferredLayout indicates that frame is compatible with deferred layout

type DrawFrame

type DrawFrame struct {
	Projection mgl32.Mat4
	View       mgl32.Mat4
	EyePos     mgl32.Vec4
}

DrawFrame are frame settings sent to first Phase (draw geometry)

type DrawLights

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

func (*DrawLights) AddLight

func (dl *DrawLights) AddLight(standard vscene.Light, special interface{})

func (*DrawLights) Begin

func (dl *DrawLights) Begin() (atEnd func())

func (*DrawLights) GetCache

func (dl *DrawLights) GetCache() *vk.RenderCache

type LightsFrame

type LightsFrame struct {
	NoProbes      float32
	NoLight       float32
	Debug         float32
	Index         float32
	InvProjection mgl32.Mat4
	InvView       mgl32.Mat4
	View          mgl32.Mat4
	EyePos        mgl32.Vec4
	Probes        [MAX_PROBES]Probe
	Lights        [MAX_LIGHTS]vscene.Light
}

type Probe

type Probe struct {
	SPH      [9]mgl32.Vec4
	EnvImage float32
	Filler1  float32
	Filler2  float32
	Filler3  float32
}

type Renderer

type Renderer struct {
	// RenderDone is an optional function that is called each time after completing rendering of scene
	RenderDone func(started time.Time)

	Ctx vk.APIContext
	// contains filtered or unexported fields
}

Renderer implement deferred shading that first render all objects into G-buffer. Light calculations are done from G-buffer data after all objects have been rendered to G-buffers. Deferred rendering uses much more resources from GPU than forward shader but it should be faster with scenes that have lots of light (that don't cast shadows). Deferred rendering may also later support post processing effects that are not easily done with forward shader but currently they both have nearly same features.

func NewRenderer

func NewRenderer() *Renderer

func (*Renderer) Dispose

func (f *Renderer) Dispose()

func (*Renderer) GetPerRenderer

func (r *Renderer) GetPerRenderer(key vk.Key, ctor func(ctx vk.APIContext) interface{}) interface{}

func (*Renderer) GetRenderPass

func (f *Renderer) GetRenderPass() vk.RenderPass

func (*Renderer) Render

func (f *Renderer) Render(camera vscene.Camera, sc *vscene.Scene, rc *vk.RenderCache, mainImage *vk.Image, imageIndex int, infos []vk.SubmitInfo)

func (*Renderer) RenderView

func (f *Renderer) RenderView(camera vscene.Camera, sc *vscene.Scene, rc *vk.RenderCache, mainView *vk.ImageView, imageIndex int, infos []vk.SubmitInfo)

func (*Renderer) SetTimedOutput

func (f *Renderer) SetTimedOutput(output func(started time.Time, gpuTimes []float64))

func (*Renderer) Setup

func (f *Renderer) Setup(ctx vk.APIContext, dev *vk.Device, mainImage vk.ImageDescription, images int)