/ - Diff - Distorted Android

« Previous | Next »

Revision a5a3b341

Added by Leszek Koltunski 6 months ago

ID a5a3b341fc9299ab6d0c03f4d87470d2952d120e
Parent 6a02a170
Child 5c149b50

transition of the mesh package.
Compiles, but does not work.

                 var mainVertHeader = version + ("#define NUM_VERTEX " + (if (numV>0) DistortedLibrary.getMax(EffectType.VERTEX) else 0) + "\n")
                 val mainFragHeader = version + "\n"
                 mainVertHeader += "#define MAX_COMPON " + MeshBase.getMaxEffComponents() + "\n"
                 if (MeshBase.getUseCenters()) mainVertHeader += "#define COMP_CENTERS\n"
                 mainVertHeader += "#define MAX_COMPON " + MeshBase.maxEffComponents + "\n"
                 if (MeshBase.useCenters) mainVertHeader += "#define COMP_CENTERS\n"
                 if (DistortedLibrary.isUBOBuggy()) mainVertHeader += "#define BUGGY_UBOS\n"
                 mainVertHeader += "#define POSTPROCESS\n"
-...
             mPreProgram!!.useProgram()
             mesh.bindVertexAttribs(mPreProgram)
             mesh.bindVertexAttribs(mPreProgram as DistortedProgram)
             mesh.send(mPreProgramH, 2)
             val queues = effects.queues
-...
                 GLES30.glUniform1i(mPreTextureH, 0)
+            }
             GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, mesh.numVertices)
             GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, mesh.getNumVertices() )
             mPreProgram!!.stopUsingProgram()
             InternalRenderState.restoreBlending()

     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Execute all VertexEffects and adjust all vertices
+     *
      * @y.exclude
      */
       public static void adjustVertices(MeshBase mesh, EffectQueueVertex queue)
