/ - Diff - Distorted Android

src/main/java/org/distorted/library/effect/Effect.kt
64	64	*
65	65	* @y.exclude
66	66	*/
67		@JvmStatic
68	67	fun onPause()
69	68	{
70	69	for (i in 0 until NUM_EFFECTS) mEnabled[i] = false
...	...
83	82	*
84	83	* @param type EffectType to enable.
85	84	*/
86		@JvmStatic
87	85	fun enableEffects(type: EffectType)
88	86	{
89	87	var method: Method?

src/main/java/org/distorted/library/effect/EffectQuality.kt
38	38
39	39	companion object
40	40	{
41		@JvmField val LENGTH: Int = entries.size
	41	val LENGTH: Int = entries.size
42	42	private val qualities: Array<EffectQuality?>
43	43
44	44	init
...	...
48	48	for (q in entries) qualities[i++] = q
49	49	}
50	50
51		@JvmStatic fun getMipmap(quality: Int): Float = qualities[quality]!!.mipmap
	51	fun getMipmap(quality: Int): Float = qualities[quality]!!.mipmap
52	52	}
53	53	}
54	54

src/main/java/org/distorted/library/effect/EffectType.kt
36	36
37	37	companion object
38	38	{
39		@JvmField val LENGTH: Int = entries.size
40		@JvmField val MASK: Int = (1 shl LENGTH)-1
41		@JvmStatic fun reset(maxtable: IntArray)
	39	val LENGTH: Int = entries.size
	40	val MASK: Int = (1 shl LENGTH)-1
	41	fun reset(maxtable: IntArray)
42	42	{
43	43	maxtable[0] = 100 // By default, there can be a maximum 100 MATRIX effects in a single
44	44	// EffectQueueMatrix at any given time. This can be changed with a call
...	...
48	48	maxtable[3] = 3 // Max 3 POSTPROCESSING Effects
49	49	}
50	50
51		@JvmStatic fun getType(ordinal: Int): EffectType = entries[ordinal]
	51	fun getType(ordinal: Int): EffectType = entries[ordinal]
52	52	}
53	53	}

             val MAX_REGION: Static3D = Static3D(1000000f, 1000000f, 1000000f)
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun getGLSL(): String = mGLSL+"{}"
             fun getGLSL(): String = mGLSL+"{}"
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun getNumEnabled(): Int = numEnabled
             fun getNumEnabled(): Int = numEnabled
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             // prepare code to be injected into the 'main_fragment_shader' main() function.

             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic fun enable()
             fun enable()
