kaze/orx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove orx-glslify

Browse Source
This commit is contained in:
Edwin Jakobs
2023-08-26 07:37:42 +02:00
parent d1efc35000
commit f81cebd01e
62 changed files with 0 additions and 1915 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
gradle/libs.versions.toml
View File

@@ -20,7 +20,6 @@ librealsense = "2.53.1-1.5.9"
gson = "2.10.1"
antlr = "4.13.0"
tensorflow = "0.5.0"
jarchivelib = "1.2.0"
minim = "2.2.2"
netty = "4.1.92.Final"
rabbitcontrol = "0.3.29"
@@ -60,7 +59,6 @@ tensorflow = { group = "org.tensorflow", name = "tensorflow-core-api", version.r
boofcv = { group = "org.boofcv", name = "boofcv-core", version.ref = "boofcv" }
libfreenect = { group = "org.bytedeco", name = "libfreenect", version.ref = "libfreenect" }
librealsense = { group = "org.bytedeco", name = "librealsense2", version.ref = "librealsense" }
jarchivelib = { group = "org.rauschig", name = "jarchivelib", version.ref = "jarchivelib" }
minim = { group = "net.compartmental.code", name = "minim", version.ref = "minim" }
netty-all = { group = "io.netty", name = "netty-all", version.ref = "netty" }
rabbitcontrol-rcp = { group = "cc.rabbitcontrol", name = "rcp", version.ref = "rabbitcontrol" }

57
orx-glslify/README.md
View File

@@ -1,57 +0,0 @@
# orx-glslify
Load glslify compatible shaders from [npm](https://www.npmjs.com/search?q=glslify).
### Caveats
There's also a mapping functionality that glslify provides that we don't support. This can be easily solved
by doing as the following example (based on `glsl-raytrace` package):
```glsl
const int steps = 50;
vec2 map(vec3 p);
#pragma glslify: raytrace = require(glsl-raytrace)
```
## Example
Shader file:
```glsl
#version 330
in vec2 v_texCoord0;
uniform sampler2D tex0;
uniform float uTime;
out vec4 o_color;
#pragma glslify: checker = require(glsl-checker)
#pragma glslify: perlin = require(glsl-noise/classic/3d)
#pragma glslify: easing = require(glsl-easings/cubic-in-out)
void main() {
vec2 uv = v_texCoord0;
float n = perlin(vec3(uv * 2.5 + uTime * 0.01, uTime * 0.2)) * 0.5 + 0.5;
float patt = checker(uv * easing(n), 6.0);
vec3 col = mix(vec3(0.173, 0.216, 0.278),vec3(0.792, 0.282, 0.478), vec3(patt)) * (n + 0.1);
o_color = vec4(col, 1.0);
}
```
Then preprocess it with either:
```kotlin
preprocessGlslifyFromUrl(resourceUrl("/shaders/ray-marching.glsl"))
```
or
```kotlin
preprocessGlslify("""version #330 ...""")
```

21
orx-glslify/build.gradle.kts
View File

@@ -1,21 +0,0 @@
plugins {
org.openrndr.extra.convention.`kotlin-jvm`
}
dependencies {
implementation(libs.openrndr.application)
implementation(libs.openrndr.math)
implementation(libs.gson)
implementation(libs.jarchivelib)
implementation(project(":orx-noise"))
testImplementation(libs.kluent)
testImplementation(libs.spek.dsl)
testRuntimeOnly(libs.spek.junit5)
testRuntimeOnly(libs.kotlin.reflect)
}
tasks.test {
useJUnitPlatform {
includeEngines("spek2")
}
}

42
orx-glslify/src/main/kotlin/FileSystemUtils.kt
View File

@@ -1,42 +0,0 @@
package org.openrndr.extra.glslify
import org.rauschig.jarchivelib.Archiver
import org.rauschig.jarchivelib.ArchiverFactory
import java.io.File
import java.io.InputStream
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths
internal fun extractGzipStream(tarStream: InputStream, dest: File) {
val archiver: Archiver = ArchiverFactory.createArchiver("tar", "gz")
archiver.extract(tarStream, dest)
}
internal fun moveFilesUp(modulePath: Path) {
val packageFolder = modulePath.resolve("package")
val packageFiles = Files.list(packageFolder).filter {
Files.isDirectory(it) || shaderExtensions.contains(it.fileName.toString().substringAfterLast("."))
}
packageFiles.forEach {
// fileName also retrieves folders ¯\_(ツ)_/¯
val dest = modulePath.resolve(modulePath.relativize(it).fileName)
Files.move(it, dest)
}
}
internal fun parseModule(module: String): Pair<String, Path> {
val path = Paths.get(module)
val pathLen = path.nameCount
val moduleName = path.subpath(0, 1).toString()
var shaderPath = Paths.get("index")
if (pathLen > 1) {
shaderPath = path.subpath(1, pathLen)
}
return Pair(moduleName, shaderPath)
}

182
orx-glslify/src/main/kotlin/Glslify.kt
View File

@@ -1,182 +0,0 @@
package org.openrndr.extra.glslify
import mu.KotlinLogging
import org.openrndr.draw.codeFromURL
import java.io.ByteArrayInputStream
import java.io.InputStream
import java.net.URL
import java.nio.file.Files
import java.nio.file.Path
import java.nio.file.Paths
import javax.net.ssl.HttpsURLConnection
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"
internal val shaderExtensions = arrayOf("glsl", "frag")
internal val logger = KotlinLogging.logger {}
private var importTree = mutableSetOf<String>()
fun preprocessGlslifyFromUrl(url: String, glslifyPath: String = "src/main/resources/glslify"): String {
return preprocessGlslify(codeFromURL(url), glslifyPath)
}
data class GlslifyModule(
val requirePath: String,
val functionName: String,
val lineNumber: Int
) {
private var shaderFile: MutableList<String> = mutableListOf()
lateinit var moduleName: String
lateinit var shaderFilePath: Path
var exportName: String? = null
private val dependencies = mutableListOf<GlslifyModule>()
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<String> {
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<GlslifyModule>()
fun preprocessGlslify(source: String, glslifyPath: String = "src/main/resources/glslify"): String {
importTree = mutableSetOf()
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 requirePath = it.groupValues[2]
if (importTree.contains(requirePath)) return@mapIndexed ""
importTree.add(requirePath)
stack.add(GlslifyModule(requirePath, functionName, lineNumber))
}
}
}
line
}.toMutableList()
stack.asReversed().forEach {
mainShader[it.lineNumber] = it.import(glslifyPath)
}
return mainShader.joinToString("\n").trimMargin()
}
internal fun fetchModule(moduleName: String, moduleDir: Path) {
val packageUrl = getPackageUrl(moduleName)
if (packageUrl.isNullOrEmpty()) {
throw error("[glslify] $moduleName not found")
}
try {
Files.createDirectories(moduleDir)
val url = URL(packageUrl)
val con = url.openConnection()
val tarStream: InputStream = ByteArrayInputStream(con.getInputStream().readBytes())
extractGzipStream(tarStream, moduleDir.toFile())
moveFilesUp(moduleDir)
moduleDir.resolve("package").toFile().deleteRecursively()
logger.trace("[glslify] $moduleName downloaded")
(con as HttpsURLConnection).disconnect()
} catch (ex: Exception) {
logger.error(ex) { "[glslify]: There was an error getting $moduleName" }
}
}

