/ - Diff - TwistyPuzzleLib - Distorted Android

         float quotient = radius/(float)Math.sqrt(vX*vX + vY*vY);
         float ret = computeAngle(vX,-vY)-computeQuotientOfCurvature(quotient,curvature);
         if( ret>=2*PI ) ret -= 2*PI;
         if( ret<0     ) ret += 2*PI;
         while( ret>=2*PI ) ret -= 2*PI;
         while( ret<0     ) ret += 2*PI;
         return ret;
+        }
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
       private void drawRoundCorner(Canvas canvas, Paint paint,int color, int left, int bottom, float stroke,
                                   float radius, float cX, float cY, float pA, float cA)
       private void drawRoundCorner(Canvas canvas, Paint paint, int color, int left, int bottom,
                                    float stroke, float radius, float cX, float cY, float pA, float cA)
+        {
         final float A = 4.0f;
         cX = (0.5f+cX)*mTexHeight;
         cY = (0.5f-cY)*mTexHeight;
         float R = radius*mTexHeight + stroke/2;
         float r = radius*mTexHeight + stroke/2;    // distance from the center of the circle arc of
                                                    // which we are drawing to the center of the edge line
         float R = radius*mTexHeight + A*stroke/2;  // distance from the center of the circle to the center
                                                    // of the arc being drawn; the arc is A times thicker.
         boolean isConvex = ((pA<cA && cA<pA+PI) || (pA<cA+2*PI && cA+2*PI<pA+PI));
         float startA, stopA, centerA, alpha, D;
-...
           float diff = cA-centerA;
           if( diff<0 ) diff += 2*PI;
           alpha = diff> PI/2 ? PI-diff : diff;
           D = (float)(R/Math.sin(alpha));
           D = (float)(r/Math.sin(alpha));
+          }
         else
+          {
-...
           float diff = centerA-cA;
           if( diff<0 ) diff += 2*PI;
           alpha = diff> PI/2 ? PI-diff : diff;
           D = (float)((R-stroke)/Math.sin(alpha));
           D = (float)((r-stroke)/Math.sin(alpha));
+          }
         float sweepA = startA-stopA;
-...
         sweepA *= 180/PI;
         if( !isConvex ) paint.setColor(color);
         paint.setStrokeWidth(A*stroke);
         canvas.drawArc( left+oX-R, bottom-oY-R, left+oX+R, bottom-oY+R, startA, sweepA, false, paint);
         if( !isConvex ) paint.setColor(COLOR_STROKE);
+        }
-...
     // TODO: this doesn't really support proper drawing of rounded corners in case two neighbouring
     // strokes are not equal to each other.
       private void drawEdge(Canvas canvas, Paint paint, int left, int bottom, int color,
                             float[] strokes, float[][] vertices, float[] angles, float[] radii )
       private void drawEdge(Canvas canvas, Paint paint, int left, int bottom, int color, float[] strokes,
                             float[][] vertices, float[] angles, float[] radii, float borders, float corners )
