seedy projeckt jolked

src/main/kotlin/Colin.kt

@@ -0,0 +1,105 @@
+package gay.pizza.CavesOfJolk
+
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.Input
+import com.badlogic.gdx.audio.Sound
+import com.badlogic.gdx.controllers.Controllers
+import com.badlogic.gdx.graphics.PerspectiveCamera
+import com.badlogic.gdx.graphics.Texture
+import com.badlogic.gdx.graphics.g2d.SpriteBatch
+import com.badlogic.gdx.graphics.g2d.TextureRegion
+import com.badlogic.gdx.math.MathUtils
+import com.badlogic.gdx.math.Vector2
+import com.badlogic.gdx.math.Vector3
+import gay.pizza.CavesOfJolk.Resources.Companion.assetManager
+import ktx.math.minusAssign
+import ktx.math.plusAssign
+import ktx.math.times
+
+class Colin
+{
+	private var pos = Vector2()
+	private var angle = 0.0f
+	private var cam: PerspectiveCamera
+	private var nutted = false
+
+	private var texture: Texture = assetManager.get("colin.png")
+	private val nut: Sound = assetManager.get("nut.wav")
+
+	init
+	{
+		cam = PerspectiveCamera(60.0f,
+			Gdx.graphics.width.toFloat(),
+			Gdx.graphics.height.toFloat())
+		cam.near = 0.1f
+		cam.far = 40.0f
+	}
+
+	private fun updateCamera()
+	{
+		cam.position.set(Vector3(pos.x, 1.0f, pos.y))
+		val forward = Vector3(0.0f, 0.0f, -1.0f)
+		val up = Vector3(0.0f, 1.0f, 0.0f)
+		cam.direction.set(forward.rotateRad(up, angle))
+		cam.update()
+	}
+
+	fun update(deltaTime: Float)
+	{
+		val stick = Controllers.getCurrent()?.let { pad ->
+			Vector2(
+				pad.getAxis(pad.mapping.axisLeftX),
+				pad.getAxis(pad.mapping.axisLeftY))
+					.cardinalDeadzone(0.1f, 1.0f)
+		} ?: Vector2()
+
+		val turnSpeed = MathUtils.PI2 * 0.1f
+		if (Gdx.input.isKeyPressed(Input.Keys.LEFT))
+			angle += turnSpeed * deltaTime
+		if (Gdx.input.isKeyPressed(Input.Keys.RIGHT))
+			angle -= turnSpeed * deltaTime
+		if (!stick.isZero)
+			angle -= stick.x * 2.0f * turnSpeed * deltaTime
+
+		val speed = 2.0f
+		val forward = Vector2(-MathUtils.sin(angle), -MathUtils.cos(angle))
+		if (Gdx.input.isKeyPressed(Input.Keys.UP))
+			pos += forward * speed * deltaTime
+		if (Gdx.input.isKeyPressed(Input.Keys.DOWN))
+			pos -= forward * speed * deltaTime
+		if (!stick.isZero)
+			pos -= forward * stick.y * speed * deltaTime
+
+		if (Controllers.getCurrent()?.let { pad -> pad.getButton(pad.mapping.buttonA) } == true || Gdx.input.isKeyJustPressed(Input.Keys.N))
+		{
+			if (!nutted)
+			{
+				nut.stop()
+				nut.play()
+				nutted = true
+			}
+		}
+		else
+		{
+			nutted = false
+		}
+
+		updateCamera()
+	}
+
+	fun draw(spriteBatch: SpriteBatch)
+	{
+		val drawPos = Vector2(pos.x * 100.0f, -pos.y * 100.0f)
+		//spriteBatch.draw(texture, drawPos.x - 32.0f, drawPos.y - 32.0f, 64.0f, 64.0f)
+		val region = TextureRegion(texture)
+		spriteBatch.draw(region,
+			drawPos.x - 32.0f, drawPos.y - 32.0f,
+			32.0f, 32.0f,
+			64.0f, 64.0f,
+			1.0f, 1.0f, angle * MathUtils.radiansToDegrees)
+
+	}
+
+	val camera get() = cam
+	val position get() = pos
+}

src/main/kotlin/Game.kt

