Distorted Android

  private static final int JOB_TYPE_CENTER   = 8;

    private float mX,mY,mZ;

    Job(int type, MeshBase target, MeshBase[] source, VertexEffect vEff, MatrixEffect mEff, Static4D[] maps, int comp, int and, int equ, float x, float y, float z)

      mX        = x;

      mY        = y;

      mZ        = z;

        case JOB_TYPE_CENTER   : mTarget.setComponentCenterNow(mComp,mX,mY,mZ);

                                 break;

        case JOB_TYPE_CENTER   : return "CENTER";

      Job job = new Job(JOB_TYPE_VERTEX,target,null,effect,null,null,0,0,0,0,0,0);

        Job job = new Job(JOB_TYPE_VERTEX,target,null,effect,null,null,0,0,0,0,0,0);

    Job job = new Job(JOB_TYPE_MATRIX,target,null,null,effect,null,0,andAssoc,ecuAssoc,0,0,0);

    Job job = new Job(JOB_TYPE_MERGE_TEX,target,null,null,null,null,0,0,0,0,0,0);

    Job job = new Job(JOB_TYPE_MERGE_EFF,target,null,null,null,null,0,0,0,0,0,0);

    Job job = new Job(JOB_TYPE_JOIN,target,meshes,null,null,null,0,0,0,0,0,0);

    Job job = new Job(JOB_TYPE_COPY,target,meshes,null,null,null,0,0,0,0,0,0);

    Job job = new Job(JOB_TYPE_TEXTURE,target,null,null,null,maps,comp,0,0,0,0,0);

    Job job = new Job(JOB_TYPE_ASSOC,target,null,null,null,null,comp,andAssoc,equAssoc,0,0,0);

    JobNode node = new JobNode(job);

    node.mPrevJobs.add(jn);

    jn.mNextJobs.add(node);

    mJobs.add(node);

    return node;

    }

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

  static JobNode componentCenter(MeshBase target, int comp, float x, float y, float z)

    {

    JobNode jn = target.mJobNode[0];

    Job job = new Job(JOB_TYPE_CENTER,target,null,null,null,null,comp,0,0,x,y,z);

   void setComponentCenterNow(int component, float x, float y, float z)

         DataOutputStream dos = new DataOutputStream(new java.io.FileOutputStream(name));

       catch(java.io.FileNotFoundException ex)

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

     // read version, number of vertices, number of tex components, number of effect components

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

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

     // read contents of all texture and effect components

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

       int vert1InFile = version==2 ? VERT1_ATTRIBS : VERT1_ATTRIBS+3;

       // ... and there was no center.

       int centerSize  = version==2 ? 3*numEff : 0;

       buffer = new byte[BYTES_PER_FLOAT*(size + centerSize + mNumVertices*(vert1InFile+VERT2_ATTRIBS))];

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

       // read vert1 array, vert2 array and (if version>1) the component centers.

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

       switch(version)

         {

         case 1 : index = floatBuf.position();

                  for(int vert=0; vert<mNumVertices; vert++)

                    {

                    mVertAttribs1[VERT1_ATTRIBS*vert+POS_ATTRIB  ] = floatBuf.get(index+POS_ATTRIB  );

                    mVertAttribs1[VERT1_ATTRIBS*vert+POS_ATTRIB+1] = floatBuf.get(index+POS_ATTRIB+1);

                    mVertAttribs1[VERT1_ATTRIBS*vert+POS_ATTRIB+2] = floatBuf.get(index+POS_ATTRIB+2);

                    mVertAttribs1[VERT1_ATTRIBS*vert+NOR_ATTRIB  ] = floatBuf.get(index+NOR_ATTRIB  );

                    mVertAttribs1[VERT1_ATTRIBS*vert+NOR_ATTRIB+1] = floatBuf.get(index+NOR_ATTRIB+1);

                    mVertAttribs1[VERT1_ATTRIBS*vert+NOR_ATTRIB+2] = floatBuf.get(index+NOR_ATTRIB+2);

                    index+=vert1InFile;

                    }

                  floatBuf.position(index);

                  break;

         case 2 : float[] centers = new float[3*numEff];

                  floatBuf.get(centers,0,3*numEff);

                  for(int eff=0; eff<numEff; eff++)

                    {

                    mUBC.setEffectCenterNow(eff, centers[3*eff], centers[3*eff+1], centers[3*eff+2]);

                    }

                  floatBuf.get(mVertAttribs1, 0, VERT1_ATTRIBS*mNumVertices);

                  break;

         default: android.util.Log.e("mesh", "Error: unknown mesh file version "+String.format("0x%08X", version));

                  return 0;

         }

       floatBuf.get(mVertAttribs2, 0, VERT2_ATTRIBS*mNumVertices);

       float[] centers = mUBC.getBackingArray();

       for(int i=0; i<numEff; i++)

         {

         stream.writeFloat(centers[4*i  ]);

         stream.writeFloat(centers[4*i+1]);

         stream.writeFloat(centers[4*i+2]);

         }

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

/**

 * Set center of a Component.

 *

 * A 'center' of a (effect) component is a 3D point in space. The array of centers gets sent to

 * the vertex shader as a Uniform Buffer Object; in the vertex shader we can then use it to compute

 * the 'Inflation' of the whole Mesh per-component. 'Inflation' is needed by postprocess effects to

 * add the 'halo' around an object.

 *

 * This is all 'per-component' so that a user has a chance to make the halo look right in case of

 * non-convex meshes: then we need to ensure that each component of such a mesh is a convex

 * sub-mesh with its center being more-or-less the center of gravity of the sub-mesh.

 */

   public void setComponentCenter(int component, float centerX, float centerY, float centerZ)

     {

     if( component>=0 && component<MAX_EFFECT_COMPONENTS )

       {

       if( mJobNode[0]==null )

         {

         setComponentCenterNow(component, centerX, centerY, centerZ);

         }

       else

         {

         mJobNode[0] = DeferredJobs.componentCenter(this,component,centerX, centerY, centerZ);

         }

       }

     }

  void setEffectCenterNow(int comp, float x, float y, float z)

    {

    mCenter[4*comp  ] = x;

    mCenter[4*comp+1] = y;

    mCenter[4*comp+2] = z;

    mUBO.invalidate();

    }

  int getIndex()

    {

    return mUBO.createImmediatelyFloat( BLOCK_SIZE, mCenter);

    }

  void copy(int compTo, UniformBlockCenter blockFrom, int compFrom)

    {

    mCenter[4*compTo  ] = blockFrom.mCenter[4*compFrom  ];

    mCenter[4*compTo+1] = blockFrom.mCenter[4*compFrom+1];

    mCenter[4*compTo+2] = blockFrom.mCenter[4*compFrom+2];

    }

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

  float[] getBackingArray()

    {

    return mCenter;

    }