+        {
-...
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Not an external API
+     *
      * @y.exclude
      */
       public static void logMessage(String message)
+        {
         mUser.logMessage(message);

src/main/java/org/distorted/library/mesh/DeferredJobs.kt
153	153	}
154	154
155	155	///////////////////////////////////////////////////////////////////////////////////////////////////
156		fun <T:MeshBase> join(target: T, meshes: Array<T>): JobNode
	156	fun <T:MeshBase> join(target: T, meshes: Array<MeshBase>): JobNode
157	157	{
158	158	var jn: JobNode?
159
160	159	val job = Job(JOB_TYPE_JOIN, target, meshes, null, null, null, 0, 0, 0, 0f, 0f, 0f, null)
161	160	val node = JobNode(job)
162	161
...	...
176	175	}
177	176
178	177	///////////////////////////////////////////////////////////////////////////////////////////////////
179		fun <T:MeshBase> copy(target: T, mesh: T): JobNode
	178	fun <T:MeshBase> copy(target: T, mesh: MeshBase): JobNode
180	179	{
181	180	val jn = mesh.mJobNode[0]
182	181	val meshes = arrayOf(mesh)

         var mJobNode: Array<DeferredJobs.JobNode?>
         companion object
+        {
             private const val ASSOC_UBO_BINDING = 3
             private const val CENTER_UBO_BINDING = 4
             // sizes of attributes of an individual vertex.
             private const val POS_DATA_SIZE = 3 // vertex coordinates: x,y,z
             private const val NOR_DATA_SIZE = 3 // normal vector: x,y,z
             private const val TEX_DATA_SIZE = 2 // texture coordinates: s,t
             private const val COM_DATA_SIZE = 1 // component number, a single float
             const val POS_ATTRIB: Int = 0
             const val NOR_ATTRIB: Int = POS_DATA_SIZE
             const val TEX_ATTRIB: Int = 0
             const val COM_ATTRIB: Int = TEX_DATA_SIZE
             const val VERT1_ATTRIBS: Int = POS_DATA_SIZE+NOR_DATA_SIZE // number of attributes of a vertex (the part changed by preapply)
             const val VERT2_ATTRIBS: Int = TEX_DATA_SIZE+COM_DATA_SIZE // number of attributes of a vertex (the 'preapply invariant' part)
             const val TRAN_ATTRIBS: Int = POS_DATA_SIZE+NOR_DATA_SIZE // number of attributes of a transform feedback vertex
             private const val BYTES_PER_FLOAT = 4
             private const val OFFSET_POS = POS_ATTRIB*BYTES_PER_FLOAT
             private const val OFFSET_NOR = NOR_ATTRIB*BYTES_PER_FLOAT
             private const val OFFSET_TEX = TEX_ATTRIB*BYTES_PER_FLOAT
             private const val OFFSET_COM = COM_ATTRIB*BYTES_PER_FLOAT
             private const val TRAN_SIZE = TRAN_ATTRIBS*BYTES_PER_FLOAT
             private const val VERT1_SIZE = VERT1_ATTRIBS*BYTES_PER_FLOAT
             private const val VERT2_SIZE = VERT2_ATTRIBS*BYTES_PER_FLOAT
             private val mCenterBlockIndex = IntArray(EffectQueue.MAIN_VARIANTS)
             private val mAssocBlockIndex = IntArray(EffectQueue.MAIN_VARIANTS)
             private const val TEX_COMP_SIZE = 5 // 5 four-byte entities inside the component
             private var mStride = 0
             /**
              * 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")
                 mAssocBlockIndex[variant] = GLES30.glGetUniformBlockIndex(programH, "componentAssociation")
                 if (mStride==0)
+                {
                     val uniformNames = arrayOf("vComAssoc")
                     val indices = IntArray(1)
                     val params = IntArray(1)
                     GLES30.glGetUniformIndices(programH, uniformNames, indices, 0)
                     GLES30.glGetActiveUniformsiv(programH, 1, indices, 0, GLES30.GL_UNIFORM_ARRAY_STRIDE, params, 0)
                     mStride = params[0]/4
+                }
+            }
+        }
         private class TexComponent
+        {
             var mEndIndex: Int
-...
             var mesh: MeshBase
             var comp: TexComponent
             val numMeshes = meshes.size
             var numVertices: Int
             var origVertices = this.numVertices
             val origTexComponents: Int
             var numTexComponents: Int
-...
+            }
             if (immediateJoin) joinAttribs(meshes)
             else mJobNode[0] = DeferredJobs.join(this, meshes)
             else mJobNode[0] = DeferredJobs.join(this, meshes as Array<MeshBase>)
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
-...
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         val tFO: Int
             /**
              * Not part of public API, do not document (public only because has to be used from the main package)
+             *
              * @y.exclude
              */
             get()
             = mTFO.createImmediatelyFloat(numVertices*TRAN_SIZE, null)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         val tFO: Int get() = mTFO.createImmediatelyFloat(numVertices*TRAN_SIZE, null)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Not part of public API, do not document (public only because has to be used from the main package)
+         *
          * @y.exclude
          */
         fun send(programH: Int, variant: Int)
+        {
             if (!mStrideCorrected)
-...
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Not part of public API, do not document (public only because has to be used from the main package)
+         *
          * @y.exclude
          */
         fun bindVertexAttribs(program: DistortedProgram)
+        {
             if (mJobNode[0]!=null) mJobNode[0]!!.execute() // this will set itself to null
-...
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Not part of public API, do not document (public only because has to be used from the main package)
+         *
          * @y.exclude
          */
         fun bindTransformAttribs(program: DistortedProgram)
+        {
             val index = mTFO.createImmediatelyFloat(numVertices*TRAN_SIZE, null)
-...
             GLES30.glBindBuffer(GLES30.GL_ARRAY_BUFFER, 0)
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         // Return the number of bytes read.
         fun read(stream: DataInputStream): Int
-...
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * @y.exclude
          */
         fun getLastVertexEff(effComponent: Int): Int
+        {
             if (effComponent>=0&&effComponent<mTexComponent!!.size)
-...
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * @y.exclude
          */
         fun getLastVertexTex(texComponent: Int): Int
+        {
             if (texComponent>=0&&texComponent<mTexComponent!!.size)
-...
+            }
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Merge all texture components of this Mesh into a single one.
-...
                 mJobNode[0] = DeferredJobs.mergeEff(this)
+            }
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
          * Return the number of vertices in this Mesh.
          */
         fun getNumVertices() = numVertices
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
-...
         /**
          * Apply a Matrix Effect to the components which match the (addAssoc,equAssoc) association.
+         *
+         *
          * This is a static, permanent modification of the vertices contained in this Mesh. If the effect
          * contains any Dynamics, they will be evaluated at 0.
+         *
-...
         /**
          * Apply a Vertex Effect to the vertex mesh.
+         *
+         *
          * This is a static, permanent modification of the vertices contained in this Mesh. If the effects
          * contain any Dynamics, the Dynamics will be evaluated at 0.
          * We would call this several times building up a list of Effects to do. This list of effects gets
-...
         /**
          * Sets texture maps for (some of) the components of this mesh.
+         *
+         *
          * Format: ( x of lower-left corner, y of lower-left corner, width, height ).
          * For example maps[0] = new Static4D( 0.0, 0.5, 0.5, 0.5 ) sets the 0th component texture map to the
          * upper-left quadrant of the texture.
+         *
+         *
          * Probably the most common user case would be sending as many maps as there are components in this
          * Mesh. One can also send less, or more (the extraneous ones will be ignored) and set some of them
          * to null (those will be ignored as well). So if there are 5 components, and we want to set the map
-...
          * The point: this way we can configure the system so that each Vertex Effect acts only on a certain
          * subset of a Mesh, thus potentially significantly reducing the number of render calls.
+         *
+         *
          * Only the bottom 31 bits of the 'andAssociation' are possible, the top one is taken by Postprocessing
          * Association [i.e. marking which components are disabled when we postprocess]
          */
         fun setEffectAssociation(component: Int, andAssociation: Int, equAssociation: Int)
+        {
             if (component>=0&&component<maxEffComponents)
             if( component in 0..<maxEffComponents )
+            {
                 if (mJobNode[0]==null)
+                {
-...
          */
         fun setComponentCenter(component: Int, centerX: Float, centerY: Float, centerZ: Float)
+        {
             if (component>=0&&component<maxEffComponents)
             if( component in 0..<maxEffComponents )
+            {
                 if (mJobNode[0]==null)
+                {
-...
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         val numTexComponents: Int
             /**
              * Return the number of texture components, i.e. individual subsets of the whole set of vertices
              * which can be independently textured.
+             *
              * @return The number of Texture Components of this Mesh.
              */
             get()
             = mTexComponent!!.size
         /**
          * Return the number of texture components, i.e. individual subsets of the whole set of vertices
          * which can be independently textured.
+         *
          * @return The number of Texture Components of this Mesh.
          */
         val numTexComponents: Int get() = mTexComponent!!.size
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         val numEffComponents: Int
             /**
              * Return the number of 'effect' components, i.e. individual subsets of the whole set of vertices
              * to which a VertexEffect can be addressed, independently of other vertices.
+             *
              * @return The number of Effect Components of this Mesh.
              */
             get()
             = mEffComponent!!.size
         /**
          * Return the number of 'effect' components, i.e. individual subsets of the whole set of vertices
          * to which a VertexEffect can be addressed, independently of other vertices.
+         *
          * @return The number of Effect Components of this Mesh.
          */
         val numEffComponents: Int get() = mEffComponent!!.size
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**
-...
          * coordinates and effect associations, is always deep copied)
          */
         abstract fun copy(deep: Boolean): MeshBase
         companion object
+        {
             private const val ASSOC_UBO_BINDING = 3
             private const val CENTER_UBO_BINDING = 4
             // sizes of attributes of an individual vertex.
             private const val POS_DATA_SIZE = 3 // vertex coordinates: x,y,z
             private const val NOR_DATA_SIZE = 3 // normal vector: x,y,z
             private const val TEX_DATA_SIZE = 2 // texture coordinates: s,t
             private const val COM_DATA_SIZE = 1 // component number, a single float
             const val POS_ATTRIB: Int = 0
             const val NOR_ATTRIB: Int = POS_DATA_SIZE
             const val TEX_ATTRIB: Int = 0
             const val COM_ATTRIB: Int = TEX_DATA_SIZE
             const val VERT1_ATTRIBS: Int = POS_DATA_SIZE+NOR_DATA_SIZE // number of attributes of a vertex (the part changed by preapply)
             const val VERT2_ATTRIBS: Int = TEX_DATA_SIZE+COM_DATA_SIZE // number of attributes of a vertex (the 'preapply invariant' part)
             const val TRAN_ATTRIBS: Int = POS_DATA_SIZE+NOR_DATA_SIZE // number of attributes of a transform feedback vertex
             private const val BYTES_PER_FLOAT = 4
             private const val OFFSET_POS = POS_ATTRIB*BYTES_PER_FLOAT
             private const val OFFSET_NOR = NOR_ATTRIB*BYTES_PER_FLOAT
             private const val OFFSET_TEX = TEX_ATTRIB*BYTES_PER_FLOAT
             private const val OFFSET_COM = COM_ATTRIB*BYTES_PER_FLOAT
             private const val TRAN_SIZE = TRAN_ATTRIBS*BYTES_PER_FLOAT
             private const val VERT1_SIZE = VERT1_ATTRIBS*BYTES_PER_FLOAT
             private const val VERT2_SIZE = VERT2_ATTRIBS*BYTES_PER_FLOAT
             private val mCenterBlockIndex = IntArray(EffectQueue.MAIN_VARIANTS)
             private val mAssocBlockIndex = IntArray(EffectQueue.MAIN_VARIANTS)
             private const val TEX_COMP_SIZE = 5 // 5 four-byte entities inside the component
             /**
              * Are we using per-component centers?
              */
             var useCenters: Boolean = false
                 private set
             private var mStride = 0
             /**
              * How many mesh components are we going to need? Call before compilation of the shaders.
              */
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             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.
              */
             fun setUseCenters()
+            {
                 useCenters = true
+            }
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             ///////////////////////////////////////////////////////////////////////////////////////////////////
             @JvmStatic
             fun getUniforms(programH: Int, variant: Int)
+            {
                 mCenterBlockIndex[variant] = GLES30.glGetUniformBlockIndex(programH, "componentCenter")
                 mAssocBlockIndex[variant] = GLES30.glGetUniformBlockIndex(programH, "componentAssociation")
                 if (mStride==0)
+                {
                     val uniformNames = arrayOf("vComAssoc")
                     val indices = IntArray(1)
                     val params = IntArray(1)
                     GLES30.glGetUniformIndices(programH, uniformNames, indices, 0)
                     GLES30.glGetActiveUniformsiv(programH, 1, indices, 0, GLES30.GL_UNIFORM_ARRAY_STRIDE, params, 0)
                     mStride = params[0]/4
+                }
+            }
+        }
+    }

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

          * all bands go to.
          * @param centerY    Y coordinate of the center.
          */
         @JvmOverloads
         constructor(verticesXY: Array<FloatArray>, bands: FloatArray, exBand: Int = 0, exVertices: Int = 0, centerX: Float = 0.0f, centerY: Float = 0.0f) : super()
         constructor(verticesXY: Array<FloatArray>, bands: FloatArray, exBand: Int, exVertices: Int, centerX: Float, centerY: Float) : super()
+        {
             mPolygonVertices = verticesXY
             mPolygonBands = bands
-...
+        }
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         constructor(verticesXY: Array<FloatArray>, bands: FloatArray, exIndex: Int, exVertices: Int) : this(verticesXY, bands, exIndex, exVertices, 0.0f, 0.0f)
         constructor(verticesXY: Array<FloatArray>, bands: FloatArray, exIndex: Int, exVertices: Int)
                    : this(verticesXY, bands, exIndex, exVertices, 0.0f, 0.0f)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         constructor(verticesXY: Array<FloatArray>, bands: FloatArray)
                    : this(verticesXY, bands, 0, 0, 0.0f, 0.0f)
         ///////////////////////////////////////////////////////////////////////////////////////////////////
         /**

         ///////////////////////////////////////////////////////////////////////////////////////////////
         constructor()
+        {
             mMax = MeshBase.getMaxEffComponents()
             mMax = MeshBase.maxEffComponents
             mStride = DEFAULT_STRIDE
             mAssociations = IntArray(mStride*mMax)

src/main/java/org/distorted/library/uniformblock/UniformBlockCenter.kt
38	38	///////////////////////////////////////////////////////////////////////////////////////////////
39	39	constructor()
40	40	{
41		mMax = MeshBase.getMaxEffComponents()
	41	mMax = MeshBase.maxEffComponents
42	42	backingArray = FloatArray(4*mMax)
43	43	mUBO = InternalBuffer()
44	44	}

Also available in: Unified diff

Project

General

Profile

Distorted Android

Revision a5a3b341

Added by Leszek Koltunski 6 months ago