Fixed incompatibility with newer nim

Author: yglukhov

nimsl.nimble

@@ -1,5 +1,5 @@
 # Package
-version = "0.2"
+version = "0.2.1"
 author = "Yuriy Glukhov"
 description = "Shaders in Nim"
 license = "MIT"

nimsl/nimsl.nim

@@ -1,8 +1,6 @@
 import macros, math, strutils
 import private.glsl_codegen
 
-{.pragma: glslinfix, tags: [glslinfix_t].}
-
 proc getShaderCode(s: NimNode, k: ShaderKind, mainProcName: string): string =
     var ctx = newCtx()
     ctx.mainProcName = mainProcName
@@ -192,26 +190,44 @@ proc `*`*(m: mat4, v: vec4): vec4 =
     result[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w
     result[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w
 
-proc `.`*[T](v: vecBase[2, T], f: static[string]): vecBase[f.len, T] {.glslinfix.} =
+proc validateAttrs(s: string, a: set[char]) {.compileTime.} =
+    for c in s:
+        assert(c in a, "Invalid vector component: " & $c)
+
+proc nimsl_deriveVectorWithComponents[T](v: vecBase[2, T], f: static[string]): vecBase[f.len, T] =
+    glslinfix()
+    static: validateAttrs(f, {'x', 'r', 'y', 'g'})
     for i, c in f:
         case c
             of 'x', 'r': result[i] = v.x
             of 'y', 'g': result[i] = v.y
-            else: assert(false, "Unknown field: " & $c)
+            else: discard # Should be prevented by validateAttrs
 
-proc `.`*[T](v: vecBase[3, T], f: static[string]): vecBase[f.len, T] {.glslinfix.} =
+proc nimsl_deriveVectorWithComponents[T](v: vecBase[3, T], f: static[string]): vecBase[f.len, T] =
+    glslinfix()
+    static: validateAttrs(f, {'x', 'r', 'y', 'g', 'z', 'b'})
     for i, c in f:
         case c
             of 'x', 'r': result[i] = v.x
             of 'y', 'g': result[i] = v.y
             of 'z', 'b': result[i] = v.z
-            else: assert(false, "Unknown field: " & $c)
+            else: discard # Should be prevented by validateAttrs
 
-proc `.`*[T](v: vecBase[4, T], f: static[string]): vecBase[f.len, T] {.glslinfix.} =
+proc nimsl_deriveVectorWithComponents[T](v: vecBase[4, T], f: static[string]): vecBase[f.len, T] =
+    glslinfix()
+    static: validateAttrs(f, {'x', 'r', 'y', 'g', 'z', 'b', 'w', 'a'})
     for i, c in f:
         case c
             of 'x', 'r': result[i] = v.x
             of 'y', 'g': result[i] = v.y
             of 'z', 'b': result[i] = v.z
             of 'w', 'a': result[i] = v.w
-            else: assert(false, "Unknown field: " & $c)
+            else: discard # Should be prevented by validateAttrs
+
+when defined(nimNewDot):
+    template `.`*[I, T](v: vecBase[I, T], f: untyped): auto =
+        nimsl_deriveVectorWithComponents(v, astToStr(f))
+else:
+    proc `.`*[I, T](v: vecBase[I, T], f: static[string]): vecBase[f.len, T] {.inline.} =
+        glslinfix()
+        result = nimsl_deriveVectorWithComponents(v, f)

nimsl/private/glsl_codegen.nim

@@ -2,10 +2,9 @@ import macros, strutils
 
 {.push stackTrace: off.}
 proc glslbuiltin*() {.inline.} = discard
+proc glslinfix*() {.inline.} = discard
 {.pop.}
 
-type
-    glslinfix_t* = object
 
 type ShaderKind* = enum
     skVertexShader
@@ -38,28 +37,25 @@ proc isRange(n: NimNode, rangeLen: int = -1): bool =
         elif n[2].intVal - n[1].intVal + 1 == rangeLen:
             result = true
 
-proc hasTag(n: NimNode, tag: string): bool =
-    case n.kind
-    of nnkProcDef:
-        for i in n.pragma:
-            if i.kind == nnkPragma and i[0].kind == nnkExprColonExpr and $(i[0][0]) == "tags":
-                for j in i[0][1]:
-                    if $j == tag: return true
-    of nnkSym:
-        result = n.symbol.getImpl().hasTag(tag)
-    else: discard
+proc hasMagicMarker(n: NimNode, marker: string): bool =
+    template isMagicCallNode(n: NimNode): bool =
+        n.kind == nnkCall and n[0].kind == nnkSym and $n[0] == marker
 
-proc isGLSLBuiltin(n: NimNode): bool =
     case n.kind
     of nnkProcDef:
         let b = n.body
         if b.kind == nnkStmtList:
             let fs = b[0]
-            result = fs.kind == nnkCall and fs[0].kind == nnkSym and $fs[0] == "glslbuiltin"
+            result = fs.isMagicCallNode()
     of nnkSym:
-        result = isGLSLBuiltin(getImpl(n.symbol))
+        result = hasMagicMarker(getImpl(n.symbol), marker)
+    of nnkStmtListExpr:
+        let fs = n[0]
+        result = fs.isMagicCallNode()
     else: discard
 
+proc isGLSLBuiltin(n: NimNode): bool = n.hasMagicMarker("glslbuiltin")
+
 proc getTypeName(ctx: var GLSLCompilerContext, t: NimNode, skipVar = false): string =
     case t.kind
     of nnkBracketExpr:
@@ -146,8 +142,8 @@ proc genSystemCall(ctx: var GLSLCompilerContext, n: NimNode, r: var string) =
         echo "UNKNOWN SYSTEM CALL: ", treeRepr(n)
 
 proc genCall(ctx: var GLSLCompilerContext, n: NimNode, r: var string) =
-    if n[0].hasTag("glslinfix_t"):
-        if $(n[0]) == ".":
+    if n[0].hasMagicMarker("glslinfix"):
+        if $n[0] in [".", "nimsl_deriveVectorWithComponents"]:
             # This is a property
             gen(ctx, n[1], r)
             r &= "."

test.nim

@@ -31,11 +31,19 @@ proc myFragmentShader(vPos: vec2): vec4 =
     result.drawShape(sdEllipseInRect(vPos, bounds), uStrokeColor);
     result.drawShape(sdEllipseInRect(vPos, insetRect(bounds, uStrokeWidth)), uFillColor);
 
+proc myVertexShader2(a: vec4): vec3 =
+    result = a.xxz
+
 
 suite "codegen":
     test "vs":
-        check(getGLSLVertexShader(myVertexShader) ==
-            "uniform mat4 mvp;attribute vec2 a;varying vec2 vPos;void main(){vec4 result=vec4(0.0);vPos=a;result=(mvp*vec4(a,0.0,1.0));gl_Position=result;}")
+        check getGLSLVertexShader(myVertexShader) ==
+            "uniform mat4 mvp;attribute vec2 a;varying vec2 vPos;void main(){vec4 result=vec4(0.0);vPos=a;result=(mvp*vec4(a,0.0,1.0));gl_Position=result;}"
+
+    test "vector accessors":
+        check getGLSLVertexShader(myVertexShader2) ==
+            "attribute vec4 a;void main(){vec3 result=vec4(0.0);result=a.xxz;gl_Position=result;}"
+
 
 # import nimx.write_image_impl