@@ -0,0 +1,155 @@
+package gay.pizza.CavesOfJolk
+
+import com.badlogic.gdx.ApplicationAdapter
+import com.badlogic.gdx.Gdx
+import com.badlogic.gdx.audio.Sound
+import com.badlogic.gdx.graphics.*
+import com.badlogic.gdx.graphics.g2d.BitmapFont
+import com.badlogic.gdx.graphics.g2d.SpriteBatch
+import com.badlogic.gdx.graphics.g3d.*
+import com.badlogic.gdx.graphics.g3d.attributes.ColorAttribute
+import com.badlogic.gdx.graphics.g3d.attributes.IntAttribute
+import com.badlogic.gdx.graphics.g3d.attributes.TextureAttribute
+import com.badlogic.gdx.graphics.g3d.environment.DirectionalLight
+import com.badlogic.gdx.graphics.g3d.shaders.DefaultShader
+import com.badlogic.gdx.graphics.g3d.utils.DefaultShaderProvider
+import com.badlogic.gdx.graphics.g3d.utils.ModelBuilder
+import com.badlogic.gdx.graphics.g3d.utils.TextureDescriptor
+import com.badlogic.gdx.math.*
+import com.badlogic.gdx.utils.ScreenUtils
+import gay.pizza.CavesOfJolk.Resources.Companion.assetManager
+
+class Game: ApplicationAdapter()
+{
+	private lateinit var texJolk: Texture
+	private lateinit var fntComic: BitmapFont
+	private lateinit var nut: Sound
+	private lateinit var cube: Model
+	private lateinit var floor: Model
+
+	private lateinit var spriteBatch: SpriteBatch
+	private lateinit var modelBatch: ModelBatch
+	private lateinit var env: Environment
+
+	private lateinit var colin: Colin
+	private var jolkRot = 0.0f
+
+	private lateinit var cubeInstance: ModelInstance
+	private lateinit var floorInstance: ModelInstance
+	private lateinit var suzanneInstance: ModelInstance
+
+	private fun makeCube(texture: Texture): Model
+	{
+		val modelBuilder = ModelBuilder()
+		val size = 2.0f
+		//val material = Material(ColorAttribute.createDiffuse(Color.WHITE))
+		val material = Material(TextureAttribute(TextureAttribute.Diffuse,
+			TextureDescriptor(texture,
+				Texture.TextureFilter.Linear,
+				Texture.TextureFilter.Linear,
+				Texture.TextureWrap.ClampToEdge,
+				Texture.TextureWrap.ClampToEdge)))
+		val attribs = VertexAttributes.Usage.Position or VertexAttributes.Usage.TextureCoordinates or VertexAttributes.Usage.Normal
+		return modelBuilder.createBox(size, size, size, material, attribs.toLong())
+	}
+
+	private fun makeFloor(texture: Texture): Model
+	{
+		val modelBuilder = ModelBuilder()
+		//val material = Material(ColorAttribute.createDiffuse(XnaColor.BlanchedAlmond))
+		val material = Material(TextureAttribute.createDiffuse(texture))
+		val attribs = VertexAttributes.Usage.Position or VertexAttributes.Usage.TextureCoordinates or VertexAttributes.Usage.Normal
+		val size = 10.0f
+		return modelBuilder.createRect(
+			0.0f, 0.0f, 0.0f,
+			size, 0.0f, 0.0f,
+			size, 0.0f, -size,
+			0.0f, 0.0f, -size,
+			0.0f, 1.0f, 0.0f,
+			material, attribs.toLong())
+	}
+
+	override fun create()
+	{
+		Resources.instance.loadAssets()
+		assetManager.finishLoading()
+
+		texJolk = assetManager.get("jolkmeup.jpg")
+		fntComic = assetManager.get("Comic Sans MS.ttf")
+
+
+		cube = makeCube(texJolk)
+		floor = makeFloor(assetManager.get("cobblestone.png"))
+
+		spriteBatch = SpriteBatch()
+
+		env = Environment()
+		env.set(IntAttribute.createCullFace(GL20.GL_BACK))
+		env.set(ColorAttribute.createAmbientLight(XnaColor.DarkSlateGray.lighten(-0.6)))
+		env.set(ColorAttribute.createFog(XnaColor.CornflowerBlue))
+		env.add(DirectionalLight().set(XnaColor.White, Vector3(1.0f, -1.0f, -1.0f).nor()))
+
+		val shaderConfig = DefaultShader.Config(
+			Gdx.files.internal("lit.vert.glsl").readString(),
+			Gdx.files.internal("lit.frag.glsl").readString())
+		shaderConfig.numDirectionalLights = 1
+		shaderConfig.numPointLights = 0
+		shaderConfig.numBones = 0
+		modelBatch = ModelBatch(DefaultShaderProvider(shaderConfig))
+
+		colin = Colin()
+
+		cubeInstance = ModelInstance(cube)
+		floorInstance = ModelInstance(floor)
+		suzanneInstance = ModelInstance(assetManager.get("suzanne.g3db", Model::class.java))
+		suzanneInstance.transform = Matrix4().translate(3.0f, 1.0f, -3.5f)
+	}
+
+	private fun update(deltaTime: Float)
+	{
+		colin.update(deltaTime)
+
+		jolkRot += 15.0f * deltaTime
+	}
+
+	override fun render()
+	{
+		val deltaTime = Gdx.graphics.deltaTime
+		update(deltaTime)
+
+		val fogColour = XnaColor.CornflowerBlue.lighten(Math.sin(0.056 * jolkRot.toDouble()) * 0.15 - 0.15)
+		ScreenUtils.clear(fogColour, true)
+		env.set(ColorAttribute.createFog(fogColour))
+
+		val jolkPos = Vector3(0.0f, 1.0f + MathUtils.sin(jolkRot * 0.25f) * 0.25f, -4.0f)
+		val world = Matrix4()
+			.setTranslation(jolkPos)
+			.rotateRad(1.0f, 0.0f, 0.0f, jolkRot * 0.25f)
+			.rotate(0.0f, 1.0f, 0.0f, jolkRot)
+			.scale(0.25f, 0.25f, 0.25f)
+		cubeInstance.transform = world
+
+		modelBatch.begin(colin.camera)
+		modelBatch.render(floorInstance, env)
+		modelBatch.render(cubeInstance, env)
+		modelBatch.render(suzanneInstance, env)
+		modelBatch.end()
+
+		spriteBatch.begin()
+		colin.draw(spriteBatch)
+		val textPos = colin.camera.project(jolkPos)
+		if (textPos.z < 1.0)
+			fntComic.draw(spriteBatch, "I am filled with jolk", textPos.x, textPos.y)
+		fntComic.draw(spriteBatch, "${colin.position.x}\n${colin.position.y}", 10.0f, Gdx.graphics.height - 10.0f)
+		spriteBatch.end()
+	}
+
+	override fun dispose()
+	{
+		floor.dispose()
+		cube.dispose()
+		modelBatch.dispose()
+		spriteBatch.dispose()
+		assetManager.dispose()
+	}
+}

