ebiten/internal/shaderir/program.go

255 lines
5.8 KiB
Go
Raw Normal View History

2020-05-11 17:19:42 +02:00
// Copyright 2020 The Ebiten Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
2020-05-16 16:42:32 +02:00
// Package shaderir offers intermediate representation for shader programs.
2020-05-11 17:19:42 +02:00
package shaderir
type Program struct {
2020-05-16 15:18:58 +02:00
Uniforms []Type
Attributes []Type
Varyings []Type
Funcs []Func
VertexFunc VertexFunc
FragmentFunc FragmentFunc
2020-05-11 17:19:42 +02:00
structNames map[string]string
structTypes []Type
}
type Func struct {
2020-05-16 20:00:57 +02:00
Index int
2020-05-13 16:31:17 +02:00
InParams []Type
InOutParams []Type
OutParams []Type
2020-05-16 13:16:04 +02:00
Return Type
2020-05-13 16:31:17 +02:00
Block Block
2020-05-11 17:19:42 +02:00
}
2020-05-16 15:18:58 +02:00
// VertexFunc takes pseudo params, and the number if len(attributes) + len(varyings) + 1.
// If 0 <= index < len(attributes), the params are in-params and treated as attribute variables.
// If len(attributes) <= index < len(attributes) + len(varyings), the params are out-params and treated as varying
// variables.
// The last param represents the position in vec4 (gl_Position in GLSL).
type VertexFunc struct {
Block Block
}
// FragmentFunc takes pseudo params, and the number is len(varyings) + 2.
2020-05-23 19:07:57 +02:00
// If index == len(varyings), the param represents the coordinate of the fragment (gl_FragCoord in GLSL).
// If index == len(varyings)+1, the param is an out-param representing the color of the pixel (gl_FragColor in GLSL).
2020-05-16 15:18:58 +02:00
type FragmentFunc struct {
Block Block
}
2020-05-11 17:19:42 +02:00
type Block struct {
LocalVars []Type
Stmts []Stmt
}
type Stmt struct {
2020-05-15 20:10:03 +02:00
Type StmtType
Exprs []Expr
Blocks []Block
ForInit int
ForEnd int
ForOp Op
2020-05-15 20:10:03 +02:00
ForDelta int
2020-05-11 17:19:42 +02:00
}
type StmtType int
const (
ExprStmt StmtType = iota
2020-05-13 18:45:33 +02:00
BlockStmt
2020-05-11 17:19:42 +02:00
Assign
If
For
Continue
Break
2020-05-13 20:14:39 +02:00
Return
2020-05-11 17:19:42 +02:00
Discard
)
type Expr struct {
2020-05-16 17:25:31 +02:00
Type ExprType
Exprs []Expr
Int int32
Float float32
BuiltinFunc BuiltinFunc
2020-05-16 20:00:57 +02:00
Swizzling string
Index int
2020-05-16 17:25:31 +02:00
Op Op
2020-05-11 17:19:42 +02:00
}
type ExprType int
const (
2020-05-15 20:40:33 +02:00
IntExpr ExprType = iota
FloatExpr
UniformVariable
LocalVariable
StructMember
2020-05-16 17:25:31 +02:00
BuiltinFuncExpr
2020-05-16 19:24:35 +02:00
SwizzlingExpr
2020-05-16 20:00:57 +02:00
FunctionExpr
2020-05-11 17:19:42 +02:00
Unary
Binary
2020-05-16 10:22:17 +02:00
Selection
2020-05-11 17:19:42 +02:00
Call
2020-05-16 10:22:17 +02:00
FieldSelector
2020-05-11 17:19:42 +02:00
Index
)
type Op string
const (
2020-05-16 17:25:31 +02:00
Add Op = "+"
Sub Op = "-"
Neg Op = "!"
Mul Op = "*"
Div Op = "/"
ModOp Op = "%"
LeftShift Op = "<<"
RightShift Op = ">>"
LessThanOp Op = "<"
LessThanEqualOp Op = "<="
GreaterThanOp Op = ">"
GreaterThanEqualOp Op = ">="
EqualOp Op = "=="
NotEqualOp Op = "!="
And Op = "&"
Xor Op = "^"
Or Op = "|"
AndAnd Op = "&&"
OrOr Op = "||"
)
type BuiltinFunc string
const (
2020-05-23 11:07:28 +02:00
Vec2F BuiltinFunc = "vec2"
Vec3F BuiltinFunc = "vec3"
Vec4F BuiltinFunc = "vec4"
2020-05-23 15:01:10 +02:00
Mat2F BuiltinFunc = "mat2"
Mat3F BuiltinFunc = "mat3"
Mat4F BuiltinFunc = "mat4"
2020-05-16 17:25:31 +02:00
Radians BuiltinFunc = "radians"
Degrees BuiltinFunc = "degrees"
Sin BuiltinFunc = "sin"
Cos BuiltinFunc = "cos"
Tan BuiltinFunc = "tan"
Asin BuiltinFunc = "asin"
Acos BuiltinFunc = "acos"
Atan BuiltinFunc = "atan"
Pow BuiltinFunc = "pow"
Exp BuiltinFunc = "exp"
Log BuiltinFunc = "log"
Exp2 BuiltinFunc = "exp2"
Log2 BuiltinFunc = "log2"
Sqrt BuiltinFunc = "sqrt"
Inversesqrt BuiltinFunc = "inversesqrt"
Abs BuiltinFunc = "abs"
Sign BuiltinFunc = "sign"
Floor BuiltinFunc = "floor"
Ceil BuiltinFunc = "ceil"
Fract BuiltinFunc = "fract"
Mod BuiltinFunc = "mod"
Min BuiltinFunc = "min"
Max BuiltinFunc = "max"
Clamp BuiltinFunc = "clamp"
Mix BuiltinFunc = "mix"
Step BuiltinFunc = "step"
Smoothstep BuiltinFunc = "smoothstep"
Length BuiltinFunc = "length"
Distance BuiltinFunc = "distance"
Dot BuiltinFunc = "dot"
Cross BuiltinFunc = "cross"
Normalize BuiltinFunc = "normalize"
Faceforward BuiltinFunc = "faceforward"
Reflect BuiltinFunc = "reflect"
MatrixCompMult BuiltinFunc = "matrixCompMult"
OuterProduct BuiltinFunc = "outerProduct"
Transpose BuiltinFunc = "transpose"
LessThan BuiltinFunc = "lessThan"
LessThanEqual BuiltinFunc = "lessThanEqual"
GreaterThan BuiltinFunc = "greaterThan"
GreaterThanEqual BuiltinFunc = "greaterThanEqual"
Equal BuiltinFunc = "equal"
NotEqual BuiltinFunc = "notEqual"
Any BuiltinFunc = "any"
All BuiltinFunc = "all"
Not BuiltinFunc = "not"
Texture2DF BuiltinFunc = "texture2D"
2020-05-11 17:19:42 +02:00
)
2020-05-31 11:11:55 +02:00
func ParseBuiltinFunc(str string) (BuiltinFunc, bool) {
switch BuiltinFunc(str) {
case Vec2F,
Vec3F,
Vec4F,
Mat2F,
Mat3F,
Mat4F,
Radians,
Degrees,
Sin,
Cos,
Tan,
Asin,
Acos,
Atan,
Pow,
Exp,
Log,
Exp2,
Log2,
Sqrt,
Inversesqrt,
Abs,
Sign,
Floor,
Ceil,
Fract,
Mod,
Min,
Max,
Clamp,
Mix,
Step,
Smoothstep,
Length,
Distance,
Dot,
Cross,
Normalize,
Faceforward,
Reflect,
MatrixCompMult,
OuterProduct,
Transpose,
LessThan,
LessThanEqual,
GreaterThan,
GreaterThanEqual,
Equal,
NotEqual,
Any,
All,
Not,
Texture2DF:
return BuiltinFunc(str), true
}
return "", false
}