From 9f3e43c39e2960cdc84365693707a923107e467f Mon Sep 17 00:00:00 2001 From: Ricardo Matias Date: Sat, 25 Apr 2020 10:10:40 +0200 Subject: [PATCH] Fix glslify relative imports + inner module imports --- orx-glslify/src/main/kotlin/Glslify.kt | 167 ++++++++++------- orx-glslify/src/test/kotlin/TestGlslify.kt | 16 +- .../glslify/glsl-easings/back-in-out.glsl | 17 ++ .../glslify/glsl-easings/back-in.glsl | 9 + .../glslify/glsl-easings/back-out.glsl | 10 ++ .../glslify/glsl-easings/bounce-in-out.glsl | 11 ++ .../glslify/glsl-easings/bounce-in.glsl | 7 + .../glslify/glsl-easings/bounce-out.glsl | 25 +++ .../glslify/glsl-easings/circular-in-out.glsl | 7 + .../glslify/glsl-easings/circular-in.glsl | 5 + .../glslify/glsl-easings/circular-out.glsl | 5 + .../glslify/glsl-easings/cubic-in.glsl | 5 + .../glslify/glsl-easings/cubic-out.glsl | 6 + .../glslify/glsl-easings/elastic-in-out.glsl | 11 ++ .../glslify/glsl-easings/elastic-in.glsl | 9 + .../glslify/glsl-easings/elastic-out.glsl | 9 + .../glsl-easings/exponential-in-out.glsl | 9 + .../glslify/glsl-easings/exponential-in.glsl | 5 + .../glslify/glsl-easings/exponential-out.glsl | 5 + .../glslify/glsl-easings/linear.glsl | 5 + .../glsl-easings/quadratic-in-out.glsl | 6 + .../glslify/glsl-easings/quadratic-in.glsl | 5 + .../glslify/glsl-easings/quadratic-out.glsl | 5 + .../glslify/glsl-easings/quartic-in-out.glsl | 7 + .../glslify/glsl-easings/quartic-in.glsl | 5 + .../glslify/glsl-easings/quartic-out.glsl | 5 + .../glslify/glsl-easings/quintic-in-out.glsl | 7 + .../glslify/glsl-easings/quintic-in.glsl | 5 + .../glslify/glsl-easings/quintic-out.glsl | 5 + .../glslify/glsl-easings/sine-in-out.glsl | 9 + .../glslify/glsl-easings/sine-in.glsl | 9 + .../glslify/glsl-easings/sine-out.glsl | 9 + .../glslify/glsl-luma/example/index.frag | 13 ++ .../glslify/glsl-luma/example/index.js | 23 +++ .../glslify/glsl-luma/example/index.vert | 10 ++ .../glslify/glsl-noise/classic/2d.glsl | 74 ++++++++ .../glslify/glsl-noise/classic/4d.glsl | 169 ++++++++++++++++++ .../glslify/glsl-noise/periodic/2d.glsl | 75 ++++++++ .../glslify/glsl-noise/periodic/3d.glsl | 109 +++++++++++ .../glslify/glsl-noise/periodic/4d.glsl | 169 ++++++++++++++++++ .../glslify/glsl-noise/simplex/2d.glsl | 72 ++++++++ .../glslify/glsl-noise/simplex/3d.glsl | 104 +++++++++++ .../glslify/glsl-noise/simplex/4d.glsl | 130 ++++++++++++++ .../test/resources/glslify/solve/index.glsl | 3 +- .../resources/glslify/solve/subtract.glsl | 5 + .../resources/glslify/src/test/src-test.js | 74 ++++++++ .../resources/glslify/subtract/lib/index.js | 1 + 47 files changed, 1389 insertions(+), 62 deletions(-) create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/back-in-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/back-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/back-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/bounce-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/circular-in-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/circular-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/circular-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/cubic-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/cubic-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/elastic-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/exponential-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/linear.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/quartic-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/quintic-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/sine-in-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/sine-in.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-easings/sine-out.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-luma/example/index.frag create mode 100644 orx-glslify/src/test/resources/glslify/glsl-luma/example/index.js create mode 100644 orx-glslify/src/test/resources/glslify/glsl-luma/example/index.vert create mode 100644 orx-glslify/src/test/resources/glslify/glsl-noise/classic/2d.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-noise/classic/4d.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-noise/periodic/2d.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-noise/periodic/3d.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-noise/periodic/4d.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-noise/simplex/2d.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-noise/simplex/3d.glsl create mode 100644 orx-glslify/src/test/resources/glslify/glsl-noise/simplex/4d.glsl create mode 100644 orx-glslify/src/test/resources/glslify/solve/subtract.glsl create mode 100644 orx-glslify/src/test/resources/glslify/src/test/src-test.js create mode 100644 orx-glslify/src/test/resources/glslify/subtract/lib/index.js diff --git a/orx-glslify/src/main/kotlin/Glslify.kt b/orx-glslify/src/main/kotlin/Glslify.kt index 1bcdeca8..a90dabe6 100644 --- a/orx-glslify/src/main/kotlin/Glslify.kt +++ b/orx-glslify/src/main/kotlin/Glslify.kt @@ -13,6 +13,7 @@ import kotlin.streams.toList internal const val BASE_URL = "https://registry.npmjs.org" internal const val IMPORT_PATT = """#pragma\sglslify:\s([\w]+).*\s=\s*require\('?([\w\-\\/]+).*'?\)$""" +internal const val IMPORT_RELATIVE_PATT = """#pragma\sglslify:\s([\w]+).*\s=\s*require\('?(\./[\w\-\\/]+).*'?\)$""" internal const val EXPORT_PATT = """#pragma\sglslify:\s*export\(([\w\-]+)\)""" internal const val PRAGMA_IDENTIFIER = "#pragma glslify" @@ -26,85 +27,131 @@ fun preprocessGlslifyFromUrl(url: String, glslifyPath: String = "src/main/resour return preprocessGlslify(codeFromURL(url), glslifyPath) } +data class GlslifyModule( + val requirePath: String, + val functionName: String, + val lineNumber: Int +) { + private var shaderFile: MutableList = mutableListOf() + + lateinit var moduleName: String + lateinit var shaderFilePath: Path + + var exportName: String? = null + + private val dependencies = mutableListOf() + + fun import(glslifyPath: String): String { + val parsed = parseModule(requirePath) + + moduleName = parsed.first + shaderFilePath = parsed.second + + val importPath = Paths.get(glslifyPath).resolve(moduleName) + + shaderFile = glslifyImport(moduleName, importPath, shaderFilePath) + + dependencies.asReversed().map { + shaderFile[it.lineNumber] = it.import(glslifyPath) + } + + var shader = shaderFile.joinToString("\n") + + if (exportName != null) { + shader = shader.replace(exportName!!, functionName) + } + + return shader.trimMargin() + } + + private fun glslifyImport(moduleName: String, moduleDir: Path, shaderPath: Path): MutableList { + if (!Files.exists(moduleDir)) { + fetchModule(moduleName, moduleDir) + } else { + logger.trace("[glslify] $moduleName already exists.. Skipping download") + } + + val shaderFile: Path + + try { + shaderFile = shaderExtensions.map { + moduleDir.resolve("$shaderPath.$it") + }.first { Files.exists(it) } + } catch (ex: NoSuchElementException) { + throw error("[glslify] $moduleName: $shaderPath doesn't lead to any shader file") + } + + return Files.lines(shaderFile).toList().mapIndexed { dependencyLineNumber, line -> + if (line.startsWith(PRAGMA_IDENTIFIER)) { + Regex(IMPORT_PATT).find(line)?.let { + val functionName = it.groupValues[1] + val dependencyRequirePath = it.groupValues[2] + + if (importTree.contains(dependencyRequirePath)) return@mapIndexed "" + + importTree.add(dependencyRequirePath) + + dependencies.add(GlslifyModule(dependencyRequirePath, functionName, dependencyLineNumber)) + } + + Regex(IMPORT_RELATIVE_PATT).find(line)?.let { + val functionName = it.groupValues[1] + val dependencyRequirePath = it.groupValues[2] + + if (importTree.contains(dependencyRequirePath)) return@mapIndexed "" + + importTree.add(dependencyRequirePath) + + val dependency = moduleDir.fileName.resolve(Paths.get(dependencyRequirePath).normalize()).toString() + + dependencies.add(GlslifyModule(dependency, functionName, dependencyLineNumber)) + } + + Regex(EXPORT_PATT).find(line)?.let { + if (it.groupValues.size > 1) { + exportName = it.groupValues[1] + } + + return@mapIndexed "" + } + } + + line + }.toMutableList() + } +} + +internal val stack = mutableListOf() fun preprocessGlslify(source: String, glslifyPath: String = "src/main/resources/glslify"): String { importTree = mutableSetOf() - return source.split("\n").map { line -> + stack.clear() + + val mainShader = source.split("\n").mapIndexed { lineNumber, line -> if (line.trimStart().startsWith(PRAGMA_IDENTIFIER)) { Regex(IMPORT_PATT).find(line)?.let { if (it.groupValues.size > 1) { val functionName = it.groupValues[1] - val module = it.groupValues[2] + val requirePath = it.groupValues[2] - val (moduleName, shaderPath) = parseModule(module) - val importPath = Paths.get(glslifyPath).resolve(moduleName) + if (importTree.contains(requirePath)) return@mapIndexed "" - if (importTree.contains(moduleName)) return@map "" + importTree.add(requirePath) - importTree.add(moduleName) - - return@map glslifyImport(moduleName, importPath, shaderPath, functionName, glslifyPath) + stack.add(GlslifyModule(requirePath, functionName, lineNumber)) } } } line - }.joinToString("\n").trimMargin() -} + }.toMutableList() -private fun glslifyImport(moduleName: String, moduleDir: Path, shaderPath: Path, renameFunctionTo: String? = null, glslifyPath: String): String { - if (!Files.exists(moduleDir)) { - fetchModule(moduleName, moduleDir) - } else { - logger.trace("[glslify] $moduleName already exists.. Skipping download") + stack.asReversed().forEach { + mainShader[it.lineNumber] = it.import(glslifyPath) } - val shaderFile: Path - - try { - shaderFile = shaderExtensions.map { - moduleDir.resolve("$shaderPath.$it") - }.first { Files.exists(it) } - } catch (ex: NoSuchElementException) { - throw error("[glslify] $moduleName: $shaderPath doesn't lead to any shader file") - } - - var exportName: String? = null - - var shader = Files.lines(shaderFile).map { line -> - if (line.startsWith(PRAGMA_IDENTIFIER)) { - Regex(IMPORT_PATT).find(line)?.let { - val functionName = it.groupValues[1] - val module = it.groupValues[2] - - val (innerModuleName, innerShaderPath) = parseModule(module) - val importPath = Paths.get(glslifyPath).resolve(moduleName) - - if (importTree.contains(innerModuleName)) return@map "" - - importTree.add(innerModuleName) - - return@map glslifyImport(innerModuleName, importPath, innerShaderPath, functionName, glslifyPath) - } - - Regex(EXPORT_PATT).find(line)?.let { - if (it.groupValues.size > 1) { - exportName = it.groupValues[1] - } - - return@map "" - } - } - - line - }.toList().joinToString("\n") - - if (renameFunctionTo != null && exportName != null) { - shader = shader.replace( exportName!!, renameFunctionTo) - } - - return shader.trimMargin() + return mainShader.joinToString("\n").trimMargin() } internal fun fetchModule(moduleName: String, moduleDir: Path) { diff --git a/orx-glslify/src/test/kotlin/TestGlslify.kt b/orx-glslify/src/test/kotlin/TestGlslify.kt index 13f5fbfc..0d78200b 100644 --- a/orx-glslify/src/test/kotlin/TestGlslify.kt +++ b/orx-glslify/src/test/kotlin/TestGlslify.kt @@ -42,11 +42,12 @@ object TestGlslify : Spek({ describe("should import everything in order + write naming") { val url = resourceUrl("/a.glsl") val processed = preprocessGlslifyFromUrl(url, glslifyPath = glslifyPath) - + println(processed) processed shouldContainAll listOf( "float add(float a, float b)", "float multiply(float a, float b)", "float equation(float a, float b)", + "float subtract(float a, float b)", "float luminance(vec3 color)", "void main()" ) @@ -81,5 +82,18 @@ float luma(vec4 color) { return dot(color.rgb, vec3(0.299, 0.587, 0.114)); }""" } + + describe("should import multiple from same package") { + val shader = """#version 330 +#pragma glslify: snoise = require(glsl-noise/simplex/2d) +#pragma glslify: cnoise = require(glsl-noise/classic/2d) +""" + val processed = preprocessGlslify(shader, glslifyPath = glslifyPath) + + processed shouldContainAll listOf( + "float snoise(vec2 v)", + "float cnoise(vec2 P)" + ) + } } }) \ No newline at end of file diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/back-in-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/back-in-out.glsl new file mode 100644 index 00000000..dcdff90e --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/back-in-out.glsl @@ -0,0 +1,17 @@ +#ifndef PI +#define PI 3.141592653589793 +#endif + +float backOut(float t) { + float f = t < 0.5 + ? 2.0 * t + : 1.0 - (2.0 * t - 1.0); + + float g = pow(f, 3.0) - f * sin(f * PI); + + return t < 0.5 + ? 0.5 * g + : 0.5 * (1.0 - g) + 0.5; +} + +#pragma glslify: export(backOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/back-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/back-in.glsl new file mode 100644 index 00000000..7cf59755 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/back-in.glsl @@ -0,0 +1,9 @@ +#ifndef PI +#define PI 3.141592653589793 +#endif + +float backIn(float t) { + return pow(t, 3.0) - t * sin(t * PI); +} + +#pragma glslify: export(backIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/back-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/back-out.glsl new file mode 100644 index 00000000..72bbba8f --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/back-out.glsl @@ -0,0 +1,10 @@ +#ifndef PI +#define PI 3.141592653589793 +#endif + +float backOut(float t) { + float f = 1.0 - t; + return 1.0 - (pow(f, 3.0) - f * sin(f * PI)); +} + +#pragma glslify: export(backOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in-out.glsl new file mode 100644 index 00000000..31942784 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in-out.glsl @@ -0,0 +1,11 @@ +#pragma glslify: bounceOut = require(./bounce-out) + +float bounceInOut(float t) { + return t < 0.5 + ? 0.5 * (1.0 - bounceOut(1.0 - t * 2.0)) + : 0.5 * bounceOut(t * 2.0 - 1.0) + 0.5; +} + + + +#pragma glslify: export(bounceInOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in.glsl new file mode 100644 index 00000000..f92f8582 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in.glsl @@ -0,0 +1,7 @@ +#pragma glslify: bounceOut = require(./bounce-out) + +float bounceIn(float t) { + return 1.0 - bounceOut(1.0 - t); +} + +#pragma glslify: export(bounceIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/bounce-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/bounce-out.glsl new file mode 100644 index 00000000..2faf30a7 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/bounce-out.glsl @@ -0,0 +1,25 @@ +#ifndef PI +#define PI 3.141592653589793 +#endif + +float bounceOut(float t) { + const float a = 4.0 / 11.0; + const float b = 8.0 / 11.0; + const float c = 9.0 / 10.0; + + const float ca = 4356.0 / 361.0; + const float cb = 35442.0 / 1805.0; + const float cc = 16061.0 / 1805.0; + + float t2 = t * t; + + return t < a + ? 7.5625 * t2 + : t < b + ? 9.075 * t2 - 9.9 * t + 3.4 + : t < c + ? ca * t2 - cb * t + cc + : 10.8 * t * t - 20.52 * t + 10.72; +} + +#pragma glslify: export(bounceOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/circular-in-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/circular-in-out.glsl new file mode 100644 index 00000000..899aa92a --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/circular-in-out.glsl @@ -0,0 +1,7 @@ +float circularInOut(float t) { + return t < 0.5 + ? 0.5 * (1.0 - sqrt(1.0 - 4.0 * t * t)) + : 0.5 * (sqrt((3.0 - 2.0 * t) * (2.0 * t - 1.0)) + 1.0); +} + +#pragma glslify: export(circularInOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/circular-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/circular-in.glsl new file mode 100644 index 00000000..9dee4e9e --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/circular-in.glsl @@ -0,0 +1,5 @@ +float circularIn(float t) { + return 1.0 - sqrt(1.0 - t * t); +} + +#pragma glslify: export(circularIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/circular-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/circular-out.glsl new file mode 100644 index 00000000..cdab403d --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/circular-out.glsl @@ -0,0 +1,5 @@ +float circularOut(float t) { + return sqrt((2.0 - t) * t); +} + +#pragma glslify: export(circularOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/cubic-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/cubic-in.glsl new file mode 100644 index 00000000..62cac01f --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/cubic-in.glsl @@ -0,0 +1,5 @@ +float cubicIn(float t) { + return t * t * t; +} + +#pragma glslify: export(cubicIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/cubic-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/cubic-out.glsl new file mode 100644 index 00000000..f19d5e48 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/cubic-out.glsl @@ -0,0 +1,6 @@ +float cubicOut(float t) { + float f = t - 1.0; + return f * f * f + 1.0; +} + +#pragma glslify: export(cubicOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in-out.glsl new file mode 100644 index 00000000..a1b8dcd0 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in-out.glsl @@ -0,0 +1,11 @@ +#ifndef HALF_PI +#define HALF_PI 1.5707963267948966 +#endif + +float elasticInOut(float t) { + return t < 0.5 + ? 0.5 * sin(+13.0 * HALF_PI * 2.0 * t) * pow(2.0, 10.0 * (2.0 * t - 1.0)) + : 0.5 * sin(-13.0 * HALF_PI * ((2.0 * t - 1.0) + 1.0)) * pow(2.0, -10.0 * (2.0 * t - 1.0)) + 1.0; +} + +#pragma glslify: export(elasticInOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in.glsl new file mode 100644 index 00000000..474c47c5 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in.glsl @@ -0,0 +1,9 @@ +#ifndef HALF_PI +#define HALF_PI 1.5707963267948966 +#endif + +float elasticIn(float t) { + return sin(13.0 * t * HALF_PI) * pow(2.0, 10.0 * (t - 1.0)); +} + +#pragma glslify: export(elasticIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/elastic-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/elastic-out.glsl new file mode 100644 index 00000000..c9e4aca4 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/elastic-out.glsl @@ -0,0 +1,9 @@ +#ifndef HALF_PI +#define HALF_PI 1.5707963267948966 +#endif + +float elasticOut(float t) { + return sin(-13.0 * (t + 1.0) * HALF_PI) * pow(2.0, -10.0 * t) + 1.0; +} + +#pragma glslify: export(elasticOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in-out.glsl new file mode 100644 index 00000000..b8a4ca52 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in-out.glsl @@ -0,0 +1,9 @@ +float exponentialInOut(float t) { + return t == 0.0 || t == 1.0 + ? t + : t < 0.5 + ? +0.5 * pow(2.0, (20.0 * t) - 10.0) + : -0.5 * pow(2.0, 10.0 - (t * 20.0)) + 1.0; +} + +#pragma glslify: export(exponentialInOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in.glsl new file mode 100644 index 00000000..1c3b913d --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in.glsl @@ -0,0 +1,5 @@ +float exponentialIn(float t) { + return t == 0.0 ? t : pow(2.0, 10.0 * (t - 1.0)); +} + +#pragma glslify: export(exponentialIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/exponential-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/exponential-out.glsl new file mode 100644 index 00000000..8e834f4c --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/exponential-out.glsl @@ -0,0 +1,5 @@ +float exponentialOut(float t) { + return t == 1.0 ? t : 1.0 - pow(2.0, -10.0 * t); +} + +#pragma glslify: export(exponentialOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/linear.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/linear.glsl new file mode 100644 index 00000000..2ca43a42 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/linear.glsl @@ -0,0 +1,5 @@ +float linear(float t) { + return t; +} + +#pragma glslify: export(linear) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in-out.glsl new file mode 100644 index 00000000..dfea04a2 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in-out.glsl @@ -0,0 +1,6 @@ +float quadraticInOut(float t) { + float p = 2.0 * t * t; + return t < 0.5 ? p : -p + (4.0 * t) - 1.0; +} + +#pragma glslify: export(quadraticInOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in.glsl new file mode 100644 index 00000000..6f3ae44d --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in.glsl @@ -0,0 +1,5 @@ +float quadraticIn(float t) { + return t * t; +} + +#pragma glslify: export(quadraticIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-out.glsl new file mode 100644 index 00000000..7cd66777 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-out.glsl @@ -0,0 +1,5 @@ +float quadraticOut(float t) { + return -t * (t - 2.0); +} + +#pragma glslify: export(quadraticOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in-out.glsl new file mode 100644 index 00000000..094ab67e --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in-out.glsl @@ -0,0 +1,7 @@ +float quarticInOut(float t) { + return t < 0.5 + ? +8.0 * pow(t, 4.0) + : -8.0 * pow(t - 1.0, 4.0) + 1.0; +} + +#pragma glslify: export(quarticInOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in.glsl new file mode 100644 index 00000000..5ba8c289 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in.glsl @@ -0,0 +1,5 @@ +float quarticIn(float t) { + return pow(t, 4.0); +} + +#pragma glslify: export(quarticIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/quartic-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/quartic-out.glsl new file mode 100644 index 00000000..d488d34a --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/quartic-out.glsl @@ -0,0 +1,5 @@ +float quarticOut(float t) { + return pow(t - 1.0, 3.0) * (1.0 - t) + 1.0; +} + +#pragma glslify: export(quarticOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in-out.glsl new file mode 100644 index 00000000..6c9c505d --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in-out.glsl @@ -0,0 +1,7 @@ +float qinticInOut(float t) { + return t < 0.5 + ? +16.0 * pow(t, 5.0) + : -0.5 * pow(2.0 * t - 2.0, 5.0) + 1.0; +} + +#pragma glslify: export(qinticInOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in.glsl new file mode 100644 index 00000000..3bf24e7c --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in.glsl @@ -0,0 +1,5 @@ +float qinticIn(float t) { + return pow(t, 5.0); +} + +#pragma glslify: export(qinticIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/quintic-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/quintic-out.glsl new file mode 100644 index 00000000..5e9e9468 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/quintic-out.glsl @@ -0,0 +1,5 @@ +float qinticOut(float t) { + return 1.0 - (pow(t - 1.0, 5.0)); +} + +#pragma glslify: export(qinticOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/sine-in-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/sine-in-out.glsl new file mode 100644 index 00000000..c8f0a1a7 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/sine-in-out.glsl @@ -0,0 +1,9 @@ +#ifndef PI +#define PI 3.141592653589793 +#endif + +float sineInOut(float t) { + return -0.5 * (cos(PI * t) - 1.0); +} + +#pragma glslify: export(sineInOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/sine-in.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/sine-in.glsl new file mode 100644 index 00000000..e3f05095 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/sine-in.glsl @@ -0,0 +1,9 @@ +#ifndef HALF_PI +#define HALF_PI 1.5707963267948966 +#endif + +float sineIn(float t) { + return sin((t - 1.0) * HALF_PI) + 1.0; +} + +#pragma glslify: export(sineIn) diff --git a/orx-glslify/src/test/resources/glslify/glsl-easings/sine-out.glsl b/orx-glslify/src/test/resources/glslify/glsl-easings/sine-out.glsl new file mode 100644 index 00000000..16bb32a9 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-easings/sine-out.glsl @@ -0,0 +1,9 @@ +#ifndef HALF_PI +#define HALF_PI 1.5707963267948966 +#endif + +float sineOut(float t) { + return sin(t * HALF_PI); +} + +#pragma glslify: export(sineOut) diff --git a/orx-glslify/src/test/resources/glslify/glsl-luma/example/index.frag b/orx-glslify/src/test/resources/glslify/glsl-luma/example/index.frag new file mode 100644 index 00000000..a59afbc5 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-luma/example/index.frag @@ -0,0 +1,13 @@ +precision mediump float; + +uniform sampler2D uTexture; +varying vec2 vUv; + +#pragma glslify: luma = require(../) + +void main() { + vec4 color = texture2D(uTexture, vUv); + float brightness = luma(color); + + gl_FragColor = vec4(vec3(brightness), 1.0); +} diff --git a/orx-glslify/src/test/resources/glslify/glsl-luma/example/index.js b/orx-glslify/src/test/resources/glslify/glsl-luma/example/index.js new file mode 100644 index 00000000..96d3633f --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-luma/example/index.js @@ -0,0 +1,23 @@ +var canvas = document.body.appendChild(document.createElement('canvas')) +var triangle = require('a-big-triangle') +var createContext = require('gl-context') +var createTex2d = require('gl-texture2d') +var glslify = require('glslify') +var createShell = require('gl-now') +var lena = require('lena') + +canvas.width = 512 +canvas.height = 512 + +var gl = createContext(canvas, render) +var tex = createTex2d(gl, lena) +var shader = glslify({ + vert: './index.vert' + , frag: './index.frag' +})(gl) + +function render() { + shader.bind() + shader.uniforms.uTexture = tex.bind(0) + triangle(gl) +} diff --git a/orx-glslify/src/test/resources/glslify/glsl-luma/example/index.vert b/orx-glslify/src/test/resources/glslify/glsl-luma/example/index.vert new file mode 100644 index 00000000..2ed29279 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-luma/example/index.vert @@ -0,0 +1,10 @@ +precision mediump float; + +attribute vec2 position; +varying vec2 vUv; + +void main() { + vUv = (position + vec2(1.0)) / 2.0; + vUv.y = 1.0 - vUv.y; + gl_Position = vec4(position, 1.0, 1.0); +} diff --git a/orx-glslify/src/test/resources/glslify/glsl-noise/classic/2d.glsl b/orx-glslify/src/test/resources/glslify/glsl-noise/classic/2d.glsl new file mode 100644 index 00000000..20b6e3e0 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-noise/classic/2d.glsl @@ -0,0 +1,74 @@ +// +// GLSL textureless classic 2D noise "cnoise", +// with an RSL-style periodic variant "pnoise". +// Author: Stefan Gustavson (stefan.gustavson@liu.se) +// Version: 2011-08-22 +// +// Many thanks to Ian McEwan of Ashima Arts for the +// ideas for permutation and gradient selection. +// +// Copyright (c) 2011 Stefan Gustavson. All rights reserved. +// Distributed under the MIT license. See LICENSE file. +// https://github.com/ashima/webgl-noise +// + +vec4 mod289(vec4 x) +{ + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 permute(vec4 x) +{ + return mod289(((x*34.0)+1.0)*x); +} + +vec4 taylorInvSqrt(vec4 r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +vec2 fade(vec2 t) { + return t*t*t*(t*(t*6.0-15.0)+10.0); +} + +// Classic Perlin noise +float cnoise(vec2 P) +{ + vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0); + vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0); + Pi = mod289(Pi); // To avoid truncation effects in permutation + vec4 ix = Pi.xzxz; + vec4 iy = Pi.yyww; + vec4 fx = Pf.xzxz; + vec4 fy = Pf.yyww; + + vec4 i = permute(permute(ix) + iy); + + vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ; + vec4 gy = abs(gx) - 0.5 ; + vec4 tx = floor(gx + 0.5); + gx = gx - tx; + + vec2 g00 = vec2(gx.x,gy.x); + vec2 g10 = vec2(gx.y,gy.y); + vec2 g01 = vec2(gx.z,gy.z); + vec2 g11 = vec2(gx.w,gy.w); + + vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11))); + g00 *= norm.x; + g01 *= norm.y; + g10 *= norm.z; + g11 *= norm.w; + + float n00 = dot(g00, vec2(fx.x, fy.x)); + float n10 = dot(g10, vec2(fx.y, fy.y)); + float n01 = dot(g01, vec2(fx.z, fy.z)); + float n11 = dot(g11, vec2(fx.w, fy.w)); + + vec2 fade_xy = fade(Pf.xy); + vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x); + float n_xy = mix(n_x.x, n_x.y, fade_xy.y); + return 2.3 * n_xy; +} + +#pragma glslify: export(cnoise) diff --git a/orx-glslify/src/test/resources/glslify/glsl-noise/classic/4d.glsl b/orx-glslify/src/test/resources/glslify/glsl-noise/classic/4d.glsl new file mode 100644 index 00000000..3c908795 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-noise/classic/4d.glsl @@ -0,0 +1,169 @@ +// +// GLSL textureless classic 4D noise "cnoise", +// with an RSL-style periodic variant "pnoise". +// Author: Stefan Gustavson (stefan.gustavson@liu.se) +// Version: 2011-08-22 +// +// Many thanks to Ian McEwan of Ashima Arts for the +// ideas for permutation and gradient selection. +// +// Copyright (c) 2011 Stefan Gustavson. All rights reserved. +// Distributed under the MIT license. See LICENSE file. +// https://github.com/ashima/webgl-noise +// + +vec4 mod289(vec4 x) +{ + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 permute(vec4 x) +{ + return mod289(((x*34.0)+1.0)*x); +} + +vec4 taylorInvSqrt(vec4 r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +vec4 fade(vec4 t) { + return t*t*t*(t*(t*6.0-15.0)+10.0); +} + +// Classic Perlin noise +float cnoise(vec4 P) +{ + vec4 Pi0 = floor(P); // Integer part for indexing + vec4 Pi1 = Pi0 + 1.0; // Integer part + 1 + Pi0 = mod289(Pi0); + Pi1 = mod289(Pi1); + vec4 Pf0 = fract(P); // Fractional part for interpolation + vec4 Pf1 = Pf0 - 1.0; // Fractional part - 1.0 + vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x); + vec4 iy = vec4(Pi0.yy, Pi1.yy); + vec4 iz0 = vec4(Pi0.zzzz); + vec4 iz1 = vec4(Pi1.zzzz); + vec4 iw0 = vec4(Pi0.wwww); + vec4 iw1 = vec4(Pi1.wwww); + + vec4 ixy = permute(permute(ix) + iy); + vec4 ixy0 = permute(ixy + iz0); + vec4 ixy1 = permute(ixy + iz1); + vec4 ixy00 = permute(ixy0 + iw0); + vec4 ixy01 = permute(ixy0 + iw1); + vec4 ixy10 = permute(ixy1 + iw0); + vec4 ixy11 = permute(ixy1 + iw1); + + vec4 gx00 = ixy00 * (1.0 / 7.0); + vec4 gy00 = floor(gx00) * (1.0 / 7.0); + vec4 gz00 = floor(gy00) * (1.0 / 6.0); + gx00 = fract(gx00) - 0.5; + gy00 = fract(gy00) - 0.5; + gz00 = fract(gz00) - 0.5; + vec4 gw00 = vec4(0.75) - abs(gx00) - abs(gy00) - abs(gz00); + vec4 sw00 = step(gw00, vec4(0.0)); + gx00 -= sw00 * (step(0.0, gx00) - 0.5); + gy00 -= sw00 * (step(0.0, gy00) - 0.5); + + vec4 gx01 = ixy01 * (1.0 / 7.0); + vec4 gy01 = floor(gx01) * (1.0 / 7.0); + vec4 gz01 = floor(gy01) * (1.0 / 6.0); + gx01 = fract(gx01) - 0.5; + gy01 = fract(gy01) - 0.5; + gz01 = fract(gz01) - 0.5; + vec4 gw01 = vec4(0.75) - abs(gx01) - abs(gy01) - abs(gz01); + vec4 sw01 = step(gw01, vec4(0.0)); + gx01 -= sw01 * (step(0.0, gx01) - 0.5); + gy01 -= sw01 * (step(0.0, gy01) - 0.5); + + vec4 gx10 = ixy10 * (1.0 / 7.0); + vec4 gy10 = floor(gx10) * (1.0 / 7.0); + vec4 gz10 = floor(gy10) * (1.0 / 6.0); + gx10 = fract(gx10) - 0.5; + gy10 = fract(gy10) - 0.5; + gz10 = fract(gz10) - 0.5; + vec4 gw10 = vec4(0.75) - abs(gx10) - abs(gy10) - abs(gz10); + vec4 sw10 = step(gw10, vec4(0.0)); + gx10 -= sw10 * (step(0.0, gx10) - 0.5); + gy10 -= sw10 * (step(0.0, gy10) - 0.5); + + vec4 gx11 = ixy11 * (1.0 / 7.0); + vec4 gy11 = floor(gx11) * (1.0 / 7.0); + vec4 gz11 = floor(gy11) * (1.0 / 6.0); + gx11 = fract(gx11) - 0.5; + gy11 = fract(gy11) - 0.5; + gz11 = fract(gz11) - 0.5; + vec4 gw11 = vec4(0.75) - abs(gx11) - abs(gy11) - abs(gz11); + vec4 sw11 = step(gw11, vec4(0.0)); + gx11 -= sw11 * (step(0.0, gx11) - 0.5); + gy11 -= sw11 * (step(0.0, gy11) - 0.5); + + vec4 g0000 = vec4(gx00.x,gy00.x,gz00.x,gw00.x); + vec4 g1000 = vec4(gx00.y,gy00.y,gz00.y,gw00.y); + vec4 g0100 = vec4(gx00.z,gy00.z,gz00.z,gw00.z); + vec4 g1100 = vec4(gx00.w,gy00.w,gz00.w,gw00.w); + vec4 g0010 = vec4(gx10.x,gy10.x,gz10.x,gw10.x); + vec4 g1010 = vec4(gx10.y,gy10.y,gz10.y,gw10.y); + vec4 g0110 = vec4(gx10.z,gy10.z,gz10.z,gw10.z); + vec4 g1110 = vec4(gx10.w,gy10.w,gz10.w,gw10.w); + vec4 g0001 = vec4(gx01.x,gy01.x,gz01.x,gw01.x); + vec4 g1001 = vec4(gx01.y,gy01.y,gz01.y,gw01.y); + vec4 g0101 = vec4(gx01.z,gy01.z,gz01.z,gw01.z); + vec4 g1101 = vec4(gx01.w,gy01.w,gz01.w,gw01.w); + vec4 g0011 = vec4(gx11.x,gy11.x,gz11.x,gw11.x); + vec4 g1011 = vec4(gx11.y,gy11.y,gz11.y,gw11.y); + vec4 g0111 = vec4(gx11.z,gy11.z,gz11.z,gw11.z); + vec4 g1111 = vec4(gx11.w,gy11.w,gz11.w,gw11.w); + + vec4 norm00 = taylorInvSqrt(vec4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100))); + g0000 *= norm00.x; + g0100 *= norm00.y; + g1000 *= norm00.z; + g1100 *= norm00.w; + + vec4 norm01 = taylorInvSqrt(vec4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101))); + g0001 *= norm01.x; + g0101 *= norm01.y; + g1001 *= norm01.z; + g1101 *= norm01.w; + + vec4 norm10 = taylorInvSqrt(vec4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110))); + g0010 *= norm10.x; + g0110 *= norm10.y; + g1010 *= norm10.z; + g1110 *= norm10.w; + + vec4 norm11 = taylorInvSqrt(vec4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111))); + g0011 *= norm11.x; + g0111 *= norm11.y; + g1011 *= norm11.z; + g1111 *= norm11.w; + + float n0000 = dot(g0000, Pf0); + float n1000 = dot(g1000, vec4(Pf1.x, Pf0.yzw)); + float n0100 = dot(g0100, vec4(Pf0.x, Pf1.y, Pf0.zw)); + float n1100 = dot(g1100, vec4(Pf1.xy, Pf0.zw)); + float n0010 = dot(g0010, vec4(Pf0.xy, Pf1.z, Pf0.w)); + float n1010 = dot(g1010, vec4(Pf1.x, Pf0.y, Pf1.z, Pf0.w)); + float n0110 = dot(g0110, vec4(Pf0.x, Pf1.yz, Pf0.w)); + float n1110 = dot(g1110, vec4(Pf1.xyz, Pf0.w)); + float n0001 = dot(g0001, vec4(Pf0.xyz, Pf1.w)); + float n1001 = dot(g1001, vec4(Pf1.x, Pf0.yz, Pf1.w)); + float n0101 = dot(g0101, vec4(Pf0.x, Pf1.y, Pf0.z, Pf1.w)); + float n1101 = dot(g1101, vec4(Pf1.xy, Pf0.z, Pf1.w)); + float n0011 = dot(g0011, vec4(Pf0.xy, Pf1.zw)); + float n1011 = dot(g1011, vec4(Pf1.x, Pf0.y, Pf1.zw)); + float n0111 = dot(g0111, vec4(Pf0.x, Pf1.yzw)); + float n1111 = dot(g1111, Pf1); + + vec4 fade_xyzw = fade(Pf0); + vec4 n_0w = mix(vec4(n0000, n1000, n0100, n1100), vec4(n0001, n1001, n0101, n1101), fade_xyzw.w); + vec4 n_1w = mix(vec4(n0010, n1010, n0110, n1110), vec4(n0011, n1011, n0111, n1111), fade_xyzw.w); + vec4 n_zw = mix(n_0w, n_1w, fade_xyzw.z); + vec2 n_yzw = mix(n_zw.xy, n_zw.zw, fade_xyzw.y); + float n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x); + return 2.2 * n_xyzw; +} + +#pragma glslify: export(cnoise) diff --git a/orx-glslify/src/test/resources/glslify/glsl-noise/periodic/2d.glsl b/orx-glslify/src/test/resources/glslify/glsl-noise/periodic/2d.glsl new file mode 100644 index 00000000..c2679704 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-noise/periodic/2d.glsl @@ -0,0 +1,75 @@ +// +// GLSL textureless classic 2D noise "cnoise", +// with an RSL-style periodic variant "pnoise". +// Author: Stefan Gustavson (stefan.gustavson@liu.se) +// Version: 2011-08-22 +// +// Many thanks to Ian McEwan of Ashima Arts for the +// ideas for permutation and gradient selection. +// +// Copyright (c) 2011 Stefan Gustavson. All rights reserved. +// Distributed under the MIT license. See LICENSE file. +// https://github.com/ashima/webgl-noise +// + +vec4 mod289(vec4 x) +{ + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 permute(vec4 x) +{ + return mod289(((x*34.0)+1.0)*x); +} + +vec4 taylorInvSqrt(vec4 r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +vec2 fade(vec2 t) { + return t*t*t*(t*(t*6.0-15.0)+10.0); +} + +// Classic Perlin noise, periodic variant +float pnoise(vec2 P, vec2 rep) +{ + vec4 Pi = floor(P.xyxy) + vec4(0.0, 0.0, 1.0, 1.0); + vec4 Pf = fract(P.xyxy) - vec4(0.0, 0.0, 1.0, 1.0); + Pi = mod(Pi, rep.xyxy); // To create noise with explicit period + Pi = mod289(Pi); // To avoid truncation effects in permutation + vec4 ix = Pi.xzxz; + vec4 iy = Pi.yyww; + vec4 fx = Pf.xzxz; + vec4 fy = Pf.yyww; + + vec4 i = permute(permute(ix) + iy); + + vec4 gx = fract(i * (1.0 / 41.0)) * 2.0 - 1.0 ; + vec4 gy = abs(gx) - 0.5 ; + vec4 tx = floor(gx + 0.5); + gx = gx - tx; + + vec2 g00 = vec2(gx.x,gy.x); + vec2 g10 = vec2(gx.y,gy.y); + vec2 g01 = vec2(gx.z,gy.z); + vec2 g11 = vec2(gx.w,gy.w); + + vec4 norm = taylorInvSqrt(vec4(dot(g00, g00), dot(g01, g01), dot(g10, g10), dot(g11, g11))); + g00 *= norm.x; + g01 *= norm.y; + g10 *= norm.z; + g11 *= norm.w; + + float n00 = dot(g00, vec2(fx.x, fy.x)); + float n10 = dot(g10, vec2(fx.y, fy.y)); + float n01 = dot(g01, vec2(fx.z, fy.z)); + float n11 = dot(g11, vec2(fx.w, fy.w)); + + vec2 fade_xy = fade(Pf.xy); + vec2 n_x = mix(vec2(n00, n01), vec2(n10, n11), fade_xy.x); + float n_xy = mix(n_x.x, n_x.y, fade_xy.y); + return 2.3 * n_xy; +} + +#pragma glslify: export(pnoise) diff --git a/orx-glslify/src/test/resources/glslify/glsl-noise/periodic/3d.glsl b/orx-glslify/src/test/resources/glslify/glsl-noise/periodic/3d.glsl new file mode 100644 index 00000000..b88ffa6e --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-noise/periodic/3d.glsl @@ -0,0 +1,109 @@ +// +// GLSL textureless classic 3D noise "cnoise", +// with an RSL-style periodic variant "pnoise". +// Author: Stefan Gustavson (stefan.gustavson@liu.se) +// Version: 2011-10-11 +// +// Many thanks to Ian McEwan of Ashima Arts for the +// ideas for permutation and gradient selection. +// +// Copyright (c) 2011 Stefan Gustavson. All rights reserved. +// Distributed under the MIT license. See LICENSE file. +// https://github.com/ashima/webgl-noise +// + +vec3 mod289(vec3 x) +{ + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 mod289(vec4 x) +{ + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 permute(vec4 x) +{ + return mod289(((x*34.0)+1.0)*x); +} + +vec4 taylorInvSqrt(vec4 r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +vec3 fade(vec3 t) { + return t*t*t*(t*(t*6.0-15.0)+10.0); +} + +// Classic Perlin noise, periodic variant +float pnoise(vec3 P, vec3 rep) +{ + vec3 Pi0 = mod(floor(P), rep); // Integer part, modulo period + vec3 Pi1 = mod(Pi0 + vec3(1.0), rep); // Integer part + 1, mod period + Pi0 = mod289(Pi0); + Pi1 = mod289(Pi1); + vec3 Pf0 = fract(P); // Fractional part for interpolation + vec3 Pf1 = Pf0 - vec3(1.0); // Fractional part - 1.0 + vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x); + vec4 iy = vec4(Pi0.yy, Pi1.yy); + vec4 iz0 = Pi0.zzzz; + vec4 iz1 = Pi1.zzzz; + + vec4 ixy = permute(permute(ix) + iy); + vec4 ixy0 = permute(ixy + iz0); + vec4 ixy1 = permute(ixy + iz1); + + vec4 gx0 = ixy0 * (1.0 / 7.0); + vec4 gy0 = fract(floor(gx0) * (1.0 / 7.0)) - 0.5; + gx0 = fract(gx0); + vec4 gz0 = vec4(0.5) - abs(gx0) - abs(gy0); + vec4 sz0 = step(gz0, vec4(0.0)); + gx0 -= sz0 * (step(0.0, gx0) - 0.5); + gy0 -= sz0 * (step(0.0, gy0) - 0.5); + + vec4 gx1 = ixy1 * (1.0 / 7.0); + vec4 gy1 = fract(floor(gx1) * (1.0 / 7.0)) - 0.5; + gx1 = fract(gx1); + vec4 gz1 = vec4(0.5) - abs(gx1) - abs(gy1); + vec4 sz1 = step(gz1, vec4(0.0)); + gx1 -= sz1 * (step(0.0, gx1) - 0.5); + gy1 -= sz1 * (step(0.0, gy1) - 0.5); + + vec3 g000 = vec3(gx0.x,gy0.x,gz0.x); + vec3 g100 = vec3(gx0.y,gy0.y,gz0.y); + vec3 g010 = vec3(gx0.z,gy0.z,gz0.z); + vec3 g110 = vec3(gx0.w,gy0.w,gz0.w); + vec3 g001 = vec3(gx1.x,gy1.x,gz1.x); + vec3 g101 = vec3(gx1.y,gy1.y,gz1.y); + vec3 g011 = vec3(gx1.z,gy1.z,gz1.z); + vec3 g111 = vec3(gx1.w,gy1.w,gz1.w); + + vec4 norm0 = taylorInvSqrt(vec4(dot(g000, g000), dot(g010, g010), dot(g100, g100), dot(g110, g110))); + g000 *= norm0.x; + g010 *= norm0.y; + g100 *= norm0.z; + g110 *= norm0.w; + vec4 norm1 = taylorInvSqrt(vec4(dot(g001, g001), dot(g011, g011), dot(g101, g101), dot(g111, g111))); + g001 *= norm1.x; + g011 *= norm1.y; + g101 *= norm1.z; + g111 *= norm1.w; + + float n000 = dot(g000, Pf0); + float n100 = dot(g100, vec3(Pf1.x, Pf0.yz)); + float n010 = dot(g010, vec3(Pf0.x, Pf1.y, Pf0.z)); + float n110 = dot(g110, vec3(Pf1.xy, Pf0.z)); + float n001 = dot(g001, vec3(Pf0.xy, Pf1.z)); + float n101 = dot(g101, vec3(Pf1.x, Pf0.y, Pf1.z)); + float n011 = dot(g011, vec3(Pf0.x, Pf1.yz)); + float n111 = dot(g111, Pf1); + + vec3 fade_xyz = fade(Pf0); + vec4 n_z = mix(vec4(n000, n100, n010, n110), vec4(n001, n101, n011, n111), fade_xyz.z); + vec2 n_yz = mix(n_z.xy, n_z.zw, fade_xyz.y); + float n_xyz = mix(n_yz.x, n_yz.y, fade_xyz.x); + return 2.2 * n_xyz; +} + +#pragma glslify: export(pnoise) diff --git a/orx-glslify/src/test/resources/glslify/glsl-noise/periodic/4d.glsl b/orx-glslify/src/test/resources/glslify/glsl-noise/periodic/4d.glsl new file mode 100644 index 00000000..a754ba4c --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-noise/periodic/4d.glsl @@ -0,0 +1,169 @@ +// +// GLSL textureless classic 4D noise "cnoise", +// with an RSL-style periodic variant "pnoise". +// Author: Stefan Gustavson (stefan.gustavson@liu.se) +// Version: 2011-08-22 +// +// Many thanks to Ian McEwan of Ashima Arts for the +// ideas for permutation and gradient selection. +// +// Copyright (c) 2011 Stefan Gustavson. All rights reserved. +// Distributed under the MIT license. See LICENSE file. +// https://github.com/ashima/webgl-noise +// + +vec4 mod289(vec4 x) +{ + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 permute(vec4 x) +{ + return mod289(((x*34.0)+1.0)*x); +} + +vec4 taylorInvSqrt(vec4 r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +vec4 fade(vec4 t) { + return t*t*t*(t*(t*6.0-15.0)+10.0); +} + +// Classic Perlin noise, periodic version +float pnoise(vec4 P, vec4 rep) +{ + vec4 Pi0 = mod(floor(P), rep); // Integer part modulo rep + vec4 Pi1 = mod(Pi0 + 1.0, rep); // Integer part + 1 mod rep + Pi0 = mod289(Pi0); + Pi1 = mod289(Pi1); + vec4 Pf0 = fract(P); // Fractional part for interpolation + vec4 Pf1 = Pf0 - 1.0; // Fractional part - 1.0 + vec4 ix = vec4(Pi0.x, Pi1.x, Pi0.x, Pi1.x); + vec4 iy = vec4(Pi0.yy, Pi1.yy); + vec4 iz0 = vec4(Pi0.zzzz); + vec4 iz1 = vec4(Pi1.zzzz); + vec4 iw0 = vec4(Pi0.wwww); + vec4 iw1 = vec4(Pi1.wwww); + + vec4 ixy = permute(permute(ix) + iy); + vec4 ixy0 = permute(ixy + iz0); + vec4 ixy1 = permute(ixy + iz1); + vec4 ixy00 = permute(ixy0 + iw0); + vec4 ixy01 = permute(ixy0 + iw1); + vec4 ixy10 = permute(ixy1 + iw0); + vec4 ixy11 = permute(ixy1 + iw1); + + vec4 gx00 = ixy00 * (1.0 / 7.0); + vec4 gy00 = floor(gx00) * (1.0 / 7.0); + vec4 gz00 = floor(gy00) * (1.0 / 6.0); + gx00 = fract(gx00) - 0.5; + gy00 = fract(gy00) - 0.5; + gz00 = fract(gz00) - 0.5; + vec4 gw00 = vec4(0.75) - abs(gx00) - abs(gy00) - abs(gz00); + vec4 sw00 = step(gw00, vec4(0.0)); + gx00 -= sw00 * (step(0.0, gx00) - 0.5); + gy00 -= sw00 * (step(0.0, gy00) - 0.5); + + vec4 gx01 = ixy01 * (1.0 / 7.0); + vec4 gy01 = floor(gx01) * (1.0 / 7.0); + vec4 gz01 = floor(gy01) * (1.0 / 6.0); + gx01 = fract(gx01) - 0.5; + gy01 = fract(gy01) - 0.5; + gz01 = fract(gz01) - 0.5; + vec4 gw01 = vec4(0.75) - abs(gx01) - abs(gy01) - abs(gz01); + vec4 sw01 = step(gw01, vec4(0.0)); + gx01 -= sw01 * (step(0.0, gx01) - 0.5); + gy01 -= sw01 * (step(0.0, gy01) - 0.5); + + vec4 gx10 = ixy10 * (1.0 / 7.0); + vec4 gy10 = floor(gx10) * (1.0 / 7.0); + vec4 gz10 = floor(gy10) * (1.0 / 6.0); + gx10 = fract(gx10) - 0.5; + gy10 = fract(gy10) - 0.5; + gz10 = fract(gz10) - 0.5; + vec4 gw10 = vec4(0.75) - abs(gx10) - abs(gy10) - abs(gz10); + vec4 sw10 = step(gw10, vec4(0.0)); + gx10 -= sw10 * (step(0.0, gx10) - 0.5); + gy10 -= sw10 * (step(0.0, gy10) - 0.5); + + vec4 gx11 = ixy11 * (1.0 / 7.0); + vec4 gy11 = floor(gx11) * (1.0 / 7.0); + vec4 gz11 = floor(gy11) * (1.0 / 6.0); + gx11 = fract(gx11) - 0.5; + gy11 = fract(gy11) - 0.5; + gz11 = fract(gz11) - 0.5; + vec4 gw11 = vec4(0.75) - abs(gx11) - abs(gy11) - abs(gz11); + vec4 sw11 = step(gw11, vec4(0.0)); + gx11 -= sw11 * (step(0.0, gx11) - 0.5); + gy11 -= sw11 * (step(0.0, gy11) - 0.5); + + vec4 g0000 = vec4(gx00.x,gy00.x,gz00.x,gw00.x); + vec4 g1000 = vec4(gx00.y,gy00.y,gz00.y,gw00.y); + vec4 g0100 = vec4(gx00.z,gy00.z,gz00.z,gw00.z); + vec4 g1100 = vec4(gx00.w,gy00.w,gz00.w,gw00.w); + vec4 g0010 = vec4(gx10.x,gy10.x,gz10.x,gw10.x); + vec4 g1010 = vec4(gx10.y,gy10.y,gz10.y,gw10.y); + vec4 g0110 = vec4(gx10.z,gy10.z,gz10.z,gw10.z); + vec4 g1110 = vec4(gx10.w,gy10.w,gz10.w,gw10.w); + vec4 g0001 = vec4(gx01.x,gy01.x,gz01.x,gw01.x); + vec4 g1001 = vec4(gx01.y,gy01.y,gz01.y,gw01.y); + vec4 g0101 = vec4(gx01.z,gy01.z,gz01.z,gw01.z); + vec4 g1101 = vec4(gx01.w,gy01.w,gz01.w,gw01.w); + vec4 g0011 = vec4(gx11.x,gy11.x,gz11.x,gw11.x); + vec4 g1011 = vec4(gx11.y,gy11.y,gz11.y,gw11.y); + vec4 g0111 = vec4(gx11.z,gy11.z,gz11.z,gw11.z); + vec4 g1111 = vec4(gx11.w,gy11.w,gz11.w,gw11.w); + + vec4 norm00 = taylorInvSqrt(vec4(dot(g0000, g0000), dot(g0100, g0100), dot(g1000, g1000), dot(g1100, g1100))); + g0000 *= norm00.x; + g0100 *= norm00.y; + g1000 *= norm00.z; + g1100 *= norm00.w; + + vec4 norm01 = taylorInvSqrt(vec4(dot(g0001, g0001), dot(g0101, g0101), dot(g1001, g1001), dot(g1101, g1101))); + g0001 *= norm01.x; + g0101 *= norm01.y; + g1001 *= norm01.z; + g1101 *= norm01.w; + + vec4 norm10 = taylorInvSqrt(vec4(dot(g0010, g0010), dot(g0110, g0110), dot(g1010, g1010), dot(g1110, g1110))); + g0010 *= norm10.x; + g0110 *= norm10.y; + g1010 *= norm10.z; + g1110 *= norm10.w; + + vec4 norm11 = taylorInvSqrt(vec4(dot(g0011, g0011), dot(g0111, g0111), dot(g1011, g1011), dot(g1111, g1111))); + g0011 *= norm11.x; + g0111 *= norm11.y; + g1011 *= norm11.z; + g1111 *= norm11.w; + + float n0000 = dot(g0000, Pf0); + float n1000 = dot(g1000, vec4(Pf1.x, Pf0.yzw)); + float n0100 = dot(g0100, vec4(Pf0.x, Pf1.y, Pf0.zw)); + float n1100 = dot(g1100, vec4(Pf1.xy, Pf0.zw)); + float n0010 = dot(g0010, vec4(Pf0.xy, Pf1.z, Pf0.w)); + float n1010 = dot(g1010, vec4(Pf1.x, Pf0.y, Pf1.z, Pf0.w)); + float n0110 = dot(g0110, vec4(Pf0.x, Pf1.yz, Pf0.w)); + float n1110 = dot(g1110, vec4(Pf1.xyz, Pf0.w)); + float n0001 = dot(g0001, vec4(Pf0.xyz, Pf1.w)); + float n1001 = dot(g1001, vec4(Pf1.x, Pf0.yz, Pf1.w)); + float n0101 = dot(g0101, vec4(Pf0.x, Pf1.y, Pf0.z, Pf1.w)); + float n1101 = dot(g1101, vec4(Pf1.xy, Pf0.z, Pf1.w)); + float n0011 = dot(g0011, vec4(Pf0.xy, Pf1.zw)); + float n1011 = dot(g1011, vec4(Pf1.x, Pf0.y, Pf1.zw)); + float n0111 = dot(g0111, vec4(Pf0.x, Pf1.yzw)); + float n1111 = dot(g1111, Pf1); + + vec4 fade_xyzw = fade(Pf0); + vec4 n_0w = mix(vec4(n0000, n1000, n0100, n1100), vec4(n0001, n1001, n0101, n1101), fade_xyzw.w); + vec4 n_1w = mix(vec4(n0010, n1010, n0110, n1110), vec4(n0011, n1011, n0111, n1111), fade_xyzw.w); + vec4 n_zw = mix(n_0w, n_1w, fade_xyzw.z); + vec2 n_yzw = mix(n_zw.xy, n_zw.zw, fade_xyzw.y); + float n_xyzw = mix(n_yzw.x, n_yzw.y, fade_xyzw.x); + return 2.2 * n_xyzw; +} + +#pragma glslify: export(pnoise) diff --git a/orx-glslify/src/test/resources/glslify/glsl-noise/simplex/2d.glsl b/orx-glslify/src/test/resources/glslify/glsl-noise/simplex/2d.glsl new file mode 100644 index 00000000..7c89a877 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-noise/simplex/2d.glsl @@ -0,0 +1,72 @@ +// +// Description : Array and textureless GLSL 2D simplex noise function. +// Author : Ian McEwan, Ashima Arts. +// Maintainer : ijm +// Lastmod : 20110822 (ijm) +// License : Copyright (C) 2011 Ashima Arts. All rights reserved. +// Distributed under the MIT License. See LICENSE file. +// https://github.com/ashima/webgl-noise +// + +vec3 mod289(vec3 x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec2 mod289(vec2 x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec3 permute(vec3 x) { + return mod289(((x*34.0)+1.0)*x); +} + +float snoise(vec2 v) + { + const vec4 C = vec4(0.211324865405187, // (3.0-sqrt(3.0))/6.0 + 0.366025403784439, // 0.5*(sqrt(3.0)-1.0) + -0.577350269189626, // -1.0 + 2.0 * C.x + 0.024390243902439); // 1.0 / 41.0 +// First corner + vec2 i = floor(v + dot(v, C.yy) ); + vec2 x0 = v - i + dot(i, C.xx); + +// Other corners + vec2 i1; + //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0 + //i1.y = 1.0 - i1.x; + i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0); + // x0 = x0 - 0.0 + 0.0 * C.xx ; + // x1 = x0 - i1 + 1.0 * C.xx ; + // x2 = x0 - 1.0 + 2.0 * C.xx ; + vec4 x12 = x0.xyxy + C.xxzz; + x12.xy -= i1; + +// Permutations + i = mod289(i); // Avoid truncation effects in permutation + vec3 p = permute( permute( i.y + vec3(0.0, i1.y, 1.0 )) + + i.x + vec3(0.0, i1.x, 1.0 )); + + vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0); + m = m*m ; + m = m*m ; + +// Gradients: 41 points uniformly over a line, mapped onto a diamond. +// The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287) + + vec3 x = 2.0 * fract(p * C.www) - 1.0; + vec3 h = abs(x) - 0.5; + vec3 ox = floor(x + 0.5); + vec3 a0 = x - ox; + +// Normalise gradients implicitly by scaling m +// Approximation of: m *= inversesqrt( a0*a0 + h*h ); + m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h ); + +// Compute final noise value at P + vec3 g; + g.x = a0.x * x0.x + h.x * x0.y; + g.yz = a0.yz * x12.xz + h.yz * x12.yw; + return 130.0 * dot(m, g); +} + +#pragma glslify: export(snoise) diff --git a/orx-glslify/src/test/resources/glslify/glsl-noise/simplex/3d.glsl b/orx-glslify/src/test/resources/glslify/glsl-noise/simplex/3d.glsl new file mode 100644 index 00000000..711e5bf8 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-noise/simplex/3d.glsl @@ -0,0 +1,104 @@ +// +// Description : Array and textureless GLSL 2D/3D/4D simplex +// noise functions. +// Author : Ian McEwan, Ashima Arts. +// Maintainer : ijm +// Lastmod : 20110822 (ijm) +// License : Copyright (C) 2011 Ashima Arts. All rights reserved. +// Distributed under the MIT License. See LICENSE file. +// https://github.com/ashima/webgl-noise +// + +vec3 mod289(vec3 x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 mod289(vec4 x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; +} + +vec4 permute(vec4 x) { + return mod289(((x*34.0)+1.0)*x); +} + +vec4 taylorInvSqrt(vec4 r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +float snoise(vec3 v) + { + const vec2 C = vec2(1.0/6.0, 1.0/3.0) ; + const vec4 D = vec4(0.0, 0.5, 1.0, 2.0); + +// First corner + vec3 i = floor(v + dot(v, C.yyy) ); + vec3 x0 = v - i + dot(i, C.xxx) ; + +// Other corners + vec3 g = step(x0.yzx, x0.xyz); + vec3 l = 1.0 - g; + vec3 i1 = min( g.xyz, l.zxy ); + vec3 i2 = max( g.xyz, l.zxy ); + + // x0 = x0 - 0.0 + 0.0 * C.xxx; + // x1 = x0 - i1 + 1.0 * C.xxx; + // x2 = x0 - i2 + 2.0 * C.xxx; + // x3 = x0 - 1.0 + 3.0 * C.xxx; + vec3 x1 = x0 - i1 + C.xxx; + vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y + vec3 x3 = x0 - D.yyy; // -1.0+3.0*C.x = -0.5 = -D.y + +// Permutations + i = mod289(i); + vec4 p = permute( permute( permute( + i.z + vec4(0.0, i1.z, i2.z, 1.0 )) + + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) + + i.x + vec4(0.0, i1.x, i2.x, 1.0 )); + +// Gradients: 7x7 points over a square, mapped onto an octahedron. +// The ring size 17*17 = 289 is close to a multiple of 49 (49*6 = 294) + float n_ = 0.142857142857; // 1.0/7.0 + vec3 ns = n_ * D.wyz - D.xzx; + + vec4 j = p - 49.0 * floor(p * ns.z * ns.z); // mod(p,7*7) + + vec4 x_ = floor(j * ns.z); + vec4 y_ = floor(j - 7.0 * x_ ); // mod(j,N) + + vec4 x = x_ *ns.x + ns.yyyy; + vec4 y = y_ *ns.x + ns.yyyy; + vec4 h = 1.0 - abs(x) - abs(y); + + vec4 b0 = vec4( x.xy, y.xy ); + vec4 b1 = vec4( x.zw, y.zw ); + + //vec4 s0 = vec4(lessThan(b0,0.0))*2.0 - 1.0; + //vec4 s1 = vec4(lessThan(b1,0.0))*2.0 - 1.0; + vec4 s0 = floor(b0)*2.0 + 1.0; + vec4 s1 = floor(b1)*2.0 + 1.0; + vec4 sh = -step(h, vec4(0.0)); + + vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ; + vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ; + + vec3 p0 = vec3(a0.xy,h.x); + vec3 p1 = vec3(a0.zw,h.y); + vec3 p2 = vec3(a1.xy,h.z); + vec3 p3 = vec3(a1.zw,h.w); + +//Normalise gradients + vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3))); + p0 *= norm.x; + p1 *= norm.y; + p2 *= norm.z; + p3 *= norm.w; + +// Mix final noise value + vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0); + m = m * m; + return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), + dot(p2,x2), dot(p3,x3) ) ); + } + +#pragma glslify: export(snoise) diff --git a/orx-glslify/src/test/resources/glslify/glsl-noise/simplex/4d.glsl b/orx-glslify/src/test/resources/glslify/glsl-noise/simplex/4d.glsl new file mode 100644 index 00000000..76ee01c9 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/glsl-noise/simplex/4d.glsl @@ -0,0 +1,130 @@ +// +// Description : Array and textureless GLSL 2D/3D/4D simplex +// noise functions. +// Author : Ian McEwan, Ashima Arts. +// Maintainer : ijm +// Lastmod : 20110822 (ijm) +// License : Copyright (C) 2011 Ashima Arts. All rights reserved. +// Distributed under the MIT License. See LICENSE file. +// https://github.com/ashima/webgl-noise +// + +vec4 mod289(vec4 x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; } + +float mod289(float x) { + return x - floor(x * (1.0 / 289.0)) * 289.0; } + +vec4 permute(vec4 x) { + return mod289(((x*34.0)+1.0)*x); +} + +float permute(float x) { + return mod289(((x*34.0)+1.0)*x); +} + +vec4 taylorInvSqrt(vec4 r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +float taylorInvSqrt(float r) +{ + return 1.79284291400159 - 0.85373472095314 * r; +} + +vec4 grad4(float j, vec4 ip) + { + const vec4 ones = vec4(1.0, 1.0, 1.0, -1.0); + vec4 p,s; + + p.xyz = floor( fract (vec3(j) * ip.xyz) * 7.0) * ip.z - 1.0; + p.w = 1.5 - dot(abs(p.xyz), ones.xyz); + s = vec4(lessThan(p, vec4(0.0))); + p.xyz = p.xyz + (s.xyz*2.0 - 1.0) * s.www; + + return p; + } + +// (sqrt(5) - 1)/4 = F4, used once below +#define F4 0.309016994374947451 + +float snoise(vec4 v) + { + const vec4 C = vec4( 0.138196601125011, // (5 - sqrt(5))/20 G4 + 0.276393202250021, // 2 * G4 + 0.414589803375032, // 3 * G4 + -0.447213595499958); // -1 + 4 * G4 + +// First corner + vec4 i = floor(v + dot(v, vec4(F4)) ); + vec4 x0 = v - i + dot(i, C.xxxx); + +// Other corners + +// Rank sorting originally contributed by Bill Licea-Kane, AMD (formerly ATI) + vec4 i0; + vec3 isX = step( x0.yzw, x0.xxx ); + vec3 isYZ = step( x0.zww, x0.yyz ); +// i0.x = dot( isX, vec3( 1.0 ) ); + i0.x = isX.x + isX.y + isX.z; + i0.yzw = 1.0 - isX; +// i0.y += dot( isYZ.xy, vec2( 1.0 ) ); + i0.y += isYZ.x + isYZ.y; + i0.zw += 1.0 - isYZ.xy; + i0.z += isYZ.z; + i0.w += 1.0 - isYZ.z; + + // i0 now contains the unique values 0,1,2,3 in each channel + vec4 i3 = clamp( i0, 0.0, 1.0 ); + vec4 i2 = clamp( i0-1.0, 0.0, 1.0 ); + vec4 i1 = clamp( i0-2.0, 0.0, 1.0 ); + + // x0 = x0 - 0.0 + 0.0 * C.xxxx + // x1 = x0 - i1 + 1.0 * C.xxxx + // x2 = x0 - i2 + 2.0 * C.xxxx + // x3 = x0 - i3 + 3.0 * C.xxxx + // x4 = x0 - 1.0 + 4.0 * C.xxxx + vec4 x1 = x0 - i1 + C.xxxx; + vec4 x2 = x0 - i2 + C.yyyy; + vec4 x3 = x0 - i3 + C.zzzz; + vec4 x4 = x0 + C.wwww; + +// Permutations + i = mod289(i); + float j0 = permute( permute( permute( permute(i.w) + i.z) + i.y) + i.x); + vec4 j1 = permute( permute( permute( permute ( + i.w + vec4(i1.w, i2.w, i3.w, 1.0 )) + + i.z + vec4(i1.z, i2.z, i3.z, 1.0 )) + + i.y + vec4(i1.y, i2.y, i3.y, 1.0 )) + + i.x + vec4(i1.x, i2.x, i3.x, 1.0 )); + +// Gradients: 7x7x6 points over a cube, mapped onto a 4-cross polytope +// 7*7*6 = 294, which is close to the ring size 17*17 = 289. + vec4 ip = vec4(1.0/294.0, 1.0/49.0, 1.0/7.0, 0.0) ; + + vec4 p0 = grad4(j0, ip); + vec4 p1 = grad4(j1.x, ip); + vec4 p2 = grad4(j1.y, ip); + vec4 p3 = grad4(j1.z, ip); + vec4 p4 = grad4(j1.w, ip); + +// Normalise gradients + vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3))); + p0 *= norm.x; + p1 *= norm.y; + p2 *= norm.z; + p3 *= norm.w; + p4 *= taylorInvSqrt(dot(p4,p4)); + +// Mix contributions from the five corners + vec3 m0 = max(0.6 - vec3(dot(x0,x0), dot(x1,x1), dot(x2,x2)), 0.0); + vec2 m1 = max(0.6 - vec2(dot(x3,x3), dot(x4,x4) ), 0.0); + m0 = m0 * m0; + m1 = m1 * m1; + return 49.0 * ( dot(m0*m0, vec3( dot( p0, x0 ), dot( p1, x1 ), dot( p2, x2 ))) + + dot(m1*m1, vec2( dot( p3, x3 ), dot( p4, x4 ) ) ) ) ; + + } + +#pragma glslify: export(snoise) diff --git a/orx-glslify/src/test/resources/glslify/solve/index.glsl b/orx-glslify/src/test/resources/glslify/solve/index.glsl index 5fabb2c6..73e39bfe 100644 --- a/orx-glslify/src/test/resources/glslify/solve/index.glsl +++ b/orx-glslify/src/test/resources/glslify/solve/index.glsl @@ -1,8 +1,9 @@ #pragma glslify: add = require(sum) #pragma glslify: multiply = require(multiply) +#pragma glslify: subtract = require('./subtract.glsl') float solve(float a, float b) { - return multiply(add(a, b), b); + return subtract(multiply(add(a, b), b), b); } #pragma glslify: export(solve) \ No newline at end of file diff --git a/orx-glslify/src/test/resources/glslify/solve/subtract.glsl b/orx-glslify/src/test/resources/glslify/solve/subtract.glsl new file mode 100644 index 00000000..97c97f88 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/solve/subtract.glsl @@ -0,0 +1,5 @@ +float subtract(float a, float b) { + return a - b; +} + +#pragma glslify: export(subtract) \ No newline at end of file diff --git a/orx-glslify/src/test/resources/glslify/src/test/src-test.js b/orx-glslify/src/test/resources/glslify/src/test/src-test.js new file mode 100644 index 00000000..bd2204db --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/src/test/src-test.js @@ -0,0 +1,74 @@ +var assert = require('assert'); +var src = require(__dirname + '/../index'); +var async = require('async') +var _ = require('underscore') +var cache = src({expiry:2}); +describe('Simple Redis Cache', function(){ + it('should connect to a redis instance', function(done){ + //Give redis some time to init + setTimeout(function(){ + assert.equal('localhost', cache.client.host); + done(); + }, 100); + }); + it('should set a key with a value', function(done){ + cache.set('test', 'this is a string', done); + }); + it('should retrieve the value', function(done){ + cache.get('test', function(err, value){ + assert.equal('this is a string', value); + done(); + }); + }); + it('the key should be valid still', function(done){ + setTimeout(function(){ + cache.get('test', function(err, value){ + assert.notEqual(null, value); + done(); + })}, 1000); + }); + it('the key should be invalid now', function(done){ + setTimeout(function(){ + cache.get('test', function(err, value){ + assert.equal(null, value); + done(); + })}, 3000); + }); + it('should be able to delete a key', function(done){ + cache.set('test2', 'whatever', function(err){ + cache.del('test2', function(){ + cache.get('test2', function(err, value){ + assert.equal(value, null); + done() + }); + }); + }); + }); + it('should have a function to get the cache id', function() { + assert.ok(cache.id()) + }) + it('should allow setting cache id', function() { + assert.equal(src({id:'id-test'}).id(), 'id-test') + }) + it('should list the cache keys', function(done) { + var keys = _.map([ + 1,2,3,4,5,6,7,8,9,10,11,12 + ], String) + async.each(keys, function(k, cb) { + cache.set(k, new Date().toJSON(), cb) + }, function() { + cache.keys(function(err, ks) { + _.each(keys, function(k) { + assert.ok(ks.indexOf(k) !== -1) + }) + cache.keys(function(er, ks) { + var raws = _.map(keys, function(p) { return cache.id() + ':' + p }) + _.each(raws, function(k) { + assert.ok(ks.indexOf(k) !== -1) + }) + done() + }, { raw: true }) + }); + }) + }) +}); diff --git a/orx-glslify/src/test/resources/glslify/subtract/lib/index.js b/orx-glslify/src/test/resources/glslify/subtract/lib/index.js new file mode 100644 index 00000000..bf2c29f0 --- /dev/null +++ b/orx-glslify/src/test/resources/glslify/subtract/lib/index.js @@ -0,0 +1 @@ +module.exports = (a, b) => a - b