/**
* @param id
* @param data @Info Stocke le FloatBuffer dans le GPU
*/
public void bufferData() {
buffer = BufferUtils.createFloatBuffer(floatlist.size());
for (Float f : floatlist) {
buffer.put(f);
}
buffer.flip();
glBindBuffer(GL_ARRAY_BUFFER, vboID);
glBufferData(GL_ARRAY_BUFFER, buffer, GL_STATIC_DRAW);
// glBufferSubData(vboID, 0, buffer);
glBindBuffer(GL_ARRAY_BUFFER, 0);
bufferSize = buffer.limit() / 7; // 7 = 3 vertex(x,y,z) + 4 color (r,g,b,a)
}
/**
* 描画用オブジェクト情報を作成する
*
* @param mqoMats MQOファイルから読み込んだマテリアル情報配列
* @param mqoObjs MQOファイルのオブジェクト情報
* @return 描画用オブジェクト情報
*/
private GLObject makeObjs(GL10 gl, material mqoMats[], objects mqoObjs) {
GLObject ret = null;
ArrayList<GLMaterial> mats = new ArrayList<GLMaterial>();
GLMaterial mr;
KGLPoint[] vn = null;
vn = vNormal(mqoObjs);
for (int m = 0; m < mqoMats.length; m++) {
mr = makeMats(gl, mqoMats[m], m, mqoObjs, vn);
if (mr != null) {
mats.add(mr);
}
}
if (mats.size() == 0) return null;
ret = new GLObject();
ret.name = mqoObjs.name;
ret.mat = mats.toArray(new GLMaterial[0]);
ret.isVisible = (mqoObjs.data.visible != 0);
return ret;
}
protected synchronized Message receiveMessage() throws IOException {
if (messageBuffer.size() > 0) {
Message m = (Message) messageBuffer.get(0);
messageBuffer.remove(0);
return m;
}
try {
InetSocketAddress remoteAddress = (InetSocketAddress) channel.receive(receiveBuffer);
if (remoteAddress != null) {
int len = receiveBuffer.position();
receiveBuffer.rewind();
receiveBuffer.get(buf, 0, len);
try {
IP address = IP.fromInetAddress(remoteAddress.getAddress());
int port = remoteAddress.getPort();
extractor.appendData(buf, 0, len, new SocketDescriptor(address, port));
receiveBuffer.clear();
extractor.updateAvailableMessages();
return extractor.nextMessage();
} catch (EOFException exc) {
exc.printStackTrace();
System.err.println(buf.length + ", " + len);
} catch (InvocationTargetException exc) {
exc.printStackTrace();
} catch (IllegalAccessException exc) {
exc.printStackTrace();
} catch (InstantiationException exc) {
exc.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvalidCompressionMethodException e) {
e.printStackTrace();
}
}
} catch (ClosedChannelException exc) {
if (isKeepAlive()) {
throw exc;
}
}
return null;
}
void removeUnboundConnections() {
if (UnboundConnections.size() == 0) {
return;
}
ArrayList<Long> currentUnboundConnections = UnboundConnections;
// fix concurrent modification exception
UnboundConnections = new ArrayList<Long>();
for (long b : currentUnboundConnections) {
EventableChannel ec = Connections.remove(b);
if (ec != null) {
if (ProxyConnections != null) {
ProxyConnections.remove(b);
}
eventCallback(b, EM_CONNECTION_UNBOUND, null);
ec.close();
EventableSocketChannel sc = (EventableSocketChannel) ec;
if (sc != null && sc.isAttached()) DetachedConnections.add(sc);
}
}
}
void checkIO() {
long timeout;
if (NewConnections.size() > 0) {
timeout = -1;
} else if (!Timers.isEmpty()) {
long now = new Date().getTime();
long k = Timers.firstKey();
long diff = k - now;
if (diff <= 0) timeout = -1; // don't wait, just poll once
else timeout = diff;
} else {
timeout = 0; // wait indefinitely
}
try {
if (timeout == -1) mySelector.selectNow();
else mySelector.select(timeout);
} catch (IOException e) {
e.printStackTrace();
}
}
String[] getPluginDirectories() {
ArrayList<String> directories = new ArrayList<String>();
PackageManager pm = this.mAppContext.getPackageManager();
List<ResolveInfo> plugins =
pm.queryIntentServices(
new Intent(PLUGIN_ACTION), PackageManager.GET_SERVICES | PackageManager.GET_META_DATA);
synchronized (mPackageInfoCache) {
// clear the list of existing packageInfo objects
mPackageInfoCache.clear();
for (ResolveInfo info : plugins) {
// retrieve the plugin's service information
ServiceInfo serviceInfo = info.serviceInfo;
if (serviceInfo == null) {
Log.w(LOGTAG, "Ignore bad plugin");
continue;
}
Log.w(LOGTAG, "Loading plugin: " + serviceInfo.packageName);
// retrieve information from the plugin's manifest
PackageInfo pkgInfo;
try {
pkgInfo =
pm.getPackageInfo(
serviceInfo.packageName,
PackageManager.GET_PERMISSIONS | PackageManager.GET_SIGNATURES);
} catch (Exception e) {
Log.w(LOGTAG, "Can't find plugin: " + serviceInfo.packageName);
continue;
}
if (pkgInfo == null) {
Log.w(
LOGTAG,
"Loading plugin: "
+ serviceInfo.packageName
+ ". Could not load package information.");
continue;
}
/*
* find the location of the plugin's shared library. The default
* is to assume the app is either a user installed app or an
* updated system app. In both of these cases the library is
* stored in the app's data directory.
*/
String directory = pkgInfo.applicationInfo.dataDir + "/lib";
final int appFlags = pkgInfo.applicationInfo.flags;
final int updatedSystemFlags =
ApplicationInfo.FLAG_SYSTEM | ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
// preloaded system app with no user updates
if ((appFlags & updatedSystemFlags) == ApplicationInfo.FLAG_SYSTEM) {
directory = PLUGIN_SYSTEM_LIB + pkgInfo.packageName;
}
// check if the plugin has the required permissions
String permissions[] = pkgInfo.requestedPermissions;
if (permissions == null) {
Log.w(
LOGTAG,
"Loading plugin: "
+ serviceInfo.packageName
+ ". Does not have required permission.");
continue;
}
boolean permissionOk = false;
for (String permit : permissions) {
if (PLUGIN_PERMISSION.equals(permit)) {
permissionOk = true;
break;
}
}
if (!permissionOk) {
Log.w(
LOGTAG,
"Loading plugin: "
+ serviceInfo.packageName
+ ". Does not have required permission (2).");
continue;
}
// check to ensure the plugin is properly signed
Signature signatures[] = pkgInfo.signatures;
if (signatures == null) {
Log.w(LOGTAG, "Loading plugin: " + serviceInfo.packageName + ". Not signed.");
continue;
}
// determine the type of plugin from the manifest
if (serviceInfo.metaData == null) {
Log.e(LOGTAG, "The plugin '" + serviceInfo.name + "' has no type defined");
continue;
}
String pluginType = serviceInfo.metaData.getString(PLUGIN_TYPE);
if (!TYPE_NATIVE.equals(pluginType)) {
Log.e(LOGTAG, "Unrecognized plugin type: " + pluginType);
continue;
}
try {
Class<?> cls = getPluginClass(serviceInfo.packageName, serviceInfo.name);
// TODO implement any requirements of the plugin class here!
boolean classFound = true;
if (!classFound) {
Log.e(
LOGTAG,
"The plugin's class' "
+ serviceInfo.name
+ "' does not extend the appropriate class.");
continue;
}
} catch (NameNotFoundException e) {
Log.e(LOGTAG, "Can't find plugin: " + serviceInfo.packageName);
continue;
} catch (ClassNotFoundException e) {
Log.e(LOGTAG, "Can't find plugin's class: " + serviceInfo.name);
continue;
}
// if all checks have passed then make the plugin available
mPackageInfoCache.add(pkgInfo);
directories.add(directory);
}
}
return directories.toArray(new String[directories.size()]);
}
/**
* 描画用マテリアル情報をMQOデータから作成
*
* @param mqomat MQOファイルから読み込んだマテリアル情報
* @param i_mqomat MQOファイルのマテリアル番号
* @param mqoObjs MQOファイルのオブジェクト情報
* @param vn 頂点法線配列
* @return 描画用マテリアル情報
*/
private GLMaterial makeMats(
GL10 gl, material mqomat, int i_mqomat, objects mqoObjs, KGLPoint[] vn) {
GLMaterial ret = new GLMaterial();
ArrayList<KGLPoint> apv = new ArrayList<KGLPoint>();
ArrayList<KGLPoint> apn = new ArrayList<KGLPoint>();
ArrayList<KGLPoint> apuv = new ArrayList<KGLPoint>();
ArrayList<KGLPoint> apc = new ArrayList<KGLPoint>();
KGLPoint wpoint = null;
boolean uvValid = false;
boolean colValid = false;
KGLPoint fn;
float s;
for (int f = 0; f < mqoObjs.face.length; f++) {
if (mqoObjs.face[f].M == null) {
continue;
}
if (mqoObjs.face[f].M != i_mqomat) continue;
fn =
calcNormal(
mqoObjs.vertex, mqoObjs.face[f].V[0], mqoObjs.face[f].V[1], mqoObjs.face[f].V[2]);
for (int v = 0; v < 3; v++) {
apv.add(mqoObjs.vertex[mqoObjs.face[f].V[v]]);
// apv.add(new KGLPoint(mqoObjs.vertex[mqoObjs.face[f].V[v]])) ;
s =
(float)
Math.acos(
fn.X() * vn[mqoObjs.face[f].V[v]].X()
+ fn.Y() * vn[mqoObjs.face[f].V[v]].Y()
+ fn.Z() * vn[mqoObjs.face[f].V[v]].Z());
if (mqoObjs.data.facet < s) {
apn.add(fn);
} else {
apn.add(vn[mqoObjs.face[f].V[v]]);
}
wpoint = new KGLPoint(2);
if (mqoObjs.face[f].UV == null) {
wpoint.set_UV(0, 0);
} else {
wpoint.set_UV(mqoObjs.face[f].UV[v * 2 + 0], mqoObjs.face[f].UV[v * 2 + 1]);
uvValid = true;
}
apuv.add(wpoint);
wpoint = new KGLPoint(4);
if (mqoObjs.face[f].COL == null) {
if (mqomat.data.col == null) {
wpoint.set_COLOR(1.0f, 1.0f, 1.0f, 1.0f);
} else {
wpoint.set_COLOR(
mqomat.data.col[0], mqomat.data.col[1], mqomat.data.col[2], mqomat.data.col[3]);
}
} else {
wpoint.set_COLOR(
mqoObjs.face[f].COL[v * 4 + 0],
mqoObjs.face[f].COL[v * 4 + 1],
mqoObjs.face[f].COL[v * 4 + 2],
mqoObjs.face[f].COL[v * 4 + 3]);
colValid = true;
}
apc.add(wpoint);
}
}
ret.texID = texPool.getGLTexture(gl, mqomat.data.tex, mqomat.data.aplane, false);
// @@@ reload 用
if (ret.texID != 0) {
ret.texName = mqomat.data.tex;
ret.alphaTexName = mqomat.data.aplane;
} else {
ret.texName = null;
ret.alphaTexName = null;
}
if (apv.size() == 0) return null;
uvValid &= (ret.texID != 0);
ret.name = mqomat.name;
// uvValid = false ;
KGLPoint[] wfv = null;
KGLPoint[] wfn = null;
KGLPoint[] wft = null;
KGLPoint[] wfc = null;
wfv = apv.toArray(new KGLPoint[0]);
wfn = apn.toArray(new KGLPoint[0]);
wft = apuv.toArray(new KGLPoint[0]);
wfc = apc.toArray(new KGLPoint[0]);
ret.vertex_num = wfv.length;
// @@@ interleaveFormat は無いので分ける
ret.uvValid = uvValid;
ret.colValid = colValid;
ret.vertexBuffer = ByteBuffer.allocateDirect(ret.vertex_num * 3 * 4);
ret.vertexBuffer.order(ByteOrder.nativeOrder());
ret.vertexBuffer.position(0);
ret.normalBuffer = ByteBuffer.allocateDirect(ret.vertex_num * 3 * 4);
ret.normalBuffer.order(ByteOrder.nativeOrder());
ret.normalBuffer.position(0);
if (uvValid) {
ret.uvBuffer = ByteBuffer.allocateDirect(ret.vertex_num * 2 * 4);
ret.uvBuffer.order(ByteOrder.nativeOrder());
ret.uvBuffer.position(0);
}
if (colValid) {
ret.colBuffer = ByteBuffer.allocateDirect(ret.vertex_num * 4 * 4);
ret.colBuffer.order(ByteOrder.nativeOrder());
ret.colBuffer.position(0);
}
// Log.i("KGLMetaseq", "vertex_num: "+ ret.vertex_num);
for (int v = 0; v < ret.vertex_num; v++) {
ret.vertexBuffer.putFloat(wfv[v].X());
ret.vertexBuffer.putFloat(wfv[v].Y());
ret.vertexBuffer.putFloat(wfv[v].Z());
ret.normalBuffer.putFloat(wfn[v].X());
ret.normalBuffer.putFloat(wfn[v].Y());
ret.normalBuffer.putFloat(wfn[v].Z());
if (uvValid) {
ret.uvBuffer.putFloat(wft[v].U());
ret.uvBuffer.putFloat(wft[v].V());
}
if (colValid) {
ret.colBuffer.putFloat(wfc[v].R());
ret.colBuffer.putFloat(wfc[v].G());
ret.colBuffer.putFloat(wfc[v].B());
ret.colBuffer.putFloat(wfc[v].A());
}
}
if (mqomat.data.col != null) {
ret.color = new float[mqomat.data.col.length];
for (int c = 0; c < mqomat.data.col.length; c++) {
ret.color[c] = mqomat.data.col[c];
}
if (mqomat.data.dif != null) {
ret.dif = new float[mqomat.data.col.length];
for (int c = 0; c < mqomat.data.col.length; c++) {
ret.dif[c] = mqomat.data.dif * mqomat.data.col[c];
}
// KEICHECK difでアルファ値を１未満にすると透明度が変化する？
ret.dif[3] = mqomat.data.col[3];
}
if (mqomat.data.amb != null) {
ret.amb = new float[mqomat.data.col.length];
for (int c = 0; c < mqomat.data.col.length; c++) {
ret.amb[c] = mqomat.data.amb * mqomat.data.col[c];
}
}
if (mqomat.data.emi != null) {
ret.emi = new float[mqomat.data.col.length];
for (int c = 0; c < mqomat.data.col.length; c++) {
ret.emi[c] = mqomat.data.emi * mqomat.data.col[c];
}
}
if (mqomat.data.spc != null) {
ret.spc = new float[mqomat.data.col.length];
for (int c = 0; c < mqomat.data.col.length; c++) {
ret.spc[c] = mqomat.data.spc * mqomat.data.col[c];
}
}
}
if (mqomat.data.pow != null) {
ret.power = new float[1];
ret.power[0] = mqomat.data.pow;
}
ret.shadeMode_IsSmooth = true; // defaultはtrue
if (mqoObjs.data.shading == 0) ret.shadeMode_IsSmooth = false;
return ret;
}
/**
* faceチャンクの読み込み
*
* @param br 読み込みストリーム
* @return 面配列
* @throws Exception
*/
private Face[] readFace(multiInput br) throws Exception {
ArrayList<Face> qf;
String line = null;
String[] s;
Integer Mn;
Face[] wface = null;
int p;
int pe;
qf = new ArrayList<Face>();
try {
while ((line = br.readLine()) != null) {
if (line.length() <= 0) continue;
line = line.trim();
if (line.equals("}")) break;
wface = null;
Mn = null;
p = line.indexOf("M(");
if (p != -1) {
pe = line.indexOf(")", p);
Mn = Integer.parseInt(line.substring(p + 2, pe));
}
p = line.indexOf("V(");
if (p == -1) continue;
pe = line.indexOf(")", p);
s = line.substring(p + 2, pe).split(" ");
if (s.length == 3) {
wface = new Face[1];
wface[0] = new Face();
wface[0].V = new Integer[3];
wface[0].V[0] = Integer.parseInt(s[0]);
wface[0].V[1] = Integer.parseInt(s[1]);
wface[0].V[2] = Integer.parseInt(s[2]);
wface[0].M = Mn;
p = line.indexOf("UV(");
if (p != -1) {
pe = line.indexOf(")", p);
s = line.substring(p + 3, pe).split(" ");
if (s.length != 2 * 3) throw new Exception("UVの数が不正");
wface[0].UV = new Float[2 * 3];
for (int i = 0; i < s.length; i++) {
wface[0].UV[i] = Float.parseFloat(s[i]);
}
}
p = line.indexOf("COL(");
if (p != -1) {
pe = line.indexOf(")", p);
s = line.substring(p + 4, pe).split(" ");
if (s.length != 3) throw new Exception("COLの数が不正");
wface[0].COL = new Float[4 * 3];
long wl;
float wf;
for (int i = 0; i < s.length; i++) {
wl = Long.parseLong(s[i]);
wf = (wl >>> 0) & 0x000000ff;
wface[0].COL[i * 4 + 0] = wf / 255f;
wf = (wl >>> 8) & 0x000000ff;
wface[0].COL[i * 4 + 1] = wf / 255f;
wf = (wl >>> 16) & 0x000000ff;
wface[0].COL[i * 4 + 2] = wf / 255f;
wf = (wl >>> 24) & 0x000000ff;
wface[0].COL[i * 4 + 3] = wf / 255f;
}
}
}
// 頂点配列はすべて三角にするので、四角は三角ｘ２に分割
// 0 3 0 0 3
// □ → △ ▽
// 1 2 1 2 2
if (s.length == 4) {
wface = new Face[2];
wface[0] = new Face();
wface[1] = new Face();
wface[0].V = new Integer[3];
wface[0].V[0] = Integer.parseInt(s[0]);
wface[0].V[1] = Integer.parseInt(s[1]);
wface[0].V[2] = Integer.parseInt(s[2]);
wface[0].M = Mn;
wface[1].V = new Integer[3];
wface[1].V[0] = Integer.parseInt(s[0]);
wface[1].V[1] = Integer.parseInt(s[2]);
wface[1].V[2] = Integer.parseInt(s[3]);
wface[1].M = Mn;
p = line.indexOf("UV(");
if (p != -1) {
int uv_p;
pe = line.indexOf(")", p);
s = line.substring(p + 3, pe).split(" ");
if (s.length != 2 * 4) throw new Exception("UVの数が不正");
wface[0].UV = new Float[2 * 3];
wface[1].UV = new Float[2 * 3];
for (int i = 0; i < 2; i++) {
uv_p = 0;
for (int j = 0; j < 4; j++) {
if (i == 0 && j == 3) continue;
if (i == 1 && j == 1) continue;
wface[i].UV[uv_p++] = Float.parseFloat(s[j * 2 + 0]);
wface[i].UV[uv_p++] = Float.parseFloat(s[j * 2 + 1]);
}
}
}
p = line.indexOf("COL(");
if (p != -1) {
pe = line.indexOf(")", p);
s = line.substring(p + 4, pe).split(" ");
if (s.length != 4) throw new Exception("COLの数が不正");
wface[0].COL = new Float[4 * 3];
wface[1].COL = new Float[4 * 3];
long wl;
float wf;
int col_p;
for (int i = 0; i < 2; i++) {
col_p = 0;
for (int j = 0; j < s.length; j++) {
if (i == 0 && j == 3) continue;
if (i == 1 && j == 1) continue;
wl = Long.parseLong(s[j]);
wf = (wl >>> 0) & 0x000000ff;
wface[i].COL[col_p * 4 + 0] = wf / 255f;
wf = (wl >>> 8) & 0x000000ff;
wface[i].COL[col_p * 4 + 1] = wf / 255f;
wf = (wl >>> 16) & 0x000000ff;
wface[i].COL[col_p * 4 + 2] = wf / 255f;
wf = (wl >>> 24) & 0x000000ff;
wface[i].COL[col_p * 4 + 3] = wf / 255f;
col_p++;
}
}
}
}
if (wface != null) {
for (int i = 0; i < wface.length; i++) {
qf.add(wface[i]);
}
}
}
} catch (Exception e) {
Log.e("KGLMetaseq", "MQOファイル フォーマットエラー（Object>face）" + e.getMessage() + "[" + line + "]");
throw e;
}
if (qf.size() == 0) return null;
return qf.toArray(new Face[0]);
}
public void build_bricks() {
ImagePlus imp;
ImagePlus orgimp;
ImageStack stack;
FileInfo finfo;
if (lvImgTitle.isEmpty()) return;
orgimp = WindowManager.getImage(lvImgTitle.get(0));
imp = orgimp;
finfo = imp.getFileInfo();
if (finfo == null) return;
int[] dims = imp.getDimensions();
int imageW = dims[0];
int imageH = dims[1];
int nCh = dims[2];
int imageD = dims[3];
int nFrame = dims[4];
int bdepth = imp.getBitDepth();
double xspc = finfo.pixelWidth;
double yspc = finfo.pixelHeight;
double zspc = finfo.pixelDepth;
double z_aspect = Math.max(xspc, yspc) / zspc;
int orgW = imageW;
int orgH = imageH;
int orgD = imageD;
double orgxspc = xspc;
double orgyspc = yspc;
double orgzspc = zspc;
lv = lvImgTitle.size();
if (filetype == "JPEG") {
for (int l = 0; l < lv; l++) {
if (WindowManager.getImage(lvImgTitle.get(l)).getBitDepth() != 8) {
IJ.error("A SOURCE IMAGE MUST BE 8BIT GLAYSCALE");
return;
}
}
}
// calculate levels
/* int baseXY = 256;
int baseZ = 256;
if (z_aspect < 0.5) baseZ = 128;
if (z_aspect > 2.0) baseXY = 128;
if (z_aspect >= 0.5 && z_aspect < 1.0) baseZ = (int)(baseZ*z_aspect);
if (z_aspect > 1.0 && z_aspect <= 2.0) baseXY = (int)(baseXY/z_aspect);
IJ.log("Z_aspect: " + z_aspect);
IJ.log("BaseXY: " + baseXY);
IJ.log("BaseZ: " + baseZ);
*/
int baseXY = 256;
int baseZ = 128;
int dbXY = Math.max(orgW, orgH) / baseXY;
if (Math.max(orgW, orgH) % baseXY > 0) dbXY *= 2;
int dbZ = orgD / baseZ;
if (orgD % baseZ > 0) dbZ *= 2;
lv = Math.max(log2(dbXY), log2(dbZ)) + 1;
int ww = orgW;
int hh = orgH;
int dd = orgD;
for (int l = 0; l < lv; l++) {
int bwnum = ww / baseXY;
if (ww % baseXY > 0) bwnum++;
int bhnum = hh / baseXY;
if (hh % baseXY > 0) bhnum++;
int bdnum = dd / baseZ;
if (dd % baseZ > 0) bdnum++;
if (bwnum % 2 == 0) bwnum++;
if (bhnum % 2 == 0) bhnum++;
if (bdnum % 2 == 0) bdnum++;
int bw = (bwnum <= 1) ? ww : ww / bwnum + 1 + (ww % bwnum > 0 ? 1 : 0);
int bh = (bhnum <= 1) ? hh : hh / bhnum + 1 + (hh % bhnum > 0 ? 1 : 0);
int bd = (bdnum <= 1) ? dd : dd / bdnum + 1 + (dd % bdnum > 0 ? 1 : 0);
bwlist.add(bw);
bhlist.add(bh);
bdlist.add(bd);
IJ.log("LEVEL: " + l);
IJ.log(" width: " + ww);
IJ.log(" hight: " + hh);
IJ.log(" depth: " + dd);
IJ.log(" bw: " + bw);
IJ.log(" bh: " + bh);
IJ.log(" bd: " + bd);
int xyl2 = Math.max(ww, hh) / baseXY;
if (Math.max(ww, hh) % baseXY > 0) xyl2 *= 2;
if (lv - 1 - log2(xyl2) <= l) {
ww /= 2;
hh /= 2;
}
IJ.log(" xyl2: " + (lv - 1 - log2(xyl2)));
int zl2 = dd / baseZ;
if (dd % baseZ > 0) zl2 *= 2;
if (lv - 1 - log2(zl2) <= l) dd /= 2;
IJ.log(" zl2: " + (lv - 1 - log2(zl2)));
if (l < lv - 1) {
lvImgTitle.add(lvImgTitle.get(0) + "_level" + (l + 1));
IJ.selectWindow(lvImgTitle.get(0));
IJ.run(
"Scale...",
"x=- y=- z=- width="
+ ww
+ " height="
+ hh
+ " depth="
+ dd
+ " interpolation=Bicubic average process create title="
+ lvImgTitle.get(l + 1));
}
}
for (int l = 0; l < lv; l++) {
IJ.log(lvImgTitle.get(l));
}
Document doc = newXMLDocument();
Element root = doc.createElement("BRK");
root.setAttribute("version", "1.0");
root.setAttribute("nLevel", String.valueOf(lv));
root.setAttribute("nChannel", String.valueOf(nCh));
root.setAttribute("nFrame", String.valueOf(nFrame));
doc.appendChild(root);
for (int l = 0; l < lv; l++) {
IJ.showProgress(0.0);
int[] dims2 = imp.getDimensions();
IJ.log(
"W: "
+ String.valueOf(dims2[0])
+ " H: "
+ String.valueOf(dims2[1])
+ " C: "
+ String.valueOf(dims2[2])
+ " D: "
+ String.valueOf(dims2[3])
+ " T: "
+ String.valueOf(dims2[4])
+ " b: "
+ String.valueOf(bdepth));
bw = bwlist.get(l).intValue();
bh = bhlist.get(l).intValue();
bd = bdlist.get(l).intValue();
boolean force_pow2 = false;
/* if(IsPowerOf2(bw) && IsPowerOf2(bh) && IsPowerOf2(bd)) force_pow2 = true;
if(force_pow2){
//force pow2
if(Pow2(bw) > bw) bw = Pow2(bw)/2;
if(Pow2(bh) > bh) bh = Pow2(bh)/2;
if(Pow2(bd) > bd) bd = Pow2(bd)/2;
}
if(bw > imageW) bw = (Pow2(imageW) == imageW) ? imageW : Pow2(imageW)/2;
if(bh > imageH) bh = (Pow2(imageH) == imageH) ? imageH : Pow2(imageH)/2;
if(bd > imageD) bd = (Pow2(imageD) == imageD) ? imageD : Pow2(imageD)/2;
*/
if (bw > imageW) bw = imageW;
if (bh > imageH) bh = imageH;
if (bd > imageD) bd = imageD;
if (bw <= 1 || bh <= 1 || bd <= 1) break;
if (filetype == "JPEG" && (bw < 8 || bh < 8)) break;
Element lvnode = doc.createElement("Level");
lvnode.setAttribute("lv", String.valueOf(l));
lvnode.setAttribute("imageW", String.valueOf(imageW));
lvnode.setAttribute("imageH", String.valueOf(imageH));
lvnode.setAttribute("imageD", String.valueOf(imageD));
lvnode.setAttribute("xspc", String.valueOf(xspc));
lvnode.setAttribute("yspc", String.valueOf(yspc));
lvnode.setAttribute("zspc", String.valueOf(zspc));
lvnode.setAttribute("bitDepth", String.valueOf(bdepth));
root.appendChild(lvnode);
Element brksnode = doc.createElement("Bricks");
brksnode.setAttribute("brick_baseW", String.valueOf(bw));
brksnode.setAttribute("brick_baseH", String.valueOf(bh));
brksnode.setAttribute("brick_baseD", String.valueOf(bd));
lvnode.appendChild(brksnode);
ArrayList<Brick> bricks = new ArrayList<Brick>();
int mw, mh, md, mw2, mh2, md2;
double tx0, ty0, tz0, tx1, ty1, tz1;
double bx0, by0, bz0, bx1, by1, bz1;
for (int k = 0; k < imageD; k += bd) {
if (k > 0) k--;
for (int j = 0; j < imageH; j += bh) {
if (j > 0) j--;
for (int i = 0; i < imageW; i += bw) {
if (i > 0) i--;
mw = Math.min(bw, imageW - i);
mh = Math.min(bh, imageH - j);
md = Math.min(bd, imageD - k);
if (force_pow2) {
mw2 = Pow2(mw);
mh2 = Pow2(mh);
md2 = Pow2(md);
} else {
mw2 = mw;
mh2 = mh;
md2 = md;
}
if (filetype == "JPEG") {
if (mw2 < 8) mw2 = 8;
if (mh2 < 8) mh2 = 8;
}
tx0 = i == 0 ? 0.0d : ((mw2 - mw + 0.5d) / mw2);
ty0 = j == 0 ? 0.0d : ((mh2 - mh + 0.5d) / mh2);
tz0 = k == 0 ? 0.0d : ((md2 - md + 0.5d) / md2);
tx1 = 1.0d - 0.5d / mw2;
if (mw < bw) tx1 = 1.0d;
if (imageW - i == bw) tx1 = 1.0d;
ty1 = 1.0d - 0.5d / mh2;
if (mh < bh) ty1 = 1.0d;
if (imageH - j == bh) ty1 = 1.0d;
tz1 = 1.0d - 0.5d / md2;
if (md < bd) tz1 = 1.0d;
if (imageD - k == bd) tz1 = 1.0d;
bx0 = i == 0 ? 0.0d : (i + 0.5d) / (double) imageW;
by0 = j == 0 ? 0.0d : (j + 0.5d) / (double) imageH;
bz0 = k == 0 ? 0.0d : (k + 0.5d) / (double) imageD;
bx1 = Math.min((i + bw - 0.5d) / (double) imageW, 1.0d);
if (imageW - i == bw) bx1 = 1.0d;
by1 = Math.min((j + bh - 0.5d) / (double) imageH, 1.0d);
if (imageH - j == bh) by1 = 1.0d;
bz1 = Math.min((k + bd - 0.5d) / (double) imageD, 1.0d);
if (imageD - k == bd) bz1 = 1.0d;
int x, y, z;
x = i - (mw2 - mw);
y = j - (mh2 - mh);
z = k - (md2 - md);
bricks.add(
new Brick(
x, y, z, mw2, mh2, md2, 0, 0, tx0, ty0, tz0, tx1, ty1, tz1, bx0, by0, bz0, bx1,
by1, bz1));
}
}
}
Element fsnode = doc.createElement("Files");
lvnode.appendChild(fsnode);
stack = imp.getStack();
int totalbricknum = nFrame * nCh * bricks.size();
int curbricknum = 0;
for (int f = 0; f < nFrame; f++) {
for (int ch = 0; ch < nCh; ch++) {
int sizelimit = bdsizelimit * 1024 * 1024;
int bytecount = 0;
int filecount = 0;
int pd_bufsize = Math.max(sizelimit, bw * bh * bd * bdepth / 8);
byte[] packed_data = new byte[pd_bufsize];
String base_dataname =
basename
+ "_Lv"
+ String.valueOf(l)
+ "_Ch"
+ String.valueOf(ch)
+ "_Fr"
+ String.valueOf(f);
String current_dataname = base_dataname + "_data" + filecount;
Brick b_first = bricks.get(0);
if (b_first.z_ != 0) IJ.log("warning");
int st_z = b_first.z_;
int ed_z = b_first.z_ + b_first.d_;
LinkedList<ImageProcessor> iplist = new LinkedList<ImageProcessor>();
for (int s = st_z; s < ed_z; s++)
iplist.add(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
// ImagePlus test;
// ImageStack tsst;
// test = NewImage.createByteImage("test", imageW, imageH, imageD,
// NewImage.FILL_BLACK);
// tsst = test.getStack();
for (int i = 0; i < bricks.size(); i++) {
Brick b = bricks.get(i);
if (ed_z > b.z_ || st_z < b.z_ + b.d_) {
if (b.z_ > st_z) {
for (int s = 0; s < b.z_ - st_z; s++) iplist.pollFirst();
st_z = b.z_;
} else if (b.z_ < st_z) {
IJ.log("warning");
for (int s = st_z - 1; s > b.z_; s--)
iplist.addFirst(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
st_z = b.z_;
}
if (b.z_ + b.d_ > ed_z) {
for (int s = ed_z; s < b.z_ + b.d_; s++)
iplist.add(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
ed_z = b.z_ + b.d_;
} else if (b.z_ + b.d_ < ed_z) {
IJ.log("warning");
for (int s = 0; s < ed_z - (b.z_ + b.d_); s++) iplist.pollLast();
ed_z = b.z_ + b.d_;
}
} else {
IJ.log("warning");
iplist.clear();
st_z = b.z_;
ed_z = b.z_ + b.d_;
for (int s = st_z; s < ed_z; s++)
iplist.add(stack.getProcessor(imp.getStackIndex(ch + 1, s + 1, f + 1)));
}
if (iplist.size() != b.d_) {
IJ.log("Stack Error");
return;
}
// int zz = st_z;
int bsize = 0;
byte[] bdata = new byte[b.w_ * b.h_ * b.d_ * bdepth / 8];
Iterator<ImageProcessor> ipite = iplist.iterator();
while (ipite.hasNext()) {
// ImageProcessor tsip = tsst.getProcessor(zz+1);
ImageProcessor ip = ipite.next();
ip.setRoi(b.x_, b.y_, b.w_, b.h_);
if (bdepth == 8) {
byte[] data = (byte[]) ip.crop().getPixels();
System.arraycopy(data, 0, bdata, bsize, data.length);
bsize += data.length;
} else if (bdepth == 16) {
ByteBuffer buffer = ByteBuffer.allocate(b.w_ * b.h_ * bdepth / 8);
buffer.order(ByteOrder.LITTLE_ENDIAN);
short[] data = (short[]) ip.crop().getPixels();
for (short e : data) buffer.putShort(e);
System.arraycopy(buffer.array(), 0, bdata, bsize, buffer.array().length);
bsize += buffer.array().length;
} else if (bdepth == 32) {
ByteBuffer buffer = ByteBuffer.allocate(b.w_ * b.h_ * bdepth / 8);
buffer.order(ByteOrder.LITTLE_ENDIAN);
float[] data = (float[]) ip.crop().getPixels();
for (float e : data) buffer.putFloat(e);
System.arraycopy(buffer.array(), 0, bdata, bsize, buffer.array().length);
bsize += buffer.array().length;
}
}
String filename =
basename
+ "_Lv"
+ String.valueOf(l)
+ "_Ch"
+ String.valueOf(ch)
+ "_Fr"
+ String.valueOf(f)
+ "_ID"
+ String.valueOf(i);
int offset = bytecount;
int datasize = bdata.length;
if (filetype == "RAW") {
int dummy = -1;
// do nothing
}
if (filetype == "JPEG" && bdepth == 8) {
try {
DataBufferByte db = new DataBufferByte(bdata, datasize);
Raster raster = Raster.createPackedRaster(db, b.w_, b.h_ * b.d_, 8, null);
BufferedImage img =
new BufferedImage(b.w_, b.h_ * b.d_, BufferedImage.TYPE_BYTE_GRAY);
img.setData(raster);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ImageOutputStream ios = ImageIO.createImageOutputStream(baos);
String format = "jpg";
Iterator<javax.imageio.ImageWriter> iter =
ImageIO.getImageWritersByFormatName("jpeg");
javax.imageio.ImageWriter writer = iter.next();
ImageWriteParam iwp = writer.getDefaultWriteParam();
iwp.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
iwp.setCompressionQuality((float) jpeg_quality * 0.01f);
writer.setOutput(ios);
writer.write(null, new IIOImage(img, null, null), iwp);
// ImageIO.write(img, format, baos);
bdata = baos.toByteArray();
datasize = bdata.length;
} catch (IOException e) {
e.printStackTrace();
return;
}
}
if (filetype == "ZLIB") {
byte[] tmpdata = new byte[b.w_ * b.h_ * b.d_ * bdepth / 8];
Deflater compresser = new Deflater();
compresser.setInput(bdata);
compresser.setLevel(Deflater.DEFAULT_COMPRESSION);
compresser.setStrategy(Deflater.DEFAULT_STRATEGY);
compresser.finish();
datasize = compresser.deflate(tmpdata);
bdata = tmpdata;
compresser.end();
}
if (bytecount + datasize > sizelimit && bytecount > 0) {
BufferedOutputStream fis = null;
try {
File file = new File(directory + current_dataname);
fis = new BufferedOutputStream(new FileOutputStream(file));
fis.write(packed_data, 0, bytecount);
} catch (IOException e) {
e.printStackTrace();
return;
} finally {
try {
if (fis != null) fis.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
}
filecount++;
current_dataname = base_dataname + "_data" + filecount;
bytecount = 0;
offset = 0;
System.arraycopy(bdata, 0, packed_data, bytecount, datasize);
bytecount += datasize;
} else {
System.arraycopy(bdata, 0, packed_data, bytecount, datasize);
bytecount += datasize;
}
Element filenode = doc.createElement("File");
filenode.setAttribute("filename", current_dataname);
filenode.setAttribute("channel", String.valueOf(ch));
filenode.setAttribute("frame", String.valueOf(f));
filenode.setAttribute("brickID", String.valueOf(i));
filenode.setAttribute("offset", String.valueOf(offset));
filenode.setAttribute("datasize", String.valueOf(datasize));
filenode.setAttribute("filetype", String.valueOf(filetype));
fsnode.appendChild(filenode);
curbricknum++;
IJ.showProgress((double) (curbricknum) / (double) (totalbricknum));
}
if (bytecount > 0) {
BufferedOutputStream fis = null;
try {
File file = new File(directory + current_dataname);
fis = new BufferedOutputStream(new FileOutputStream(file));
fis.write(packed_data, 0, bytecount);
} catch (IOException e) {
e.printStackTrace();
return;
} finally {
try {
if (fis != null) fis.close();
} catch (IOException e) {
e.printStackTrace();
return;
}
}
}
}
}
for (int i = 0; i < bricks.size(); i++) {
Brick b = bricks.get(i);
Element bricknode = doc.createElement("Brick");
bricknode.setAttribute("id", String.valueOf(i));
bricknode.setAttribute("st_x", String.valueOf(b.x_));
bricknode.setAttribute("st_y", String.valueOf(b.y_));
bricknode.setAttribute("st_z", String.valueOf(b.z_));
bricknode.setAttribute("width", String.valueOf(b.w_));
bricknode.setAttribute("height", String.valueOf(b.h_));
bricknode.setAttribute("depth", String.valueOf(b.d_));
brksnode.appendChild(bricknode);
Element tboxnode = doc.createElement("tbox");
tboxnode.setAttribute("x0", String.valueOf(b.tx0_));
tboxnode.setAttribute("y0", String.valueOf(b.ty0_));
tboxnode.setAttribute("z0", String.valueOf(b.tz0_));
tboxnode.setAttribute("x1", String.valueOf(b.tx1_));
tboxnode.setAttribute("y1", String.valueOf(b.ty1_));
tboxnode.setAttribute("z1", String.valueOf(b.tz1_));
bricknode.appendChild(tboxnode);
Element bboxnode = doc.createElement("bbox");
bboxnode.setAttribute("x0", String.valueOf(b.bx0_));
bboxnode.setAttribute("y0", String.valueOf(b.by0_));
bboxnode.setAttribute("z0", String.valueOf(b.bz0_));
bboxnode.setAttribute("x1", String.valueOf(b.bx1_));
bboxnode.setAttribute("y1", String.valueOf(b.by1_));
bboxnode.setAttribute("z1", String.valueOf(b.bz1_));
bricknode.appendChild(bboxnode);
}
if (l < lv - 1) {
imp = WindowManager.getImage(lvImgTitle.get(l + 1));
int[] newdims = imp.getDimensions();
imageW = newdims[0];
imageH = newdims[1];
imageD = newdims[3];
xspc = orgxspc * ((double) orgW / (double) imageW);
yspc = orgyspc * ((double) orgH / (double) imageH);
zspc = orgzspc * ((double) orgD / (double) imageD);
bdepth = imp.getBitDepth();
}
}
File newXMLfile = new File(directory + basename + ".vvd");
writeXML(newXMLfile, doc);
for (int l = 1; l < lv; l++) {
imp = WindowManager.getImage(lvImgTitle.get(l));
imp.changes = false;
imp.close();
}
}
@Override
public byte[] getBinaryData() {
final ArrayList<byte[]> binGroups = new ArrayList<byte[]>(this.m_actionGroups.size());
final ArrayList<byte[]> binRewars = new ArrayList<byte[]>(this.m_rewards.size());
int presize = 0;
presize += 4;
try {
for (final String var : this.m_varMapping) {
presize += 4 + var.getBytes("UTF-8").length;
}
} catch (Exception e) {
ScenarioBinaryStorable.m_logger.error((Object) "Exception", (Throwable) e);
}
try {
presize += 8;
presize +=
((this.m_joinCriterion != null) ? this.m_joinCriterion.getBytes("UTF-8").length : 0);
presize +=
((this.m_rewardEligibilityCriterion != null)
? this.m_rewardEligibilityCriterion.getBytes("UTF-8").length
: 0);
} catch (Exception e) {
ScenarioBinaryStorable.m_logger.error((Object) "Exception", (Throwable) e);
}
for (final ActionGroupStorable g : this.m_actionGroups) {
final byte[] bin = g.serialize();
presize += bin.length + 4;
binGroups.add(bin);
}
for (final RewardStorable r : this.m_rewards) {
final byte[] bin = r.serialize();
presize += bin.length + 4;
binRewars.add(bin);
}
try {
presize += 4;
presize += ((this.m_params != null) ? this.m_params.getBytes("UTF-8").length : 0);
} catch (Exception e) {
ScenarioBinaryStorable.m_logger.error((Object) "Exception", (Throwable) e);
}
final ByteBuffer bb = ByteBuffer.allocate(31 + presize);
bb.putInt(this.m_id);
bb.put(this.m_type);
bb.put(this.m_userType);
bb.put((byte) (this.m_autoTrigger ? 1 : 0));
bb.put((byte) (this.m_isChallenge ? 1 : 0));
bb.put((byte) (this.m_isChaos ? 1 : 0));
bb.putShort(this.m_duration);
bb.putShort(this.m_minUsers);
bb.putShort(this.m_maxUsers);
if (this.m_expirationDate != null) {
bb.putLong(this.m_expirationDate.toLong());
} else {
bb.putLong(0L);
}
try {
if (this.m_params != null) {
final byte[] bytes = this.m_params.getBytes("UTF-8");
bb.putInt(bytes.length);
bb.put(bytes);
} else {
bb.putInt(0);
}
} catch (Exception e2) {
ScenarioBinaryStorable.m_logger.error((Object) "Exception", (Throwable) e2);
}
try {
bb.putInt(this.m_varMapping.length);
for (final String var2 : this.m_varMapping) {
final byte[] bytes2 = var2.getBytes("UTF-8");
bb.putInt(bytes2.length);
bb.put(bytes2);
}
} catch (Exception e2) {
ScenarioBinaryStorable.m_logger.error((Object) "Exception", (Throwable) e2);
}
try {
if (this.m_joinCriterion != null) {
final byte[] bytes = this.m_joinCriterion.getBytes("UTF-8");
bb.putInt(bytes.length);
bb.put(bytes);
} else {
bb.putInt(0);
}
if (this.m_rewardEligibilityCriterion != null) {
final byte[] bytes = this.m_rewardEligibilityCriterion.getBytes("UTF-8");
bb.putInt(bytes.length);
bb.put(bytes);
} else {
bb.putInt(0);
}
} catch (Exception e2) {
ScenarioBinaryStorable.m_logger.error((Object) "Exception", (Throwable) e2);
}
bb.putInt(binGroups.size());
for (final byte[] gdata : binGroups) {
bb.putInt(gdata.length);
bb.put(gdata);
}
bb.putInt(binRewars.size());
for (final byte[] rdata : binRewars) {
bb.putInt(rdata.length);
bb.put(rdata);
}
return bb.array();
}
/** @throws Exception If failed. */
public void testCompact() throws Exception {
File file = new File(UUID.randomUUID().toString());
X.println("file: " + file.getPath());
FileSwapSpaceSpi.SwapFile f = new FileSwapSpaceSpi.SwapFile(file, 8);
Random rnd = new Random();
ArrayList<FileSwapSpaceSpi.SwapValue> arr = new ArrayList<>();
int size = 0;
for (int a = 0; a < 100; a++) {
FileSwapSpaceSpi.SwapValue[] vals = new FileSwapSpaceSpi.SwapValue[1 + rnd.nextInt(10)];
int size0 = 0;
for (int i = 0; i < vals.length; i++) {
byte[] bytes = new byte[1 + rnd.nextInt(49)];
rnd.nextBytes(bytes);
size0 += bytes.length;
vals[i] = new FileSwapSpaceSpi.SwapValue(bytes);
arr.add(vals[i]);
}
f.write(new FileSwapSpaceSpi.SwapValues(vals, size0), 1);
size += size0;
assertEquals(f.length(), size);
assertEquals(file.length(), size);
}
int i = 0;
for (FileSwapSpaceSpi.SwapValue val : arr) assertEquals(val.idx(), ++i);
i = 0;
for (int cnt = arr.size() / 2; i < cnt; i++) {
FileSwapSpaceSpi.SwapValue v = arr.remove(rnd.nextInt(arr.size()));
assertTrue(f.tryRemove(v.idx(), v));
}
int hash0 = 0;
for (FileSwapSpaceSpi.SwapValue val : arr) hash0 += Arrays.hashCode(val.readValue(f.readCh));
ArrayList<T2<ByteBuffer, ArrayDeque<FileSwapSpaceSpi.SwapValue>>> bufs = new ArrayList();
for (; ; ) {
ArrayDeque<FileSwapSpaceSpi.SwapValue> que = new ArrayDeque<>();
ByteBuffer buf = f.compact(que, 1024);
if (buf == null) break;
bufs.add(new T2(buf, que));
}
f.delete();
int hash1 = 0;
for (FileSwapSpaceSpi.SwapValue val : arr) hash1 += Arrays.hashCode(val.value(null));
assertEquals(hash0, hash1);
File file0 = new File(UUID.randomUUID().toString());
FileSwapSpaceSpi.SwapFile f0 = new FileSwapSpaceSpi.SwapFile(file0, 8);
for (T2<ByteBuffer, ArrayDeque<FileSwapSpaceSpi.SwapValue>> t : bufs)
f0.write(t.get2(), t.get1(), 1);
int hash2 = 0;
for (FileSwapSpaceSpi.SwapValue val : arr) hash2 += Arrays.hashCode(val.readValue(f0.readCh));
assertEquals(hash2, hash1);
}
@SuppressWarnings("unchecked")
public Mesh(LinkedHashMap mesh, User user) {
this.mesh = mesh;
this.user = user;
try {
title = getStringFromHash(mesh, "title", "Some Object");
ArrayList<Float> vs = new ArrayList<Float>(256);
ArrayList<Float> ns = new ArrayList<Float>(256);
ArrayList<Float> tp = new ArrayList<Float>(256);
LinkedList verts = getListFromHash(mesh, "vertices");
for (Object vert : verts) {
vs.add(getFloatFromList(vert, 0, 0f));
vs.add(getFloatFromList(vert, 1, 0f));
vs.add(getFloatFromList(vert, 2, 0f));
}
LinkedList norms = getListFromHash(mesh, "normals");
for (Object norm : norms) {
ns.add(getFloatFromList(norm, 0, 0f));
ns.add(getFloatFromList(norm, 1, 0f));
ns.add(getFloatFromList(norm, 2, 0f));
}
LinkedList texts = getListFromHash(mesh, "texturepoints");
for (Object text : texts) {
tp.add(getFloatFromList(text, 0, 0f));
tp.add(getFloatFromList(text, 1, 0f));
}
ArrayList<Float> vnt = new ArrayList<Float>(1024);
ArrayList<Short> ind = new ArrayList<Short>(1024);
short index = 0;
LinkedList faces = getListFromHash(mesh, "faces");
for (Object face : faces) {
for (int i = 0; i < 3; i++) {
String f = getStringFromList(face, i, "1/1/2");
StringTokenizer st = new StringTokenizer(f, "/");
int fv = Integer.parseInt(st.nextToken()) - 1;
int ft = Integer.parseInt(st.nextToken()) - 1;
int fn = Integer.parseInt(st.nextToken()) - 1;
vnt.add(vs.get(fv * 3));
vnt.add(vs.get(fv * 3 + 1));
vnt.add(vs.get(fv * 3 + 2));
vnt.add(ns.get(fn * 3));
vnt.add(ns.get(fn * 3 + 1));
vnt.add(ns.get(fn * 3 + 2));
vnt.add(tp.get(ft * 2));
vnt.add(tp.get(ft * 2 + 1));
ind.add(index++);
}
}
vnt.trimToSize();
float[] va = new float[vnt.size()];
for (int i = 0; i < vnt.size(); i++) va[i] = vnt.get(i);
ind.trimToSize();
short[] ia = new short[ind.size()];
for (int i = 0; i < ind.size(); i++) ia[i] = ind.get(i);
vb = ByteBuffer.allocateDirect(va.length * 4).order(ByteOrder.nativeOrder()).asFloatBuffer();
vb.put(va).position(0);
ib = ByteBuffer.allocateDirect(ia.length * 2).order(ByteOrder.nativeOrder()).asShortBuffer();
ib.put(ia).position(0);
il = ia.length;
textures = getListFromHash(mesh, "textures");
if (textures.size() == 0) textures = list("placeholder");
vertexShader = user.shaders.get(getStringFromHash(mesh, "vertex-shader", ""));
fragmentShader = user.shaders.get(getStringFromHash(mesh, "fragment-shader", ""));
subObjects = getListFromHash(mesh, "sub-items");
rotationX = getFloatFromList(getListFromHash(mesh, "rotation"), 0, 0f);
rotationY = getFloatFromList(getListFromHash(mesh, "rotation"), 1, 0f);
rotationZ = getFloatFromList(getListFromHash(mesh, "rotation"), 2, 0f);
scaleX = getFloatFromList(getListFromHash(mesh, "scale"), 0, 1f);
scaleY = getFloatFromList(getListFromHash(mesh, "scale"), 1, 1f);
scaleZ = getFloatFromList(getListFromHash(mesh, "scale"), 2, 1f);
lightR = getFloatFromList(getListFromHash(mesh, "light"), 0, 0f);
lightG = getFloatFromList(getListFromHash(mesh, "light"), 1, 0f);
lightB = getFloatFromList(getListFromHash(mesh, "light"), 2, 0f);
} catch (Exception e) {
e.printStackTrace();
Log.e("Mesh Constructor", e.getLocalizedMessage());
return;
}
}
/** Return the number of subscriptions. * */
public int getNumSubscriptions() {
if (this.closed) throw new IllegalStateException();
return subscriptions.size();
}