Project

General

Profile

« Previous | Next » 

Revision 026856ec

Added by Leszek Koltunski about 13 hours ago

  • ID 026856eccdb4c9066d55adde1cc644958e1ec1dd
  • Parent 033e8feb

progress with the 'mesh' package.

View differences:

src/main/java/org/distorted/library/mesh/DeferredJobs.kt
179 179
    fun copy(target: MeshBase, mesh: MeshBase): JobNode
180 180
    {
181 181
        val jn = mesh.mJobNode[0]
182
        val meshes = arrayOfNulls<MeshBase>(1)
183
        meshes[0] = mesh
182
        val meshes = arrayOf(mesh)
184 183
        val job = Job(JOB_TYPE_COPY, target, meshes, null, null, null, 0, 0, 0, 0f, 0f, 0f, null)
185 184
        val node = JobNode(job)
186 185
        node.mPrevJobs!!.add(jn)
......
253 252

  
254 253
    //////////////////////////////////////////////////////////////////////////
255 254
    class Job
256
        (val mType: Int, val mTarget: MeshBase, source: Array<MeshBase?>?, vEff: VertexEffect?, mEff: MatrixEffect?,
255
        (val mType: Int, val mTarget: MeshBase, source: Array<MeshBase>?, vEff: VertexEffect?, mEff: MatrixEffect?,
257 256
         maps: Array<Static4D?>?, comp: Int, and: Int, equ: Int, x: Float, y: Float, z: Float, comps: IntArray?)
258 257
    {
259 258
        private val mSource = source!!
src/main/java/org/distorted/library/mesh/MeshBandedTriangle.kt
32 32
 */
33 33
class MeshBandedTriangle : MeshBase
34 34
{
35
    private var mMode = 0
36
    private var mNumBands = 0
37
    private var remainingVert = 0
38
    private var numVertices = 0
39
    private var extraBands = 0
40
    private var extraVertices = 0
41
    private var mVecX = 0f
42
    private var mVecY = 0f
35 43
    private var mLeftX = 0f
36 44
    private var mLeftY = 0f
37 45
    private var mRightX = 0f
......
41 49

  
42 50
    private lateinit var mNormL: FloatArray
43 51
    private lateinit var mNormR: FloatArray
44
    private var mMode = 0
45

  
46 52
    private lateinit var mBands: FloatArray
47
    private var mNumBands = 0
48

  
49
    private var remainingVert = 0
50
    override var numVertices: Int = 0
51
    private var extraBands = 0
52
    private var extraVertices = 0
53

  
54 53
    private lateinit var mCurveCache: FloatArray
55
    private var mVecX = 0f
56
    private var mVecY = 0f
57 54

  
58 55
    companion object
59 56
    {
src/main/java/org/distorted/library/mesh/MeshBase.kt
51 51
    private var mVBO1: InternalBuffer? = null
52 52
    private var mVBO2: InternalBuffer? = null
53 53
    private var mTFO: InternalBuffer // main vertex buffer and transform feedback buffer
54
    var numVertices: Int = 0
55
        private set
54
    private var numVertices: Int = 0
56 55
    private var mVertAttribs1: FloatArray? = null // packed: PosX,PosY,PosZ, NorX,NorY,NorZ
57 56
    private var mVertAttribs2: FloatArray? = null // packed: TexS,TexT, Component
58 57
    var inflate: Float
......
145 144
    fun copy(original: MeshBase)
146 145
    {
147 146
        shallowCopy(original)
148

  
149 147
        mVBO1 = InternalBuffer(GLES30.GL_ARRAY_BUFFER, GLES30.GL_STATIC_DRAW)
150
        mVertAttribs1 = FloatArray(numVertices*VERT1_ATTRIBS)
151
        System.arraycopy(original.mVertAttribs1, 0, mVertAttribs1, 0, numVertices*VERT1_ATTRIBS)
148
        mVertAttribs1 = original.mVertAttribs1?.copyOf()
152 149
    }
153 150

  
154 151
    ///////////////////////////////////////////////////////////////////////////////////////////////////
......
167 164
        mEffComponent!!.addAll(original.mEffComponent!!)
168 165

  
169 166
        mVBO2 = InternalBuffer(GLES30.GL_ARRAY_BUFFER, GLES30.GL_STATIC_DRAW)
170
        mVertAttribs2 = FloatArray(numVertices*VERT2_ATTRIBS)
171
        System.arraycopy(original.mVertAttribs2, 0, mVertAttribs2, 0, numVertices*VERT2_ATTRIBS)
167
        mVertAttribs2 = original.mVertAttribs2?.copyOf()
172 168
    }
173 169

  
174 170
    ///////////////////////////////////////////////////////////////////////////////////////////////////
......
384 380

  
385 381
        if (origVertices>0)
386 382
        {
387
            System.arraycopy(mVertAttribs1, 0, newAttribs1, 0, VERT1_ATTRIBS*numVertices)
388
            System.arraycopy(mVertAttribs1, VERT1_ATTRIBS*(origVertices-1), newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS)
389
            System.arraycopy(mVertAttribs2, 0, newAttribs2, 0, VERT2_ATTRIBS*numVertices)
390
            System.arraycopy(mVertAttribs2, VERT2_ATTRIBS*(origVertices-1), newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS)
383
            val v1 = VERT1_ATTRIBS*origVertices
384
            val v2 = VERT2_ATTRIBS*origVertices
385

  
386
            mVertAttribs1?.copyInto(newAttribs1, 0               , 0 , v1)
387
            mVertAttribs1?.copyInto(newAttribs1, v1-VERT1_ATTRIBS, v1, v1+VERT1_ATTRIBS)
388
            mVertAttribs2?.copyInto(newAttribs2, 0               , 0 , v2)
389
            mVertAttribs2?.copyInto(newAttribs2, v2-VERT2_ATTRIBS, v2, v2+VERT2_ATTRIBS)
390
            /*
391
            System.arraycopy(mVertAttribs1, 0, newAttribs1, 0, v1)
392
            System.arraycopy(mVertAttribs1, v1-VERT1_ATTRIBS, newAttribs1, v1, VERT1_ATTRIBS)
393
            System.arraycopy(mVertAttribs2, 0, newAttribs2, 0, v2)
394
            System.arraycopy(mVertAttribs2, v2-VERT2_ATTRIBS, newAttribs2, v2, VERT2_ATTRIBS)
395
            */
391 396
            origVertices++
392 397

  
393 398
            if (numVertices%2==1)
394 399
            {
395
                System.arraycopy(mVertAttribs1, VERT1_ATTRIBS*(origVertices-1), newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS)
396
                System.arraycopy(mVertAttribs2, VERT2_ATTRIBS*(origVertices-1), newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS)
400
                val w1 = VERT1_ATTRIBS*origVertices
401
                val w2 = VERT2_ATTRIBS*origVertices
402

  
403
                mVertAttribs1?.copyInto(newAttribs1,w1-VERT1_ATTRIBS,w1,w1+VERT1_ATTRIBS)
404
                mVertAttribs2?.copyInto(newAttribs2,w2-VERT2_ATTRIBS,w2,w2+VERT2_ATTRIBS)
405
                /*
406
                System.arraycopy(mVertAttribs1, w1-VERT1_ATTRIBS, newAttribs1, w1, VERT1_ATTRIBS)
407
                System.arraycopy(mVertAttribs2, w2-VERT2_ATTRIBS, newAttribs2, w2, VERT2_ATTRIBS)
408
                */
397 409
                origVertices++
398 410
            }
399 411
        }
......
405 417

  
406 418
            if (origVertices>0)
407 419
            {
420
                val v1 = VERT1_ATTRIBS*origVertices
421
                val v2 = VERT2_ATTRIBS*origVertices
422
                mesh.mVertAttribs1?.copyInto(newAttribs1,0, v1, v1+VERT1_ATTRIBS)
423
                mesh.mVertAttribs2?.copyInto(newAttribs2,0, v2, v2+VERT2_ATTRIBS)
424

  
425
                /*
408 426
                System.arraycopy(mesh.mVertAttribs1, 0, newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS)
409 427
                System.arraycopy(mesh.mVertAttribs2, 0, newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS)
428
                */
410 429
                origVertices++
411 430
            }
431
            val v1 = VERT1_ATTRIBS*origVertices
432
            val v2 = VERT2_ATTRIBS*origVertices
433
            mesh.mVertAttribs1?.copyInto(newAttribs1,0, v1, v1+VERT1_ATTRIBS*numVertices)
434
            mesh.mVertAttribs2?.copyInto(newAttribs2,0, v2, v2+VERT2_ATTRIBS*numVertices)
435
            /*
412 436
            System.arraycopy(mesh.mVertAttribs1, 0, newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS*numVertices)
413 437
            System.arraycopy(mesh.mVertAttribs2, 0, newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS*numVertices)
438
             */
414 439
            origVertices += numVertices
415 440

  
416 441
            if (i<numMeshes-1&&numVertices>0)
417 442
            {
443
                val w1 = VERT1_ATTRIBS*origVertices
444
                val w2 = VERT2_ATTRIBS*origVertices
445
                mesh.mVertAttribs1?.copyInto(newAttribs1, VERT1_ATTRIBS*(numVertices-1), w1, w1+VERT1_ATTRIBS)
446
                mesh.mVertAttribs2?.copyInto(newAttribs2, VERT2_ATTRIBS*(numVertices-1), w2, w2+VERT2_ATTRIBS)
447
                /*
418 448
                System.arraycopy(mesh.mVertAttribs1, VERT1_ATTRIBS*(numVertices-1), newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS)
419 449
                System.arraycopy(mesh.mVertAttribs2, VERT2_ATTRIBS*(numVertices-1), newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS)
450
                */
420 451
                origVertices++
421 452

  
422 453
                if (numVertices%2==1)
423 454
                {
455
                    val z1 = VERT1_ATTRIBS*origVertices
456
                    val z2 = VERT2_ATTRIBS*origVertices
457
                    mesh.mVertAttribs1?.copyInto(newAttribs1, VERT1_ATTRIBS*(numVertices-1), z1, z1+VERT1_ATTRIBS)
458
                    mesh.mVertAttribs2?.copyInto(newAttribs2, VERT2_ATTRIBS*(numVertices-1), z2, z2+VERT2_ATTRIBS)
459
                    /*
424 460
                    System.arraycopy(mesh.mVertAttribs1, VERT1_ATTRIBS*(numVertices-1), newAttribs1, VERT1_ATTRIBS*origVertices, VERT1_ATTRIBS)
425 461
                    System.arraycopy(mesh.mVertAttribs2, VERT2_ATTRIBS*(numVertices-1), newAttribs2, VERT2_ATTRIBS*origVertices, VERT2_ATTRIBS)
462
                    */
426 463
                    origVertices++
427 464
                }
428 465
            }
src/main/java/org/distorted/library/mesh/MeshCubes.kt
31 31
 */
32 32
class MeshCubes : MeshBase
33 33
{
34
    private class Edge
35
        (val side: Int, val row: Int, val col: Int)
34
    private class Edge(val side: Int, val row: Int, val col: Int)
36 35

  
37 36
    private var mTexMappingX: FloatArray? = null
38 37
    private var mTexMappingY: FloatArray? = null
......
48 47
    private var mEdges: ArrayList<Edge>? = ArrayList()
49 48

  
50 49
    private var currVert = 0
51
    override var numVertices: Int = 0
50
    private var numVertices = 0
52 51
    private var mSideBends = 0
53 52
    private var mEdgeNum = 0
54 53
    private var mSideWalls = 0
src/main/java/org/distorted/library/mesh/MeshMultigon.kt
258 258
                }
259 259
            }
260 260

  
261
            return MeshBandedTriangle.Companion.MODE_NORMAL
261
            return MeshBandedTriangle.MODE_NORMAL
262 262
        }
263 263
        else
264 264
        {
......
278 278
                normR[0] = 0f
279 279
                normR[1] = 1f
280 280

  
281
                return MeshBandedTriangle.Companion.MODE_FLAT
281
                return MeshBandedTriangle.MODE_FLAT
282 282
            }
283 283
            else
284 284
            {
......
301 301
                    normR[1] = dy
302 302
                }
303 303

  
304
                return MeshBandedTriangle.Companion.MODE_INVERTED
304
                return MeshBandedTriangle.MODE_INVERTED
305 305
            }
306 306
        }