50
orx-glslify/src/main/kotlin/NpmUtils.kt
View File

@@ -1,50 +0,0 @@
package org.openrndr.extra.glslify
import com.google.gson.GsonBuilder
import com.google.gson.annotations.SerializedName
import java.net.URL
import javax.net.ssl.HttpsURLConnection
internal data class NPMPackageDist(
val shasum: String,
val tarball: String
)
internal data class NPMPackageVersion(
val name: String,
val version: String,
val dist: NPMPackageDist
)
internal data class NPMResponse(
val name: String?,
val error: String?,
@SerializedName("dist-tags")
val distTags: MutableMap<String, String>?,
val versions: Map<String, NPMPackageVersion>?
)
internal fun getPackageUrl(module: String): String? {
val moduleUrl = "$BASE_URL/$module"
val url = URL(moduleUrl)
val con = url.openConnection() as HttpsURLConnection
con.setRequestProperty("Accept", "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8")
val json = String(con.inputStream.readBytes())
val gson = GsonBuilder().create()
val npmResponse = gson.fromJson(json, NPMResponse::class.java)
if (npmResponse.error != null) {
return null
}
return npmResponse.distTags?.let {
val latest = it["latest"]
npmResponse.versions?.get(latest)?.dist?.tarball
}
}

99
orx-glslify/src/test/kotlin/TestGlslify.kt
View File

