Revision c3a033e9
Added by Leszek Koltunski over 2 years ago
| src/main/java/org/distorted/objectlib/helpers/FactoryCubit.java | ||
|---|---|---|
| 34 | 34 |
|
| 35 | 35 |
import java.util.ArrayList; |
| 36 | 36 |
|
| 37 |
import static org.distorted.objectlib.main.TwistyObject.MESH_FAST; |
|
| 38 |
import static org.distorted.objectlib.main.TwistyObject.MESH_NICE; |
|
| 39 |
|
|
| 37 | 40 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 38 | 41 |
|
| 39 | 42 |
public class FactoryCubit |
| ... | ... | |
| 856 | 859 |
|
| 857 | 860 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 858 | 861 |
|
| 859 |
public MeshBase createRoundedSolid(final ObjectShape shape) |
|
| 862 |
public MeshBase createRoundedSolid(final ObjectShape shape, int meshState)
|
|
| 860 | 863 |
{
|
| 861 | 864 |
float[][] vertices = shape.getVertices(); |
| 862 | 865 |
int[][] vertIndexes = shape.getVertIndices(); |
| ... | ... | |
| 870 | 873 |
float[] convexityCenter = shape.getConvexityCenter(); |
| 871 | 874 |
|
| 872 | 875 |
return createRoundedSolid(vertices,vertIndexes,bands,bandIndexes,corners,cornerIndexes, |
| 873 |
centers,centerIndexes,numComponents,convexityCenter); |
|
| 876 |
centers,centerIndexes,numComponents,convexityCenter, meshState);
|
|
| 874 | 877 |
} |
| 875 | 878 |
|
| 876 | 879 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 879 | 882 |
final float[][] bands , final int[] bandIndexes, |
| 880 | 883 |
final float[][] corners , final int[] cornerIndexes, |
| 881 | 884 |
final float[][] centers , final int[] centerIndexes, |
| 882 |
final int numComponents , final float[] convexityCenter ) |
|
| 885 |
final int numComponents , final float[] convexityCenter, |
|
| 886 |
final int meshState ) |
|
| 883 | 887 |
{
|
| 884 | 888 |
int numFaces = vertIndexes.length; |
| 885 |
float[] band, bandsComputed; |
|
| 889 |
float[] band, bandsComputed=null;
|
|
| 886 | 890 |
MeshBase[] meshes = new MeshBase[numFaces]; |
| 887 | 891 |
FaceTransform fInfo; |
| 888 | 892 |
StickerCoords sInfo; |
| 889 | 893 |
float[] convexXY = new float[4]; |
| 894 |
int exIndex=0, exVertices=0; |
|
| 890 | 895 |
|
| 891 | 896 |
for(int face=0; face<numFaces; face++) |
| 892 | 897 |
{
|
| ... | ... | |
| 901 | 906 |
computeConvexityCenter(convexXY,convexityCenter,fInfo); |
| 902 | 907 |
|
| 903 | 908 |
band = bands[bandIndexes[face]]; |
| 904 |
bandsComputed = computeBands( band[0], (int)band[1], band[2], band[3], (int)band[4]); |
|
| 905 |
meshes[face] = new MeshPolygon(copiedVerts,bandsComputed,(int)band[5],(int)band[6], convexXY[0], convexXY[1]); |
|
| 909 |
|
|
| 910 |
switch(meshState) |
|
| 911 |
{
|
|
| 912 |
case MESH_NICE: // keep the original shape |
|
| 913 |
bandsComputed = computeBands( band[0], (int)band[1], band[2], band[3], (int)band[4]); |
|
| 914 |
exIndex = (int)band[5]; |
|
| 915 |
exVertices = (int)band[6]; |
|
| 916 |
break; |
|
| 917 |
case MESH_FAST: // reduce the number of vertices to minimum |
|
| 918 |
bandsComputed = computeBands(0,0,0,0,2); |
|
| 919 |
exIndex = 0; |
|
| 920 |
exVertices = 0; |
|
| 921 |
break; |
|
| 922 |
} |
|
| 923 |
|
|
| 924 |
meshes[face] = new MeshPolygon(copiedVerts,bandsComputed,exIndex,exVertices, convexXY[0], convexXY[1]); |
|
| 906 | 925 |
meshes[face].setEffectAssociation(0,(1<<face),0); |
| 907 | 926 |
} |
| 908 | 927 |
|
| ... | ... | |
| 932 | 951 |
mesh.apply(new MatrixEffectMove(move3D) ,assoc,-1); |
| 933 | 952 |
} |
| 934 | 953 |
|
| 935 |
prepareAndRoundCorners(mesh, vertices, corners, cornerIndexes, centers, centerIndexes); |
|
| 954 |
if( meshState==MESH_NICE ) |
|
| 955 |
{
|
|
| 956 |
prepareAndRoundCorners(mesh, vertices, corners, cornerIndexes, centers, centerIndexes); |
|
| 957 |
} |
|
| 936 | 958 |
|
| 937 | 959 |
correctComponents(mesh,numComponents); |
| 938 | 960 |
|
| src/main/java/org/distorted/objectlib/main/ObjectControl.java | ||
|---|---|---|
| 81 | 81 |
private boolean mIsLocked, mRemLocked; |
| 82 | 82 |
private final int[] mBuffer; |
| 83 | 83 |
private final float[] mAxis; |
| 84 |
private int mMeshState; |
|
| 84 | 85 |
|
| 85 | 86 |
private static final Static4D mQuat= new Static4D(-0.25189602f,0.3546389f,0.009657208f,0.90038127f); |
| 86 | 87 |
private static final Static4D mTemp= new Static4D(0,0,0,1); |
| ... | ... | |
| 532 | 533 |
mLastX = new float[NUM_SPEED_PROBES]; |
| 533 | 534 |
mLastY = new float[NUM_SPEED_PROBES]; |
| 534 | 535 |
mLastT = new long[NUM_SPEED_PROBES]; |
| 535 |
mFirstIndex =0; |
|
| 536 |
mLastIndex =0; |
|
| 536 |
mFirstIndex= 0; |
|
| 537 |
mLastIndex = 0; |
|
| 538 |
mMeshState =-1; |
|
| 537 | 539 |
|
| 538 | 540 |
DisplayMetrics dm = new DisplayMetrics(); |
| 539 | 541 |
act.getWindowManager().getDefaultDisplay().getMetrics(dm); |
| ... | ... | |
| 711 | 713 |
|
| 712 | 714 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 713 | 715 |
|
| 714 |
public void changeObject(int ordinal, InputStream jsonStream, InputStream meshStream) |
|
| 716 |
public void changeObject(int ordinal, int meshState, InputStream jsonStream, InputStream meshStream)
|
|
| 715 | 717 |
{
|
| 716 |
mPreRender.changeObject(ordinal, jsonStream, meshStream); |
|
| 718 |
mPreRender.changeObject(ordinal, meshState, jsonStream, meshStream);
|
|
| 717 | 719 |
} |
| 718 | 720 |
|
| 719 | 721 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 720 | 722 |
|
| 721 |
public void changeIfDifferent(int ordinal, InputStream jsonStream, InputStream meshStream) |
|
| 723 |
public void changeIfDifferent(int ordinal, int meshState, InputStream jsonStream, InputStream meshStream)
|
|
| 722 | 724 |
{
|
| 723 | 725 |
TwistyObject object = mPreRender.getObject(); |
| 724 | 726 |
ObjectType old = object==null ? null : object.getObjectType(); |
| 725 | 727 |
|
| 726 |
if( old==null || old.ordinal() != ordinal ) |
|
| 728 |
if( old==null || old.ordinal() != ordinal || mMeshState!=meshState )
|
|
| 727 | 729 |
{
|
| 728 |
mPreRender.changeObject(ordinal, jsonStream, meshStream); |
|
| 730 |
mMeshState = meshState; |
|
| 731 |
mPreRender.changeObject(ordinal, meshState, jsonStream, meshStream); |
|
| 729 | 732 |
} |
| 730 | 733 |
} |
| 731 | 734 |
|
| ... | ... | |
| 784 | 787 |
{
|
| 785 | 788 |
mPreRender.restorePreferences(preferences); |
| 786 | 789 |
} |
| 790 |
|
|
| 787 | 791 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 788 | 792 |
|
| 789 | 793 |
public boolean retLocked() |
| src/main/java/org/distorted/objectlib/main/ObjectPreRender.java | ||
|---|---|---|
| 64 | 64 |
private int mCubit, mFace, mNewColor; |
| 65 | 65 |
private int mNearestAngle; |
| 66 | 66 |
private long mDebugStartTime; |
| 67 |
private int mMeshState; |
|
| 67 | 68 |
|
| 68 | 69 |
// debugging only |
| 69 | 70 |
private long mAddRotationTime; |
| ... | ... | |
| 100 | 101 |
|
| 101 | 102 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 102 | 103 |
|
| 103 |
private void createObjectNow(int ordinal, InputStream jsonStream, InputStream meshStream) |
|
| 104 |
private void createObjectNow(int ordinal, int meshState, InputStream jsonStream, InputStream meshStream)
|
|
| 104 | 105 |
{
|
| 105 | 106 |
boolean firstTime = (mNewObject==null); |
| 106 | 107 |
|
| ... | ... | |
| 111 | 112 |
|
| 112 | 113 |
long time1 = System.currentTimeMillis(); |
| 113 | 114 |
|
| 114 |
if( jsonStream==null ) mNewObject = ObjectType.create( ordinal, quat, move, mScale, meshStream); |
|
| 115 |
else mNewObject = new TwistyJson( jsonStream, quat, move, mScale, meshStream); |
|
| 115 |
if( jsonStream==null ) mNewObject = ObjectType.create( ordinal, meshState, quat, move, mScale, meshStream);
|
|
| 116 |
else mNewObject = new TwistyJson( jsonStream, meshState, quat, move, mScale, meshStream);
|
|
| 116 | 117 |
|
| 117 | 118 |
long time2 = System.currentTimeMillis(); |
| 118 | 119 |
mInterface.onObjectCreated(time2-time1); |
| ... | ... | |
| 241 | 242 |
{
|
| 242 | 243 |
mChangeObject = false; |
| 243 | 244 |
blockEverything(BlockController.PLACE_1); |
| 244 |
createObjectNow(mOrdinal,mJsonStream,mMeshStream); |
|
| 245 |
createObjectNow(mOrdinal,mMeshState,mJsonStream,mMeshStream);
|
|
| 245 | 246 |
doEffectNow( BaseEffect.Type.SIZECHANGE ); |
| 246 | 247 |
} |
| 247 | 248 |
|
| ... | ... | |
| 411 | 412 |
|
| 412 | 413 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 413 | 414 |
|
| 414 |
public void changeObject(int ordinal, InputStream jsonStream, InputStream meshStream) |
|
| 415 |
public void changeObject(int ordinal, int meshState, InputStream jsonStream, InputStream meshStream)
|
|
| 415 | 416 |
{
|
| 416 | 417 |
mChangeObject = true; |
| 417 | 418 |
mOrdinal = ordinal; |
| 419 |
mMeshState = meshState; |
|
| 418 | 420 |
mJsonStream = jsonStream; |
| 419 | 421 |
mMeshStream = meshStream; |
| 420 | 422 |
} |
| src/main/java/org/distorted/objectlib/main/ObjectType.java | ||
|---|---|---|
| 144 | 144 |
|
| 145 | 145 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 146 | 146 |
|
| 147 |
public static TwistyObject create(int ordinal, Static4D quat, Static3D move, float scale, InputStream meshStream) |
|
| 147 |
public static TwistyObject create(int ordinal, int meshState, Static4D quat, Static3D move, float scale, InputStream meshStream)
|
|
| 148 | 148 |
{
|
| 149 | 149 |
int[] numL= objects[ordinal].mNumLayers; |
| 150 | 150 |
Class<? extends TwistyObject> clazz = objects[ordinal].mClass; |
| ... | ... | |
| 155 | 155 |
|
| 156 | 156 |
if( cons.length==1 ) |
| 157 | 157 |
{
|
| 158 |
Object[] parameters = new Object[] { numL,quat,move,scale,meshStream };
|
|
| 158 |
Object[] parameters = new Object[] { numL,meshState,quat,move,scale,meshStream };
|
|
| 159 | 159 |
return (TwistyObject)cons[0].newInstance(parameters); |
| 160 | 160 |
} |
| 161 | 161 |
else |
| src/main/java/org/distorted/objectlib/main/ShapeDodecahedron.java | ||
|---|---|---|
| 54 | 54 |
|
| 55 | 55 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 56 | 56 |
|
| 57 |
public ShapeDodecahedron(int[] numLayers, float realSize, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 57 |
public ShapeDodecahedron(int[] numLayers, int meshState, float realSize, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 58 | 58 |
{
|
| 59 |
super(numLayers, realSize, quat, move, scale, stream); |
|
| 59 |
super(numLayers, meshState, realSize, quat, move, scale, stream);
|
|
| 60 | 60 |
} |
| 61 | 61 |
|
| 62 | 62 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/main/ShapeHexahedron.java | ||
|---|---|---|
| 41 | 41 |
|
| 42 | 42 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 43 | 43 |
|
| 44 |
public ShapeHexahedron(int[] numLayers, float realSize, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 44 |
public ShapeHexahedron(int[] numLayers, int meshState, float realSize, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 45 | 45 |
{
|
| 46 |
super(numLayers, realSize, quat, move, scale, stream); |
|
| 46 |
super(numLayers, meshState, realSize, quat, move, scale, stream);
|
|
| 47 | 47 |
} |
| 48 | 48 |
|
| 49 | 49 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/main/ShapeOctahedron.java | ||
|---|---|---|
| 42 | 42 |
|
| 43 | 43 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 44 | 44 |
|
| 45 |
public ShapeOctahedron(int[] numLayers, float realSize, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 45 |
public ShapeOctahedron(int[] numLayers, int meshState, float realSize, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 46 | 46 |
{
|
| 47 |
super(numLayers, realSize, quat, move, scale, stream); |
|
| 47 |
super(numLayers, meshState, realSize, quat, move, scale, stream);
|
|
| 48 | 48 |
} |
| 49 | 49 |
|
| 50 | 50 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/main/ShapeTetrahedron.java | ||
|---|---|---|
| 40 | 40 |
|
| 41 | 41 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 42 | 42 |
|
| 43 |
public ShapeTetrahedron(int[] numLayers, float realSize, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 43 |
public ShapeTetrahedron(int[] numLayers, int meshState, float realSize, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 44 | 44 |
{
|
| 45 |
super(numLayers, realSize, quat, move, scale, stream); |
|
| 45 |
super(numLayers, meshState, realSize, quat, move, scale, stream);
|
|
| 46 | 46 |
} |
| 47 | 47 |
|
| 48 | 48 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/main/TwistyJson.java | ||
|---|---|---|
| 36 | 36 |
|
| 37 | 37 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 38 | 38 |
|
| 39 |
public TwistyJson(InputStream jsonStream, Static4D quat, Static3D move, float scale, InputStream meshStream) |
|
| 39 |
public TwistyJson(InputStream jsonStream, int meshState, Static4D quat, Static3D move, float scale, InputStream meshStream)
|
|
| 40 | 40 |
{
|
| 41 |
super(jsonStream, quat, move, scale, meshStream); |
|
| 41 |
super(jsonStream, meshState, quat, move, scale, meshStream);
|
|
| 42 | 42 |
} |
| 43 | 43 |
|
| 44 | 44 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/main/TwistyObject.java | ||
|---|---|---|
| 64 | 64 |
|
| 65 | 65 |
public abstract class TwistyObject |
| 66 | 66 |
{
|
| 67 |
public static final int MESH_NICE = 0; |
|
| 68 |
public static final int MESH_FAST = 1; |
|
| 69 |
|
|
| 67 | 70 |
public static final int COLOR_YELLOW = 0xffffff00; |
| 68 | 71 |
public static final int COLOR_WHITE = 0xffffffff; |
| 69 | 72 |
public static final int COLOR_BLUE = 0xff0000ff; |
| ... | ... | |
| 142 | 145 |
|
| 143 | 146 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 144 | 147 |
|
| 145 |
TwistyObject(InputStream jsonStream, Static4D quat, Static3D move, float scale, InputStream meshStream) |
|
| 148 |
TwistyObject(InputStream jsonStream, int meshState, Static4D quat, Static3D move, float scale, InputStream meshStream)
|
|
| 146 | 149 |
{
|
| 147 | 150 |
JsonReader reader = new JsonReader(); |
| 148 | 151 |
reader.parseJsonFile(jsonStream); |
| ... | ... | |
| 150 | 153 |
|
| 151 | 154 |
mNumLayers = reader.getNumLayers(); |
| 152 | 155 |
mSize = reader.getSize(); |
| 153 |
initialize(quat,move,scale,meshStream); |
|
| 156 |
initialize(meshState,quat,move,scale,meshStream);
|
|
| 154 | 157 |
} |
| 155 | 158 |
|
| 156 | 159 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 157 | 160 |
|
| 158 |
TwistyObject(int[] numLayers, float size, Static4D quat, Static3D move, float scale, InputStream meshStream) |
|
| 161 |
TwistyObject(int[] numLayers, int meshState, float size, Static4D quat, Static3D move, float scale, InputStream meshStream)
|
|
| 159 | 162 |
{
|
| 160 | 163 |
mNumLayers = numLayers; |
| 161 | 164 |
mSize = size; |
| 162 |
initialize(quat,move,scale,meshStream); |
|
| 165 |
initialize(meshState,quat,move,scale,meshStream);
|
|
| 163 | 166 |
} |
| 164 | 167 |
|
| 165 | 168 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 166 | 169 |
|
| 167 |
private void initialize(Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 170 |
private void initialize(int meshState,Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 168 | 171 |
{
|
| 169 | 172 |
mQuat = quat; |
| 170 | 173 |
mOrigPos = getCubitPositions(mNumLayers); |
| ... | ... | |
| 230 | 233 |
if( mNumTexCols*mNumTexRows < NUM_TEXTURES+1 ) mNumTexRows++; |
| 231 | 234 |
|
| 232 | 235 |
CUBITS = new Cubit[NUM_CUBITS]; |
| 233 |
createMeshAndCubits(stream); |
|
| 236 |
createMeshAndCubits(stream,meshState);
|
|
| 234 | 237 |
createDataStructuresForSolved(mNumLayers); |
| 235 | 238 |
|
| 236 | 239 |
mTexture = new DistortedTexture(); |
| ... | ... | |
| 278 | 281 |
|
| 279 | 282 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 280 | 283 |
|
| 281 |
private void createMeshAndCubits(InputStream stream) |
|
| 284 |
private void createMeshAndCubits(InputStream stream, int meshState)
|
|
| 282 | 285 |
{
|
| 283 |
if( stream!=null ) |
|
| 286 |
if( stream!=null && meshState==MESH_NICE )
|
|
| 284 | 287 |
{
|
| 285 | 288 |
DataInputStream dos = new DataInputStream(stream); |
| 286 | 289 |
mMesh = new MeshFile(dos); |
| ... | ... | |
| 309 | 312 |
for(int i=0; i<NUM_CUBITS; i++) |
| 310 | 313 |
{
|
| 311 | 314 |
CUBITS[i] = new Cubit(this,mOrigPos[i], NUM_AXIS); |
| 312 |
cubitMesh[i] = createCubitMesh(i,mNumLayers); |
|
| 315 |
cubitMesh[i] = createCubitMesh(i,mNumLayers,meshState);
|
|
| 313 | 316 |
Static3D pos = getPos(mOrigPos[i]); |
| 314 | 317 |
cubitMesh[i].apply(new MatrixEffectMove(pos),1,0); |
| 315 | 318 |
cubitMesh[i].setEffectAssociation(0, CUBITS[i].computeAssociation(), 0); |
| ... | ... | |
| 322 | 325 |
|
| 323 | 326 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 324 | 327 |
|
| 325 |
private MeshBase createCubitMesh(int cubit, int[] numLayers) |
|
| 328 |
private MeshBase createCubitMesh(int cubit, int[] numLayers, int meshState)
|
|
| 326 | 329 |
{
|
| 327 | 330 |
int variant = getCubitVariant(cubit,numLayers); |
| 328 | 331 |
|
| ... | ... | |
| 338 | 341 |
ObjectShape shape = getObjectShape(variant); |
| 339 | 342 |
FactoryCubit factory = FactoryCubit.getInstance(); |
| 340 | 343 |
factory.createNewFaceTransform(shape); |
| 341 |
mMeshes[variant] = factory.createRoundedSolid(shape); |
|
| 344 |
mMeshes[variant] = factory.createRoundedSolid(shape,meshState);
|
|
| 342 | 345 |
} |
| 343 | 346 |
|
| 344 | 347 |
MeshBase mesh = mMeshes[variant].copy(true); |
| src/main/java/org/distorted/objectlib/objects/TwistyBandaged2Bar.java | ||
|---|---|---|
| 31 | 31 |
|
| 32 | 32 |
public class TwistyBandaged2Bar extends TwistyBandagedAbstract |
| 33 | 33 |
{
|
| 34 |
public TwistyBandaged2Bar(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 34 |
public TwistyBandaged2Bar(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 35 | 35 |
{
|
| 36 |
super(numL, quat, move, scale, stream); |
|
| 36 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 37 | 37 |
} |
| 38 | 38 |
|
| 39 | 39 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyBandaged3Plate.java | ||
|---|---|---|
| 31 | 31 |
|
| 32 | 32 |
public class TwistyBandaged3Plate extends TwistyBandagedAbstract |
| 33 | 33 |
{
|
| 34 |
public TwistyBandaged3Plate(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 34 |
public TwistyBandaged3Plate(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 35 | 35 |
{
|
| 36 |
super(numL, quat, move, scale, stream); |
|
| 36 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 37 | 37 |
} |
| 38 | 38 |
|
| 39 | 39 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyBandagedAbstract.java | ||
|---|---|---|
| 70 | 70 |
|
| 71 | 71 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 72 | 72 |
|
| 73 |
TwistyBandagedAbstract(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 73 |
TwistyBandagedAbstract(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 74 | 74 |
{
|
| 75 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 75 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 76 | 76 |
} |
| 77 | 77 |
|
| 78 | 78 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyBandagedEvil.java | ||
|---|---|---|
| 31 | 31 |
|
| 32 | 32 |
public class TwistyBandagedEvil extends TwistyBandagedAbstract |
| 33 | 33 |
{
|
| 34 |
public TwistyBandagedEvil(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 34 |
public TwistyBandagedEvil(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 35 | 35 |
{
|
| 36 |
super(numL, quat, move, scale, stream); |
|
| 36 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 37 | 37 |
} |
| 38 | 38 |
|
| 39 | 39 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyBandagedFused.java | ||
|---|---|---|
| 31 | 31 |
|
| 32 | 32 |
public class TwistyBandagedFused extends TwistyBandagedAbstract |
| 33 | 33 |
{
|
| 34 |
public TwistyBandagedFused(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 34 |
public TwistyBandagedFused(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 35 | 35 |
{
|
| 36 |
super(numL, quat, move, scale, stream); |
|
| 36 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 37 | 37 |
} |
| 38 | 38 |
|
| 39 | 39 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyCuboid.java | ||
|---|---|---|
| 54 | 54 |
|
| 55 | 55 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 56 | 56 |
|
| 57 |
public TwistyCuboid(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 57 |
public TwistyCuboid(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 58 | 58 |
{
|
| 59 |
super(numL, (numL[0]+numL[1]+numL[2])/3.0f, quat, move, scale, stream); |
|
| 59 |
super(numL, meshState, (numL[0]+numL[1]+numL[2])/3.0f, quat, move, scale, stream);
|
|
| 60 | 60 |
} |
| 61 | 61 |
|
| 62 | 62 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyDiamond.java | ||
|---|---|---|
| 58 | 58 |
|
| 59 | 59 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 60 | 60 |
|
| 61 |
public TwistyDiamond(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 61 |
public TwistyDiamond(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 62 | 62 |
{
|
| 63 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 63 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 64 | 64 |
} |
| 65 | 65 |
|
| 66 | 66 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyDino.java | ||
|---|---|---|
| 55 | 55 |
|
| 56 | 56 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 57 | 57 |
|
| 58 |
TwistyDino(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 58 |
TwistyDino(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 59 | 59 |
{
|
| 60 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 60 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 61 | 61 |
} |
| 62 | 62 |
|
| 63 | 63 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyDino4.java | ||
|---|---|---|
| 35 | 35 |
|
| 36 | 36 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 37 | 37 |
|
| 38 |
public TwistyDino4(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 38 |
public TwistyDino4(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 39 | 39 |
{
|
| 40 |
super(numL, quat, move, scale, stream); |
|
| 40 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 41 | 41 |
} |
| 42 | 42 |
|
| 43 | 43 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyDino6.java | ||
|---|---|---|
| 35 | 35 |
|
| 36 | 36 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 37 | 37 |
|
| 38 |
public TwistyDino6(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 38 |
public TwistyDino6(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 39 | 39 |
{
|
| 40 |
super(numL, quat, move, scale, stream); |
|
| 40 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 41 | 41 |
} |
| 42 | 42 |
|
| 43 | 43 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyHelicopter.java | ||
|---|---|---|
| 61 | 61 |
|
| 62 | 62 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 63 | 63 |
|
| 64 |
public TwistyHelicopter(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 64 |
public TwistyHelicopter(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 65 | 65 |
{
|
| 66 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 66 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 67 | 67 |
} |
| 68 | 68 |
|
| 69 | 69 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyIvy.java | ||
|---|---|---|
| 60 | 60 |
|
| 61 | 61 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 62 | 62 |
|
| 63 |
public TwistyIvy(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 63 |
public TwistyIvy(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 64 | 64 |
{
|
| 65 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 65 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 66 | 66 |
} |
| 67 | 67 |
|
| 68 | 68 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyJing.java | ||
|---|---|---|
| 62 | 62 |
|
| 63 | 63 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 64 | 64 |
|
| 65 |
public TwistyJing(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 65 |
public TwistyJing(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 66 | 66 |
{
|
| 67 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 67 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 68 | 68 |
} |
| 69 | 69 |
|
| 70 | 70 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyKilominx.java | ||
|---|---|---|
| 41 | 41 |
|
| 42 | 42 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 43 | 43 |
|
| 44 |
public TwistyKilominx(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 44 |
public TwistyKilominx(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 45 | 45 |
{
|
| 46 |
super(numL, quat, move, scale, stream); |
|
| 46 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 47 | 47 |
} |
| 48 | 48 |
|
| 49 | 49 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyMegaminx.java | ||
|---|---|---|
| 42 | 42 |
|
| 43 | 43 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 44 | 44 |
|
| 45 |
public TwistyMegaminx(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 45 |
public TwistyMegaminx(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 46 | 46 |
{
|
| 47 |
super(numL, quat, move, scale, stream); |
|
| 47 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 48 | 48 |
} |
| 49 | 49 |
|
| 50 | 50 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 370 | 370 |
{
|
| 371 | 371 |
{-X1,+Y1*sinA, Y1*cosA},
|
| 372 | 372 |
{-X2,-Y2*sinA,-Y2*cosA},
|
| 373 |
{ 0 ,-R*sinA, -R*cosA},
|
|
| 373 |
{ 0 ,-R*sinA ,-R*cosA },
|
|
| 374 | 374 |
{+X2,-Y2*sinA,-Y2*cosA},
|
| 375 |
{+X1,+Y1*sinA, Y1*cosA}
|
|
| 375 |
{+X1,+Y1*sinA, Y1*cosA},
|
|
| 376 |
{ 0 , R*cosA ,-R*sinA }
|
|
| 376 | 377 |
}; |
| 377 | 378 |
|
| 378 | 379 |
int[][] vertIndexes = new int[][] |
| 379 | 380 |
{
|
| 380 | 381 |
{0,1,2,3,4},
|
| 381 |
{0,1,2,3,4}
|
|
| 382 |
{0,1,5},
|
|
| 383 |
{1,2,5},
|
|
| 384 |
{2,3,5},
|
|
| 385 |
{3,4,5},
|
|
| 386 |
{4,0,5}
|
|
| 382 | 387 |
}; |
| 383 | 388 |
|
| 384 | 389 |
int N = small ? 4 : 3; |
| ... | ... | |
| 389 | 394 |
{0.00f,45, R/3,0.2f,2,0,0}
|
| 390 | 395 |
}; |
| 391 | 396 |
|
| 392 |
int[] bandIndices = new int[] { 0,1 };
|
|
| 397 |
int[] bandIndices = new int[] { 0,1,1,1,1,1 };
|
|
| 393 | 398 |
float[][] corners = new float[][] { {0.04f,0.10f} };
|
| 394 |
int[] cornerIndices = new int[] { -1,-1,-1,-1, -1 };
|
|
| 399 |
int[] cornerIndices = new int[] { -1,-1,-1,-1, -1,-1 };
|
|
| 395 | 400 |
float[][] centers = new float[][] { {0.0f, 0.0f, 0.0f} };
|
| 396 |
int[] centerIndices = new int[] { -1,-1,-1,-1, -1 };
|
|
| 401 |
int[] centerIndices = new int[] { -1,-1,-1,-1, -1,-1 };
|
|
| 397 | 402 |
|
| 398 | 403 |
return new ObjectShape(vertices,vertIndexes,bands,bandIndices,corners,cornerIndices,centers,centerIndices,getNumCubitFaces(), null); |
| 399 | 404 |
} |
| src/main/java/org/distorted/objectlib/objects/TwistyMinx.java | ||
|---|---|---|
| 75 | 75 |
|
| 76 | 76 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 77 | 77 |
|
| 78 |
TwistyMinx(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 78 |
TwistyMinx(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 79 | 79 |
{
|
| 80 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 80 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 81 | 81 |
} |
| 82 | 82 |
|
| 83 | 83 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyMirror.java | ||
|---|---|---|
| 75 | 75 |
|
| 76 | 76 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 77 | 77 |
|
| 78 |
public TwistyMirror(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 78 |
public TwistyMirror(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 79 | 79 |
{
|
| 80 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 80 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 81 | 81 |
} |
| 82 | 82 |
|
| 83 | 83 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyPyraminx.java | ||
|---|---|---|
| 55 | 55 |
|
| 56 | 56 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 57 | 57 |
|
| 58 |
public TwistyPyraminx(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 58 |
public TwistyPyraminx(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 59 | 59 |
{
|
| 60 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 60 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 61 | 61 |
} |
| 62 | 62 |
|
| 63 | 63 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyRedi.java | ||
|---|---|---|
| 57 | 57 |
|
| 58 | 58 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 59 | 59 |
|
| 60 |
public TwistyRedi(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 60 |
public TwistyRedi(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 61 | 61 |
{
|
| 62 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 62 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 63 | 63 |
} |
| 64 | 64 |
|
| 65 | 65 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyRex.java | ||
|---|---|---|
| 58 | 58 |
|
| 59 | 59 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 60 | 60 |
|
| 61 |
public TwistyRex(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 61 |
public TwistyRex(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 62 | 62 |
{
|
| 63 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 63 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 64 | 64 |
} |
| 65 | 65 |
|
| 66 | 66 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistySkewb.java | ||
|---|---|---|
| 56 | 56 |
|
| 57 | 57 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 58 | 58 |
|
| 59 |
public TwistySkewb(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 59 |
public TwistySkewb(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 60 | 60 |
{
|
| 61 |
super(numL, 2*numL[0]-2, quat, move, scale, stream); |
|
| 61 |
super(numL, meshState, 2*numL[0]-2, quat, move, scale, stream);
|
|
| 62 | 62 |
} |
| 63 | 63 |
|
| 64 | 64 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistySquare.java | ||
|---|---|---|
| 53 | 53 |
|
| 54 | 54 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 55 | 55 |
|
| 56 |
TwistySquare(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 56 |
TwistySquare(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 57 | 57 |
{
|
| 58 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 58 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 59 | 59 |
} |
| 60 | 60 |
|
| 61 | 61 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistySquare1.java | ||
|---|---|---|
| 45 | 45 |
|
| 46 | 46 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 47 | 47 |
|
| 48 |
public TwistySquare1(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 48 |
public TwistySquare1(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 49 | 49 |
{
|
| 50 |
super(numL, quat, move, scale, stream); |
|
| 50 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 51 | 51 |
} |
| 52 | 52 |
|
| 53 | 53 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistySquare2.java | ||
|---|---|---|
| 45 | 45 |
|
| 46 | 46 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 47 | 47 |
|
| 48 |
public TwistySquare2(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 48 |
public TwistySquare2(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 49 | 49 |
{
|
| 50 |
super(numL, quat, move, scale, stream); |
|
| 50 |
super(numL, meshState, quat, move, scale, stream);
|
|
| 51 | 51 |
} |
| 52 | 52 |
|
| 53 | 53 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| src/main/java/org/distorted/objectlib/objects/TwistyUltimate.java | ||
|---|---|---|
| 66 | 66 |
|
| 67 | 67 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 68 | 68 |
|
| 69 |
public TwistyUltimate(int[] numL, Static4D quat, Static3D move, float scale, InputStream stream) |
|
| 69 |
public TwistyUltimate(int[] numL, int meshState, Static4D quat, Static3D move, float scale, InputStream stream)
|
|
| 70 | 70 |
{
|
| 71 |
super(numL, numL[0], quat, move, scale, stream); |
|
| 71 |
super(numL, meshState, numL[0], quat, move, scale, stream);
|
|
| 72 | 72 |
} |
| 73 | 73 |
|
| 74 | 74 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
Also available in: Unified diff
Introduce 'Simple' and 'Nice' meshes.