/ - Diff - Distorted Android

           MeshBase mesh = node.getMesh();
           DistortedEffects effects = node.getEffects();
           float halfW = effects.getStartchX() / 2.0f;
           float halfH = effects.getStartchY() / 2.0f;
           float halfZ = effects.getStartchZ() / 2.0f;
           float halfW = mesh.getStretchX() / 2.0f;
           float halfH = mesh.getStretchY() / 2.0f;
           float halfZ = mesh.getStretchZ() / 2.0f;
           int width   = buffer.getWidth();
           int height  = buffer.getHeight();

       private long mID;
       private EffectQueue[] mQueues;
       private int[] mStretchX, mStretchY, mStretchZ;
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * @y.exclude
-...
     /**
      * Create empty effect queue.
      */
       public DistortedEffects(int stretchX, int stretchY, int stretchZ)
+        {
         mStretchX = new int[1];
         mStretchY = new int[1];
         mStretchZ = new int[1];
         mStretchX[0] = stretchX;
         mStretchY[0] = stretchY;
         mStretchZ[0] = stretchZ;
         mID = ++mNextID;
         mQueues = new EffectQueue[EffectType.LENGTH];
         EffectQueue.allocateQueues(mQueues,null,0);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Temporary constructor.
      */
      public DistortedEffects(int dummy)
      public DistortedEffects()
+        {
         mStretchX = new int[1];
         mStretchY = new int[1];
         mStretchZ = new int[1];
         mStretchX[0] = 1;
         mStretchY[0] = 1;
         mStretchZ[0] = 1;
         mID = ++mNextID;
         mQueues = new EffectQueue[EffectType.LENGTH];
         EffectQueue.allocateQueues(mQueues,null,0);
-...
      */
       public DistortedEffects(DistortedEffects dc, int flags)
+        {
         mStretchX = dc.mStretchX;
         mStretchY = dc.mStretchY;
         mStretchZ = dc.mStretchZ;
         mID = ++mNextID;
         mQueues = new EffectQueue[EffectType.LENGTH];
         EffectQueue.allocateQueues(mQueues,dc.getQueues(),flags);
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the stretch parameters. Coordinates of all vertices of any Mesh rendered with those Effects
      * will be first pre-multiplied by those.
      */
       public void setStretch(int sx, int sy, int sz)
+        {
         mStretchX[0] = sx;
         mStretchY[0] = sy;
         mStretchZ[0] = sz;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * X coordinates of all vertices of any Mesh rendered with those Effects will be first pre-multiplied
      * by this parameter.
      */
       public int getStartchX()
+        {
         return mStretchX[0];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Y coordinates of all vertices of any Mesh rendered with those Effects will be first pre-multiplied
      * by this parameter.
      */
       public int getStartchY()
+        {
         return mStretchY[0];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Z coordinates of all vertices of any Mesh rendered with those Effects will be first pre-multiplied
      * by this parameter.
      */
       public int getStartchZ()
+        {
         return mStretchZ[0];
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Returns unique ID of this instance.

       static void drawPrivOIT(DistortedEffects effects, MeshBase mesh, InternalOutputSurface surface, long currTime)
+        {
         float halfX = effects.getStartchX() / 2.0f;
         float halfY = effects.getStartchY() / 2.0f;
         float halfZ = effects.getStartchZ() / 2.0f;
         float halfX = mesh.getStretchX() / 2.0f;
         float halfY = mesh.getStretchY() / 2.0f;
         float halfZ = mesh.getStretchZ() / 2.0f;
         EffectQueue[] queues = effects.getQueues();
-...
       static void drawPriv(DistortedEffects effects, MeshBase mesh, InternalOutputSurface surface, long currTime)
+        {
         float halfX = effects.getStartchX() / 2.0f;
         float halfY = effects.getStartchY() / 2.0f;
         float halfZ = effects.getStartchZ() / 2.0f;
         float halfX = mesh.getStretchX() / 2.0f;
         float halfY = mesh.getStretchY() / 2.0f;
         float halfZ = mesh.getStretchZ() / 2.0f;
         EffectQueue[] queues = effects.getQueues();

src/main/java/org/distorted/library/main/DistortedNode.java
240	240
241	241	private DistortedFramebuffer allocateNewFBO()
242	242	{
243		int width = mFboW <= 0 ? mEffects.getStartchX() : mFboW;
244		int height = mFboH <= 0 ? mEffects.getStartchY() : mFboH;
	243	int width = mFboW <= 0 ? (int)mMesh.getStretchX() : mFboW;
	244	int height = mFboH <= 0 ? (int)mMesh.getStretchY() : mFboH;
245	245	return new DistortedFramebuffer(1,mFboDepthStencil, InternalSurface.TYPE_TREE, width, height);
246	246	}
247	247

           fpsTexture = new DistortedTexture();
           fpsTexture.setTexture(fpsBitmap);
           fpsCanvas = new Canvas(fpsBitmap);
           fpsEffects = new DistortedEffects(FPS_W,FPS_H,0);
           fpsEffects = new DistortedEffects();
           fpsMesh.setStretch(FPS_W,FPS_H,0);
           fpsEffects.apply(mMoveEffect);
           mPaint = new Paint();

        private int mNumVertices;
        private float[] mVertAttribs;      // packed: PosX,PosY,PosZ, NorX,NorY,NorZ, InfX,InfY,InfZ, TexS,TexT
        private float mInflate;
        private float mStretchX, mStretchY, mStretchZ;
        private class Component
+         {
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
        MeshBase()
        MeshBase(float width, float height, float depth)
+         {
          mStretchX = width;
          mStretchY = height;
          mStretchZ = depth;
          mShowNormals = false;
          mInflate     = 0.0f;
          mComponent = new ArrayList<>();
-...
        MeshBase(MeshBase original)
+         {
          mStretchX = original.mStretchX;
          mStretchY = original.mStretchY;
          mStretchZ = original.mStretchZ;
          mShowNormals = original.mShowNormals;
          mInflate     = original.mInflate;
-...
          return mNumVertices;
+         }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Sets the stretch parameters. Coordinates of all vertices will be first pre-multiplied by those.
      */
       public void setStretch(int sx, int sy, int sz)
+        {
         mStretchX = sx;
         mStretchY = sy;
         mStretchZ = sz;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * X coordinates of all vertices will be first pre-multiplied by this parameter.
      */
       public float getStretchX()
+        {
         return mStretchX;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Y coordinates of all vertices will be first pre-multiplied by this parameter.
      */
       public float getStretchY()
+        {
         return mStretchY;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Z coordinates of all vertices will be first pre-multiplied by this parameter.
      */
       public float getStretchZ()
+        {
         return mStretchZ;
+        }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     /**
      * Not part of public API, do not document (public only because has to be used from the main package)

      */
      public MeshCubes(int cols, String desc, int slices)
+       {
        super(1,1,1);
        Static4D map = new Static4D(0.0f,0.0f,1.0f,1.0f);
        fillTexMappings(map,map,map,map,map,map);
        prepareDataStructures(cols,desc,slices);
-...
      */
      public MeshCubes(int cols, String desc, int slices, Static4D front, Static4D back, Static4D left, Static4D right, Static4D top, Static4D bottom)
+       {
        super(1,1,1);
        fillTexMappings(front,back,left,right,top,bottom);
        prepareDataStructures(cols,desc,slices);
        build();
-...
      */
      public MeshCubes(int cols, int rows, int slices)
+       {
        super(1,1,1);
        Static4D map = new Static4D(0.0f,0.0f,1.0f,1.0f);
        fillTexMappings(map,map,map,map,map,map);
        prepareDataStructures(cols,rows,slices);
-...
      */
      public MeshCubes(int cols, int rows, int slices, Static4D front, Static4D back, Static4D left, Static4D right, Static4D top, Static4D bottom)
+       {
        super(1,1,1);
        fillTexMappings(front,back,left,right,top,bottom);
        prepareDataStructures(cols,rows,slices);
        build();

src/main/java/org/distorted/library/mesh/MeshQuad.java
56	56	*/
57	57	public MeshQuad()
58	58	{
	59	super(1,1,0);
59	60	float[] attribs= new float[VERT_ATTRIBS*4];
60	61
61	62	addVertex(0.0f,0.0f, attribs,0);

src/main/java/org/distorted/library/mesh/MeshRectangles.java
158	158	*/
159	159	public MeshRectangles(int cols, int rows)
160	160	{
	161	super(1,1,0);
161	162	computeNumberOfVertices(cols,rows);
162	163
163	164	float[] attribs= new float[VERT_ATTRIBS*numVertices];

src/main/java/org/distorted/library/mesh/MeshSphere.java
253	253	*/
254	254	public MeshSphere(int level)
255	255	{
	256	super(1,1,1);
256	257	computeNumberOfVertices(level);
257	258	float[] attribs= new float[VERT_ATTRIBS*numVertices];
258	259

Project

General

Profile

Distorted Android

Revision 044b5494

Added by Leszek Koltunski about 4 years ago