/*Construtor da camera*/
mCamera(float px, float py, float pz,
float centerx,float centery, float centerz,
float upx, float upy, float upz)
{
Matriz<4,1> _mp;
_mp.setZero();
_mp(0,0) = px;
_mp(1,0) = py;
_mp(2,0) = pz;
_mp(3,0) = 1;
_p = _mp;
_V.setZero();
_V(0,0) = upx;
_V(1,0) = upy;
_V(2,0) = upz;
_V(3,0) = 1;
_V = mat.normalizeVector3D(_V);
_N.setZero();
_N(0,0) = centerx - px;
_N(1,0) = centery - py;
_N(2,0) = centerz - pz;
_N = mat.normalizeVector3D(_N);
_U = mat.normalizeVector3D(mat.crossProduct3D(_V,_N));
_V = mat.normalizeVector3D(mat.crossProduct3D(_U,_N));
tipo_de_projecao = 1;
graus = 0.02f;
}
static void JRefObjectFinalizer(SEXP ref) {
if (java_is_dead) return;
if (TYPEOF(ref)==EXTPTRSXP) {
JNIEnv *env=getJNIEnv();
jobject o = R_ExternalPtrAddr(ref);
#ifdef RJ_DEBUG
{
jstring s=callToString(env, o);
const char *c="???";
if (s) c=(*env)->GetStringUTFChars(env, s, 0);
_dbg(rjprintf("Finalizer releases Java object [%s] reference %lx (SEXP@%lx)\n", c, (long)o, (long)ref));
if (s) {
(*env)->ReleaseStringUTFChars(env, s, c);
releaseObject(env, s);
}
}
#endif
if (env && o) {
/* _dbg(rjprintf(" finalizer releases global reference %lx\n", (long)o);) */
_mp(MEM_PROF_OUT("R %08x FIN\n", (int)o))
releaseGlobal(env, o);
}
}
}
/** get contents of the object array in the form of list of ext. pointers */
REPC SEXP RgetObjectArrayCont(SEXP e) {
SEXP ar;
jarray o;
int l,i;
JNIEnv *env=getJNIEnv();
profStart();
if (e==R_NilValue) return R_NilValue;
if (TYPEOF(e)==EXTPTRSXP) {
jverify(e);
o=(jobject)EXTPTR_PTR(e);
} else
error("invalid object parameter");
_dbg(rjprintf("RgetObjectArrayCont: jarray %x\n",o));
if (!o) return R_NilValue;
l=(int)(*env)->GetArrayLength(env, o);
_dbg(rjprintf(" convert object array of length %d\n",l));
if (l<1) return R_NilValue;
PROTECT(ar=allocVector(VECSXP,l));
i=0;
while (i<l) {
jobject ae = (*env)->GetObjectArrayElement(env, o, i);
_mp(MEM_PROF_OUT(" %08x LNEW object array element [%d]\n", (int) ae, i))
SET_VECTOR_ELT(ar, i, j2SEXP(env, ae, 1));
i++;
}
UNPROTECT(1);
_prof(profReport("RgetObjectArrayCont[%d]:",o));
return ar;
}
/* loader: if NULL does NOT use any custom loader but uses system FindClass,
otherwise Class.forName(..., true, loader) if user first and system only as fall-back */
HIDE jclass findClass(JNIEnv *env, const char *cName, jobject loader) {
if (loader) {
char cn[128], *c=cn;
jobject cns;
jclass cl;
strcpy(cn, cName);
while (*c) { if (*c=='/') *c='.'; c++; };
cns = newString(env, cn);
if (!cns) error("unable to create Java string from '%s'", cn);
#ifdef DEBUG_CL
printf("findClass(\"%s\") [with %s loader]\n", cn, (loader && loader == oClassLoader) ? "rJava" : "custom");
#endif
cl = (jclass) (*env)->CallStaticObjectMethod(env, javaClassClass, mid_forName, cns, (jboolean) 1, loader);
#if RJAVA_LEGACY
clx(env);
#endif
_mp(MEM_PROF_OUT(" %08x LNEW class\n", (int) cl))
releaseObject(env, cns);
#ifdef DEBUG_CL
printf(" - got %x\n", (unsigned int) cl);
#endif
#if RJAVA_LEGACY
if (cl)
#endif
return cl;
}
#ifdef DEBUG_CL
printf("findClass(\"%s\") (no loader)\n", cName);
#endif
{
jclass cl = (*env)->FindClass(env, cName);
_mp(MEM_PROF_OUT(" %08x LNEW class\n", (int) cl))
#ifdef DEBUG_CL
printf(" - got %x\n", (unsigned int) cl);
#endif
return cl;
}
}
/**
* get contents of the String array in the form of STRSXP vector
*
* @param e a pointer to a String[] object
*
* @return a STRSXP vector mirroring the java array
*/
HIDE SEXP getStringArrayCont(jarray o) {
SEXP ar;
int l,i;
const char *c;
JNIEnv *env=getJNIEnv();
profStart();
_dbg(rjprintf("RgetStringArrayCont: jarray %x\n",o));
if (!o) return R_NilValue;
l=(int)(*env)->GetArrayLength(env, o);
_dbg(rjprintf(" convert string array of length %d\n",l));
if (l<0) return R_NilValue;
PROTECT(ar=allocVector(STRSXP,l));
i=0;
while (i<l) {
jobject sobj=(*env)->GetObjectArrayElement(env, o, i);
_mp(MEM_PROF_OUT(" %08x LNEW object array element [%d]\n", (int) sobj, i))
c=0;
if (sobj) {
/* we could (should?) check the type here ...
if (!(*env)->IsInstanceOf(env, sobj, javaStringClass)) {
printf(" not a String\n");
} else
*/
c=(*env)->GetStringUTFChars(env, sobj, 0);
}
if (!c)
SET_STRING_ELT(ar, i, R_NaString);
else {
SET_STRING_ELT(ar, i, mkCharUTF8(c));
(*env)->ReleaseStringUTFChars(env, sobj, c);
}
if (sobj) releaseObject(env, sobj);
i++;
}
UNPROTECT(1);
_prof(profReport("RgetStringArrayCont[%d]:",o))
return ar;
}
/** get value of a field of an object or class
object (int), return signature (string), field name (string)
arrays and objects are returned as IDs (hence not evaluated)
class name can be in either form / or .
*/
REPC SEXP RgetField(SEXP obj, SEXP sig, SEXP name, SEXP trueclass) {
jobject o = 0;
SEXP e;
const char *retsig, *fnam;
char *clnam = 0, *detsig = 0;
jfieldID fid;
jclass cls;
int tc = asInteger(trueclass);
JNIEnv *env=getJNIEnv();
if (obj == R_NilValue) return R_NilValue;
if ( IS_JOBJREF(obj) )
obj = GET_SLOT(obj, install("jobj"));
if (TYPEOF(obj)==EXTPTRSXP) {
jverify(obj);
o=(jobject)EXTPTR_PTR(obj);
} else if (TYPEOF(obj)==STRSXP && LENGTH(obj)==1)
clnam = strdup(CHAR(STRING_ELT(obj, 0)));
else
error("invalid object parameter");
if (!o && !clnam)
error("cannot access a field of a NULL object");
#ifdef RJ_DEBUG
if (o) {
rjprintf("RgetField.object: "); printObject(env, o);
} else {
rjprintf("RgetField.class: %s\n", clnam);
}
#endif
if (o)
cls = objectClass(env, o);
else {
char *c = clnam;
while(*c) { if (*c=='/') *c='.'; c++; }
cls = findClass(env, clnam);
free(clnam);
if (!cls) {
error("cannot find class %s", CHAR(STRING_ELT(obj, 0)));
}
}
if (!cls)
error("cannot determine object class");
#ifdef RJ_DEBUG
rjprintf("RgetField.class: "); printObject(env, cls);
#endif
if (TYPEOF(name)!=STRSXP || LENGTH(name)!=1) {
releaseObject(env, cls);
error("invalid field name");
}
fnam = CHAR(STRING_ELT(name,0));
if (sig == R_NilValue) {
retsig = detsig = findFieldSignature(env, cls, fnam);
if (!retsig) {
releaseObject(env, cls);
error("unable to detect signature for field '%s'", fnam);
}
} else {
if (TYPEOF(sig)!=STRSXP || LENGTH(sig)!=1) {
releaseObject(env, cls);
error("invalid signature parameter");
}
retsig = CHAR(STRING_ELT(sig,0));
}
_dbg(rjprintf("field %s signature is %s\n",fnam,retsig));
if (o) { /* first try non-static fields */
fid = (*env)->GetFieldID(env, cls, fnam, retsig);
checkExceptionsX(env, 1);
if (!fid) { /* if that fails, try static ones */
o = 0;
fid = (*env)->GetStaticFieldID(env, cls, fnam, retsig);
}
} else /* no choice if the object was a string */
fid = (*env)->GetStaticFieldID(env, cls, fnam, retsig);
if (!fid) {
checkExceptionsX(env, 1);
releaseObject(env, cls);
if (detsig) free(detsig);
error("RgetField: field %s not found", fnam);
}
switch (*retsig) {
case 'I': {
int r=o?
(*env)->GetIntField(env, o, fid):
(*env)->GetStaticIntField(env, cls, fid);
e = allocVector(INTSXP, 1);
INTEGER(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'S': {
jshort r=o?
(*env)->GetShortField(env, o, fid):
(*env)->GetStaticShortField(env, cls, fid);
e = allocVector(INTSXP, 1);
INTEGER(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'C': {
int r=(int) (o?
(*env)->GetCharField(env, o, fid):
(*env)->GetStaticCharField(env, cls, fid));
e = allocVector(INTSXP, 1);
INTEGER(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'B': {
int r=(int) (o?
(*env)->GetByteField(env, o, fid):
(*env)->GetStaticByteField(env, cls, fid));
e = allocVector(INTSXP, 1);
INTEGER(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'J': {
jlong r=o?
(*env)->GetLongField(env, o, fid):
(*env)->GetStaticLongField(env, cls, fid);
e = allocVector(REALSXP, 1);
REAL(e)[0] = (double)r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'Z': {
jboolean r=o?
(*env)->GetBooleanField(env, o, fid):
(*env)->GetStaticBooleanField(env, cls, fid);
e = allocVector(LGLSXP, 1);
LOGICAL(e)[0] = r?1:0;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'D': {
double r=o?
(*env)->GetDoubleField(env, o, fid):
(*env)->GetStaticDoubleField(env, cls, fid);
e = allocVector(REALSXP, 1);
REAL(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'F': {
double r = (double) (o?
(*env)->GetFloatField(env, o, fid):
(*env)->GetStaticFloatField(env, cls, fid));
e = allocVector(REALSXP, 1);
REAL(e)[0] = r;
releaseObject(env, cls);
if (detsig) free(detsig);
return e;
}
case 'L':
case '[': {
SEXP rv;
jobject r = o?
(*env)->GetObjectField(env, o, fid):
(*env)->GetStaticObjectField(env, cls, fid);
_mp(MEM_PROF_OUT(" %08x LNEW field value\n", (int) r))
releaseObject(env, cls);
if (tc) {
if (detsig) free(detsig);
return new_jobjRef(env, r, 0);
}
if (*retsig=='L') { /* need to fix the class name */
char *d = strdup(retsig), *c = d;
while (*c) { if (*c==';') { *c=0; break; }; c++; }
rv = new_jobjRef(env, r, d+1);
free(d);
} else
rv = new_jobjRef(env, r, retsig);
if (detsig) free(detsig);
return rv;
}
} /* switch */
releaseObject(env, cls);
if (detsig) {
free(detsig);
error("unknown field signature");
}
error("unknown field signature '%s'", retsig);
return R_NilValue;
}