+            {
                 addEffect(EffectName.ALPHA, EffectName.SMOOTH_ALPHA,
                     "color.a *= (degree*(fUniforms[effect].x-1.0)+1.0);")

             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic fun enable()
             fun enable()
+            {
                 addEffect(EffectName.BRIGHTNESS, EffectName.SMOOTH_BRIGHTNESS,
                     "color.rgb = mix(vec3(0.0,0.0,0.0), color.rgb, degree*(fUniforms[effect].x-1.0)+1.0 );")

             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic fun enable()
             fun enable()
+            {
                 addEffect(EffectName.CHROMA, EffectName.SMOOTH_CHROMA,
                     "color.rgb = mix(color.rgb, fUniforms[effect].yzw, degree*fUniforms[effect].x);")

             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic fun enable()
             fun enable()
+            {
                 addEffect(EffectName.CONTRAST, EffectName.SMOOTH_CONTRAST,
                     "color.rgb = mix(vec3(0.5,0.5,0.5), color.rgb, degree*(fUniforms[effect].x-1.0)+1.0 );")

             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic fun enable()
             fun enable()
+            {
                 addEffect(EffectName.SATURATION, EffectName.SMOOTH_SATURATION,
                     """

src/main/java/org/distorted/library/effect/PostprocessEffect.kt
102	102	}
103	103
104	104	///////////////////////////////////////////////////////////////////////////////////////////
105		@JvmStatic fun createPrograms(GLSL: Int)
	105	fun createPrograms(GLSL: Int)
106	106	{
107	107	var source: Source
108	108	val len = mSources.size

             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic fun enable() = enable("BLUR1", "BLUR2")
             fun enable() = enable("BLUR1", "BLUR2")
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             // Clean up of static variables on exit. Called by reflection from super class.
             @Suppress("unused")
             @JvmStatic
             fun destroyStatics() = PostprocessEffectBlurred.destroyStatics()
+        }

             private var mIndex2 = 0
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun destroyStatics()
             fun destroyStatics()
+            {
                 mProgram1 = null
                 mProgram2 = null
-...
             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic fun enable(prog1: String, prog2: String)
             fun enable(prog1: String, prog2: String)
+            {
                 val vertex =
                     """ precision lowp float;

+        {
             ///////////////////////////////////////////////////////////////////////////////////////////
             // Clean up of static variables on exit. Called by reflection from super class.
             @Suppress("unused") @JvmStatic fun destroyStatics() { }
             @Suppress("unused") fun destroyStatics() { }
             /**
              * No local programs; we do not postprocess anything here. No need to do anything
              */
             @JvmStatic fun enable() { }
             fun enable() { }
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean

             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic fun enable() = enable("GLOW1", "GLOW2")
             fun enable() = enable("GLOW1", "GLOW2")
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             // Clean up of static variables on exit. Called by reflection from super class.
             @Suppress("unused") @JvmStatic fun destroyStatics() = PostprocessEffectBlurred.destroyStatics()
             @Suppress("unused")  fun destroyStatics() = PostprocessEffectBlurred.destroyStatics()
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean

             val MAX_REGION: Static4D = Static4D(0f,0f,0f,1000000f)
             @JvmStatic val allGLSL: String
             val allGLSL: String
                 get()
+                {
                     if (!mFullPrepared)
-...
                     return mFullGLSL+"{}"
+                }
             @JvmStatic val allEnabled: Int
             val allEnabled: Int
                 get()
+                {
                     if (!mFullPrepared)
-...
+                }
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun getNumEnabled(): Int = numEnabled
             fun getNumEnabled(): Int = numEnabled
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun getGLSL(): String = mGLSL+"{}"
             fun getGLSL(): String = mGLSL+"{}"
             ///////////////////////////////////////////////////////////////////////////////////////////
             private fun retSection(effect: Int, code: String?): String
-...
             /**
              * Return a constructed VertexEffect based on its name, the 5 variables, center & region.
              */
             @JvmStatic
             fun constructEffect(name: String, vars: FloatArray, center: FloatArray, region: FloatArray): VertexEffect?
+            {
                 val staCenter = Static3D(center[0], center[1], center[2])

             ///////////////////////////////////////////////////////////////////////////////////////////
             // 2020-05-03: replaced vec3 'u_Bounding' with a uniform 'vUniforms[effect].w' (i.e. mRadius)
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun code(): String
             fun code(): String
+            {
                 return ("""
                          const vec3 ONE = vec3(1.0,1.0,1.0);
-...
             /**
              * Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
              */
             @JvmStatic fun enable() = addEffect(NAME, code())
             fun enable() = addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**

src/main/java/org/distorted/library/effect/VertexEffectDisappear.kt
29	29	companion object
30	30	{
31	31	private val NAME = EffectName.DISAPPEAR
32		@JvmStatic fun code(): String = "v = vec3(0.0, 0.0, 0.0);"
33		@JvmStatic fun enable() = addEffect(NAME, code())
	32	fun code(): String = "v = vec3(0.0, 0.0, 0.0);"
	33	fun enable() = addEffect(NAME, code())
34	34	}
35	35
36	36	///////////////////////////////////////////////////////////////////////////////////////////////

             // which makes Vrot = (a+n.y*c , b-n.y*c , v*n) where
             // a = vx*nz-vz*nx , b = vy*nz-vz*ny , c = (vx*ny-vy*nx)/(1+nz)    (unless n=(0,0,-1))
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun code(): String
             fun code(): String
+            {
                 return (""" vec3 ps = vUniforms[effect+1].yzw - v;
                             vec3 force = vUniforms[effect].xyz;
-...
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun enable() =addEffect(NAME, code())
             fun enable() =addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean

         companion object
+        {
             private val NAME = EffectName.VERTEX_MOVE
             @JvmStatic fun code(): String = "v += vUniforms[effect].xyz;"
             @JvmStatic fun enable() = addEffect(NAME, code())
             fun code(): String = "v += vUniforms[effect].xyz;"
             fun enable() = addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean

             // when h>1 we are pushing points away from S: P' = P + (1/h-1)*dist(line to P)
             // (where 'line' above passes through the center point and goes along the vector)
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun code(): String
             fun code(): String
+            {
                 return ("""
                          vec3 ps = vUniforms[effect+1].yzw -v;
-...
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun enable() = addEffect(NAME, code())
             fun enable() = addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean

             // line defined by 'center' and 'vect' (so 'ps' is very small)
             // Then by means of some miracle we have
             // dot_ps>0, (sign_ps-1.0)==0.0 and dot_ps-(sign_ps-1.0) == 0.0 !! so n_ps - undef.
             @JvmStatic fun code(): String
             fun code(): String
+            {
                 return ("""
                          vec3 pc = vUniforms[effect+1].yzw - v;
-...
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun enable() = addEffect(NAME, code())
             fun enable() = addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean

             private val NAME = EffectName.VERTEX_QUATERNION
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun code(): String
             fun code(): String
+            {
                 return ("""
                          float qx = vUniforms[effect].x;
-...
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun enable() = addEffect(NAME, code())
             fun enable() = addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean

src/main/java/org/distorted/library/effect/VertexEffectRotate.kt
39	39	private val NAME = EffectName.VERTEX_ROTATE
40	40
41	41	///////////////////////////////////////////////////////////////////////////////////////////////////
42		@JvmStatic fun code(): String
	42	fun code(): String
43	43	{
44	44	return ("""
45	45	float angle = vUniforms[effect].x*3.14159265/360.0;
...	...
71	71	}
72	72
73	73	///////////////////////////////////////////////////////////////////////////////////////////////////
74		@JvmStatic fun enable() = addEffect(NAME, code())
	74	fun enable() = addEffect(NAME, code())
75	75	}
76	76
77	77	///////////////////////////////////////////////////////////////////////////////////////////////////

             private val NAME = EffectName.VERTEX_SCALE
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun code(): String
             fun code(): String
+            {
                 return """
                      v *= vUniforms[effect].xyz;
-...
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun enable() = addEffect(NAME, code())
             fun enable() = addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean

src/main/java/org/distorted/library/effect/VertexEffectShear.kt
37	37
38	38	///////////////////////////////////////////////////////////////////////////////////////////
39	39	// For explanation (esp. about the way we modify vectors n and i) see MatrixEffectShear.
40		@JvmStatic fun code(): String
	40	fun code(): String
41	41	{
42	42	return ("""
43	43	float sx = vUniforms[effect].x;
...	...
62	62	}
63	63
64	64	///////////////////////////////////////////////////////////////////////////////////////////////////
65		@JvmStatic fun enable() = addEffect(NAME, code())
	65	fun enable() = addEffect(NAME, code())
66	66	}
67	67
68	68	///////////////////////////////////////////////////////////////////////////////////////////////

             // Changed to the four complicated lines because the previous Sink effect fails to fully inflate the
             // Masterball.
             // Current function inflates and deflates much more as H is at the extremes (close to 0 and inf)
             @JvmStatic fun code(): String
             fun code(): String
+            {
                 return ("""
                          vec3 ps = vUniforms[effect+1].yzw - v;
-...
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun enable() = addEffect(NAME, code())
             fun enable() = addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////

             // This effect rotates the current vertex V by vInterpolated.x radians clockwise around the circle dilated
             // by (1-d) around the center of the effect S.
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun code(): String
             fun code(): String
+            {
                 return ("""
                          vec3 center = vUniforms[effect+1].yzw;
-...
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun enable() = addEffect(NAME, code())
             fun enable() = addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////

             //
             // Generally speaking I'd keep to amplitude < length, as the opposite case has some other problems as well.
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun code(): String
             fun code(): String
+            {
                 return ("""
                          vec3 center     = vUniforms[effect+1].yzw;
-...
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic fun enable() = addEffect(NAME, code())
             fun enable() = addEffect(NAME, code())
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////
         override fun compute(uniforms: FloatArray, index: Int, currentDuration: Long, step: Long): Boolean

src/main/java/org/distorted/library/effectqueue/EffectQueue.kt
64	64	private const val DETALL = 3
65	65
66	66	///////////////////////////////////////////////////////////////////////////////////////////
67		@JvmStatic
68	67	fun createQueues() : Array<EffectQueue>
69	68	{
70	69	val queues: Array<EffectQueue?> = arrayOfNulls(EffectType.LENGTH)
...	...
78	77	}
79	78
80	79	///////////////////////////////////////////////////////////////////////////////////////////
81		@JvmStatic
82	80	fun createQueues(from: Array<EffectQueue>, flags: Int) : Array<EffectQueue>
83	81	{
84	82	val queues: Array<EffectQueue?> = arrayOfNulls(EffectType.LENGTH)
...	...
92	90	}
93	91
94	92	///////////////////////////////////////////////////////////////////////////////////////////
95		@JvmStatic
96	93	fun compute(queues: Array<EffectQueue>, currTime: Long, step: Long)
97	94	{
98	95	(queues[0] as EffectQueueMatrix ).compute(currTime, step)
...	...
102	99	}
103	100
104	101	///////////////////////////////////////////////////////////////////////////////////////////
105		@JvmStatic
106	102	fun send(queues: Array<EffectQueue>, programH: Int, distance: Float, mipmap: Float,
107	103	projection: FloatArray, inflate: Float, variant: Int)
108	104	{
...	...
113	109
114	110	///////////////////////////////////////////////////////////////////////////////////////////
115	111	// variant: 0 --> MAIN 1 --> OIT 2 --> prePOST 3 --> FULL
116		@JvmStatic
117	112	fun getUniforms(programH: Int, variant: Int)
118	113	{
119	114	EffectQueueFragment.uniforms(programH, variant)
...	...
122	117	}
123	118
124	119	///////////////////////////////////////////////////////////////////////////////////////////
125		@JvmStatic
126	120	fun setMax(index: Int, m: Int): Boolean
127	121	{
128	122	return InternalStackFrameList.setMax(index, max(m,0) )
129	123	}
130	124
131	125	///////////////////////////////////////////////////////////////////////////////////////////
132		@JvmStatic
133	126	fun getMax(index: Int): Int = InternalStackFrameList.getMax(index)
134	127	}
135	128

             private var mPreProgramH = 0
             ///////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic
             fun createPrograms(vert: InputStream, frag: InputStream, GLSL: Int)
+            {
                 val numV = VertexEffect.getNumEnabled()

src/main/java/org/distorted/library/helpers/MatrixHelper.kt
23	23
24	24	object MatrixHelper
25	25	{
26		@JvmStatic fun setIdentity(output: FloatArray)
	26	fun setIdentity(output: FloatArray)
27	27	{
28	28	output[ 0] = 1f
29	29	output[ 1] = 0f
...	...
44	44	}
45	45
46	46	///////////////////////////////////////////////////////////////////////////////////////////////////
47		@JvmStatic
48	47	fun multiply(output: FloatArray, m1: FloatArray, m2: FloatArray)
49	48	{
50	49	output[ 0] = m1[0] * m2[ 0] + m1[4] * m2[ 1] + m1[ 8] * m2[ 2] + m1[12] * m2[ 3]
...	...
69	68	}
70	69
71	70	///////////////////////////////////////////////////////////////////////////////////////////////////
72		@JvmStatic
73	71	fun frustum(output: FloatArray, l: Float, r: Float, b: Float, t: Float, n: Float, f: Float)
74	72	{
75	73	output[ 0] = 2 * n / (r - l)
...	...
91	89	}
92	90
93	91	///////////////////////////////////////////////////////////////////////////////////////////////////
94		@JvmStatic
95	92	fun ortho(output: FloatArray, l: Float, r: Float, b: Float, t: Float, n: Float, f: Float)
96	93	{
97	94	output[ 0] = 2 / (r - l)
...	...
124	121	///////////////////////////////////////////////////////////////////////////////////////////////////
125	122	// this is android.opengl.Matrix.rotateM(), but with pre-computed sin and cos of the angle
126	123	// and also we have to pre-allocate and pass here two temp arrays.
127		@JvmStatic
128	124	fun rotateSinCos(output: FloatArray, tmp1: FloatArray, tmp2: FloatArray, sin: Float, cos: Float, x: Float, y: Float, z: Float)
129	125	{
130	126	tmp1[ 0] = (1-cos)xx + cos
...	...
165	161	}
166	162
167	163	///////////////////////////////////////////////////////////////////////////////////////////////////
168		@JvmStatic
169	164	fun translate(output: FloatArray, dx: Float, dy: Float, dz: Float)
170	165	{
171	166	output[12] += (output[0]dx + output[4]dy + output[ 8]*dz)
...	...
175	170	}
176	171
177	172	///////////////////////////////////////////////////////////////////////////////////////////////////
178		@JvmStatic
179	173	fun scale(output: FloatArray, sx: Float, sy: Float, sz: Float)
180	174	{
181	175	output[ 0] *= sx

          * There are only three possibilities: 300 (OpenGL ES 3.0) or 310 (at least OpenGL ES 3.1)
          * or 200 (OpenGL ES 2.0)
          */
         @JvmStatic var gLSL: Int = 0
          var gLSL: Int = 0
             private set
         private var mGLSL_VERSION: String? = null
         private var mOITCompilationAttempted = false
-...
         /**
          * Return the maximum size of the texture supported by the driver.
          */
         @JvmStatic var maxTextureSize: Int = Int.MAX_VALUE
         var maxTextureSize: Int = Int.MAX_VALUE
             private set
         /**
-...
          * @param user The Code which will be using this library, which must implement the LibraryUser interface.
          * @param queueSize the size of the FBO queue, a workaround for the bug on Mali drivers. Use a small integer - 1,...,4
          */
         @JvmStatic
         @JvmOverloads
         fun onSurfaceCreated(user: LibraryUser, queueSize: Int = 4)
+        {
             mUser = user
-...
         /**
          * Switch face culling on/off
          */
         @JvmStatic
         fun setCull(on: Boolean)
+        {
             if (on)
-...
          * @param id id of an Activity that is using the library; anything unique so that the Library can
          * tell between Activities in case you're going to be using it from more than one.
          */
         @JvmStatic
         @JvmOverloads
         fun onCreate(id: Long = 0)
+        {
             InternalStackFrameList.onCreate(id)
-...
          * @param id id of an Activity that is using the library; anything unique so that the Library can
          * tell between Activities in case you're going to be using it from more than one.
          */
         @JvmStatic
         @JvmOverloads
         fun onResume(id: Long = 0)
+        {
             InternalStackFrameList.onResume(id)
-...
          * @param id id of an Activity that is using the library; anything unique so that the Library can
          * tell between Activities in case you're going to be using it from more than one.
          */
         @JvmStatic
         @JvmOverloads
         fun onPause(id: Long = 0)
+        {
             InternalStackFrameList.onPause(id)
-...
          * @param id id of an Activity that is using the library; anything unique so that the Library can
          * tell between Activities in case you're going to be using it from more than one.
          */
         @JvmStatic
         @JvmOverloads
         fun onDestroy(id: Long = 0)
+        {
             if (isInitialized)
-...
          * suffer from a very slow compilation of GLSL program if said program includes Transform Feedback.
          * Return true if the platform we are running on does not suffer from this problem.
          */
         @JvmStatic
         fun fastCompilationTF(): Boolean
+        {
             return mFastCompilationTF
-...
         /**
          * Call this before calling onSurfaceCreated() if you want to access normal vectors in CPU.
          */
         @JvmStatic
         fun needTransformFeedback()
+        {
             mNeedsTransformFeedback = true
-...
          * than Byte.MAX_VALUE
          * @return `true` if operation was successful, `false` otherwise.
          */
         @JvmStatic
         @Suppress("unused")
         fun setMax(type: EffectType, max: Int): Boolean
+        {

      * Create a Texture of arbitrary size and feed some pixels to it via the setTexture() method.
      */
     class DistortedTexture
     @JvmOverloads constructor(type: Int = TYPE_USER) : InternalSurface(NOT_CREATED_YET, 1, 1, type, STORAGE_PRIVATE)
     constructor(type: Int = TYPE_USER) : InternalSurface(NOT_CREATED_YET, 1, 1, type, STORAGE_PRIVATE)
+    {
         private var mBmp: Bitmap? = null
         private var mBitmapInverted = false

     /**
      * This is a member of DistortedNode. Makes sure two isomorphic Nodes only get rendered once.
      */
     class InternalNodeData(@JvmField val ID: Long, private val mKey: ArrayList<Long>)
     class InternalNodeData( val ID: Long, private val mKey: ArrayList<Long>)
+    {
         private var numPointingNodes = 1
         private var currTime: Long
         @JvmField var mFBO: DistortedFramebuffer? = null
         var mFBO: DistortedFramebuffer? = null
         init { currTime = -1 }
         companion object
+        {
             @JvmStatic fun returnData(list: ArrayList<Long>): InternalNodeData
             fun returnData(list: ArrayList<Long>): InternalNodeData
+            {
                 var data = InternalStackFrameList.getMapID(list)
                 if (data!=null) data.numPointingNodes++

      */
     abstract class InternalOutputSurface
         internal constructor(var mWidth: Int, var mHeight: Int, createColor: Int, numfbos: Int, numcolors: Int,
                              @JvmField var mDepthStencil: Int, fbo: Int, type: Int, storage: Int)
                              var mDepthStencil: Int, fbo: Int, type: Int, storage: Int)
         : InternalSurface(createColor, numfbos, numcolors, type, storage), InternalChildrenList.Parent
+    {
         var fOV: Float
-...
         private val mChildren: InternalChildrenList
         private val mBufferInitialized: BooleanArray
         @JvmField var mDistance: Float = 0f
         @JvmField var mNear: Float
         @JvmField var mMipmap: Float = 1.0f
         @JvmField var mProjectionMatrix: FloatArray
         @JvmField var mDepthStencilCreated: Int
         @JvmField var mDepthStencilH: IntArray? = null
         @JvmField var mFBOH: IntArray
         @JvmField var mRealWidth: Int // the Surface can be backed up by a texture larger than the viewport we have to it.
         @JvmField var mRealHeight: Int // mWidth,mHeight are the sizes of the Viewport, those - sizes of the backing up texture.
         @JvmField var mCurrFBO: Int = 0 // internal current FBO (see DistortedLibrary.FBO_QUEUE_SIZE)
         var mDistance: Float = 0f
         var mNear: Float
         var mMipmap: Float = 1.0f
         var mProjectionMatrix: FloatArray
         var mDepthStencilCreated: Int
         var mDepthStencilH: IntArray? = null
         var mFBOH: IntArray
         var mRealWidth: Int // the Surface can be backed up by a texture larger than the viewport we have to it.
         var mRealHeight: Int // mWidth,mHeight are the sizes of the Viewport, those - sizes of the backing up texture.
         var mCurrFBO: Int = 0 // internal current FBO (see DistortedLibrary.FBO_QUEUE_SIZE)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         companion object
-...
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic
             @Synchronized
             fun onPause()
+            {

src/main/java/org/distorted/library/main/InternalRenderState.kt
467	467	}
468	468
469	469	///////////////////////////////////////////////////////////////////////////////////////////////////
470		@JvmStatic fun switchOffDrawing()
	470	fun switchOffDrawing()
471	471	{
472	472	GLES30.glEnable(GLES30.GL_SCISSOR_TEST)
473	473	GLES30.glScissor(0, 0, 0, 0)
474	474	}
475	475
476	476	///////////////////////////////////////////////////////////////////////////////////////////////////
477		@JvmStatic fun restoreDrawing()
	477	fun restoreDrawing()
478	478	{
479	479	GLES30.glDisable(GLES30.GL_SCISSOR_TEST)
480	480	}

src/main/java/org/distorted/library/main/InternalStackFrameList.kt
41	41	private val mFrameList = ArrayList<InternalStackFrame?>()
42	42
43	43	///////////////////////////////////////////////////////////////////////////////////////////////////
44		@JvmStatic
45	44	fun onCreate(taskId: Long)
46	45	{
47	46	val num = mFrameList.size
...	...
73	72	}
74	73
75	74	///////////////////////////////////////////////////////////////////////////////////////////////////
76		@JvmStatic
77	75	fun onResume(taskId: Long)
78	76	{
79	77	val num = mFrameList.size
...	...
94	92	}
95	93
96	94	///////////////////////////////////////////////////////////////////////////////////////////////////
97		@JvmStatic
98	95	fun onPause(taskId: Long)
99	96	{
100	97	val num = mFrameList.size
...	...
116	113	}
117	114
118	115	///////////////////////////////////////////////////////////////////////////////////////////////////
119		@JvmStatic
120	116	fun onDestroy(taskId: Long)
121	117	{
122	118	val num = mFrameList.size
...	...
201	197	}
202	198	}
203	199
204		@JvmStatic val nextEffectsID: Long get() = currentFrame!!.nextEffectsID
	200	val nextEffectsID: Long get() = currentFrame!!.nextEffectsID
205	201
206	202	///////////////////////////////////////////////////////////////////////////////////////////////////
207	203	fun getMapID(key: ArrayList<Long>): InternalNodeData?
...	...
225	221
226	222	val nextEffectID: Long get() = currentFrame!!.nextEffectID
227	223
228		@JvmStatic
229	224	var isInitialized: Boolean
230	225	get() = currentFrame!!.isInitialized
231	226	set(init)

     // common parent class of Texture & OutputSurface; so that we can store either in Nodes.
     abstract class InternalSurface(create: Int, numfbos: Int, numcolors: Int, type: Int, storage: Int) : InternalObject(type, storage)
+    {
         @JvmField var mColorCreated: Int = create
         @JvmField var mNumColors   : Int = numcolors
         @JvmField var mNumFBOs     : Int = numfbos
         @JvmField var mColorH      : IntArray? = null
         var mColorCreated: Int = create
         var mNumColors   : Int = numcolors
         var mNumFBOs     : Int = numfbos
         var mColorH      : IntArray? = null
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         init

src/main/java/org/distorted/library/mesh/DeferredJobs.kt
241	241	*
242	242	* @y.exclude
243	243	*/
244		@JvmStatic
245	244	fun onPause()
246	245	{
247	246	val num = mJobs.size

             /**
              * How many mesh components are we going to need? Call before compilation of the shaders.
              */
             @JvmStatic
             var maxEffComponents: Int = 100
             ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
              * Are we going to need per-component centers (needed for correct postprocessing of concave meshes)
              * Switching this on allocates 16*MAX_EFFECT_COMPONENTS bytes for uniforms in the vertex shader.
              */
             @JvmStatic
             var useCenters: Boolean = false
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic
             fun getUniforms(programH: Int, variant: Int)
+            {
                 mCenterBlockIndex[variant] = GLES30.glGetUniformBlockIndex(programH, "componentCenter")

src/main/java/org/distorted/library/mesh/MeshMultigon.kt
692	692	///////////////////////////////////////////////////////////////////////////////////////////////////
693	693	// PUBLIC API
694	694	///////////////////////////////////////////////////////////////////////////////////////////////////
695		@JvmStatic
696	695	fun computeEdgesUp(vertices: Array<Array<FloatArray>>): Array<IntArray>
697	696	{
698	697	val numPoly = vertices.size
...	...
709	708	}
710	709
711	710	///////////////////////////////////////////////////////////////////////////////////////////////////
712		@JvmStatic
713	711	fun computeOuterAndHoleVertices(vertices: Array<Array<FloatArray>>, edgesUp: Array<IntArray>): Array<Array<FloatArray>>
714	712	{
715	713	val tmp = ArrayList<FloatArray>()

src/main/java/org/distorted/library/message/EffectMessageSender.kt
75	75	private var mStartTime: Long = 0
76	76	private var mStopTime: Long = 0
77	77
78		@JvmStatic fun startSending()
	78	fun startSending()
79	79	{
80	80	synchronized(mLock)
81	81	{
...	...
91	91	}
92	92	}
93	93
94		@JvmStatic fun stopSending()
	94	fun stopSending()
95	95	{
96	96	synchronized(mLock)
97	97	{
...	...
106	106	}
107	107	}
108	108
109		@JvmStatic fun newMessage(effect: Effect)
	109	fun newMessage(effect: Effect)
110	110	{
111	111	val numListeners = effect.numListeners
112	112
...	...
129	129	}
130	130	}
131	131
132		@JvmStatic val isRunning: Boolean
	132	val isRunning: Boolean
133	133	get() = mThis!=null
134	134
135		@JvmStatic fun restartThread()
	135	fun restartThread()
136	136	{
137	137	synchronized(mLock)
138	138	{
...	...
145	145	}
146	146	}
147	147
148		@JvmStatic fun reportState(): String
	148	fun reportState(): String
149	149	{
150	150	return "running "+(mThis!=null)+" notify="+mNotify+" elements="+mList!!.size+
151	151	" start="+mStartTime+" stop="+mStopTime+" numStarts="+mNumStarts

          * Pre has 3 attributes (position,texcoord,component)
          * Maybe there are other possibilities (only position and normal? 3- position,normal,texcoord?)
          */
         @JvmField var mAttributeLayout: Int = 0
         var mAttributeLayout: Int = 0
         /**
          * List of Attributes (OpenGL ES 3.0: 'in' variables), in the same order as declared in the shader source.
          */
         @JvmField var mAttribute: IntArray? = null
         var mAttribute: IntArray? = null
         /**
          * List of Uniforms, in the same order as declared in the shader source.
          */
         @JvmField var mUniform: IntArray? = null
         var mUniform: IntArray? = null
         companion object
+        {

             private const val NUM_NOISE = 5 // used iff mNoise>0.0. Number of intermediary points between each pair of adjacent vectors
             private var mPausedTime: Long = 0
             @JvmStatic fun onPause() { mPausedTime = System.currentTimeMillis() }
             fun onPause() { mPausedTime = System.currentTimeMillis() }
+        }
         var dimension: Int = 0

Project

General

Profile

Distorted Android

Revision 0bff60a4

Added by Leszek Koltunski 5 months ago