commit 7edab735b0162362ac4bdf683fed7420dc69486f Author: Leszek Koltunski Date: Tue Oct 13 13:32:13 2020 +0100 Some improvements to MeshFile. diff --git a/src/main/java/org/distorted/examples/meshfile/CubitFactory.java b/src/main/java/org/distorted/examples/meshfile/CubitFactory.java new file mode 100644 index 0000000..94b0666 --- /dev/null +++ b/src/main/java/org/distorted/examples/meshfile/CubitFactory.java @@ -0,0 +1,1161 @@ +/////////////////////////////////////////////////////////////////////////////////////////////////// +// Copyright 2020 Leszek Koltunski // +// // +// This file is part of Magic Cube. // +// // +// Magic Cube is free software: you can redistribute it and/or modify // +// it under the terms of the GNU General Public License as published by // +// the Free Software Foundation, either version 2 of the License, or // +// (at your option) any later version. // +// // +// Magic Cube is distributed in the hope that it will be useful, // +// but WITHOUT ANY WARRANTY; without even the implied warranty of // +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // +// GNU General Public License for more details. // +// // +// You should have received a copy of the GNU General Public License // +// along with Magic Cube. If not, see . // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.examples.meshfile; + +import org.distorted.library.effect.VertexEffect; +import org.distorted.library.effect.VertexEffectDeform; +import org.distorted.library.effect.VertexEffectMove; +import org.distorted.library.effect.VertexEffectRotate; +import org.distorted.library.effect.VertexEffectScale; +import org.distorted.library.mesh.MeshBase; +import org.distorted.library.mesh.MeshJoined; +import org.distorted.library.mesh.MeshPolygon; +import org.distorted.library.type.Static1D; +import org.distorted.library.type.Static3D; +import org.distorted.library.type.Static4D; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class CubitFactory + { + private static final float SQ2 = (float)Math.sqrt(2); + private static final float SQ3 = (float)Math.sqrt(3); + private static final float SQ6 = (float)Math.sqrt(6); + + private static final Static1D RADIUS = new Static1D(1); + + private static CubitFactory mThis; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private CubitFactory() + { + + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static CubitFactory getInstance() + { + if( mThis==null ) mThis = new CubitFactory(); + + return mThis; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// +// H - height of the band in the middle +// alpha - angle of the edge [0,90] +// dist - often in a polygon the distance from edge to center is not 1, but something else. +// This is the distance. +// K - where to begin the second, much more flat part of the band. [0,1] +// N - number of bands. N>=3 +// +// theory: two distinct parts to the band: +// 1) (0,B) - steep +// 2) (B,1) - flat +// +// In first part, we have y = g(x) ; in second - y = g(f(x)) where +// +// g(x) = sqrt( R^2 - (x-D)^2 ) - R*cos(alpha) +// f(x) = ((D-B)/(1-B)*x + B*(1-D)/(1-B) +// h(x) = R*(sin(alpha) - sin(x)) +// R = H/(1-cos(alpha)) +// D = H*sin(alpha) +// B = h(K*alpha) +// +// The N points are taken at: +// +// 1) in the second part, there are K2 = (N-3)/3 such points +// 2) in the first - K1 = (N-3) - K2 +// 3) also, the 3 points 0,B,1 +// +// so we have the sequence A[i] of N points +// +// 0 +// h((i+1)*(1-K)*alpha/(K1+1)) (i=0,1,...,K1-1) +// B +// (1-B)*(i+1)/(K2+1) + B (i=0,i,...,K2-1) +// 1 + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float f(float D, float B, float x) + { + return ((D-B)*x + B*(1-D))/(1-B); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float g(float R, float D, float x, float cosAlpha) + { + float d = x-D; + return (float)(Math.sqrt(R*R-d*d)-R*cosAlpha); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float h(float R, float sinAlpha, float x) + { + return R*(sinAlpha-(float)Math.sin(x)); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float[] computeBands(float H, int alpha, float dist, float K, int N) + { + float[] bands = new float[2*N]; + + bands[0] = 1.0f; + bands[1] = 0.0f; + + float beta = (float)Math.atan(dist*Math.tan(Math.PI*alpha/180)); + float sinBeta = (float)Math.sin(beta); + float cosBeta = (float)Math.cos(beta); + float R = cosBeta<1.0f ? H/(1.0f-cosBeta) : 0.0f; + float D = R*sinBeta; + float B = h(R,sinBeta,K*beta); + + if( D>1.0f ) + { + for(int i=1; i. // +/////////////////////////////////////////////////////////////////////////////////////////////////// + +package org.distorted.examples.meshfile; + +import android.graphics.Bitmap; +import android.graphics.Canvas; +import android.graphics.Paint; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + +public class TextureFactory + { + static final int COLOR_BLACK = 0xff000000; + static final int TEXTURE_HEIGHT = 256; + + private static TextureFactory mThis; + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private TextureFactory() + { + + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + public static TextureFactory getInstance() + { + if( mThis==null ) mThis = new TextureFactory(); + + return mThis; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private float computeAngle(float dx, float dy) + { + float PI = (float)Math.PI; + double angle = Math.atan2(dy,dx); + float ret = (float)(3*PI/2-angle); + + if( ret>2*PI ) ret-= 2*PI; + + return ret; + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + private void drawCurrVertex(Canvas canvas, Paint paint, float left, float r, float stroke, float pX, float pY, float cX, float cY, float nX, float nY) + { + pX = (0.5f+pX)*TEXTURE_HEIGHT; + pY = (0.5f-pY)*TEXTURE_HEIGHT; + cX = (0.5f+cX)*TEXTURE_HEIGHT; + cY = (0.5f-cY)*TEXTURE_HEIGHT; + nX = (0.5f+nX)*TEXTURE_HEIGHT; + nY = (0.5f-nY)*TEXTURE_HEIGHT; + + canvas.drawLine(left+pX,pY,left+cX,cY,paint); + + float aX = pX-cX; + float aY = pY-cY; + float bX = cX-nX; + float bY = cY-nY; + + float aLen = (float)Math.sqrt(aX*aX+aY*aY); + float bLen = (float)Math.sqrt(bX*bX+bY*bY); + + aX /= aLen; + aY /= aLen; + bX /= bLen; + bY /= bLen; + + float sX = (aX-bX)/2; + float sY = (aY-bY)/2; + float sLen = (float)Math.sqrt(sX*sX+sY*sY); + sX /= sLen; + sY /= sLen; + + float startAngle = computeAngle(bX,-bY); + float endAngle = computeAngle(aX,-aY); + float sweepAngle = endAngle-startAngle; + if( sweepAngle<0 ) sweepAngle += 2*Math.PI; + + float R = r*TEXTURE_HEIGHT+stroke/2; + + float A = (float)(R/(Math.cos(sweepAngle/2))); + + float rX = cX + A*sX; + float rY = cY + A*sY; + + startAngle *= 180/(Math.PI); + sweepAngle *= 180/(Math.PI); + + canvas.drawArc( left+rX-R, rY-R, left+rX+R, rY+R, startAngle, sweepAngle, false, paint); + } + +/////////////////////////////////////////////////////////////////////////////////////////////////// + + void drawRoundedPolygon(Canvas canvas, Paint paint, int left, float[] vertices, float stroke, int color, float r) + { + stroke *= TEXTURE_HEIGHT; + + paint.setAntiAlias(true); + paint.setStrokeWidth(stroke); + paint.setColor(color); + paint.setStyle(Paint.Style.FILL); + + canvas.drawRect(left,0,left+TEXTURE_HEIGHT,TEXTURE_HEIGHT,paint); + + paint.setColor(COLOR_BLACK); + paint.setStyle(Paint.Style.STROKE); + + int length = vertices.length; + int numVertices = length/2; + + float prevX = vertices[length-2]; + float prevY = vertices[length-1]; + float currX = vertices[0]; + float currY = vertices[1]; + float nextX = vertices[2]; + float nextY = vertices[3]; + + for(int vert=0; vert