Revision 0e12ca44
Added by Leszek Koltunski 8 days ago
| src/main/java/org/distorted/library/effect/EffectType.kt | ||
|---|---|---|
| 48 | 48 |
maxtable[3] = 3 // Max 3 POSTPROCESSING Effects |
| 49 | 49 |
} |
| 50 | 50 |
|
| 51 |
fun getType(ordinal: Int): EffectType = entries[ordinal] |
|
| 51 |
@JvmStatic fun getType(ordinal: Int): EffectType = entries[ordinal]
|
|
| 52 | 52 |
} |
| 53 | 53 |
} |
| src/main/java/org/distorted/library/effect/FragmentEffectAlpha.kt | ||
|---|---|---|
| 39 | 39 |
/** |
| 40 | 40 |
* Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work. |
| 41 | 41 |
*/ |
| 42 |
@JvmStatic |
|
| 43 |
fun enable() |
|
| 42 |
@JvmStatic fun enable() |
|
| 44 | 43 |
{
|
| 45 | 44 |
addEffect(EffectName.ALPHA, EffectName.SMOOTH_ALPHA, |
| 46 | 45 |
"color.a *= (degree*(fUniforms[effect].x-1.0)+1.0);") |
| src/main/java/org/distorted/library/effect/FragmentEffectBrightness.kt | ||
|---|---|---|
| 39 | 39 |
/** |
| 40 | 40 |
* Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work. |
| 41 | 41 |
*/ |
| 42 |
@JvmStatic |
|
| 43 |
fun enable() |
|
| 42 |
@JvmStatic fun enable() |
|
| 44 | 43 |
{
|
| 45 | 44 |
addEffect(EffectName.BRIGHTNESS, EffectName.SMOOTH_BRIGHTNESS, |
| 46 | 45 |
"color.rgb = mix(vec3(0.0,0.0,0.0), color.rgb, degree*(fUniforms[effect].x-1.0)+1.0 );") |
| src/main/java/org/distorted/library/effect/FragmentEffectChroma.kt | ||
|---|---|---|
| 40 | 40 |
/** |
| 41 | 41 |
* Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work. |
| 42 | 42 |
*/ |
| 43 |
fun enable() |
|
| 43 |
@JvmStatic fun enable()
|
|
| 44 | 44 |
{
|
| 45 | 45 |
addEffect(EffectName.CHROMA, EffectName.SMOOTH_CHROMA, |
| 46 | 46 |
"color.rgb = mix(color.rgb, fUniforms[effect].yzw, degree*fUniforms[effect].x);") |
| src/main/java/org/distorted/library/effect/FragmentEffectContrast.kt | ||
|---|---|---|
| 38 | 38 |
/** |
| 39 | 39 |
* Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work. |
| 40 | 40 |
*/ |
| 41 |
fun enable() |
|
| 41 |
@JvmStatic fun enable()
|
|
| 42 | 42 |
{
|
| 43 | 43 |
addEffect(EffectName.CONTRAST, EffectName.SMOOTH_CONTRAST, |
| 44 | 44 |
"color.rgb = mix(vec3(0.5,0.5,0.5), color.rgb, degree*(fUniforms[effect].x-1.0)+1.0 );") |
| src/main/java/org/distorted/library/effect/FragmentEffectSaturation.kt | ||
|---|---|---|
| 39 | 39 |
/** |
| 40 | 40 |
* Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work. |
| 41 | 41 |
*/ |
| 42 |
fun enable() |
|
| 42 |
@JvmStatic fun enable()
|
|
| 43 | 43 |
{
|
| 44 | 44 |
addEffect(EffectName.SATURATION, EffectName.SMOOTH_SATURATION, |
| 45 | 45 |
""" |
| src/main/java/org/distorted/library/effect/MatrixEffectRotate.kt | ||
|---|---|---|
| 62 | 62 |
val z = uniforms[i+CENTER_OFFSET+2] |
| 63 | 63 |
|
| 64 | 64 |
val inRadians = Math.PI*angle/180 |
| 65 |
val sin = sin(inRadians) as Float
|
|
| 66 |
val cos = cos(inRadians) as Float
|
|
| 65 |
val sin = sin(inRadians).toFloat()
|
|
| 66 |
val cos = cos(inRadians).toFloat()
|
|
| 67 | 67 |
|
| 68 | 68 |
translate(matrixP, x, y, z) |
| 69 | 69 |
rotateSinCos(matrixP, mTmp1, mTmp2, sin, cos, axisX, axisY, axisZ) |
| src/main/java/org/distorted/library/effect/PostprocessEffect.kt | ||
|---|---|---|
| 59 | 59 |
* could be covered by other similarly postprocessed objects nearby) |
| 60 | 60 |
*/ |
| 61 | 61 |
var haloDepth: Boolean |
| 62 |
|
|
| 63 | 62 |
var mQualityScale: Float |
| 64 | 63 |
|
| 65 | 64 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/library/effect/PostprocessEffectBlur.kt | ||
|---|---|---|
| 37 | 37 |
/** |
| 38 | 38 |
* Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work. |
| 39 | 39 |
*/ |
| 40 |
fun enable() = enable("BLUR1", "BLUR2")
|
|
| 40 |
@JvmStatic fun enable() = enable("BLUR1", "BLUR2")
|
|
| 41 | 41 |
|
| 42 | 42 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 43 | 43 |
// Clean up of static variables on exit. Called by reflection from super class. |
| 44 |
@Suppress("unused")
|
|
| 45 |
fun destroyStatics() = PostprocessEffectBlurred.destroyStatics() |
|
| 44 |
@Suppress("unused") fun destroyStatics() = PostprocessEffectBlurred.destroyStatics()
|
|
| 46 | 45 |
} |
| 47 | 46 |
|
| 48 | 47 |
/////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/library/effect/PostprocessEffectBorder.kt | ||
|---|---|---|
| 39 | 39 |
{
|
| 40 | 40 |
/////////////////////////////////////////////////////////////////////////////////////////// |
| 41 | 41 |
// Clean up of static variables on exit. Called by reflection from super class. |
| 42 |
@Suppress("unused")
|
|
| 43 |
fun destroyStatics() { }
|
|
| 42 |
@Suppress("unused") fun destroyStatics() { }
|
|
| 44 | 43 |
|
| 45 | 44 |
/////////////////////////////////////////////////////////////////////////////////////////// |
| 46 | 45 |
// PUBLIC API |
| ... | ... | |
| 48 | 47 |
/** |
| 49 | 48 |
* No local programs; we do not postprocess anything here. No need to do anything |
| 50 | 49 |
*/ |
| 51 |
@JvmStatic |
|
| 52 |
fun enable() { }
|
|
| 50 |
@JvmStatic fun enable() { }
|
|
| 53 | 51 |
} |
| 54 | 52 |
/////////////////////////////////////////////////////////////////////////////////////////////// |
| 55 | 53 |
override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean |
| src/main/java/org/distorted/library/effect/VertexEffectDeform.kt | ||
|---|---|---|
| 135 | 135 |
/** |
| 136 | 136 |
* Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work. |
| 137 | 137 |
*/ |
| 138 |
fun enable() = addEffect(NAME, code()) |
|
| 138 |
@JvmStatic fun enable() = addEffect(NAME, code())
|
|
| 139 | 139 |
} |
| 140 | 140 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 141 | 141 |
/** |
| src/main/java/org/distorted/library/effect/VertexEffectDisappear.kt | ||
|---|---|---|
| 30 | 30 |
{
|
| 31 | 31 |
private val NAME = EffectName.DISAPPEAR |
| 32 | 32 |
fun code(): String = "v = vec3(0.0, 0.0, 0.0);" |
| 33 |
fun enable() = addEffect(NAME, code()) |
|
| 33 |
@JvmStatic fun enable() = addEffect(NAME, code())
|
|
| 34 | 34 |
} |
| 35 | 35 |
|
| 36 | 36 |
/////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/library/effect/VertexEffectDistort.kt | ||
|---|---|---|
| 138 | 138 |
} |
| 139 | 139 |
|
| 140 | 140 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 141 |
fun enable() =addEffect(NAME, code()) |
|
| 141 |
@JvmStatic fun enable() =addEffect(NAME, code())
|
|
| 142 | 142 |
} |
| 143 | 143 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 144 | 144 |
override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean |
| src/main/java/org/distorted/library/effect/VertexEffectMove.kt | ||
|---|---|---|
| 34 | 34 |
{
|
| 35 | 35 |
private val NAME = EffectName.VERTEX_MOVE |
| 36 | 36 |
fun code(): String = "v += vUniforms[effect].xyz;" |
| 37 |
fun enable() = addEffect(NAME, code()) |
|
| 37 |
@JvmStatic fun enable() = addEffect(NAME, code())
|
|
| 38 | 38 |
} |
| 39 | 39 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 40 | 40 |
override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean |
| src/main/java/org/distorted/library/effect/VertexEffectPinch.kt | ||
|---|---|---|
| 78 | 78 |
} |
| 79 | 79 |
|
| 80 | 80 |
/////////////////////////////////////////////////////////////////////////////////////////// |
| 81 |
fun enable() = addEffect(NAME, code()) |
|
| 81 |
@JvmStatic fun enable() = addEffect(NAME, code())
|
|
| 82 | 82 |
} |
| 83 | 83 |
/////////////////////////////////////////////////////////////////////////////////////////////// |
| 84 | 84 |
override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean |
| src/main/java/org/distorted/library/effect/VertexEffectPipe.kt | ||
|---|---|---|
| 70 | 70 |
} |
| 71 | 71 |
|
| 72 | 72 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 73 |
fun enable() = addEffect(NAME, code()) |
|
| 73 |
@JvmStatic fun enable() = addEffect(NAME, code())
|
|
| 74 | 74 |
} |
| 75 | 75 |
/////////////////////////////////////////////////////////////////////////////////////////////// |
| 76 | 76 |
override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean |
| src/main/java/org/distorted/library/effect/VertexEffectScale.kt | ||
|---|---|---|
| 49 | 49 |
} |
| 50 | 50 |
|
| 51 | 51 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 52 |
fun enable() = addEffect(NAME, code()) |
|
| 52 |
@JvmStatic fun enable() = addEffect(NAME, code())
|
|
| 53 | 53 |
} |
| 54 | 54 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 55 | 55 |
override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean |
| src/main/java/org/distorted/library/effect/VertexEffectShear.kt | ||
|---|---|---|
| 62 | 62 |
} |
| 63 | 63 |
|
| 64 | 64 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 65 |
fun enable() = addEffect(NAME, code()) |
|
| 65 |
@JvmStatic fun enable() = addEffect(NAME, code())
|
|
| 66 | 66 |
} |
| 67 | 67 |
|
| 68 | 68 |
/////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/library/effect/VertexEffectSwirl.kt | ||
|---|---|---|
| 67 | 67 |
} |
| 68 | 68 |
|
| 69 | 69 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 70 |
fun enable() = addEffect(NAME, code()) |
|
| 70 |
@JvmStatic fun enable() = addEffect(NAME, code())
|
|
| 71 | 71 |
} |
| 72 | 72 |
|
| 73 | 73 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/library/helpers/MatrixHelper.kt | ||
|---|---|---|
| 21 | 21 |
|
| 22 | 22 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 23 | 23 |
|
| 24 |
object MatrixHelper {
|
|
| 25 |
fun setIdentity(output: FloatArray) {
|
|
| 26 |
output[0] = 1f |
|
| 27 |
output[1] = 0f |
|
| 28 |
output[2] = 0f |
|
| 29 |
output[3] = 0f |
|
| 30 |
output[4] = 0f |
|
| 31 |
output[5] = 1f |
|
| 32 |
output[6] = 0f |
|
| 33 |
output[7] = 0f |
|
| 34 |
output[8] = 0f |
|
| 35 |
output[9] = 0f |
|
| 24 |
object MatrixHelper |
|
| 25 |
{
|
|
| 26 |
@JvmStatic fun setIdentity(output: FloatArray) |
|
| 27 |
{
|
|
| 28 |
output[ 0] = 1f |
|
| 29 |
output[ 1] = 0f |
|
| 30 |
output[ 2] = 0f |
|
| 31 |
output[ 3] = 0f |
|
| 32 |
output[ 4] = 0f |
|
| 33 |
output[ 5] = 1f |
|
| 34 |
output[ 6] = 0f |
|
| 35 |
output[ 7] = 0f |
|
| 36 |
output[ 8] = 0f |
|
| 37 |
output[ 9] = 0f |
|
| 36 | 38 |
output[10] = 1f |
| 37 | 39 |
output[11] = 0f |
| 38 | 40 |
output[12] = 0f |
| ... | ... | |
| 42 | 44 |
} |
| 43 | 45 |
|
| 44 | 46 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 45 |
@kotlin.jvm.JvmStatic |
|
| 46 |
fun multiply(output: FloatArray, m1: FloatArray, m2: FloatArray) {
|
|
| 47 |
output[0] = m1[0] * m2[0] + m1[4] * m2[1] + m1[8] * m2[2] + m1[12] * m2[3] |
|
| 48 |
output[1] = m1[1] * m2[0] + m1[5] * m2[1] + m1[9] * m2[2] + m1[13] * m2[3] |
|
| 49 |
output[2] = m1[2] * m2[0] + m1[6] * m2[1] + m1[10] * m2[2] + m1[14] * m2[3] |
|
| 50 |
output[3] = m1[3] * m2[0] + m1[7] * m2[1] + m1[11] * m2[2] + m1[15] * m2[3] |
|
| 51 |
|
|
| 52 |
output[4] = m1[0] * m2[4] + m1[4] * m2[5] + m1[8] * m2[6] + m1[12] * m2[7] |
|
| 53 |
output[5] = m1[1] * m2[4] + m1[5] * m2[5] + m1[9] * m2[6] + m1[13] * m2[7] |
|
| 54 |
output[6] = m1[2] * m2[4] + m1[6] * m2[5] + m1[10] * m2[6] + m1[14] * m2[7] |
|
| 55 |
output[7] = m1[3] * m2[4] + m1[7] * m2[5] + m1[11] * m2[6] + m1[15] * m2[7] |
|
| 56 |
|
|
| 57 |
output[8] = m1[0] * m2[8] + m1[4] * m2[9] + m1[8] * m2[10] + m1[12] * m2[11] |
|
| 58 |
output[9] = m1[1] * m2[8] + m1[5] * m2[9] + m1[9] * m2[10] + m1[13] * m2[11] |
|
| 59 |
output[10] = m1[2] * m2[8] + m1[6] * m2[9] + m1[10] * m2[10] + m1[14] * m2[11] |
|
| 60 |
output[11] = m1[3] * m2[8] + m1[7] * m2[9] + m1[11] * m2[10] + m1[15] * m2[11] |
|
| 61 |
|
|
| 62 |
output[12] = m1[0] * m2[12] + m1[4] * m2[13] + m1[8] * m2[14] + m1[12] * m2[15] |
|
| 63 |
output[13] = m1[1] * m2[12] + m1[5] * m2[13] + m1[9] * m2[14] + m1[13] * m2[15] |
|
| 47 |
@JvmStatic |
|
| 48 |
fun multiply(output: FloatArray, m1: FloatArray, m2: FloatArray) |
|
| 49 |
{
|
|
| 50 |
output[ 0] = m1[0] * m2[ 0] + m1[4] * m2[ 1] + m1[ 8] * m2[ 2] + m1[12] * m2[ 3] |
|
| 51 |
output[ 1] = m1[1] * m2[ 0] + m1[5] * m2[ 1] + m1[ 9] * m2[ 2] + m1[13] * m2[ 3] |
|
| 52 |
output[ 2] = m1[2] * m2[ 0] + m1[6] * m2[ 1] + m1[10] * m2[ 2] + m1[14] * m2[ 3] |
|
| 53 |
output[ 3] = m1[3] * m2[ 0] + m1[7] * m2[ 1] + m1[11] * m2[ 2] + m1[15] * m2[ 3] |
|
| 54 |
|
|
| 55 |
output[ 4] = m1[0] * m2[ 4] + m1[4] * m2[ 5] + m1[ 8] * m2[ 6] + m1[12] * m2[ 7] |
|
| 56 |
output[ 5] = m1[1] * m2[ 4] + m1[5] * m2[ 5] + m1[ 9] * m2[ 6] + m1[13] * m2[ 7] |
|
| 57 |
output[ 6] = m1[2] * m2[ 4] + m1[6] * m2[ 5] + m1[10] * m2[ 6] + m1[14] * m2[ 7] |
|
| 58 |
output[ 7] = m1[3] * m2[ 4] + m1[7] * m2[ 5] + m1[11] * m2[ 6] + m1[15] * m2[ 7] |
|
| 59 |
|
|
| 60 |
output[ 8] = m1[0] * m2[ 8] + m1[4] * m2[ 9] + m1[ 8] * m2[10] + m1[12] * m2[11] |
|
| 61 |
output[ 9] = m1[1] * m2[ 8] + m1[5] * m2[ 9] + m1[ 9] * m2[10] + m1[13] * m2[11] |
|
| 62 |
output[10] = m1[2] * m2[ 8] + m1[6] * m2[ 9] + m1[10] * m2[10] + m1[14] * m2[11] |
|
| 63 |
output[11] = m1[3] * m2[ 8] + m1[7] * m2[ 9] + m1[11] * m2[10] + m1[15] * m2[11] |
|
| 64 |
|
|
| 65 |
output[12] = m1[0] * m2[12] + m1[4] * m2[13] + m1[ 8] * m2[14] + m1[12] * m2[15] |
|
| 66 |
output[13] = m1[1] * m2[12] + m1[5] * m2[13] + m1[ 9] * m2[14] + m1[13] * m2[15] |
|
| 64 | 67 |
output[14] = m1[2] * m2[12] + m1[6] * m2[13] + m1[10] * m2[14] + m1[14] * m2[15] |
| 65 | 68 |
output[15] = m1[3] * m2[12] + m1[7] * m2[13] + m1[11] * m2[14] + m1[15] * m2[15] |
| 66 | 69 |
} |
| 67 | 70 |
|
| 68 | 71 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 69 |
@kotlin.jvm.JvmStatic |
|
| 70 |
fun frustum(output: FloatArray, l: Float, r: Float, b: Float, t: Float, n: Float, f: Float) {
|
|
| 71 |
output[0] = 2 * n / (r - l) |
|
| 72 |
output[1] = 0f |
|
| 73 |
output[2] = 0f |
|
| 74 |
output[3] = 0f |
|
| 75 |
output[4] = 0f |
|
| 76 |
output[5] = 2 * n / (t - b) |
|
| 77 |
output[6] = 0f |
|
| 78 |
output[7] = 0f |
|
| 79 |
output[8] = (r + l) / (r - l) |
|
| 80 |
output[9] = (t + b) / (t - b) |
|
| 72 |
@JvmStatic |
|
| 73 |
fun frustum(output: FloatArray, l: Float, r: Float, b: Float, t: Float, n: Float, f: Float) |
|
| 74 |
{
|
|
| 75 |
output[ 0] = 2 * n / (r - l) |
|
| 76 |
output[ 1] = 0f |
|
| 77 |
output[ 2] = 0f |
|
| 78 |
output[ 3] = 0f |
|
| 79 |
output[ 4] = 0f |
|
| 80 |
output[ 5] = 2 * n / (t - b) |
|
| 81 |
output[ 6] = 0f |
|
| 82 |
output[ 7] = 0f |
|
| 83 |
output[ 8] = (r + l) / (r - l) |
|
| 84 |
output[ 9] = (t + b) / (t - b) |
|
| 81 | 85 |
output[10] = -(f + n) / (f - n) |
| 82 | 86 |
output[11] = -1f |
| 83 | 87 |
output[12] = 0f |
| ... | ... | |
| 87 | 91 |
} |
| 88 | 92 |
|
| 89 | 93 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 90 |
@kotlin.jvm.JvmStatic |
|
| 91 |
fun ortho(output: FloatArray, l: Float, r: Float, b: Float, t: Float, n: Float, f: Float) {
|
|
| 92 |
output[0] = 2 / (r - l) |
|
| 93 |
output[1] = 0f |
|
| 94 |
output[2] = 0f |
|
| 95 |
output[3] = 0f |
|
| 96 |
output[4] = 0f |
|
| 97 |
output[5] = 2 / (t - b) |
|
| 98 |
output[6] = 0f |
|
| 99 |
output[7] = 0f |
|
| 100 |
output[8] = 0f |
|
| 101 |
output[9] = 0f |
|
| 94 |
@JvmStatic |
|
| 95 |
fun ortho(output: FloatArray, l: Float, r: Float, b: Float, t: Float, n: Float, f: Float) |
|
| 96 |
{
|
|
| 97 |
output[ 0] = 2 / (r - l) |
|
| 98 |
output[ 1] = 0f |
|
| 99 |
output[ 2] = 0f |
|
| 100 |
output[ 3] = 0f |
|
| 101 |
output[ 4] = 0f |
|
| 102 |
output[ 5] = 2 / (t - b) |
|
| 103 |
output[ 6] = 0f |
|
| 104 |
output[ 7] = 0f |
|
| 105 |
output[ 8] = 0f |
|
| 106 |
output[ 9] = 0f |
|
| 102 | 107 |
output[10] = -2 / (f - n) |
| 103 | 108 |
output[11] = 0f |
| 104 | 109 |
output[12] = -(r + l) / (r - l) |
| ... | ... | |
| 119 | 124 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 120 | 125 |
// this is android.opengl.Matrix.rotateM(), but with pre-computed sin and cos of the angle |
| 121 | 126 |
// and also we have to pre-allocate and pass here two temp arrays. |
| 122 |
@kotlin.jvm.JvmStatic |
|
| 123 |
fun rotateSinCos( |
|
| 124 |
output: FloatArray, |
|
| 125 |
tmp1: FloatArray, |
|
| 126 |
tmp2: FloatArray, |
|
| 127 |
sin: Float, |
|
| 128 |
cos: Float, |
|
| 129 |
x: Float, |
|
| 130 |
y: Float, |
|
| 131 |
z: Float |
|
| 132 |
) {
|
|
| 133 |
tmp1[0] = (1 - cos) * x * x + cos |
|
| 134 |
tmp1[1] = (1 - cos) * x * y + sin * z |
|
| 135 |
tmp1[2] = (1 - cos) * x * z - sin * y |
|
| 136 |
tmp1[3] = 0f |
|
| 137 |
tmp1[4] = (1 - cos) * x * y - sin * z |
|
| 138 |
tmp1[5] = (1 - cos) * y * y + cos |
|
| 139 |
tmp1[6] = (1 - cos) * y * z + sin * x |
|
| 140 |
tmp1[7] = 0f |
|
| 141 |
tmp1[8] = (1 - cos) * x * z + sin * y |
|
| 142 |
tmp1[9] = (1 - cos) * y * z - sin * x |
|
| 143 |
tmp1[10] = (1 - cos) * z * z + cos |
|
| 127 |
@JvmStatic |
|
| 128 |
fun rotateSinCos(output: FloatArray, tmp1: FloatArray, tmp2: FloatArray, sin: Float, cos: Float, x: Float, y: Float, z: Float) |
|
| 129 |
{
|
|
| 130 |
tmp1[ 0] = (1-cos)*x*x + cos |
|
| 131 |
tmp1[ 1] = (1-cos)*x*y + sin*z |
|
| 132 |
tmp1[ 2] = (1-cos)*x*z - sin*y |
|
| 133 |
tmp1[ 3] = 0f |
|
| 134 |
tmp1[ 4] = (1-cos)*x*y - sin*z |
|
| 135 |
tmp1[ 5] = (1-cos)*y*y + cos |
|
| 136 |
tmp1[ 6] = (1-cos)*y*z + sin*x |
|
| 137 |
tmp1[ 7] = 0f |
|
| 138 |
tmp1[ 8] = (1-cos)*x*z + sin*y |
|
| 139 |
tmp1[ 9] = (1-cos)*y*z - sin*x |
|
| 140 |
tmp1[10] = (1-cos)*z*z + cos |
|
| 144 | 141 |
tmp1[11] = 0f |
| 145 | 142 |
tmp1[12] = 0f |
| 146 | 143 |
tmp1[13] = 0f |
| 147 | 144 |
tmp1[14] = 0f |
| 148 | 145 |
tmp1[15] = 1f |
| 149 | 146 |
|
| 150 |
tmp2[0] = output[0] |
|
| 151 |
tmp2[1] = output[1] |
|
| 152 |
tmp2[2] = output[2] |
|
| 153 |
tmp2[3] = output[3] |
|
| 154 |
tmp2[4] = output[4] |
|
| 155 |
tmp2[5] = output[5] |
|
| 156 |
tmp2[6] = output[6] |
|
| 157 |
tmp2[7] = output[7] |
|
| 158 |
tmp2[8] = output[8] |
|
| 159 |
tmp2[9] = output[9] |
|
| 147 |
tmp2[ 0] = output[0]
|
|
| 148 |
tmp2[ 1] = output[1]
|
|
| 149 |
tmp2[ 2] = output[2]
|
|
| 150 |
tmp2[ 3] = output[3]
|
|
| 151 |
tmp2[ 4] = output[4]
|
|
| 152 |
tmp2[ 5] = output[5]
|
|
| 153 |
tmp2[ 6] = output[6]
|
|
| 154 |
tmp2[ 7] = output[7]
|
|
| 155 |
tmp2[ 8] = output[8]
|
|
| 156 |
tmp2[ 9] = output[9]
|
|
| 160 | 157 |
tmp2[10] = output[10] |
| 161 | 158 |
tmp2[11] = output[11] |
| 162 | 159 |
tmp2[12] = output[12] |
| ... | ... | |
| 168 | 165 |
} |
| 169 | 166 |
|
| 170 | 167 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 171 |
@kotlin.jvm.JvmStatic |
|
| 172 |
fun translate(output: FloatArray, dx: Float, dy: Float, dz: Float) {
|
|
| 173 |
output[12] += (output[0] * dx + output[4] * dy + output[8] * dz) |
|
| 174 |
output[13] += (output[1] * dx + output[5] * dy + output[9] * dz) |
|
| 175 |
output[14] += (output[2] * dx + output[6] * dy + output[10] * dz) |
|
| 176 |
output[15] += (output[3] * dx + output[7] * dy + output[11] * dz) |
|
| 168 |
@JvmStatic |
|
| 169 |
fun translate(output: FloatArray, dx: Float, dy: Float, dz: Float) |
|
| 170 |
{
|
|
| 171 |
output[12] += (output[0]*dx + output[4]*dy + output[ 8]*dz) |
|
| 172 |
output[13] += (output[1]*dx + output[5]*dy + output[ 9]*dz) |
|
| 173 |
output[14] += (output[2]*dx + output[6]*dy + output[10]*dz) |
|
| 174 |
output[15] += (output[3]*dx + output[7]*dy + output[11]*dz) |
|
| 177 | 175 |
} |
| 178 | 176 |
|
| 179 | 177 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 180 |
@kotlin.jvm.JvmStatic |
|
| 181 |
fun scale(output: FloatArray, sx: Float, sy: Float, sz: Float) {
|
|
| 182 |
output[0] *= sx |
|
| 183 |
output[1] *= sx |
|
| 184 |
output[2] *= sx |
|
| 185 |
output[3] *= sx |
|
| 186 |
|
|
| 187 |
output[4] *= sy |
|
| 188 |
output[5] *= sy |
|
| 189 |
output[6] *= sy |
|
| 190 |
output[7] *= sy |
|
| 191 |
|
|
| 192 |
output[8] *= sz |
|
| 193 |
output[9] *= sz |
|
| 178 |
@JvmStatic |
|
| 179 |
fun scale(output: FloatArray, sx: Float, sy: Float, sz: Float) |
|
| 180 |
{
|
|
| 181 |
output[ 0] *= sx |
|
| 182 |
output[ 1] *= sx |
|
| 183 |
output[ 2] *= sx |
|
| 184 |
output[ 3] *= sx |
|
| 185 |
output[ 4] *= sy |
|
| 186 |
output[ 5] *= sy |
|
| 187 |
output[ 6] *= sy |
|
| 188 |
output[ 7] *= sy |
|
| 189 |
output[ 8] *= sz |
|
| 190 |
output[ 9] *= sz |
|
| 194 | 191 |
output[10] *= sz |
| 195 | 192 |
output[11] *= sz |
| 196 | 193 |
} |
| 197 |
} |
|
| 194 |
} |
|
| src/main/java/org/distorted/library/mesh/MeshBase.kt | ||
|---|---|---|
| 508 | 508 |
mesh.mVertAttribs1?.copyInto(newAttribs1,0, v1, v1+VERT1_ATTRIBS*numVertices) |
| 509 | 509 |
mesh.mVertAttribs2?.copyInto(newAttribs2,0, v2, v2+VERT2_ATTRIBS*numVertices) |
| 510 | 510 |
*/ |
| 511 |
android.util.Log.e("D", "from: 0 to: "+(VERT1_ATTRIBS*origVertices)+" num: "+(VERT1_ATTRIBS*numVertices) );
|
|
| 512 |
android.util.Log.e("D", "from len: "+mesh.mVertAttribs1?.size +" to len: "+newAttribs1.size);
|
|
| 513 |
|
|
| 511 | 514 |
System.arraycopy(mesh.mVertAttribs1, 0, newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS*numVertices) |
| 515 |
|
|
| 516 |
android.util.Log.e("D", "DONE ");
|
|
| 517 |
|
|
| 512 | 518 |
System.arraycopy(mesh.mVertAttribs2, 0, newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS*numVertices) |
| 513 | 519 |
|
| 514 | 520 |
origVertices += numVertices |
| src/main/java/org/distorted/library/mesh/MeshFile.kt | ||
|---|---|---|
| 30 | 30 |
*/ |
| 31 | 31 |
class MeshFile : MeshBase |
| 32 | 32 |
{
|
| 33 |
private var numBytes: Int = 0 // number of bytes read from the mesh file.
|
|
| 33 |
@JvmField var numBytes: Int = 0 // number of bytes read from the mesh file.
|
|
| 34 | 34 |
|
| 35 | 35 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 36 | 36 |
/** |
Also available in: Unified diff
fixes for distorted-examples