src/main/kotlin/Program.kt

@@ -0,0 +1,19 @@
+@file:JvmName("Program")
+package gay.pizza.CavesOfJolk
+
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3Application
+import com.badlogic.gdx.backends.lwjgl3.Lwjgl3ApplicationConfiguration
+import com.badlogic.gdx.graphics.glutils.HdpiMode
+
+fun main()
+{
+	//val conf = Lwjgl3WindowConfiguration()
+	val conf = Lwjgl3ApplicationConfiguration()
+	conf.setTitle("Caves of Jolk: Ultimate Edition")
+	conf.setHdpiMode(HdpiMode.Logical)
+	//conf.useVsync(false)
+	//conf.setForegroundFPS(300)
+	conf.setWindowedMode(1280, 720)
+	conf.setResizable(false)
+	Lwjgl3Application(Game(), conf)
+}

src/main/kotlin/Resources.kt

@@ -0,0 +1,50 @@
+package gay.pizza.CavesOfJolk
+
+import com.badlogic.gdx.assets.AssetManager
+import com.badlogic.gdx.assets.loaders.resolvers.InternalFileHandleResolver
+import com.badlogic.gdx.audio.Sound
+import com.badlogic.gdx.graphics.Texture
+import com.badlogic.gdx.graphics.g2d.BitmapFont
+import com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGenerator
+import com.badlogic.gdx.graphics.g2d.freetype.FreeTypeFontGeneratorLoader
+import com.badlogic.gdx.graphics.g2d.freetype.FreetypeFontLoader
+import com.badlogic.gdx.graphics.g3d.Model
+
+
+class Resources private constructor()
+{
+	companion object
+	{
+		@Volatile private var _instance: Resources? = null
+
+		val instance get() = _instance ?: synchronized(this) { _instance ?: Resources().also { _instance = it } }
+		val assetManager get() = instance.assetManager
+	}
+
+	private val assetManager: AssetManager = AssetManager()
+
+	init
+	{
+		val resolver = InternalFileHandleResolver()
+		assetManager.setLoader(FreeTypeFontGenerator::class.java, FreeTypeFontGeneratorLoader(resolver))
+		assetManager.setLoader(BitmapFont::class.java, ".ttf", FreetypeFontLoader(resolver))
+	}
+
+	fun loadAssets()
+	{
+		assetManager.load("colin.png", Texture::class.java)
+		assetManager.load("jolkmeup.jpg", Texture::class.java)
+		assetManager.load("cobblestone.png", Texture::class.java)
+		assetManager.loadFont("Comic Sans MS.ttf", 20)
+		assetManager.load("suzanne.g3db", Model::class.java)
+		assetManager.load("nut.wav", Sound::class.java)
+	}
+}
+
+fun AssetManager.loadFont(filePath: String, size: Int)
+{
+	val fontParam = FreetypeFontLoader.FreeTypeFontLoaderParameter()
+	fontParam.fontFileName = filePath
+	fontParam.fontParameters.size = size
+	this.load(filePath, BitmapFont::class.java, fontParam)
+}

src/main/kotlin/Util.kt

@@ -0,0 +1,53 @@
+package gay.pizza.CavesOfJolk
+
+import com.badlogic.gdx.graphics.Color
+import com.badlogic.gdx.math.Vector2
+import ktx.math.div
+import ktx.math.times
+import org.hsluv.HUSLColorConverter
+import kotlin.math.pow
+
+fun Float.axisDeadzone(min: Float, max: Float): Float
+{
+	val xabs = Math.abs(this)
+	return if (xabs <= min) 0.0f
+	else if (xabs >= max) Math.copySign(1.0f, this)
+	else Math.copySign(xabs - min, this) / (max - min)
+}
+
+fun Vector2.cardinalDeadzone(min: Float, max: Float)
+= Vector2(this.x.axisDeadzone(min, max), this.y.axisDeadzone(min, max))
+
+fun Vector2.radialDeadzone(min: Float, max: Float): Vector2
+{
+	val magnitude = this.len()
+	if (magnitude == 0.0f || magnitude < min)
+		return Vector2()
+	if (magnitude > max)
+		return this / magnitude
+	val rescale = (magnitude - min) / (max - min)
+	return this / magnitude * rescale
+}
+
+val Double.saturate get() = if (this > 1.0) 1.0 else if (this < 0.0) 0.0 else this
+
+class Util
+{
+	companion object
+	{
+		public fun colorFromAbgr8888(abgr8888: UInt) = Color(
+			(abgr8888 and 0xFFu).toFloat() / 255.0f,
+			((abgr8888 and 0xFF00u) shr 8).toFloat() / 255.0f,
+			((abgr8888 and 0xFF0000u) shr 16).toFloat() / 255.0f,
+			((abgr8888 and 0xFF000000u) shr 24).toFloat() / 255.0f)
+	}
+}
+
+fun Color.lighten(ld: Double): Color
+{
+	val hsl = HUSLColorConverter.rgbToHsluv(doubleArrayOf(r.toDouble(), g.toDouble(), b.toDouble()))
+	val gamma = 3.0
+	hsl[2] = ((hsl[2] / 100.0).pow(1.0 / gamma) + ld * 0.8).saturate.pow(gamma) * 100.0
+	val rgb = HUSLColorConverter.hsluvToRgb(hsl)
+	return Color(rgb[0].toFloat(), rgb[1].toFloat(), rgb[2].toFloat(), a)
+}

