updated ebiten version from 2.7.9 to 2.9.9

vendor/github.com/hajimehoshi/ebiten/v2/internal/builtinshader/shader.go

@@ -12,6 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:generate go run gen.go
+//go:generate gofmt -s -w .
+
 package builtinshader
 
 import (
@@ -26,9 +29,10 @@ type Filter int
 const (
 	FilterNearest Filter = iota
 	FilterLinear
+	FilterPixelated
 )
 
-const FilterCount = 2
+const FilterCount = 3
 
 type Address int
 
@@ -60,7 +64,7 @@ var ColorMTranslation vec4
 {{end}}
 
 {{if eq .Address .AddressRepeat}}
-func adjustTexelForAddressRepeat(p vec2) vec2 {
+func adjustSrcPosForAddressRepeat(p vec2) vec2 {
 	origin := imageSrc0Origin()
 	size := imageSrc0Size()
 	return mod(p - origin, size) + origin
@@ -74,15 +78,25 @@ func Fragment(dstPos vec4, srcPos vec2, color vec4) vec4 {
 {{else if eq .Address .AddressClampToZero}}
 	clr := imageSrc0At(srcPos)
 {{else if eq .Address .AddressRepeat}}
-	clr := imageSrc0At(adjustTexelForAddressRepeat(srcPos))
+	clr := imageSrc0At(adjustSrcPosForAddressRepeat(srcPos))
 {{end}}
-{{else if eq .Filter .FilterLinear}}
+{{else}}
+{{if eq .Filter .FilterLinear}}
 	p0 := srcPos - 1/2.0
 	p1 := srcPos + 1/2.0
+{{else if eq .Filter .FilterPixelated}}
+	// inversedScale is the size of the region on the source image.
+	// The size is the inverse of the geometry-matrix scale.
+	inversedScale := vec2(abs(dfdx(srcPos.x)), abs(dfdy(srcPos.y)))
+	// Cap the inversedScale to 1 as dfdx/dfdy is not accurate on some machines (#3182).
+	inversedScale = min(inversedScale, vec2(1))
+	p0 := srcPos - inversedScale/2.0
+	p1 := srcPos + inversedScale/2.0
+{{end}}
 
 {{if eq .Address .AddressRepeat}}
-	p0 = adjustTexelForAddressRepeat(p0)
-	p1 = adjustTexelForAddressRepeat(p1)
+	p0 = adjustSrcPosForAddressRepeat(p0)
+	p1 = adjustSrcPosForAddressRepeat(p1)
 {{end}}
 
 {{if eq .Address .AddressUnsafe}}
@@ -97,7 +111,11 @@ func Fragment(dstPos vec4, srcPos vec2, color vec4) vec4 {
 	c3 := imageSrc0At(p1)
 {{end}}
 
+{{if eq .Filter .FilterLinear}}
 	rate := fract(p1)
+{{else if eq .Filter .FilterPixelated}}
+	rate := clamp(fract(p1)/inversedScale, 0, 1)
+{{end}}
 	clr := mix(mix(c0, c1, rate.x), mix(c2, c3, rate.x), rate.y)
 {{end}}
 
@@ -123,10 +141,10 @@ func Fragment(dstPos vec4, srcPos vec2, color vec4) vec4 {
 
 `))
 
-// Shader returns the built-in shader based on the given parameters.
+// ShaderSource returns the built-in shader source based on the given parameters.
 //
 // The returned shader always uses a color matrix so far.
-func Shader(filter Filter, address Address, useColorM bool) []byte {
+func ShaderSource(filter Filter, address Address, useColorM bool) []byte {
 	shadersM.Lock()
 	defer shadersM.Unlock()
 
@@ -143,6 +161,7 @@ func Shader(filter Filter, address Address, useColorM bool) []byte {
 		Filter             Filter
 		FilterNearest      Filter
 		FilterLinear       Filter
+		FilterPixelated    Filter
 		Address            Address
 		AddressUnsafe      Address
 		AddressClampToZero Address
@@ -152,6 +171,7 @@ func Shader(filter Filter, address Address, useColorM bool) []byte {
 		Filter:             filter,
 		FilterNearest:      FilterNearest,
 		FilterLinear:       FilterLinear,
+		FilterPixelated:    FilterPixelated,
 		Address:            address,
 		AddressUnsafe:      AddressUnsafe,
 		AddressClampToZero: AddressClampToZero,
@@ -165,3 +185,13 @@ func Shader(filter Filter, address Address, useColorM bool) []byte {
 	shaders[filter][address][c] = b
 	return b
 }
+
+//ebitengine:shadersource
+const ClearShaderSource = `//kage:unit pixels
+
+package main
+
+func Fragment() vec4 {
+	return vec4(0)
+}
+`