all: remove Z buffer support

It is no longer needed by any rendering backend. Signed-off-by: Elias Naur <mail@eliasnaur.com>
2026-07-01 07:35:40 +00:00 · 2021-08-06 16:36:56 +02:00
parent cea8e21f97
commit 18b4442393
14 changed files with 27 additions and 250 deletions
@@ -888,7 +888,7 @@ restart:
 		if err != nil {
 			return fmt.Errorf("compute: failed to create material atlas: %v", err)
 		}
-		fbo, err := g.ctx.NewFramebuffer(handle, 0)
+		fbo, err := g.ctx.NewFramebuffer(handle)
 		if err != nil {
 			handle.Release()
 			return fmt.Errorf("compute: failed to create material framebuffer: %v", err)
@@ -1303,7 +1303,7 @@ func (a *layerAtlas) ensureSize(useCPU bool, ctx driver.Device, size image.Point
 	if err != nil {
 		return err
 	}
-	fbo, err := ctx.NewFramebuffer(img, 0)
+	fbo, err := ctx.NewFramebuffer(img)
 	if err != nil {
 		img.Release()
 		return err
@@ -419,14 +419,10 @@ func (g *gpu) Frame(target RenderTarget) error {
 		expandPathOp(img.path, img.clip)
 	}
 	g.ctx.BindFramebuffer(defFBO)
-	g.ctx.DepthFunc(driver.DepthFuncGreater)
-	// Note that Clear must be before ClearDepth if nothing else is rendered
-	// (len(zimageOps) == 0). If not, the Fairphone 2 will corrupt the depth buffer.
 	if g.drawOps.clear {
 		g.drawOps.clear = false
 		g.ctx.Clear(g.drawOps.clearColor.Float32())
 	}
-	g.ctx.ClearDepth(0.0)
 	g.ctx.Viewport(0, 0, viewport.X, viewport.Y)
 	g.stencilTimer.begin()
 	g.ctx.SetBlend(true)
@@ -1035,8 +1031,6 @@ func (d *drawState) materialFor(rect f32.Rectangle, off f32.Point, partTrans f32
 }

 func (r *renderer) drawOps(cache *resourceCache, ops []imageOp) {
-	r.ctx.SetDepthTest(true)
-	r.ctx.DepthMask(false)
 	r.ctx.BlendFunc(driver.BlendFactorOne, driver.BlendFactorOneMinusSrcAlpha)
 	r.ctx.BindVertexBuffer(r.blitter.quadVerts, 4*4, 0)
 	r.ctx.BindInputLayout(r.pather.coverer.layout)
@@ -1071,8 +1065,6 @@ func (r *renderer) drawOps(cache *resourceCache, ops []imageOp) {
 		coverScale, coverOff := texSpaceTransform(layout.FRect(uv), fbo.size)
 		r.pather.cover(m.material, m.color, m.color1, m.color2, scale, off, m.uvTrans, coverScale, coverOff)
 	}
-	r.ctx.DepthMask(true)
-	r.ctx.SetDepthTest(false)
 }

 func (b *blitter) blit(mat materialType, col f32color.RGBA, col1, col2 f32color.RGBA, scale, off f32.Point, uvTrans f32.Affine2D) {
@@ -132,7 +132,6 @@ func setupFBO(t *testing.T, b driver.Device, size image.Point) driver.Framebuffe
 	// are in the sRGB color space.
 	col := f32color.LinearFromSRGB(clearCol)
 	b.Clear(col.Float32())
-	b.ClearDepth(0.0)
 	b.Viewport(0, 0, size.X, size.Y)
 	return fbo
 }
@@ -150,8 +149,7 @@ func newFBO(t *testing.T, b driver.Device, size image.Point) driver.Framebuffer
 	t.Cleanup(func() {
 		fboTex.Release()
 	})
-	const depthBits = 16
-	fbo, err := b.NewFramebuffer(fboTex, depthBits)
+	fbo, err := b.NewFramebuffer(fboTex)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -57,8 +57,7 @@ func NewWindow(width, height int) (*Window, error) {
 		if err != nil {
 			return nil
 		}
-		const depthBits = 16
-		fbo, err := dev.NewFramebuffer(fboTex, depthBits)
+		fbo, err := dev.NewFramebuffer(fboTex)
 		if err != nil {
 			fboTex.Release()
 			return err
@@ -23,7 +23,6 @@ type Backend struct {
 	// Temporary storage to avoid garbage.
 	clearColor [4]float32
 	viewport   d3d11.VIEWPORT
-	depthState depthState
 	blendState blendState

 	// Current program.
@@ -37,7 +36,6 @@ type Backend struct {
 	floatFormat uint32

 	// cached state objects.
-	depthStates map[depthState]*d3d11.DepthStencilState
 	blendStates map[blendState]*d3d11.BlendState
 }

@@ -47,12 +45,6 @@ type blendState struct {
 	dfactor driver.BlendFactor
 }

-type depthState struct {
-	enable bool
-	mask   bool
-	fn     driver.DepthFunc
-}
-
 type Texture struct {
 	backend  *Backend
 	format   uint32
@@ -83,7 +75,6 @@ type Framebuffer struct {
 	format       uint32
 	resource     *d3d11.Resource
 	renderTarget *d3d11.RenderTargetView
-	depthView    *d3d11.DepthStencilView
 	foreign      bool
 }

@@ -130,7 +121,6 @@ func newDirect3D11Device(api driver.Direct3D11) (driver.Device, error) {
 			MaxTextureSize: 2048, // 9.1 maximum
 			Features:       driver.FeatureSRGB,
 		},
-		depthStates: make(map[depthState]*d3d11.DepthStencilState),
 		blendStates: make(map[blendState]*d3d11.BlendState),
 	}
 	featLvl := dev.GetFeatureLevel()
@@ -149,13 +139,10 @@ func newDirect3D11Device(api driver.Direct3D11) (driver.Device, error) {
 		b.floatFormat = fmt
 		b.caps.Features |= driver.FeatureFloatRenderTargets
 	}
-	// Enable depth mask to match OpenGL.
-	b.depthState.mask = true
 	// Disable backface culling to match OpenGL.
 	state, err := dev.CreateRasterizerState(&d3d11.RASTERIZER_DESC{
-		CullMode:        d3d11.CULL_NONE,
-		FillMode:        d3d11.FILL_SOLID,
-		DepthClipEnable: 1,
+		CullMode: d3d11.CULL_NONE,
+		FillMode: d3d11.FILL_SOLID,
 	})
 	if err != nil {
 		return nil, err
@@ -168,21 +155,19 @@ func newDirect3D11Device(api driver.Direct3D11) (driver.Device, error) {
 func (b *Backend) BeginFrame(target driver.RenderTarget, clear bool, viewport image.Point) driver.Framebuffer {
 	var (
 		renderTarget *d3d11.RenderTargetView
-		depthView    *d3d11.DepthStencilView
 	)
 	if target != nil {
 		switch t := target.(type) {
 		case driver.Direct3D11RenderTarget:
 			renderTarget = (*d3d11.RenderTargetView)(t.RenderTarget)
-			depthView = (*d3d11.DepthStencilView)(t.DepthStencilView)
 		case *Framebuffer:
-			renderTarget, depthView = t.renderTarget, t.depthView
+			renderTarget = t.renderTarget
 		default:
 			panic(fmt.Errorf("opengl: invalid render target type: %T", target))
 		}
 	}
-	b.ctx.OMSetRenderTargets(renderTarget, depthView)
-	return &Framebuffer{ctx: b.ctx, dev: b.dev, renderTarget: renderTarget, depthView: depthView, foreign: true}
+	b.ctx.OMSetRenderTargets(renderTarget, nil)
+	return &Framebuffer{ctx: b.ctx, dev: b.dev, renderTarget: renderTarget, foreign: true}
 }

 func (b *Backend) BlitFramebuffer(dst, src driver.Framebuffer, srect, drect image.Rectangle) {
@@ -205,9 +190,6 @@ func (b *Backend) IsTimeContinuous() bool {
 }

 func (b *Backend) Release() {
-	for _, state := range b.depthStates {
-		d3d11.IUnknownRelease(unsafe.Pointer(state), state.Vtbl.Release)
-	}
 	for _, state := range b.blendStates {
 		d3d11.IUnknownRelease(unsafe.Pointer(state), state.Vtbl.Release)
 	}
@@ -291,7 +273,7 @@ func (b *Backend) NewTexture(format driver.TextureFormat, width, height int, min
 	return &Texture{backend: b, format: d3dfmt, tex: tex, sampler: sampler, resView: resView, bindings: bindings, width: width, height: height}, nil
 }

-func (b *Backend) NewFramebuffer(tex driver.Texture, depthBits int) (driver.Framebuffer, error) {
+func (b *Backend) NewFramebuffer(tex driver.Texture) (driver.Framebuffer, error) {
 	d3dtex := tex.(*Texture)
 	if d3dtex.bindings&driver.BufferBindingFramebuffer == 0 {
 		return nil, errors.New("the texture was created without BufferBindingFramebuffer binding")
@@ -302,14 +284,6 @@ func (b *Backend) NewFramebuffer(tex driver.Texture, depthBits int) (driver.Fram
 		return nil, err
 	}
 	fbo := &Framebuffer{ctx: b.ctx, dev: b.dev, format: d3dtex.format, resource: resource, renderTarget: renderTarget}
-	if depthBits > 0 {
-		depthView, err := d3d11.CreateDepthView(b.dev, d3dtex.width, d3dtex.height, depthBits)
-		if err != nil {
-			d3d11.IUnknownRelease(unsafe.Pointer(renderTarget), renderTarget.Vtbl.Release)
-			return nil, err
-		}
-		fbo.depthView = depthView
-	}
 	return fbo, nil
 }

@@ -430,12 +404,6 @@ func (b *Backend) Clear(colr, colg, colb, cola float32) {
 	b.ctx.ClearRenderTargetView(b.fbo.renderTarget, &b.clearColor)
 }

-func (b *Backend) ClearDepth(depth float32) {
-	if b.fbo.depthView != nil {
-		b.ctx.ClearDepthStencilView(b.fbo.depthView, d3d11.CLEAR_DEPTH|d3d11.CLEAR_STENCIL, depth, 0)
-	}
-}
-
 func (b *Backend) Viewport(x, y, width, height int) {
 	b.viewport = d3d11.VIEWPORT{
 		TopLeftX: float32(x),
@@ -480,32 +448,6 @@ func (b *Backend) prepareDraw(mode driver.DrawMode) {
 	}
 	b.ctx.IASetPrimitiveTopology(topology)

-	depthState, ok := b.depthStates[b.depthState]
-	if !ok {
-		var desc d3d11.DEPTH_STENCIL_DESC
-		if b.depthState.enable {
-			desc.DepthEnable = 1
-		}
-		if b.depthState.mask {
-			desc.DepthWriteMask = d3d11.DEPTH_WRITE_MASK_ALL
-		}
-		switch b.depthState.fn {
-		case driver.DepthFuncGreater:
-			desc.DepthFunc = d3d11.COMPARISON_GREATER
-		case driver.DepthFuncGreaterEqual:
-			desc.DepthFunc = d3d11.COMPARISON_GREATER_EQUAL
-		default:
-			panic("unsupported depth func")
-		}
-		var err error
-		depthState, err = b.dev.CreateDepthStencilState(&desc)
-		if err != nil {
-			panic(err)
-		}
-		b.depthStates[b.depthState] = depthState
-	}
-	b.ctx.OMSetDepthStencilState(depthState, 0)
-
 	blendState, ok := b.blendStates[b.blendState]
 	if !ok {
 		var desc d3d11.BLEND_DESC
@@ -532,22 +474,10 @@ func (b *Backend) prepareDraw(mode driver.DrawMode) {
 	b.ctx.OMSetBlendState(blendState, nil, 0xffffffff)
 }

-func (b *Backend) DepthFunc(f driver.DepthFunc) {
-	b.depthState.fn = f
-}
-
 func (b *Backend) SetBlend(enable bool) {
 	b.blendState.enable = enable
 }

-func (b *Backend) SetDepthTest(enable bool) {
-	b.depthState.enable = enable
-}
-
-func (b *Backend) DepthMask(mask bool) {
-	b.depthState.mask = mask
-}
-
 func (b *Backend) BlendFunc(sfactor, dfactor driver.BlendFactor) {
 	b.blendState.sfactor = sfactor
 	b.blendState.dfactor = dfactor
@@ -701,7 +631,7 @@ func (f *Framebuffer) ReadPixels(src image.Rectangle, pixels []byte) error {

 func (b *Backend) BindFramebuffer(fbo driver.Framebuffer) {
 	b.fbo = fbo.(*Framebuffer)
-	b.ctx.OMSetRenderTargets(b.fbo.renderTarget, b.fbo.depthView)
+	b.ctx.OMSetRenderTargets(b.fbo.renderTarget, nil)
 }

 func (f *Framebuffer) Invalidate() {
@@ -715,10 +645,6 @@ func (f *Framebuffer) Release() {
 		d3d11.IUnknownRelease(unsafe.Pointer(f.renderTarget), f.renderTarget.Vtbl.Release)
 		f.renderTarget = nil
 	}
-	if f.depthView != nil {
-		d3d11.IUnknownRelease(unsafe.Pointer(f.depthView), f.depthView.Vtbl.Release)
-		f.depthView = nil
-	}
 }

 func (f *Framebuffer) ImplementsRenderTarget() {}
@@ -24,8 +24,6 @@ type OpenGLRenderTarget gl.Framebuffer
 type Direct3D11RenderTarget struct {
 	// RenderTarget is a *ID3D11RenderTargetView.
 	RenderTarget unsafe.Pointer
-	// DepthStencilView is a *ID3D11DepthStencilView.
-	DepthStencilView unsafe.Pointer
 }

 type OpenGL struct {
@@ -20,22 +20,18 @@ type Device interface {
 	// are valid at the point of call.
 	IsTimeContinuous() bool
 	NewTexture(format TextureFormat, width, height int, minFilter, magFilter TextureFilter, bindings BufferBinding) (Texture, error)
-	NewFramebuffer(tex Texture, depthBits int) (Framebuffer, error)
+	NewFramebuffer(tex Texture) (Framebuffer, error)
 	NewImmutableBuffer(typ BufferBinding, data []byte) (Buffer, error)
 	NewBuffer(typ BufferBinding, size int) (Buffer, error)
 	NewComputeProgram(shader ShaderSources) (Program, error)
 	NewProgram(vertexShader, fragmentShader ShaderSources) (Program, error)
 	NewInputLayout(vertexShader ShaderSources, layout []InputDesc) (InputLayout, error)

-	DepthFunc(f DepthFunc)
-	ClearDepth(d float32)
 	Clear(r, g, b, a float32)
 	Viewport(x, y, width, height int)
 	DrawArrays(mode DrawMode, off, count int)
 	DrawElements(mode DrawMode, off, count int)
 	SetBlend(enable bool)
-	SetDepthTest(enable bool)
-	DepthMask(mask bool)
 	BlendFunc(sfactor, dfactor BlendFactor)

 	BindInputLayout(i InputLayout)
@@ -129,8 +125,6 @@ type BufferBinding uint8

 type DataType uint8

-type DepthFunc uint8
-
 type Features uint

 type Caps struct {
@@ -173,11 +167,6 @@ type Texture interface {
 	Release()
 }

-const (
-	DepthFuncGreater DepthFunc = iota
-	DepthFuncGreaterEqual
-)
-
 const (
 	DataTypeFloat DataType = iota
 	DataTypeInt
@@ -67,17 +67,13 @@ type glState struct {
 	storeBuf  gl.Buffer
 	storeBufs [4]gl.Buffer
 	vertArray gl.VertexArray
-	depthMask bool
-	depthFunc gl.Enum
 	srgb      bool
 	blend     struct {
 		enable         bool
 		srcRGB, dstRGB gl.Enum
 		srcA, dstA     gl.Enum
 	}
-	depthTest         bool
 	clearColor        [4]float32
-	clearDepth        float32
 	viewport          [4]int
 	unpack_row_length int
 }
@@ -108,11 +104,9 @@ type gpuTexture struct {
 }

 type gpuFramebuffer struct {
-	backend  *Backend
-	obj      gl.Framebuffer
-	hasDepth bool
-	depthBuf gl.Renderbuffer
-	foreign  bool
+	backend *Backend
+	obj     gl.Framebuffer
+	foreign bool
 }

 type gpuBuffer struct {
@@ -286,10 +280,6 @@ func (b *Backend) queryState() glState {
 		arrayBuf:          gl.Buffer(b.funcs.GetBinding(gl.ARRAY_BUFFER_BINDING)),
 		elemBuf:           gl.Buffer(b.funcs.GetBinding(gl.ELEMENT_ARRAY_BUFFER_BINDING)),
 		drawFBO:           gl.Framebuffer(b.funcs.GetBinding(gl.FRAMEBUFFER_BINDING)),
-		depthMask:         b.funcs.GetInteger(gl.DEPTH_WRITEMASK) != gl.FALSE,
-		depthTest:         b.funcs.IsEnabled(gl.DEPTH_TEST),
-		depthFunc:         gl.Enum(b.funcs.GetInteger(gl.DEPTH_FUNC)),
-		clearDepth:        b.funcs.GetFloat(gl.DEPTH_CLEAR_VALUE),
 		clearColor:        b.funcs.GetFloat4(gl.COLOR_CLEAR_VALUE),
 		viewport:          b.funcs.GetInteger4(gl.VIEWPORT),
 		unpack_row_length: b.funcs.GetInteger(gl.UNPACK_ROW_LENGTH),
@@ -346,8 +336,6 @@ func (b *Backend) restoreState(dst glState) {
 	src.set(f, gl.BLEND, dst.blend.enable)
 	bf := dst.blend
 	src.setBlendFuncSeparate(f, bf.srcRGB, bf.dstRGB, bf.srcA, bf.dstA)
-	src.set(f, gl.DEPTH_TEST, dst.depthTest)
-	src.setDepthFunc(f, dst.depthFunc)
 	src.set(f, gl.FRAMEBUFFER_SRGB, dst.srgb)
 	src.bindVertexArray(f, dst.vertArray)
 	src.useProgram(f, dst.prog)
@@ -360,8 +348,6 @@ func (b *Backend) restoreState(dst glState) {
 		src.bindBufferBase(f, gl.SHADER_STORAGE_BUFFER, i, b)
 	}
 	src.bindBuffer(f, gl.SHADER_STORAGE_BUFFER, dst.storeBuf)
-	src.setDepthMask(f, dst.depthMask)
-	src.setClearDepth(f, dst.clearDepth)
 	col := dst.clearColor
 	src.setClearColor(f, col[0], col[1], col[2], col[3])
 	for i, attr := range dst.vertAttribs {
@@ -583,13 +569,6 @@ func (s *glState) pixelStorei(f *gl.Functions, pname gl.Enum, val int) {
 	}
 }

-func (s *glState) setClearDepth(f *gl.Functions, d float32) {
-	if d != s.clearDepth {
-		f.ClearDepthf(d)
-		s.clearDepth = d
-	}
-}
-
 func (s *glState) setClearColor(f *gl.Functions, r, g, b, a float32) {
 	col := [4]float32{r, g, b, a}
 	if col != s.clearColor {
@@ -606,13 +585,6 @@ func (s *glState) setViewport(f *gl.Functions, x, y, width, height int) {
 	}
 }

-func (s *glState) setDepthFunc(f *gl.Functions, df gl.Enum) {
-	if df != s.depthFunc {
-		f.DepthFunc(df)
-		s.depthFunc = df
-	}
-}
-
 func (s *glState) setBlendFuncSeparate(f *gl.Functions, srcRGB, dstRGB, srcA, dstA gl.Enum) {
 	if srcRGB != s.blend.srcRGB || dstRGB != s.blend.dstRGB || srcA != s.blend.srcA || dstA != s.blend.dstA {
 		s.blend.srcRGB = srcRGB
@@ -623,13 +595,6 @@ func (s *glState) setBlendFuncSeparate(f *gl.Functions, srcRGB, dstRGB, srcA, ds
 	}
 }

-func (s *glState) setDepthMask(f *gl.Functions, enable bool) {
-	if enable != s.depthMask {
-		f.DepthMask(enable)
-		s.depthMask = enable
-	}
-}
-
 func (s *glState) set(f *gl.Functions, target gl.Enum, enable bool) {
 	switch target {
 	case gl.FRAMEBUFFER_SRGB:
@@ -642,11 +607,6 @@ func (s *glState) set(f *gl.Functions, target gl.Enum, enable bool) {
 			return
 		}
 		s.blend.enable = enable
-	case gl.DEPTH_TEST:
-		if enable == s.depthTest {
-			return
-		}
-		s.depthTest = enable
 	default:
 		panic("unknown enable")
 	}
@@ -672,7 +632,7 @@ func (b *Backend) IsTimeContinuous() bool {
 	return b.funcs.GetInteger(gl.GPU_DISJOINT_EXT) == gl.FALSE
 }

-func (b *Backend) NewFramebuffer(tex driver.Texture, depthBits int) (driver.Framebuffer, error) {
+func (b *Backend) NewFramebuffer(tex driver.Texture) (driver.Framebuffer, error) {
 	glErr(b.funcs)
 	gltex := tex.(*gpuTexture)
 	fb := b.funcs.CreateFramebuffer()
@@ -683,25 +643,6 @@ func (b *Backend) NewFramebuffer(tex driver.Texture, depthBits int) (driver.Fram
 		return nil, err
 	}
 	b.funcs.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, gltex.obj, 0)
-	if depthBits > 0 {
-		size := gl.Enum(gl.DEPTH_COMPONENT16)
-		switch {
-		case depthBits > 24:
-			size = gl.DEPTH_COMPONENT32F
-		case depthBits > 16:
-			size = gl.DEPTH_COMPONENT24
-		}
-		depthBuf := b.funcs.CreateRenderbuffer()
-		b.glstate.bindRenderbuffer(b.funcs, gl.RENDERBUFFER, depthBuf)
-		b.funcs.RenderbufferStorage(gl.RENDERBUFFER, size, gltex.width, gltex.height)
-		b.funcs.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, depthBuf)
-		fbo.depthBuf = depthBuf
-		fbo.hasDepth = true
-		if err := glErr(b.funcs); err != nil {
-			fbo.Release()
-			return nil, err
-		}
-	}
 	if st := b.funcs.CheckFramebufferStatus(gl.FRAMEBUFFER); st != gl.FRAMEBUFFER_COMPLETE {
 		fbo.Release()
 		return nil, fmt.Errorf("incomplete framebuffer, status = 0x%x, err = %d", st, b.funcs.GetError())
@@ -840,10 +781,6 @@ func (b *Backend) useProgram(p *gpuProgram) {
 	b.state.prog = p
 }

-func (b *Backend) SetDepthTest(enable bool) {
-	b.glstate.set(b.funcs, gl.DEPTH_TEST, enable)
-}
-
 func (b *Backend) BlendFunc(sfactor, dfactor driver.BlendFactor) {
 	src, dst := toGLBlendFactor(sfactor), toGLBlendFactor(dfactor)
 	b.glstate.setBlendFuncSeparate(b.funcs, src, dst, src, dst)
@@ -864,10 +801,6 @@ func toGLBlendFactor(f driver.BlendFactor) gl.Enum {
 	}
 }

-func (b *Backend) DepthMask(mask bool) {
-	b.glstate.setDepthMask(b.funcs, mask)
-}
-
 func (b *Backend) SetBlend(enable bool) {
 	b.glstate.set(b.funcs, gl.BLEND, enable)
 }
@@ -913,24 +846,6 @@ func (b *Backend) Clear(colR, colG, colB, colA float32) {
 	b.funcs.Clear(gl.COLOR_BUFFER_BIT)
 }

-func (b *Backend) ClearDepth(d float32) {
-	b.glstate.setClearDepth(b.funcs, d)
-	b.funcs.Clear(gl.DEPTH_BUFFER_BIT)
-}
-
-func (b *Backend) DepthFunc(f driver.DepthFunc) {
-	var glfunc gl.Enum
-	switch f {
-	case driver.DepthFuncGreater:
-		glfunc = gl.GREATER
-	case driver.DepthFuncGreaterEqual:
-		glfunc = gl.GEQUAL
-	default:
-		panic("unsupported depth func")
-	}
-	b.glstate.setDepthFunc(b.funcs, glfunc)
-}
-
 func (b *Backend) NewInputLayout(vs driver.ShaderSources, layout []driver.InputDesc) (driver.InputLayout, error) {
 	if len(vs.Inputs) != len(layout) {
 		return nil, fmt.Errorf("NewInputLayout: got %d inputs, expected %d", len(layout), len(vs.Inputs))
@@ -1222,7 +1137,7 @@ func (b *Backend) BlitFramebuffer(dst, src driver.Framebuffer, srect, drect imag
 	b.funcs.BlitFramebuffer(
 		srect.Min.X, srect.Min.Y, srect.Max.X, srect.Max.Y,
 		drect.Min.X, drect.Min.Y, drect.Max.X, drect.Max.Y,
-		gl.COLOR_BUFFER_BIT|gl.DEPTH_BUFFER_BIT|gl.STENCIL_BUFFER_BIT,
+		gl.COLOR_BUFFER_BIT,
 		gl.NEAREST)
 }

@@ -1250,9 +1165,6 @@ func (f *gpuFramebuffer) Release() {
 		panic("framebuffer not created by NewFramebuffer")
 	}
 	f.backend.glstate.deleteFramebuffer(f.backend.funcs, f.obj)
-	if f.hasDepth {
-		f.backend.glstate.deleteRenderbuffer(f.backend.funcs, f.depthBuf)
-	}
 }

 func (f *gpuFramebuffer) ImplementsRenderTarget() {}
@@ -22,7 +22,6 @@ type SRGBFBO struct {
 	viewport image.Point
 	fbo      gl.Framebuffer
 	tex      gl.Texture
-	depth    gl.Renderbuffer
 	blitted  bool
 	quad     gl.Buffer
 	prog     gl.Program
@@ -47,7 +46,6 @@ func NewSRGBFBO(f *gl.Functions, state *glState) (*SRGBFBO, error) {
 		format: srgbTriple,
 		fbo:    f.CreateFramebuffer(),
 		tex:    f.CreateTexture(),
-		depth:  f.CreateRenderbuffer(),
 	}
 	state.bindTexture(f, 0, s.tex)
 	f.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
@@ -87,7 +85,6 @@ func (s *SRGBFBO) Blit() {
 	s.c.DrawArrays(gl.TRIANGLE_STRIP, 0, 4)
 	s.state.bindFramebuffer(s.c, gl.FRAMEBUFFER, s.fbo)
 	s.c.InvalidateFramebuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0)
-	s.c.InvalidateFramebuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT)
 }

 func (s *SRGBFBO) Framebuffer() gl.Framebuffer {
@@ -104,11 +101,8 @@ func (s *SRGBFBO) Refresh(viewport image.Point) error {
 	s.viewport = viewport
 	s.state.bindTexture(s.c, 0, s.tex)
 	s.c.TexImage2D(gl.TEXTURE_2D, 0, s.format.internalFormat, viewport.X, viewport.Y, s.format.format, s.format.typ)
-	s.state.bindRenderbuffer(s.c, gl.RENDERBUFFER, s.depth)
-	s.c.RenderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, viewport.X, viewport.Y)
 	s.state.bindFramebuffer(s.c, gl.FRAMEBUFFER, s.fbo)
 	s.c.FramebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, s.tex, 0)
-	s.c.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, s.depth)
 	if st := s.c.CheckFramebufferStatus(gl.FRAMEBUFFER); st != gl.FRAMEBUFFER_COMPLETE {
 		return fmt.Errorf("sRGB framebuffer incomplete (%dx%d), status: %#x error: %x", viewport.X, viewport.Y, st, s.c.GetError())
 	}
@@ -135,7 +129,6 @@ func (s *SRGBFBO) Refresh(viewport image.Point) error {
 func (s *SRGBFBO) Release() {
 	s.state.deleteFramebuffer(s.c, s.fbo)
 	s.state.deleteTexture(s.c, s.tex)
-	s.state.deleteRenderbuffer(s.c, s.depth)
 	if s.blitted {
 		s.state.deleteBuffer(s.c, s.quad)
 		s.state.deleteProgram(s.c, s.prog)
@@ -252,7 +252,7 @@ func (s *fboSet) resize(ctx driver.Device, sizes []image.Point) {
 			if err != nil {
 				panic(err)
 			}
-			fbo, err := ctx.NewFramebuffer(tex, 0)
+			fbo, err := ctx.NewFramebuffer(tex)
 			if err != nil {
 				panic(err)
 			}