src/main/kotlin/XnaColor.kt

@@ -0,0 +1,147 @@
+package gay.pizza.CavesOfJolk
+
+object XnaColor
+{
+	val Transparent = Util.colorFromAbgr8888(0x00000000u)
+	val AliceBlue = Util.colorFromAbgr8888(0xFFFFF8F0u)
+	val AntiqueWhite = Util.colorFromAbgr8888(0xFFD7EBFAu)
+	val Aqua = Util.colorFromAbgr8888(0xFFFFFF00u)
+	val Aquamarine = Util.colorFromAbgr8888(0xFFD4FF7Fu)
+	val Azure = Util.colorFromAbgr8888(0xFFFFFFF0u)
+	val Beige = Util.colorFromAbgr8888(0xFFDCF5F5u)
+	val Bisque = Util.colorFromAbgr8888(0xFFC4E4FFu)
+	val Black = Util.colorFromAbgr8888(0xFF000000u)
+	val BlanchedAlmond = Util.colorFromAbgr8888(0xFFCDEBFFu)
+	val Blue = Util.colorFromAbgr8888(0xFFFF0000u)
+	val BlueViolet = Util.colorFromAbgr8888(0xFFE22B8Au)
+	val Brown = Util.colorFromAbgr8888(0xFF2A2AA5u)
+	val BurlyWood = Util.colorFromAbgr8888(0xFF87B8DEu)
+	val CadetBlue = Util.colorFromAbgr8888(0xFFA09E5Fu)
+	val Chartreuse = Util.colorFromAbgr8888(0xFF00FF7Fu)
+	val Chocolate = Util.colorFromAbgr8888(0xFF1E69D2u)
+	val Coral = Util.colorFromAbgr8888(0xFF507FFFu)
+	val CornflowerBlue = Util.colorFromAbgr8888(0xFFED9564u)
+	val Cornsilk = Util.colorFromAbgr8888(0xFFDCF8FFu)
+	val Crimson = Util.colorFromAbgr8888(0xFF3C14DCu)
+	val Cyan = Util.colorFromAbgr8888(0xFFFFFF00u)
+	val DarkBlue = Util.colorFromAbgr8888(0xFF8B0000u)
+	val DarkCyan = Util.colorFromAbgr8888(0xFF8B8B00u)
+	val DarkGoldenrod = Util.colorFromAbgr8888(0xFF0B86B8u)
+	val DarkGray = Util.colorFromAbgr8888(0xFFA9A9A9u)
+	val DarkGreen = Util.colorFromAbgr8888(0xFF006400u)
+	val DarkKhaki = Util.colorFromAbgr8888(0xFF6BB7BDu)
+	val DarkMagenta = Util.colorFromAbgr8888(0xFF8B008Bu)
+	val DarkOliveGreen = Util.colorFromAbgr8888(0xFF2F6B55u)
+	val DarkOrange = Util.colorFromAbgr8888(0xFF008CFFu)
+	val DarkOrchid = Util.colorFromAbgr8888(0xFFCC3299u)
+	val DarkRed = Util.colorFromAbgr8888(0xFF00008Bu)
+	val DarkSalmon = Util.colorFromAbgr8888(0xFF7A96E9u)
+	val DarkSeaGreen = Util.colorFromAbgr8888(0xFF8BBC8Fu)
+	val DarkSlateBlue = Util.colorFromAbgr8888(0xFF8B3D48u)
+	val DarkSlateGray = Util.colorFromAbgr8888(0xFF4F4F2Fu)
+	val DarkTurquoise = Util.colorFromAbgr8888(0xFFD1CE00u)
+	val DarkViolet = Util.colorFromAbgr8888(0xFFD30094u)
+	val DeepPink = Util.colorFromAbgr8888(0xFF9314FFu)
+	val DeepSkyBlue = Util.colorFromAbgr8888(0xFFFFBF00u)
+	val DimGray = Util.colorFromAbgr8888(0xFF696969u)
+	val DodgerBlue = Util.colorFromAbgr8888(0xFFFF901Eu)
+	val Firebrick = Util.colorFromAbgr8888(0xFF2222B2u)
+	val FloralWhite = Util.colorFromAbgr8888(0xFFF0FAFFu)
+	val ForestGreen = Util.colorFromAbgr8888(0xFF228B22u)
+	val Fuchsia = Util.colorFromAbgr8888(0xFFFF00FFu)
+	val Gainsboro = Util.colorFromAbgr8888(0xFFDCDCDCu)
+	val GhostWhite = Util.colorFromAbgr8888(0xFFFFF8F8u)
+	val Gold = Util.colorFromAbgr8888(0xFF00D7FFu)
+	val Goldenrod = Util.colorFromAbgr8888(0xFF20A5DAu)
+	val Gray = Util.colorFromAbgr8888(0xFF808080u)
+	val Green = Util.colorFromAbgr8888(0xFF008000u)
+	val GreenYellow = Util.colorFromAbgr8888(0xFF2FFFADu)
+	val Honeydew = Util.colorFromAbgr8888(0xFFF0FFF0u)
+	val HotPink = Util.colorFromAbgr8888(0xFFB469FFu)
+	val IndianRed = Util.colorFromAbgr8888(0xFF5C5CCDu)
+	val Indigo = Util.colorFromAbgr8888(0xFF82004Bu)
+	val Ivory = Util.colorFromAbgr8888(0xFFF0FFFFu)
+	val Khaki = Util.colorFromAbgr8888(0xFF8CE6F0u)
+	val Lavender = Util.colorFromAbgr8888(0xFFFAE6E6u)
+	val LavenderBlush = Util.colorFromAbgr8888(0xFFF5F0FFu)
+	val LawnGreen = Util.colorFromAbgr8888(0xFF00FC7Cu)
+	val LemonChiffon = Util.colorFromAbgr8888(0xFFCDFAFFu)
+	val LightBlue = Util.colorFromAbgr8888(0xFFE6D8ADu)
+	val LightCoral = Util.colorFromAbgr8888(0xFF8080F0u)
+	val LightCyan = Util.colorFromAbgr8888(0xFFFFFFE0u)
+	val LightGoldenrodYellow = Util.colorFromAbgr8888(0xFFD2FAFAu)
+	val LightGray = Util.colorFromAbgr8888(0xFFD3D3D3u)
+	val LightGreen = Util.colorFromAbgr8888(0xFF90EE90u)
+	val LightPink = Util.colorFromAbgr8888(0xFFC1B6FFu)
+	val LightSalmon = Util.colorFromAbgr8888(0xFF7AA0FFu)
+	val LightSeaGreen = Util.colorFromAbgr8888(0xFFAAB220u)
+	val LightSkyBlue = Util.colorFromAbgr8888(0xFFFACE87u)
+	val LightSlateGray = Util.colorFromAbgr8888(0xFF998877u)
+	val LightSteelBlue = Util.colorFromAbgr8888(0xFFDEC4B0u)
+	val LightYellow = Util.colorFromAbgr8888(0xFFE0FFFFu)
+	val Lime = Util.colorFromAbgr8888(0xFF00FF00u)
+	val LimeGreen = Util.colorFromAbgr8888(0xFF32CD32u)
+	val Linen = Util.colorFromAbgr8888(0xFFE6F0FAu)
+	val Magenta = Util.colorFromAbgr8888(0xFFFF00FFu)
+	val Maroon = Util.colorFromAbgr8888(0xFF000080u)
+	val MediumAquamarine = Util.colorFromAbgr8888(0xFFAACD66u)
+	val MediumBlue = Util.colorFromAbgr8888(0xFFCD0000u)
+	val MediumOrchid = Util.colorFromAbgr8888(0xFFD355BAu)
+	val MediumPurple = Util.colorFromAbgr8888(0xFFDB7093u)
+	val MediumSeaGreen = Util.colorFromAbgr8888(0xFF71B33Cu)
+	val MediumSlateBlue = Util.colorFromAbgr8888(0xFFEE687Bu)
+	val MediumSpringGreen = Util.colorFromAbgr8888(0xFF9AFA00u)
+	val MediumTurquoise = Util.colorFromAbgr8888(0xFFCCD148u)
+	val MediumVioletRed = Util.colorFromAbgr8888(0xFF8515C7u)
+	val MidnightBlue = Util.colorFromAbgr8888(0xFF701919u)
+	val MintCream = Util.colorFromAbgr8888(0xFFFAFFF5u)
+	val MistyRose = Util.colorFromAbgr8888(0xFFE1E4FFu)
+	val Moccasin = Util.colorFromAbgr8888(0xFFB5E4FFu)
+	val MonoGameOrange = Util.colorFromAbgr8888(0xFF003CE7u)
+	val NavajoWhite = Util.colorFromAbgr8888(0xFFADDEFFu)
+	val Navy = Util.colorFromAbgr8888(0xFF800000u)
+	val OldLace = Util.colorFromAbgr8888(0xFFE6F5FDu)
+	val Olive = Util.colorFromAbgr8888(0xFF008080u)
+	val OliveDrab = Util.colorFromAbgr8888(0xFF238E6Bu)
+	val Orange = Util.colorFromAbgr8888(0xFF00A5FFu)
+	val OrangeRed = Util.colorFromAbgr8888(0xFF0045FFu)
+	val Orchid = Util.colorFromAbgr8888(0xFFD670DAu)
+	val PaleGoldenrod = Util.colorFromAbgr8888(0xFFAAE8EEu)
+	val PaleGreen = Util.colorFromAbgr8888(0xFF98FB98u)
+	val PaleTurquoise = Util.colorFromAbgr8888(0xFFEEEEAFu)
+	val PaleVioletRed = Util.colorFromAbgr8888(0xFF9370DBu)
+	val PapayaWhip = Util.colorFromAbgr8888(0xFFD5EFFFu)
+	val PeachPuff = Util.colorFromAbgr8888(0xFFB9DAFFu)
+	val Peru = Util.colorFromAbgr8888(0xFF3F85CDu)
+	val Pink = Util.colorFromAbgr8888(0xFFCBC0FFu)
+	val Plum = Util.colorFromAbgr8888(0xFFDDA0DDu)
+	val PowderBlue = Util.colorFromAbgr8888(0xFFE6E0B0u)
+	val Purple = Util.colorFromAbgr8888(0xFF800080u)
+	val Red = Util.colorFromAbgr8888(0xFF0000FFu)
+	val RosyBrown = Util.colorFromAbgr8888(0xFF8F8FBCu)
+	val RoyalBlue = Util.colorFromAbgr8888(0xFFE16941u)
+	val SaddleBrown = Util.colorFromAbgr8888(0xFF13458Bu)
+	val Salmon = Util.colorFromAbgr8888(0xFF7280FAu)
+	val SandyBrown = Util.colorFromAbgr8888(0xFF60A4F4u)
+	val SeaGreen = Util.colorFromAbgr8888(0xFF578B2Eu)
+	val SeaShell = Util.colorFromAbgr8888(0xFFEEF5FFu)
+	val Sienna = Util.colorFromAbgr8888(0xFF2D52A0u)
+	val Silver = Util.colorFromAbgr8888(0xFFC0C0C0u)
+	val SkyBlue = Util.colorFromAbgr8888(0xFFEBCE87u)
+	val SlateBlue = Util.colorFromAbgr8888(0xFFCD5A6Au)
+	val SlateGray = Util.colorFromAbgr8888(0xFF908070u)
+	val Snow = Util.colorFromAbgr8888(0xFFFAFAFFu)
+	val SpringGreen = Util.colorFromAbgr8888(0xFF7FFF00u)
+	val SteelBlue = Util.colorFromAbgr8888(0xFFB48246u)
+	val Tan = Util.colorFromAbgr8888(0xFF8CB4D2u)
+	val Teal = Util.colorFromAbgr8888(0xFF808000u)
+	val Thistle = Util.colorFromAbgr8888(0xFFD8BFD8u)
+	val Tomato = Util.colorFromAbgr8888(0xFF4763FFu)
+	val Turquoise = Util.colorFromAbgr8888(0xFFD0E040u)
+	val Violet = Util.colorFromAbgr8888(0xFFEE82EEu)
+	val Wheat = Util.colorFromAbgr8888(0xFFB3DEF5u)
+	val White = Util.colorFromAbgr8888(UInt.MAX_VALUE)
+	val WhiteSmoke = Util.colorFromAbgr8888(0xFFF5F5F5u)
+	val Yellow = Util.colorFromAbgr8888(0xFF00FFFFu)
+	val YellowGreen = Util.colorFromAbgr8888(0xFF32CD9Au)
+}