+        {
         int length = vertices.length;
-...
         for(int vert=0; vert<length; vert++)
+          {
           float stroke = strokes[vert]*mTexHeight;
           float stroke = borders*strokes[vert]*mTexHeight;
           if( stroke>0 )
+            {
-...
         for(int vert=0; vert<length; vert++)
+          {
           float stroke = strokes[vert]*mTexHeight;
           paint.setStrokeWidth(stroke);
           float stroke = borders*strokes[vert]*mTexHeight;
           int prev = vert==0 ? length-1 : vert-1;
           float prevAngle = computeSideAngle(currX-prevX,currY-prevY,radii[prev],-prevA);
           float currAngle = computeSideAngle(nextX-currX,nextY-currY,radii[vert],+currA);
           float rp = radii[prev]*corners;
           float rv = radii[vert]*corners;
           float prevAngle = computeSideAngle(currX-prevX,currY-prevY,rp,-prevA);
           float currAngle = computeSideAngle(nextX-currX,nextY-currY,rv,+currA);
           if( radii[vert]>0 && stroke>0 )
             drawRoundCorner(canvas,paint,color,left,bottom,stroke,radii[vert],currX,currY,prevAngle,currAngle);
           if( rv>0 && stroke>0 )
             drawRoundCorner(canvas,paint,color,left,bottom,stroke,rv,currX,currY,prevAngle,currAngle);
           prevX = currX;
           prevY = currY;
-...
     ///////////////////////////////////////////////////////////////////////////////////////////////////
     // PUBLIC
       public void drawRoundedPolygons(Canvas canvas, Paint paint, int left, int bottom, int color, int height, ObjectSticker sticker)
       public void drawRoundedPolygons(Canvas canvas, Paint paint, int left, int bottom, int color,
                                       int height, ObjectSticker sticker, float borders, float corners)
+        {
         mTexHeight = height;
-...
         for(int l=0; l<numLoops; l++)
+          {
           float[] ang = (angles==null? null : angles[l]);
           drawEdge(canvas, paint, left, bottom, color, strokes[l], vertices[l], ang, radii[l]);
           drawEdge(canvas, paint, left, bottom, color, strokes[l], vertices[l], ang, radii[l], borders, corners);
+          }
         canvas.restore();

           mPreRender.resetAllTextureMaps();
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public void recreateSticker(float borders, float corners)
+          {
           TwistyObject object = mPreRender.getObject();
           object.createTexture(borders,corners);
           object.setTexture();
+          }
     ///////////////////////////////////////////////////////////////////////////////////////////////////
         public TwistyObject getObject()

src/main/java/org/distorted/objectlib/main/ObjectPreRender.java
37	37	private TwistyObject mOldObject, mNewObject;
38	38	private OperatingSystemInterface mOS;
39	39	private MovesFinished mAddActionListener;
40		// private final BlockController mBlockController;
41	40	private final ObjectLibInterface mInterface;
42	41	private String mDebug;
43	42	private float mMoveX, mMoveY;

src/main/java/org/distorted/objectlib/main/TwistyObject.java
1614	1614	///////////////////////////////////////////////////////////////////////////////////////////////////
1615	1615	// the getFaceColors + final INTERNAL_COLOR in a grid (so that we do not exceed the maximum texture size)
1616	1616
1617		private void createTexture()
	1617	void createTexture(float borders, float corners)
1618	1618	{
1619	1619	Paint paint = new Paint();
1620		mBitmap = Bitmap.createBitmap( mNumTexColsmTexHeight, mNumTexRowsmTexHeight, Bitmap.Config.ARGB_4444);
1621	1620	Canvas canvas = new Canvas(mBitmap);
1622	1621
1623	1622	paint.setAntiAlias(true);
...	...
1636	1635	{
1637	1636	ObjectSticker sticker = retSticker(texture/mNumFaceColors);
1638	1637	int color = getColor(texture%mNumFaceColors);
1639		factory.drawRoundedPolygons(canvas, paint, colmTexHeight, (mNumTexRows-row)mTexHeight, color, mTexHeight, sticker);
	1638	factory.drawRoundedPolygons(canvas, paint, colmTexHeight, (mNumTexRows-row)mTexHeight, color, mTexHeight, sticker,borders,corners);
1640	1639	}
1641	1640	else if( texture>mNumTextures-mNumOverrides && texture<=mNumTextures )
1642	1641	{
...	...
1652	1651
1653	1652	void setTexture()
1654	1653	{
1655		if( mBitmap==null ) createTexture();
	1654	if( mBitmap==null )
	1655	{
	1656	mBitmap = Bitmap.createBitmap( mNumTexColsmTexHeight, mNumTexRowsmTexHeight, Bitmap.Config.ARGB_4444);
	1657	createTexture(1.0f,1.0f);
	1658	}
1656	1659
1657	1660	if( !mTexture.setTextureAlreadyInverted(mBitmap) )
1658	1661	{

Project

General

Profile

TwistyPuzzleLib

Revision 352bd362

Added by Leszek Koltunski over 1 year ago