roodletoof/whiteboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

updated ebiten version from 2.7.9 to 2.9.9

Browse Source
This commit is contained in:
Ivar Fatland
2026-06-15 19:06:55 +02:00
parent 21edbc41c4
commit db1b625069
405 changed files with 31913 additions and 12595 deletions
Download Patch File Download Diff File Expand all files Collapse all files
vendor/github.com/hajimehoshi/ebiten/v2/internal/shader/expr.go
Generated Vendored
+137 -43
View File
@@ -88,6 +88,10 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
return nil, nil, nil, false
}
stmts = append(stmts, ss...)
if len(ts) == 0 {
cs.addError(e.Pos(), fmt.Sprintf("unexpected binary operator: %s", e.Y))
return nil, nil, nil, false
}
rhst := ts[0]
op := e.Op
@@ -199,7 +203,7 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
return nil, nil, nil, false
}
for _, expr := range es {
if expr.Type == shaderir.FunctionExpr {
if expr.Type == shaderir.FunctionExpr || expr.Type == shaderir.BuiltinFuncExpr {
cs.addError(e.Pos(), fmt.Sprintf("function name cannot be an argument: %s", e.Fun))
return nil, nil, nil, false
}
@@ -417,6 +421,16 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
return nil, nil, nil, false
}
finalType = shaderir.Type{Main: shaderir.Vec4}
case shaderir.FrontFacing:
if len(args) != 0 {
cs.addError(e.Pos(), fmt.Sprintf("number of %s's arguments must be 0 but %d", callee.BuiltinFunc, len(args)))
return nil, nil, nil, false
}
if fname != cs.fragmentEntry {
cs.addError(e.Pos(), fmt.Sprintf("frontfacing is available only in %s", cs.fragmentEntry))
return nil, nil, nil, false
}
finalType = shaderir.Type{Main: shaderir.Bool}
case shaderir.DiscardF:
if len(args) != 0 {
cs.addError(e.Pos(), fmt.Sprintf("number of %s's arguments must be 0 but %d", callee.BuiltinFunc, len(args)))
@@ -430,7 +444,6 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
Type: shaderir.Discard,
})
return nil, nil, stmts, true
case shaderir.Clamp, shaderir.Mix, shaderir.Smoothstep, shaderir.Faceforward, shaderir.Refract:
// 3 arguments
if len(args) != 3 {
@@ -571,22 +584,65 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
finalType = argts[0]
}
case shaderir.Atan2, shaderir.Pow, shaderir.Mod, shaderir.Min, shaderir.Max, shaderir.Step, shaderir.Distance, shaderir.Dot, shaderir.Cross, shaderir.Reflect:
// 2 arguments
if len(args) != 2 {
cs.addError(e.Pos(), fmt.Sprintf("number of %s's arguments must be 2 but %d", callee.BuiltinFunc, len(args)))
case shaderir.Min, shaderir.Max:
if len(args) < 1 {
cs.addError(e.Pos(), fmt.Sprintf("number of %s's arguments must be 1 or more but %d", callee.BuiltinFunc, len(args)))
return nil, nil, nil, false
}
switch callee.BuiltinFunc {
case shaderir.Min, shaderir.Max:
var hasVectors bool
var hasScalars bool
for i := range argts {
if argts[i].IsFloatVector() || argts[i].IsIntVector() {
hasVectors = true
continue
}
if argts[i].Main == shaderir.Float || argts[i].Main == shaderir.Int || argts[i].Main == shaderir.None {
hasScalars = true
continue
}
}
// Resolve the constant values.
if hasVectors && hasScalars {
// Vector values and scalar values are mixed. Resolve the constant kind based on the first vector argument.
if argts[0].IsIntVector() {
for i := 1; i < len(args); i++ {
if args[i].Const != nil {
v := gconstant.ToInt(args[i].Const)
if v.Kind() == gconstant.Unknown {
cs.addError(e.Pos(), fmt.Sprintf("cannot convert %s to type int", args[i].Const.String()))
return nil, nil, nil, false
}
args[i].Const = v
argts[i] = shaderir.Type{Main: shaderir.Int}
}
}
} else if argts[0].IsFloatVector() {
for i := 1; i < len(args); i++ {
if args[i].Const != nil {
v := gconstant.ToFloat(args[i].Const)
if v.Kind() == gconstant.Unknown {
cs.addError(e.Pos(), fmt.Sprintf("cannot convert %s to type float", args[i].Const.String()))
return nil, nil, nil, false
}
args[i].Const = v
argts[i] = shaderir.Type{Main: shaderir.Float}
}
}
} else {
cs.addError(e.Pos(), fmt.Sprintf("cannot use %s as vecN or ivecN value in argument to %s", argts[0].String(), callee.BuiltinFunc))
return nil, nil, nil, false
}
} else {
// Vector values and scalar values are not mixed. Resolve the constant kind based on all the arguments.
if kind, _ := resolveConstKind(args, argts); kind != gconstant.Unknown {
switch kind {
case gconstant.Int:
for i, arg := range args {
if arg.Const == nil {
if argts[i].Main != shaderir.Int {
cs.addError(e.Pos(), fmt.Sprintf("%s's arguments don't match: %s and %s", callee.BuiltinFunc, argts[0].String(), argts[1].String()))
cs.addError(e.Pos(), fmt.Sprintf("%s's arguments must all be compatible types but got %s", callee.BuiltinFunc, argts[i].String()))
return nil, nil, nil, false
}
continue
@@ -603,7 +659,7 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
for i, arg := range args {
if arg.Const == nil {
if argts[i].Main != shaderir.Float {
cs.addError(e.Pos(), fmt.Sprintf("%s's arguments don't match: %s and %s", callee.BuiltinFunc, argts[0].String(), argts[1].String()))
cs.addError(e.Pos(), fmt.Sprintf("%s's arguments must all be compatible types but got %s", callee.BuiltinFunc, argts[i].String()))
return nil, nil, nil, false
}
continue
@@ -618,25 +674,45 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
}
}
}
}
if argts[0].IsIntVector() && args[1].Const != nil {
v := gconstant.ToInt(args[1].Const)
if v.Kind() == gconstant.Unknown {
cs.addError(e.Pos(), fmt.Sprintf("cannot convert %s to type int", args[1].Const.String()))
return nil, nil, nil, false
}
args[1].Const = v
argts[1] = shaderir.Type{Main: shaderir.Int}
for i := range args {
if argts[i].Main != shaderir.Float && !argts[i].IsFloatVector() && argts[i].Main != shaderir.Int && !argts[i].IsIntVector() {
cs.addError(e.Pos(), fmt.Sprintf("cannot use %s as float, vecN, int, or ivecN value in argument to %s", argts[i].String(), callee.BuiltinFunc))
return nil, nil, nil, false
}
if argts[0].IsFloatVector() && args[1].Const != nil {
v := gconstant.ToFloat(args[1].Const)
if v.Kind() == gconstant.Unknown {
cs.addError(e.Pos(), fmt.Sprintf("cannot convert %s to type float", args[1].Const.String()))
return nil, nil, nil, false
}
if len(args) > 1 {
baseType := argts[0]
for i := 1; i < len(args); i++ {
if len(args) == 2 {
if !baseType.Equal(&argts[i]) {
// Only allow vector + scalar (not scalar + vector)
if !((baseType.IsFloatVector() && argts[i].Main == shaderir.Float) || (baseType.IsIntVector() && argts[i].Main == shaderir.Int)) {
cs.addError(e.Pos(), fmt.Sprintf("invalid arguments %s and %s for %s", baseType.String(), argts[i].String(), callee.BuiltinFunc))
return nil, nil, nil, false
}
}
} else {
if !baseType.Equal(&argts[i]) {
cs.addError(e.Pos(), fmt.Sprintf("all argument types must be the same but got %s and %s for variadic %s", baseType.String(), argts[i].String(), callee.BuiltinFunc))
return nil, nil, nil, false
}
}
args[1].Const = v
argts[1] = shaderir.Type{Main: shaderir.Float}
}
}
finalType = argts[0]
case shaderir.Atan2, shaderir.Pow, shaderir.Mod, shaderir.Step, shaderir.Distance, shaderir.Dot, shaderir.Cross, shaderir.Reflect:
// 2 arguments
if len(args) != 2 {
cs.addError(e.Pos(), fmt.Sprintf("number of %s's arguments must be 2 but %d", callee.BuiltinFunc, len(args)))
return nil, nil, nil, false
}
switch callee.BuiltinFunc {
default:
for i := range args {
if args[i].Const != nil && argts[i].Main == shaderir.None {
@@ -650,17 +726,9 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
}
for i := range args {
switch callee.BuiltinFunc {
case shaderir.Min, shaderir.Max:
if argts[i].Main != shaderir.Float && !argts[i].IsFloatVector() && argts[i].Main != shaderir.Int && !argts[i].IsIntVector() {
cs.addError(e.Pos(), fmt.Sprintf("cannot use %s as float, vecN, int, or ivecN value in argument to %s", argts[i].String(), callee.BuiltinFunc))
return nil, nil, nil, false
}
default:
if argts[i].Main != shaderir.Float && !argts[i].IsFloatVector() {
cs.addError(e.Pos(), fmt.Sprintf("cannot use %s as float, vec2, vec3, or vec4 value in argument to %s", argts[i].String(), callee.BuiltinFunc))
return nil, nil, nil, false
}
if argts[i].Main != shaderir.Float && !argts[i].IsFloatVector() {
cs.addError(e.Pos(), fmt.Sprintf("cannot use %s as float, vec2, vec3, or vec4 value in argument to %s", argts[i].String(), callee.BuiltinFunc))
return nil, nil, nil, false
}
}
@@ -670,11 +738,6 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
cs.addError(e.Pos(), fmt.Sprintf("the second argument for %s must equal to the first argument %s or float but %s", callee.BuiltinFunc, argts[0].String(), argts[1].String()))
return nil, nil, nil, false
}
case shaderir.Min, shaderir.Max:
if !(argts[0].Equal(&argts[1]) || (argts[0].IsFloatVector() && argts[1].Main == shaderir.Float) || (argts[0].IsIntVector() && argts[1].Main == shaderir.Int)) {
cs.addError(e.Pos(), fmt.Sprintf("the second argument for %s must equal to the first argument %s or float or int but %s", callee.BuiltinFunc, argts[0].String(), argts[1].String()))
return nil, nil, nil, false
}
case shaderir.Step:
if !argts[0].Equal(&argts[1]) && argts[0].Main != shaderir.Float {
cs.addError(e.Pos(), fmt.Sprintf("the first argument for %s must equal to the second argument %s or float but %s", callee.BuiltinFunc, argts[1].String(), argts[0].String()))
@@ -1034,8 +1097,14 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
cs.addError(e.Pos(), fmt.Sprintf("invalid composite literal type %s", t.String()))
return nil, nil, nil, false
}
if t.Main == shaderir.Array && t.Length == -1 {
t.Length = len(e.Elts)
if t.Main == shaderir.Array {
if t.Length == -1 {
t.Length = len(e.Elts)
} else if t.Length < len(e.Elts) {
// KeyValueExpr is not supported yet. Just compare the length.
cs.addError(e.Pos(), fmt.Sprintf("too many values in %s literal", t.String()))
return nil, nil, nil, false
}
}
idx := block.totalLocalVariableCount()
@@ -1146,6 +1215,31 @@ func (cs *compileState) parseExpr(block *block, fname string, expr ast.Expr, mar
x := exprs[0]
t := ts[0]
// Check the length only when the index is a constant.
if idx.Const != nil {
var length int
switch {
case t.Main == shaderir.Array:
length = t.Length
case t.IsFloatVector() || t.IsIntVector():
length = t.VectorElementCount()
case t.IsMatrix():
length = t.MatrixSize()
default:
cs.addError(e.Pos(), fmt.Sprintf("index operator cannot be applied to the type %s", t.String()))
return nil, nil, nil, false
}
v, ok := gconstant.Int64Val(gconstant.ToInt(idx.Const))
if !ok {
cs.addError(e.Pos(), fmt.Sprintf("constant %s cannot be used as an index", idx.Const.String()))
return nil, nil, nil, false
}
if v < 0 || int(v) >= length {
cs.addError(e.Pos(), fmt.Sprintf("index out of range: %d", v))
return nil, nil, nil, false
}
}
var typ shaderir.Type
switch t.Main {
case shaderir.Vec2, shaderir.Vec3, shaderir.Vec4: