Revision dcf9de7b
Added by Leszek Koltunski 12 months ago
| src/main/java/org/distorted/objectlib/tablebases/TablebasesAbstract.java | ||
|---|---|---|
| 32 | 32 |
private final int mNumQuats; |
| 33 | 33 |
private final float[][] mCuts; |
| 34 | 34 |
private final int[] mNumCuts; |
| 35 |
private final int[][] mCubitRows; |
|
| 36 |
private final int[][] mCubitQuatMap; |
|
| 35 |
private final int[][][] mCubitQuatRows; |
|
| 37 | 36 |
private final float[][] mQuats; |
| 38 | 37 |
private final float[][] mPosition; |
| 39 | 38 |
|
| ... | ... | |
| 105 | 104 |
mScalingFactor = scaling; |
| 106 | 105 |
mRotRow = new int[mNumCubits][mNumAxis]; |
| 107 | 106 |
|
| 108 |
mCubitRows = new int[mNumCubits][mNumAxis]; |
|
| 109 |
mCubitQuatMap = new int[mNumCubits][mNumQuats]; |
|
| 107 |
mCubitQuatRows = new int[mNumCubits][mNumQuats][]; |
|
| 110 | 108 |
|
| 111 | 109 |
for(int i=0; i<mNumCubits; i++) |
| 112 |
{
|
|
| 113 |
computeInitRow(i,mCubitRows[i]); |
|
| 114 |
for(int j=0; j<mNumQuats; j++) mCubitQuatMap[i][j] = computeMap(i,j); |
|
| 115 |
} |
|
| 110 |
for(int j=0; j<mNumQuats; j++) mCubitQuatRows[i][j] = computeMap(i,j); |
|
| 116 | 111 |
|
| 117 | 112 |
mInitialized = false; |
| 118 | 113 |
} |
| ... | ... | |
| 149 | 144 |
|
| 150 | 145 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 151 | 146 |
|
| 152 |
private int computeMap(int cubit, int quat) |
|
| 147 |
private int[] computeMap(int cubit, int quat)
|
|
| 153 | 148 |
{
|
| 154 | 149 |
float[] pos = mPosition[cubit]; |
| 155 | 150 |
float[] q = mQuats[quat]; |
| 156 | 151 |
|
| 157 | 152 |
QuatHelper.rotateVectorByQuat(mTmp,pos[0],pos[1],pos[2],1.0f,q); |
| 158 |
float dist = Float.MAX_VALUE; |
|
| 159 |
int min = 0; |
|
| 160 |
|
|
| 161 |
for(int i=0; i<mNumCubits; i++) |
|
| 162 |
{
|
|
| 163 |
float[] p = mPosition[i]; |
|
| 164 |
float dx = p[0]-mTmp[0]; |
|
| 165 |
float dy = p[1]-mTmp[1]; |
|
| 166 |
float dz = p[2]-mTmp[2]; |
|
| 167 | 153 |
|
| 168 |
float d = dx*dx + dy*dy + dz*dz; |
|
| 169 |
|
|
| 170 |
if( d<dist ) |
|
| 171 |
{
|
|
| 172 |
dist = d; |
|
| 173 |
min = i; |
|
| 174 |
} |
|
| 175 |
} |
|
| 154 |
int[] output = new int[mNumAxis]; |
|
| 176 | 155 |
|
| 177 |
return min; |
|
| 178 |
} |
|
| 179 |
|
|
| 180 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 181 |
|
|
| 182 |
int computeBitLayer(int ax, int layer) |
|
| 183 |
{
|
|
| 184 |
return (1<<layer); |
|
| 185 |
} |
|
| 186 |
|
|
| 187 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 188 |
|
|
| 189 |
void computeInitRow(int cubit, int[] output) |
|
| 190 |
{
|
|
| 191 |
float[] pos = mPosition[cubit]; |
|
| 192 |
int num = output.length; |
|
| 193 |
|
|
| 194 |
for(int i=0; i<num; i++) |
|
| 156 |
for(int i=0; i<mNumAxis; i++) |
|
| 195 | 157 |
{
|
| 196 |
Static3D axis = mAxis[i];
|
|
| 197 |
float axisX = axis.get0();
|
|
| 198 |
float axisY = axis.get1();
|
|
| 199 |
float axisZ = axis.get2();
|
|
| 200 |
float casted = pos[0]*axisX + pos[1]*axisY + pos[2]*axisZ;
|
|
| 158 |
Static3D ax = mAxis[i]; |
|
| 159 |
float axisX = ax.get0(); |
|
| 160 |
float axisY = ax.get1(); |
|
| 161 |
float axisZ = ax.get2(); |
|
| 162 |
float casted = mTmp[0]*axisX + mTmp[1]*axisY + mTmp[2]*axisZ;
|
|
| 201 | 163 |
output[i] = computeSingleRow(i,casted); |
| 202 | 164 |
} |
| 165 |
|
|
| 166 |
return output; |
|
| 203 | 167 |
} |
| 204 | 168 |
|
| 205 | 169 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| ... | ... | |
| 216 | 180 |
return (1<<num); |
| 217 | 181 |
} |
| 218 | 182 |
|
| 183 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
| 184 |
|
|
| 185 |
int computeBitLayer(int ax, int layer) |
|
| 186 |
{
|
|
| 187 |
return (1<<layer); |
|
| 188 |
} |
|
| 189 |
|
|
| 219 | 190 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
| 220 | 191 |
|
| 221 | 192 |
int[] computeRow(int cubit, int quat) |
| 222 | 193 |
{
|
| 223 |
int newPos = mCubitQuatMap[cubit][quat]; |
|
| 224 |
return mCubitRows[newPos]; |
|
| 194 |
return mCubitQuatRows[cubit][quat]; |
|
| 225 | 195 |
} |
| 226 | 196 |
|
| 227 | 197 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
Also available in: Unified diff
Correct a subtle bug: the way we were computing the cached Rows was incorrect in case of Pyraminx, because its initial positions of all of its edge and octa cubits are the same, and initial quats are non-zero.