src/main/resources/lit.frag.glsl

@@ -0,0 +1,241 @@
+#ifdef GL_ES
+#define LOWP lowp
+#define MEDP mediump
+#define HIGHP highp
+precision mediump float;
+#else
+#define LOWP
+#define MEDP
+#define HIGHP
+#endif
+
+#ifdef normalFlag
+varying vec3 v_normal;
+#endif // normalFlag
+
+#ifdef colorFlag
+varying vec4 v_color;
+#endif // colorFlag
+
+#if defined(diffuseTextureFlag) || defined(specularTextureFlag) || defined(emissiveTextureFlag)
+#define textureFlag
+#endif
+#ifdef diffuseTextureFlag
+varying MEDP vec2 v_diffuseUV;
+uniform sampler2D u_diffuseTexture;
+#endif // diffuseTextureFlag
+#ifdef specularTextureFlag
+varying MEDP vec2 v_specularUV;
+uniform sampler2D u_specularTexture;
+#endif // specularTextureFlag
+/*
+#ifdef emissiveTextureFlag
+varying MEDP vec2 v_emissiveUV;
+uniform sampler2D u_emissiveTexture;
+#endif // emissiveTextureFlag
+*/
+
+#ifdef diffuseColorFlag
+uniform vec4 u_diffuseColor;
+#endif // diffuseColorFlag
+
+#ifdef specularColorFlag
+uniform vec4 u_specularColor;
+#endif
+
+#ifdef lightingFlag
+varying vec3 v_lightDiffuse;
+
+#ifdef shininessFlag
+uniform float u_shininess;
+#else
+const float u_shininess = 20.0;
+#endif // shininessFlag
+
+#if numDirectionalLights > 0
+struct DirectionalLight
+{
+	vec3 color;
+	vec3 direction;
+};
+uniform DirectionalLight u_dirLights[numDirectionalLights];
+#endif // numDirectionalLights
+
+#if numPointLights > 0
+struct PointLight
+{
+	vec3 color;
+	vec3 position;
+};
+uniform PointLight u_pointLights[numPointLights];
+#endif // numPointLights
+
+#if	defined(ambientLightFlag) || defined(ambientCubemapFlag) || defined(sphericalHarmonicsFlag)
+#define ambientFlag
+varying vec3 v_ambient;
+#endif // ambientFlag
+
+#if defined(specularTextureFlag) || defined(specularColorFlag)
+#define specularFlag
+#endif
+
+#endif // lightingFlag
+
+#if defined(specularFlag) || defined(fogFlag)
+varying vec4 v_worldPosition;
+uniform vec4 u_cameraPosition;
+#endif // lightingFlag || fogFlag
+
+#ifdef fogFlag
+uniform vec4 u_fogColor;
+varying float v_fog;
+#endif // fogFlag
+
+uniform mat4 u_projViewTrans;
+uniform mat4 u_worldTrans;
+
+vec3 linearEncode(vec3 v) { return vec3(pow(v.r, 2.2), pow(v.g, 2.2), pow(v.b, 2.2)); }
+vec3 linearDecode(vec3 v) { return vec3(pow(v.r, 1.0 / 2.2), pow(v.g, 1.0 / 2.2), pow(v.b, 1.0 / 2.2)); }
+
+void main()
+{
+#if defined(diffuseTextureFlag) && defined(diffuseColorFlag) && defined(colorFlag)
+	vec4 diffuse = texture2D(u_diffuseTexture, v_diffuseUV) * u_diffuseColor * v_color;
+#elif defined(diffuseTextureFlag) && defined(diffuseColorFlag)
+	vec4 diffuse = texture2D(u_diffuseTexture, v_diffuseUV) * u_diffuseColor;
+#elif defined(diffuseTextureFlag) && defined(colorFlag)
+	vec4 diffuse = texture2D(u_diffuseTexture, v_diffuseUV) * v_color;
+#elif defined(diffuseTextureFlag)
+	vec4 diffuse = texture2D(u_diffuseTexture, v_diffuseUV);
+#elif defined(diffuseColorFlag) && defined(colorFlag)
+	vec4 diffuse = u_diffuseColor * v_color;
+#elif defined(diffuseColorFlag)
+	vec4 diffuse = u_diffuseColor;
+#elif defined(colorFlag)
+	vec4 diffuse = v_color;
+#else
+	vec4 diffuse = vec4(1.0);
+#endif
+	diffuse.rgb = linearEncode(diffuse.rgb);
+
+#ifdef lightingFlag
+
+#ifdef normalFlag
+	vec3 normal = normalize(v_normal);
+#endif // normalFlag
+
+#ifdef ambientFlag
+	vec3 accum = v_ambient;
+#else // !ambientFlag
+	vec3 accum = vec3(0.0);
+#endif // ambientFlag
+
+#ifdef specularFlag
+	vec3 eyeVec = normalize(u_cameraPosition.xyz - v_worldPosition.xyz);
+	vec3 specAccum = vec3(0.0);
+#endif // specularFlag
+
+#if defined(normalFlag) && (numDirectionalLights > 0)
+	for (int i = 0; i < numDirectionalLights; ++i)
+	{
+		vec3 lightVec = -u_dirLights[i].direction;
+		float lambert = dot(normal, lightVec);
+		float phongTerm = max(lambert, 0.0);
+		vec3 value = u_dirLights[i].color * phongTerm;
+		value = linearEncode(value);
+		value *= phongTerm;
+		accum += value;
+#ifdef specularFlag
+		vec3 halfDir = normalize(lightVec + eyeVec);
+		float specAngle = max(dot(halfDir, normal), 0.0);
+		float specTerm = pow(specAngle, u_shininess);
+		specAccum += value * specTerm;
+#endif // specularFlag
+	}
+#endif // normalFlag && numDirectionalLights
+
+	vec3 fragment;
+#ifdef specularFlag
+#ifdef specularTextureFlag
+	vec3 specularColorTex = texture2D(u_specularTexture, v_specularUV).rgb;
+	specularColorTex = linearEncode(specularColorTex);
+	specAccum *= specularColorTex;
+#endif // specularTextureFlag
+#ifdef specularColorFlag
+	vec3 specularColor = u_specularColor.rgb;
+	specularColor = linearEncode(specularColor);
+	specAccum *= specularColor;
+#endif // specularColorFlag
+	fragment = diffuse.rgb * accum + specAccum;
+#else // !specularFlag
+	fragment = diffuse.rgb * accum;
+#endif // specularFlag
+#else // !lightingFlag
+	fragment = diffuse.rgb;
+#endif // lightingFlag
+
+#ifdef fogFlag
+#define fogDistance
+//#define fogDepth
+
+//#define fogOriginal
+//#define fogLinear
+#define fogSmooth
+//#define fogInvSquare
+//#define fogExp
+//#define fogExp2
+
+#if defined(fogLinear) || defined(fogSmooth) || defined(fogInvSquare)
+	float near = 1.5;
+	float far = 20.5;
+#elif defined(fogExp) || defined(fogExp2)
+	float density = 0.12;
+#endif
+
+#ifdef fogOriginal
+	vec3 fvec = u_cameraPosition.xyz - v_worldPosition.xyz;
+	float flen = dot(fvec, fvec);
+	float fog = min(flen * u_cameraPosition.w, 1.0);
+#elif defined(fogDistance)
+	float flen = length(v_worldPosition.xyz - u_cameraPosition.xyz);
+#elif defined(fogDepth)
+	float flen = gl_FragCoord.z / gl_FragCoord.w;
+#endif // fogOriginal || fogDistance || fogDepth
+
+#ifdef fogLinear
+	// fog = saturate(linearstep(near, far, x))
+	float fog = clamp((flen - near) / (far - near), 0.0, 1.0);
+#elif defined(fogSmooth)
+	// fog = smoothstep(saturate(linearstep(near, far, x)))
+	float fog = clamp((flen - near) / (far - near), 0.0, 1.0);
+	fog = fog * fog * (3.0 - 2.0 * fog);
+	//fog = fog * fog * fog * (fog * (6.0 * fog - 15.0) + 10.0);
+#elif defined(fogInvSquare)
+	// fog = isqstep(saturate(linearstep(near, far, x)))
+	float fog = clamp((flen - near) / (far - near), 0.0, 1.0);
+	fog = 1.0 - fog;
+	fog = 1.0 - fog * fog;
+#elif defined(fogExp)
+	float fog = max(1.0 - exp(-density * flen), 0.0);
+#elif defined(fogExp2)
+	float dz = density * flen;
+	float fog = max(1.0 - exp(-dz * dz), 0.0);
+#endif // fogLinear || fogSmooth || fogInvSquare || fogExp || fogExp2
+
+	vec3 fogColor = u_fogColor.rgb;
+	fogColor = linearEncode(fogColor);
+	fragment = mix(fragment, fogColor, fog);
+#endif // fogFlag
+	gl_FragColor = vec4(linearDecode(fragment), diffuse.a);
+	/*
+	if (gl_FragCoord.x > 1280.0)
+	{
+		if (fog <= 0.0)
+			gl_FragColor = vec4(1.0, 0.0, 1.0, diffuse.a);
+		else if (fog >= 1.0)
+			gl_FragColor = vec4(1.0, 0.0, 0.0, diffuse.a);
+		else
+			gl_FragColor = vec4(fog, fog, 0.0, diffuse.a);
+	}
+	*/
+}