307 307
    }
src/main/java/org/distorted/library/mesh/MeshPolygon.kt
33 33
 */
34 34
class MeshPolygon : MeshBase
35 35
{
36
    private var mPolygonVertices: Array<FloatArray>
36
    private lateinit var mPolygonVertices: Array<FloatArray>
37
    private lateinit var mPolygonBands: FloatArray
38
    private lateinit var mCurveCache: FloatArray
39

  
37 40
    private var mNumPolygonVertices = 0
38
    private var mPolygonBands: FloatArray
39 41
    private var mNumPolygonBands = 0
40

  
41 42
    private var remainingVert = 0
42
    override var numVertices: Int = 0
43
    private var numVertices = 0
43 44
    private var extraBand = 0
44 45
    private var extraVertices = 0
45 46

  
46
    private var mCurveCache: FloatArray
47

  
48 47
    companion object
49 48
    {
50 49
        private const val NUM_CACHE = 20
51 50
    }
51

  
52 52
    ///////////////////////////////////////////////////////////////////////////////////////////////////
53 53
    // polygonVertices>=3 , polygonBands>=2
54 54
    private fun computeNumberOfVertices()
src/main/java/org/distorted/library/mesh/MeshQuad.kt
21 21
package org.distorted.library.mesh
22 22

  
23 23
///////////////////////////////////////////////////////////////////////////////////////////////////
24

  
25 24
/**
26 25
 * Create a quad - two triangles with vertices at (+-0.5,+-0.5).
27 26
 *
src/main/java/org/distorted/library/mesh/MeshSphere.kt
36 36
class MeshSphere : MeshBase
37 37
{
38 38
    private var currentVert = 0
39
    override var numVertices: Int = 0
39
    private var numVertices = 0
40 40

  
41 41
    companion object
42 42
    {
src/main/java/org/distorted/library/mesh/MeshSquare.kt
34 34
    private var mCols = 0
35 35
    private var mRows = 0
36 36
    private var remainingVert = 0
37
    override var numVertices: Int = 0
37
    private var numVertices = 0
38 38

  
39 39
    ///////////////////////////////////////////////////////////////////////////////////////////////////
40 40
    // Create a flat, full grid.
src/main/java/org/distorted/library/mesh/MeshTriangle.kt
28 28
 */
29 29
class MeshTriangle : MeshBase
30 30
{
31
    override var numVertices: Int = 0
31
    private var numVertices = 0
32 32
    private var remainingVert = 0
33 33

  
34 34
    ///////////////////////////////////////////////////////////////////////////////////////////////////

Also available in: Unified diff