Distorted Android

abstract class MeshBase

{

    var showNormals: Boolean // when rendering this mesh, draw normal vectors?

    private var mTFO: InternalBuffer // main vertex buffer and transform feedback buffer

    private var numVertices: Int = 0

    private var mVertAttribs1: FloatArray? = null // packed: PosX,PosY,PosZ, NorX,NorY,NorZ

        private const val OFFSET_TEX = TEX_ATTRIB*BYTES_PER_FLOAT

        private const val OFFSET_COM = COM_ATTRIB*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 mAssocBlockIndex = IntArray(EffectQueue.MAIN_VARIANTS)

        private const val TEX_COMP_SIZE = 5 // 5 four-byte entities inside the component

        }

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    internal constructor()

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    private fun shallowCopy(original: MeshBase)

    {

        mTexComponent = ArrayList()

        for (i in 0 until texComSize)

        {

        }

        mEffComponent = ArrayList()

        mVBO2 = InternalBuffer(GLES30.GL_ARRAY_BUFFER, GLES30.GL_STATIC_DRAW)

        mVertAttribs2 = original.mVertAttribs2?.copyOf()

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    fun mergeTexComponentsNow()

    {

        if (num>1)

        {

        }

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    fun addEmptyTexComponentNow()

    {

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    fun mergeEffComponentsNow()

    {

        if (num>1)

        {

            for (index in 0 until numVertices)

            {

                mVertAttribs2!![VERT2_ATTRIBS*index+COM_ATTRIB] = 0f

            }

        }

    }

        val uniforms = FloatArray(7)

        var start: Int

        var end = -1

        matrixP[15] = 1f

        matrixP[10] = matrixP[15]

        matrixV[15] = 1f

        matrixV[10] = matrixV[15]

        effect.compute(uniforms, 0, 0, 0)

        effect.apply(matrixP, matrixV, uniforms, 0)

        for (comp in 0 until numComp)

        {

            start = end+1

            if (mUBA.matchesAssociation(comp, andAssoc, equAssoc))

            {

            }

        }

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    // when a derived class is done computing its mesh, it has to call this method.

    {

        numVertices = vert1Attribs.size/VERT1_ATTRIBS

        mVertAttribs1 = vert1Attribs

        mVertAttribs2 = vert2Attribs

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

        if (origVertices>0)

        {

            numVertices += (if (numVertices%2==1) 2 else 1)

        }

        for (i in 0 until numMeshes)

        {

            mesh = meshes[i]

            numVert = mesh.numVertices

            val extraVerticesBefore = if (numVertices==0) 0 else 1

            for (j in 0 until numTexComponents)

            {

                comp.mEndIndex += (extraVerticesBefore+numVertices)

                if (j==numTexComponents-1) comp.mEndIndex += extraVerticesAfter

            }

            for (j in 0 until numEffComponents)

            {

                index += (extraVerticesBefore+numVertices)

                if (j==numEffComponents-1) index += extraVerticesAfter

                if (origEffComponents<maxEffComponents)

                {

        var endIndex: Int

        var index = 0

        for (component in 0 until numEffComp)

        {

            while (index<=endIndex)

            {

        mVertAttribs1 = newAttribs1

        mVertAttribs2 = newAttribs2

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    fun textureMap(maps: Array<Static4D?>, startComponent: Int)

    {

        if (startComponent>num_comp) return

        val num_maps = maps.size

        val min = min((num_comp-startComponent).toDouble(), num_maps.toDouble()).toInt()

        var newMap: Static4D?

        var oldMap: Static4D

        var comp: TexComponent

        for (i in 0 until min)

        {

            newMap = maps[i]

            if (newMap!=null)

            {

                    var index = vertex*VERT2_ATTRIBS+TEX_ATTRIB

                    while (vertex<=comp.mEndIndex)

                    {

                        mVertAttribs2!![index+1] = ratH*mVertAttribs2!![index+1]+movY

                        vertex++

                        index += VERT2_ATTRIBS

            vertex = comp.mEndIndex+1

        }

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

        val feedback = buffer.order(ByteOrder.nativeOrder()).asFloatBuffer()

        feedback[mVertAttribs1, 0, VERT1_ATTRIBS*numVertices]

        GLES30.glUnmapBuffer(GLES30.GL_TRANSFORM_FEEDBACK_BUFFER)

    }

     */

    fun printTexComponent(comp: Int)

    {

        {

            val sb = StringBuilder()

            for (vert in beg..end)

        for (i in 0 until num)

        {

            sb.append("\n")

            while (vert<=end)

    {

        if (mJobNode[0]!=null) mJobNode[0]!!.execute() // this will set itself to null

        val attr = program.mAttribute

        when (program.mAttributeLayout)

                tex = TexComponent(index)

                tex.setMap(Static4D(x, y, z, w))

                texComp++

            }

            for (effComp in 0 until numEff)

            {

                index = tmp[TEX_COMP_SIZE*texComp+effComp].toInt()

            }

            //////////////////////////////////////////////////////////////////////////////////////////

                    var vert = 0

                    while (vert<numVertices)

                    {

                        mVertAttribs1!![VERT1_ATTRIBS*vert+POS_ATTRIB+1] = floatBuf[index+POS_ATTRIB+1]

                        mVertAttribs1!![VERT1_ATTRIBS*vert+POS_ATTRIB+2] = floatBuf[index+POS_ATTRIB+2]

                        mVertAttribs1!![VERT1_ATTRIBS*vert+NOR_ATTRIB+1] = floatBuf[index+NOR_ATTRIB+1]

                        mVertAttribs1!![VERT1_ATTRIBS*vert+NOR_ATTRIB+2] = floatBuf[index+NOR_ATTRIB+2]

                        index += vert1InFile

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    fun getLastVertexEff(effComponent: Int): Int

    {

        {

        }

        return 0

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    fun getLastVertexTex(texComponent: Int): Int

    {

        {

        }

        return 0

    {

        var tex: TexComponent

        try

        {

            for (i in 0 until numTex)

            {

                stream.writeFloat(tex.mEndIndex.toFloat())

                stream.writeFloat(tex.mTextureMap.get0())

            for (i in 0 until numEff)

            {

            }

            val centers = if (useCenters) mUBC!!.backingArray else FloatArray(4*numEff)

     */

    fun mergeTexComponents()

    {

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

     */

    fun mergeEffComponents()

    {

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    /**

     * Return the number of vertices in this Mesh.

        mVertAttribs1 = null

        mVertAttribs2 = null

        mTFO.markForDeletion()

        mUBA.markForDeletion()

     */

    fun apply(effect: MatrixEffect, andAssoc: Int, equAssoc: Int)

    {

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

     */

    fun apply(effect: VertexEffect)

    {

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

     */

    fun setTextureMap(maps: Array<Static4D?>, startComponent: Int)

    {

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

     */

    fun getTextureMap(component: Int): Static4D?

    {

    }

    ///////////////////////////////////////////////////////////////////////////////////////////////////

     *

     * @return The number of Texture Components of this Mesh.

     */

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    /**

     *

     * @return The number of Effect Components of this Mesh.

     */

    ///////////////////////////////////////////////////////////////////////////////////////////////////

    /**