src/main/resources/lit.vert.glsl

@@ -0,0 +1,119 @@
+attribute vec3 a_position;
+uniform mat4 u_projViewTrans;
+
+#ifdef normalFlag
+attribute vec3 a_normal;
+uniform mat3 u_normalMatrix;
+varying vec3 v_normal;
+#endif // normalFlag
+
+#ifdef colorFlag
+varying vec4 v_color;
+attribute vec4 a_color;
+#endif // colorFlag
+
+#if defined(diffuseTextureFlag) || defined(specularTextureFlag) || defined(emissiveTextureFlag)
+#define textureFlag
+#endif
+
+#if	defined(ambientLightFlag) || defined(ambientCubemapFlag) || defined(sphericalHarmonicsFlag)
+#define ambientFlag
+#endif // ambientFlag
+
+#ifdef textureFlag
+attribute vec2 a_texCoord0;
+#endif // textureFlag
+
+#ifdef diffuseTextureFlag
+uniform vec4 u_diffuseUVTransform;
+varying vec2 v_diffuseUV;
+#endif
+
+#ifdef emissiveTextureFlag
+uniform vec4 u_emissiveUVTransform;
+varying vec2 v_emissiveUV;
+#endif
+
+#ifdef specularTextureFlag
+uniform vec4 u_specularUVTransform;
+varying vec2 v_specularUV;
+#endif
+
+uniform mat4 u_worldTrans;
+
+#ifdef lightingFlag
+
+#ifdef ambientLightFlag
+uniform vec3 u_ambientLight;
+#endif // ambientLightFlag
+
+#ifdef ambientLightFlag
+uniform vec3 u_ambientLight;
+#endif // ambientLightFlag
+
+#ifdef ambientCubemapFlag
+uniform vec3 u_ambientCubemap[6];
+#endif // ambientCubemapFlag
+
+/*
+#ifdef sphericalHarmonicsFlag
+uniform vec3 u_sphericalHarmonics[9];
+#endif // sphericalHarmonicsFlag
+*/
+
+#ifdef ambientFlag
+varying vec3 v_ambient;
+#endif // ambientFlag
+
+#endif // lightingFlag
+
+#if defined(lightingFlag) || defined(fogFlag)
+varying vec4 v_worldPosition;
+#endif // lightingFlag || fogFlag
+
+void main()
+{
+#ifdef normalFlag
+	//vec3 normal = u_normalMatrix * a_normal;
+	vec3 normal = normalize(u_normalMatrix * a_normal);
+	v_normal = normal;
+#endif // normalFlag
+
+#ifdef colorFlag
+	v_color = a_color;
+#endif // colorFlag
+
+#ifdef diffuseTextureFlag
+	v_diffuseUV = u_diffuseUVTransform.xy + a_texCoord0 * u_diffuseUVTransform.zw;
+#endif // diffuseTextureFlag
+
+#ifdef emissiveTextureFlag
+	v_emissiveUV = u_emissiveUVTransform.xy + a_texCoord0 * u_emissiveUVTransform.zw;
+#endif // emissiveTextureFlag
+
+#ifdef specularTextureFlag
+	v_specularUV = u_specularUVTransform.xy + a_texCoord0 * u_specularUVTransform.zw;
+#endif // specularTextureFlag
+
+#ifdef ambientLightFlag
+	v_ambient = u_ambientLight;
+#else // !ambientLightFlag
+	v_ambient = vec3(0.0);
+#endif // ambientLightFlag
+
+#ifdef ambientCubemapFlag
+	vec3 norm2 = normal * normal;
+	vec3 isPositive = step(0.0, normal);
+	v_ambient +=
+		norm2.x * mix(u_ambientCubemap[0], u_ambientCubemap[1], isPositive.x) +
+		norm2.y * mix(u_ambientCubemap[2], u_ambientCubemap[3], isPositive.y) +
+		norm2.z * mix(u_ambientCubemap[4], u_ambientCubemap[5], isPositive.z);
+#endif // ambientCubemapFlag
+
+	vec4 worldPos = u_worldTrans * vec4(a_position, 1.0);
+#if defined(lightingFlag) || defined(fogFlag)
+	v_worldPosition = worldPos;
+	//v_cameraPosition = u_cameraPosition;
+#endif // lightingFlag || fogFlag
+	gl_Position = u_projViewTrans * worldPos;
+}