@@ -1,99 +0,0 @@
import org.amshove.kluent.*
import org.openrndr.extra.glslify.preprocessGlslify
import org.openrndr.extra.glslify.preprocessGlslifyFromUrl
import org.openrndr.resourceUrl
import org.spekframework.spek2.Spek
import org.spekframework.spek2.style.specification.describe
const val glslifyPath = "src/test/resources/glslify"
object TestGlslify : Spek({
describe("glslify") {
describe("should download shader with full path") {
val shader = """#version 330
#pragma glslify: perlin = require(glsl-noise/classic/3d)
"""
val processed = preprocessGlslify(shader, glslifyPath = glslifyPath)
processed `should contain` "float perlin(vec3 P)"
}
describe("should download shader with just the module's name") {
val shader = """#version 330
#pragma glslify: luma = require(glsl-luma)
"""
val processed = preprocessGlslify(shader, glslifyPath = glslifyPath)
processed `should contain` "float luma(vec4 color)"
}
describe("throws exception when the import doesn't lead to a shader file") {
invoking {
val shader = """#version 330
#pragma glslify: perlin = require(glsl-noise)
"""
preprocessGlslify(shader, glslifyPath = glslifyPath)
} `should throw` RuntimeException::class `with message`
("[glslify] glsl-noise: index doesn't lead to any shader file")
}
}
describe("preprocessGlslify") {
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()"
)
}
describe("should import complex") {
val url = resourceUrl("/complex.glsl")
val processed = preprocessGlslifyFromUrl(url, glslifyPath = glslifyPath)
processed shouldContainAll listOf(
"float checker(vec2 uv, float repeats)",
"float noise3d(vec3 P)",
"float easing(float t)",
"void main()"
)
}
describe("should import only once") {
val shader = """#version 330
#pragma glslify: luma = require(glsl-luma)
#pragma glslify: luma = require(glsl-luma)
#pragma glslify: luma = require(glsl-luma)
"""
val processed = preprocessGlslify(shader, glslifyPath = glslifyPath).trimEnd()
processed shouldBeEqualTo """#version 330
float luma(vec3 color) {
return dot(color, vec3(0.299, 0.587, 0.114));
}
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)"
)
}
}
})

27
orx-glslify/src/test/resources/a-result.glsl
View File

@@ -1,27 +0,0 @@
#version 330
float add(float a, float b) {
return a + b;
}
float multiply(float a, float b) {
return a * b;
}
float equation(float a, float b) {
return multiply(add(a, b), b);
}
float luminance(vec3 color) {
return dot(color, vec3(0.299, 0.587, 0.114));
}
float luminance(vec4 color) {
return dot(color.rgb, vec3(0.299, 0.587, 0.114));
}
void main() {
}

8
orx-glslify/src/test/resources/a.glsl
View File

@@ -1,8 +0,0 @@
#version 330
#pragma glslify: equation = require(solve)
#pragma glslify: luminance = require(glsl-luma)
void main() {
}

9
orx-glslify/src/test/resources/complex.glsl
View File

@@ -1,9 +0,0 @@
#version 330
#pragma glslify: checker = require(glsl-checker, foo = bar)
#pragma glslify: noise3d = require('glsl-noise/classic/3d')
#pragma glslify: easing = require('glsl-easings/cubic-in-out')
void main() {
}

8
orx-glslify/src/test/resources/glslify/glsl-checker/index.glsl
View File

@@ -1,8 +0,0 @@
float checker(vec2 uv, float repeats) {
float cx = floor(repeats * uv.x);
float cy = floor(repeats * uv.y);
float result = mod(cx + cy, 2.0);
return sign(result);
}
#pragma glslify: export(checker)

17
orx-glslify/src/test/resources/glslify/glsl-easings/back-in-out.glsl
View File

@@ -1,17 +0,0 @@
#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)

9
orx-glslify/src/test/resources/glslify/glsl-easings/back-in.glsl
View File

@@ -1,9 +0,0 @@
#ifndef PI
#define PI 3.141592653589793
#endif
float backIn(float t) {
return pow(t, 3.0) - t * sin(t * PI);
}
#pragma glslify: export(backIn)

10
orx-glslify/src/test/resources/glslify/glsl-easings/back-out.glsl
View File

@@ -1,10 +0,0 @@
#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)

11
orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in-out.glsl
View File

@@ -1,11 +0,0 @@
#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)

7
orx-glslify/src/test/resources/glslify/glsl-easings/bounce-in.glsl
View File

@@ -1,7 +0,0 @@
#pragma glslify: bounceOut = require(./bounce-out)
float bounceIn(float t) {
return 1.0 - bounceOut(1.0 - t);
}
#pragma glslify: export(bounceIn)

25
orx-glslify/src/test/resources/glslify/glsl-easings/bounce-out.glsl
View File

@@ -1,25 +0,0 @@
#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)

7
orx-glslify/src/test/resources/glslify/glsl-easings/circular-in-out.glsl
View File

@@ -1,7 +0,0 @@
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)

5
orx-glslify/src/test/resources/glslify/glsl-easings/circular-in.glsl
View File

@@ -1,5 +0,0 @@
float circularIn(float t) {
return 1.0 - sqrt(1.0 - t * t);
}
#pragma glslify: export(circularIn)

5
orx-glslify/src/test/resources/glslify/glsl-easings/circular-out.glsl
View File

@@ -1,5 +0,0 @@
float circularOut(float t) {
return sqrt((2.0 - t) * t);
}
#pragma glslify: export(circularOut)

7
orx-glslify/src/test/resources/glslify/glsl-easings/cubic-in-out.glsl
View File

@@ -1,7 +0,0 @@
float cubicInOut(float t) {
return t < 0.5
? 4.0 * t * t * t
: 0.5 * pow(2.0 * t - 2.0, 3.0) + 1.0;
}
#pragma glslify: export(cubicInOut)

5
orx-glslify/src/test/resources/glslify/glsl-easings/cubic-in.glsl
View File

@@ -1,5 +0,0 @@
float cubicIn(float t) {
return t * t * t;
}
#pragma glslify: export(cubicIn)

6
orx-glslify/src/test/resources/glslify/glsl-easings/cubic-out.glsl
View File

@@ -1,6 +0,0 @@
float cubicOut(float t) {
float f = t - 1.0;
return f * f * f + 1.0;
}
#pragma glslify: export(cubicOut)

11
orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in-out.glsl
View File

@@ -1,11 +0,0 @@
#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)

9
orx-glslify/src/test/resources/glslify/glsl-easings/elastic-in.glsl
View File

@@ -1,9 +0,0 @@
#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)

9
orx-glslify/src/test/resources/glslify/glsl-easings/elastic-out.glsl
View File

@@ -1,9 +0,0 @@
#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)

9
orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in-out.glsl
View File

@@ -1,9 +0,0 @@
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)

5
orx-glslify/src/test/resources/glslify/glsl-easings/exponential-in.glsl
View File

@@ -1,5 +0,0 @@
float exponentialIn(float t) {
return t == 0.0 ? t : pow(2.0, 10.0 * (t - 1.0));
}
#pragma glslify: export(exponentialIn)

5
orx-glslify/src/test/resources/glslify/glsl-easings/exponential-out.glsl
View File

@@ -1,5 +0,0 @@
float exponentialOut(float t) {
return t == 1.0 ? t : 1.0 - pow(2.0, -10.0 * t);
}
#pragma glslify: export(exponentialOut)

5
orx-glslify/src/test/resources/glslify/glsl-easings/linear.glsl
View File

@@ -1,5 +0,0 @@
float linear(float t) {
return t;
}
#pragma glslify: export(linear)

6
orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in-out.glsl
View File

@@ -1,6 +0,0 @@
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)

5
orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-in.glsl
View File

@@ -1,5 +0,0 @@
float quadraticIn(float t) {
return t * t;
}
#pragma glslify: export(quadraticIn)

5
orx-glslify/src/test/resources/glslify/glsl-easings/quadratic-out.glsl
View File

@@ -1,5 +0,0 @@
float quadraticOut(float t) {
return -t * (t - 2.0);
}
#pragma glslify: export(quadraticOut)

7
orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in-out.glsl
View File

@@ -1,7 +0,0 @@
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)

5
orx-glslify/src/test/resources/glslify/glsl-easings/quartic-in.glsl
View File

@@ -1,5 +0,0 @@
float quarticIn(float t) {
return pow(t, 4.0);
}
#pragma glslify: export(quarticIn)

5
orx-glslify/src/test/resources/glslify/glsl-easings/quartic-out.glsl
View File

@@ -1,5 +0,0 @@
float quarticOut(float t) {
return pow(t - 1.0, 3.0) * (1.0 - t) + 1.0;
}
#pragma glslify: export(quarticOut)

7
orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in-out.glsl
View File

@@ -1,7 +0,0 @@
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)

5
orx-glslify/src/test/resources/glslify/glsl-easings/quintic-in.glsl
View File

@@ -1,5 +0,0 @@
float qinticIn(float t) {
return pow(t, 5.0);
}
#pragma glslify: export(qinticIn)

5
orx-glslify/src/test/resources/glslify/glsl-easings/quintic-out.glsl
View File

@@ -1,5 +0,0 @@
float qinticOut(float t) {
return 1.0 - (pow(t - 1.0, 5.0));
}
#pragma glslify: export(qinticOut)

9
orx-glslify/src/test/resources/glslify/glsl-easings/sine-in-out.glsl
View File

@@ -1,9 +0,0 @@
#ifndef PI
#define PI 3.141592653589793
#endif
float sineInOut(float t) {
return -0.5 * (cos(PI * t) - 1.0);
}
#pragma glslify: export(sineInOut)

9
orx-glslify/src/test/resources/glslify/glsl-easings/sine-in.glsl
View File

@@ -1,9 +0,0 @@
#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)

9
orx-glslify/src/test/resources/glslify/glsl-easings/sine-out.glsl
View File

@@ -1,9 +0,0 @@
#ifndef HALF_PI
#define HALF_PI 1.5707963267948966
#endif
float sineOut(float t) {
return sin(t * HALF_PI);
}
#pragma glslify: export(sineOut)

13
orx-glslify/src/test/resources/glslify/glsl-luma/example/index.frag
View File

@@ -1,13 +0,0 @@
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);
}

23
orx-glslify/src/test/resources/glslify/glsl-luma/example/index.js
View File

@@ -1,23 +0,0 @@
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)
}

10
orx-glslify/src/test/resources/glslify/glsl-luma/example/index.vert
View File

@@ -1,10 +0,0 @@
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);
}

9
orx-glslify/src/test/resources/glslify/glsl-luma/index.glsl
View File

@@ -1,9 +0,0 @@
float luma(vec3 color) {
return dot(color, vec3(0.299, 0.587, 0.114));
}
float luma(vec4 color) {
return dot(color.rgb, vec3(0.299, 0.587, 0.114));
}
#pragma glslify: export(luma)

74
orx-glslify/src/test/resources/glslify/glsl-noise/classic/2d.glsl
View File

@@ -1,74 +0,0 @@
//
// 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)

109
orx-glslify/src/test/resources/glslify/glsl-noise/classic/3d.glsl
View File

@@ -1,109 +0,0 @@
//
// 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
float cnoise(vec3 P)
{
vec3 Pi0 = floor(P); // Integer part for indexing
vec3 Pi1 = Pi0 + vec3(1.0); // Integer part + 1
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(cnoise)

169
orx-glslify/src/test/resources/glslify/glsl-noise/classic/4d.glsl
View File

@@ -1,169 +0,0 @@
//
// 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)

75
orx-glslify/src/test/resources/glslify/glsl-noise/periodic/2d.glsl
View File

@@ -1,75 +0,0 @@
//
// 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)

109
orx-glslify/src/test/resources/glslify/glsl-noise/periodic/3d.glsl
View File

@@ -1,109 +0,0 @@
//
// 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)

169
orx-glslify/src/test/resources/glslify/glsl-noise/periodic/4d.glsl
View File

@@ -1,169 +0,0 @@
//
// 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)

72
orx-glslify/src/test/resources/glslify/glsl-noise/simplex/2d.glsl
View File

@@ -1,72 +0,0 @@
//
// 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)

104
orx-glslify/src/test/resources/glslify/glsl-noise/simplex/3d.glsl
View File

@@ -1,104 +0,0 @@
//
// 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)

130
orx-glslify/src/test/resources/glslify/glsl-noise/simplex/4d.glsl
View File

@@ -1,130 +0,0 @@
//
// 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)

5
orx-glslify/src/test/resources/glslify/multiply/index.glsl
View File

@@ -1,5 +0,0 @@
float multiply(float a, float b) {
return a * b;
}
#pragma glslify: export(multiply)

9
orx-glslify/src/test/resources/glslify/solve/index.glsl
View File

@@ -1,9 +0,0 @@
#pragma glslify: add = require(sum)
#pragma glslify: multiply = require(multiply)
#pragma glslify: subtract = require('./subtract.glsl')
float solve(float a, float b) {
return subtract(multiply(add(a, b), b), b);
}
#pragma glslify: export(solve)

5
orx-glslify/src/test/resources/glslify/solve/subtract.glsl
View File

@@ -1,5 +0,0 @@
float subtract(float a, float b) {
return a - b;
}
#pragma glslify: export(subtract)

74
orx-glslify/src/test/resources/glslify/src/test/src-test.js
View File

@@ -1,74 +0,0 @@
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 })
});
})
})
});

1
orx-glslify/src/test/resources/glslify/subtract/lib/index.js
View File

@@ -1 +0,0 @@
module.exports = (a, b) => a - b

5
orx-glslify/src/test/resources/glslify/sum/index.glsl
View File

@@ -1,5 +0,0 @@
float sum(float a, float b) {
return a + b;
}
#pragma glslify: export(sum)

1
settings.gradle.kts
View File

@@ -33,7 +33,6 @@ include(
"orx-fx",
"orx-jvm:orx-git-archiver",
"orx-jvm:orx-git-archiver-gradle",
"orx-glslify",
"orx-gradient-descent",
"orx-hash-grid",
"orx-integral-image",