void ObjectMemory::deallocate(OTE* ote)
{
#ifdef _DEBUG
ASSERT(!ote->isFree());
if (Interpreter::executionTrace)
{
tracelock lock(TRACESTREAM);
TRACESTREAM << ote << " (" << hex << (UINT)ote << "), refs " << dec << (int)ote->m_count << ", is being deallocated" << endl;
}
#endif
ASSERT(!isPermanent(ote));
// We can have up to 256 different destructors (8 bits)
switch (ote->heapSpace())
{
case OTEFlags::NormalSpace:
freeChunk(ote->m_location);
releasePointer(ote);
break;
case OTEFlags::VirtualSpace:
::VirtualFree(static_cast<VirtualObject*>(ote->m_location)->getHeader(), 0, MEM_RELEASE);
releasePointer(ote);
break;
case OTEFlags::BlockSpace:
Interpreter::m_otePools[Interpreter::BLOCKPOOL].deallocate(ote);
break;
case OTEFlags::ContextSpace:
// Return it to the interpreter's free list of contexts
Interpreter::m_otePools[Interpreter::CONTEXTPOOL].deallocate(ote);
break;
case OTEFlags::DWORDSpace:
Interpreter::m_otePools[Interpreter::DWORDPOOL].deallocate(ote);
break;
case OTEFlags::HeapSpace:
//_asm int 3;
HARDASSERT(FALSE);
break;
case OTEFlags::FloatSpace:
Interpreter::m_otePools[Interpreter::FLOATPOOL].deallocate(ote);
break;
case OTEFlags::PoolSpace:
{
MWORD size = ote->sizeOf();
HARDASSERT(size <= MaxSmallObjectSize);
freeSmallChunk(ote->m_location, size);
releasePointer(ote);
}
break;
default:
ASSERT(false);
}
}
/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
static jstring
android_glGetActiveAttrib2
(JNIEnv *_env, jobject _this, jint program, jint index, jobject size_buf, jobject type_buf) {
jarray _sizeArray = (jarray) 0;
jint _sizeBufferOffset = (jint) 0;
jarray _typeArray = (jarray) 0;
jint _typeBufferOffset = (jint) 0;
jint _lengthRemaining;
GLsizei *length = (GLsizei *) 0;
jint _sizeRemaining;
GLint *size = (GLint *) 0;
jint _typeRemaining;
GLenum *type = (GLenum *) 0;
jstring result = 0;
GLint len = 0;
glGetProgramiv((GLuint)program, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &len);
if (!len) {
return _env->NewStringUTF("");
}
char* buf = (char*) malloc(len);
if (buf == NULL) {
jniThrowException(_env, "java/lang/IllegalArgumentException", "out of memory");
return NULL;
}
size = (GLint *)getPointer(_env, size_buf, &_sizeArray, &_sizeRemaining, &_sizeBufferOffset);
type = (GLenum *)getPointer(_env, type_buf, &_typeArray, &_typeRemaining, &_typeBufferOffset);
if (size == NULL) {
char * _sizeBase = (char *)_env->GetPrimitiveArrayCritical(_sizeArray, (jboolean *) 0);
size = (GLint *) (_sizeBase + _sizeBufferOffset);
}
if (type == NULL) {
char * _typeBase = (char *)_env->GetPrimitiveArrayCritical(_typeArray, (jboolean *) 0);
type = (GLenum *) (_typeBase + _typeBufferOffset);
}
glGetActiveAttrib(
(GLuint)program,
(GLuint)index,
(GLsizei)len,
NULL,
(GLint *)size,
(GLenum *)type,
(char *)buf
);
if (_typeArray) {
releasePointer(_env, _typeArray, type, JNI_TRUE);
}
if (_sizeArray) {
releasePointer(_env, _sizeArray, size, JNI_TRUE);
}
result = _env->NewStringUTF(buf);
if (buf) {
free(buf);
}
return result;
}
void ModelViewer::setReader( FileReader* p_reader ) {
Ensure::isOfType<ModelReader>( p_reader );
Viewer::setReader( p_reader );
// Load model
auto reader = this->modelReader( );
m_model = reader->getModel( );
// Create DX mesh cache
m_meshCache.SetSize( m_model.numMeshes( ) );
// Load meshes
for ( uint i = 0; i < m_model.numMeshes( ); i++ ) {
auto& mesh = m_model.mesh( i );
auto& cache = m_meshCache[i];
// Create and populate the buffers
uint vertexCount = mesh.vertices.GetSize( );
uint vertexSize = sizeof( Vertex );
uint indexCount = mesh.triangles.GetSize( ) * 3;
uint indexSize = sizeof( uint16 );
if ( !this->createBuffers( cache, vertexCount, vertexSize, indexCount, indexSize ) ) {
continue;
}
if ( !this->populateBuffers( mesh, cache ) ) {
releasePointer( cache.indexBuffer );
releasePointer( cache.vertexBuffer );
continue;
}
}
// Create DX texture cache
m_textureCache.SetSize( m_model.numMaterialData( ) );
// Load textures
for ( uint i = 0; i < m_model.numMaterialData( ); i++ ) {
auto& material = m_model.materialData( i );
auto& cache = m_textureCache[i];
// Load diffuse texture
if ( material.diffuseMap ) {
cache.diffuseMap = this->loadTexture( material.diffuseMap );
} else {
cache.diffuseMap = nullptr;
}
// Load normal map
/*if ( material.normalMap ) {
cache.normalMap = this->loadTexture( material.normalMap );
} else {
cache.normalMap = nullptr;
}*/
}
// Re-focus and re-render
this->focus( );
this->render( );
}
/* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */
static jint
android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2
(JNIEnv *_env, jobject _this, jobject mantissa_buf, jobject exponent_buf) {
jint _exception = 0;
const char * _exceptionType = NULL;
const char * _exceptionMessage = NULL;
jarray _mantissaArray = (jarray) 0;
jint _mantissaBufferOffset = (jint) 0;
jarray _exponentArray = (jarray) 0;
jint _exponentBufferOffset = (jint) 0;
GLbitfield _returnValue = -1;
jint _mantissaRemaining;
GLfixed *mantissa = (GLfixed *) 0;
jint _exponentRemaining;
GLint *exponent = (GLint *) 0;
mantissa = (GLfixed *)getPointer(_env, mantissa_buf, &_mantissaArray, &_mantissaRemaining, &_mantissaBufferOffset);
if (_mantissaRemaining < 16) {
_exception = 1;
_exceptionType = "java/lang/IllegalArgumentException";
_exceptionMessage = "remaining() < 16 < needed";
goto exit;
}
exponent = (GLint *)getPointer(_env, exponent_buf, &_exponentArray, &_exponentRemaining, &_exponentBufferOffset);
if (_exponentRemaining < 16) {
_exception = 1;
_exceptionType = "java/lang/IllegalArgumentException";
_exceptionMessage = "remaining() < 16 < needed";
goto exit;
}
if (mantissa == NULL) {
char * _mantissaBase = (char *)_env->GetPrimitiveArrayCritical(_mantissaArray, (jboolean *) 0);
mantissa = (GLfixed *) (_mantissaBase + _mantissaBufferOffset);
}
if (exponent == NULL) {
char * _exponentBase = (char *)_env->GetPrimitiveArrayCritical(_exponentArray, (jboolean *) 0);
exponent = (GLint *) (_exponentBase + _exponentBufferOffset);
}
_returnValue = glQueryMatrixxOES(
(GLfixed *)mantissa,
(GLint *)exponent
);
exit:
if (_exponentArray) {
releasePointer(_env, _exponentArray, exponent, _exception ? JNI_FALSE : JNI_TRUE);
}
if (_mantissaArray) {
releasePointer(_env, _mantissaArray, mantissa, _exception ? JNI_FALSE : JNI_TRUE);
}
if (_exception) {
jniThrowException(_env, _exceptionType, _exceptionMessage);
}
return (jint)_returnValue;
}
/* void glGetActiveAttrib ( GLuint program, GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, char *name ) */
static void
android_glGetActiveAttrib__IIILjava_nio_IntBuffer_2Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2B
(JNIEnv *_env, jobject _this, jint program, jint index, jint bufsize, jobject length_buf, jobject size_buf, jobject type_buf, jbyte name) {
jarray _lengthArray = (jarray) 0;
jint _lengthBufferOffset = (jint) 0;
jarray _sizeArray = (jarray) 0;
jint _sizeBufferOffset = (jint) 0;
jarray _typeArray = (jarray) 0;
jint _typeBufferOffset = (jint) 0;
jint _lengthRemaining;
GLsizei *length = (GLsizei *) 0;
jint _sizeRemaining;
GLint *size = (GLint *) 0;
jint _typeRemaining;
GLenum *type = (GLenum *) 0;
length = (GLsizei *)getPointer(_env, length_buf, &_lengthArray, &_lengthRemaining, &_lengthBufferOffset);
size = (GLint *)getPointer(_env, size_buf, &_sizeArray, &_sizeRemaining, &_sizeBufferOffset);
type = (GLenum *)getPointer(_env, type_buf, &_typeArray, &_typeRemaining, &_typeBufferOffset);
if (length == NULL) {
char * _lengthBase = (char *)_env->GetPrimitiveArrayCritical(_lengthArray, (jboolean *) 0);
length = (GLsizei *) (_lengthBase + _lengthBufferOffset);
}
if (size == NULL) {
char * _sizeBase = (char *)_env->GetPrimitiveArrayCritical(_sizeArray, (jboolean *) 0);
size = (GLint *) (_sizeBase + _sizeBufferOffset);
}
if (type == NULL) {
char * _typeBase = (char *)_env->GetPrimitiveArrayCritical(_typeArray, (jboolean *) 0);
type = (GLenum *) (_typeBase + _typeBufferOffset);
}
glGetActiveAttrib(
(GLuint)program,
(GLuint)index,
(GLsizei)bufsize,
(GLsizei *)length,
(GLint *)size,
(GLenum *)type,
reinterpret_cast<char *>(name)
);
if (_typeArray) {
releasePointer(_env, _typeArray, type, JNI_TRUE);
}
if (_sizeArray) {
releasePointer(_env, _sizeArray, size, JNI_TRUE);
}
if (_lengthArray) {
releasePointer(_env, _lengthArray, length, JNI_TRUE);
}
}
static void *
getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
if (!buffer) {
return NULL;
}
void* buf = _env->GetDirectBufferAddress(buffer);
if (buf) {
jint position = _env->GetIntField(buffer, positionID);
jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
buf = ((char*) buf) + (position << elementSizeShift);
} else {
if (allowIndirectBuffers(_env)) {
jarray array = 0;
jint remaining;
jint offset;
buf = getPointer(_env, buffer, &array, &remaining, &offset);
if (array) {
releasePointer(_env, array, buf, 0);
}
buf = (char*)buf + offset;
} else {
jniThrowException(_env, "java/lang/IllegalArgumentException",
"Must use a native order direct Buffer");
}
}
return buf;
}
bool release(JNIEnv *env, jint mode=0)
{
Logger::log(LOG_DEBUGTRACE, "Releasing ArrayBufferPointerData %p\n", startPointer);
releasePointer(env, mode);
env->DeleteGlobalRef(array);
return true;
}
/* void glDebugMessageControlKHR ( GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled ) */
static void
android_glDebugMessageControlKHR__IIIILjava_nio_IntBuffer_2Z
(JNIEnv *_env, jobject _this, jint source, jint type, jint severity, jint count, jobject ids_buf, jboolean enabled) {
jarray _array = (jarray) 0;
jint _bufferOffset = (jint) 0;
jint _remaining;
GLuint *ids = (GLuint *) 0;
ids = (GLuint *)getPointer(_env, ids_buf, &_array, &_remaining, &_bufferOffset);
if (ids == NULL) {
char * _idsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
ids = (GLuint *) (_idsBase + _bufferOffset);
}
glDebugMessageControlKHR(
(GLenum)source,
(GLenum)type,
(GLenum)severity,
(GLsizei)count,
(GLuint *)ids,
(GLboolean)enabled
);
if (_array) {
releasePointer(_env, _array, ids, JNI_FALSE);
}
}
// C function:: void vgSetParameterfv(VGHandle object, VGint paramType, VGint
// count, const VGfloat * values);
JNIEXPORT jint JNICALL
Java_com_example_startvg_VG11_vgSetParameterfv(
JNIEnv* env, jobject obj,
jlong object, jint paramType, jint count, jobject values){
jarray _array = (jarray) 0;
jint _remaining;
char *data = (char*) 0;
jint vgSetParameterfv_ret = FALSE;
data = (char*)getPointer(env, values, &_array, &_remaining);
if (_remaining < 0){
env->ThrowNew(AIOOBEClass, "In vgSetfv():: Empty Buffer -- _remaining < 0.");
}
vgSetParameterfv(
(VGHandle) object,
(VGint) paramType,
(VGint) count,
(const VGfloat *) data
);
vgSetParameterfv_ret = SUCCESS;
exit:
if ( _array ){
releasePointer(env, _array, data, JNI_FALSE);
}
return vgSetParameterfv_ret;
}
void Player::onMouseClick(int button, int state, int x, int y)
{
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
if (mouseControlsCamera_)
releasePointer();
else
grabPointer();
}
}
/* void glGetActiveUniformBlockName ( GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName ) */
static void
android_glGetActiveUniformBlockName_IILjava_nio_Buffer_2Ljava_nio_Buffer_2
(JNIEnv* _env, jobject _this, jint program, jint uniformBlockIndex, jobject length_buf, jobject uniformBlockName_buf) {
jint _exception = 0;
const char* _exceptionType;
const char* _exceptionMessage;
jarray _lengthArray = (jarray)0;
jint _lengthBufferOffset = (jint)0;
GLsizei* _length = (GLsizei*)0;
jint _lengthRemaining;
jarray _nameArray = (jarray)0;
jint _nameBufferOffset = (jint)0;
GLchar* _name = (GLchar*)0;
jint _nameRemaining;
_length = (GLsizei*)getPointer(_env, length_buf, &_lengthArray, &_lengthRemaining, &_lengthBufferOffset);
if (_length == NULL) {
GLsizei* _lengthBase = (GLsizei*)_env->GetPrimitiveArrayCritical(_lengthArray, (jboolean*)0);
_length = (GLsizei*)(_lengthBase + _lengthBufferOffset);
}
_name = (GLchar*)getPointer(_env, uniformBlockName_buf, &_nameArray, &_nameRemaining, &_nameBufferOffset);
if (_name == NULL) {
GLchar* _nameBase = (GLchar*)_env->GetPrimitiveArrayCritical(_nameArray, (jboolean*)0);
_name = (GLchar*)(_nameBase + _nameBufferOffset);
}
glGetActiveUniformBlockName(
(GLuint)program,
(GLuint)uniformBlockIndex,
(GLsizei)_nameRemaining,
_length, _name
);
if (_nameArray) {
releasePointer(_env, _nameArray, _name, JNI_TRUE);
}
if (_lengthArray) {
releasePointer(_env, _lengthArray, _length, JNI_TRUE);
}
}
static void
getarray
(JNIEnv *_env, jobject _this, jint pname, jobject params_buf) {
jint _exception = 0;
const char * _exceptionType;
const char * _exceptionMessage;
jarray _array = (jarray) 0;
jint _bufferOffset = (jint) 0;
jint _remaining;
CTYPE *params = (CTYPE *) 0;
int _needed = 0;
params = (CTYPE *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
_remaining /= sizeof(CTYPE); // convert from bytes to item count
_needed = getNeededCount(pname);
// if we didn't find this pname, we just assume the user passed
// an array of the right size -- this might happen with extensions
// or if we forget an enum here.
if (_needed>0 && _remaining < _needed) {
_exception = 1;
_exceptionType = "java/lang/IllegalArgumentException";
_exceptionMessage = "remaining() < needed";
goto exit;
}
if (params == NULL) {
char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
params = (CTYPE *) (_paramsBase + _bufferOffset);
}
GET(
(GLenum)pname,
(CTYPE *)params
);
exit:
if (_array) {
releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE);
}
if (_exception) {
jniThrowException(_env, _exceptionType, _exceptionMessage);
}
}
void Player::onKeyPress(unsigned char key)
{
static const auto ESCAPE = (unsigned char)27;
std::shared_ptr<Camera> camera = scene_->getCamera();
switch(key)
{
case 'a':
camera->moveRight(-TRANSLATION_SPEED);
break;
case 'd':
camera->moveRight(TRANSLATION_SPEED);
break;
case 's':
camera->moveForward(-TRANSLATION_SPEED);
break;
case 'w':
camera->moveForward(TRANSLATION_SPEED);
break;
case 'q':
camera->moveUp(-TRANSLATION_SPEED);
break;
case 'e':
camera->moveUp(TRANSLATION_SPEED);
break;
case ESCAPE:
releasePointer();
break;
}
scene_->getLights()[0]->setPosition(scene_->getCamera()->getPosition());
//std::cout << scene_->getCamera()->toString() << std::endl;
}
/* void glSamplerParameterIuivEXT ( GLuint sampler, GLenum pname, const GLuint *param ) */
static void
android_glSamplerParameterIuivEXT__IILjava_nio_IntBuffer_2
(JNIEnv *_env, jobject _this, jint sampler, jint pname, jobject param_buf) {
jarray _array = (jarray) 0;
jint _bufferOffset = (jint) 0;
jint _remaining;
GLuint *param = (GLuint *) 0;
param = (GLuint *)getPointer(_env, param_buf, &_array, &_remaining, &_bufferOffset);
if (param == NULL) {
char * _paramBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
param = (GLuint *) (_paramBase + _bufferOffset);
}
glSamplerParameterIuivEXT(
(GLuint)sampler,
(GLenum)pname,
(GLuint *)param
);
if (_array) {
releasePointer(_env, _array, param, JNI_FALSE);
}
}
/* void glGetTexParameterIivEXT ( GLenum target, GLenum pname, GLint *params ) */
static void
android_glGetTexParameterIivEXT__IILjava_nio_IntBuffer_2
(JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) {
jarray _array = (jarray) 0;
jint _bufferOffset = (jint) 0;
jint _remaining;
GLint *params = (GLint *) 0;
params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining, &_bufferOffset);
if (params == NULL) {
char * _paramsBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
params = (GLint *) (_paramsBase + _bufferOffset);
}
glGetTexParameterIivEXT(
(GLenum)target,
(GLenum)pname,
(GLint *)params
);
if (_array) {
releasePointer(_env, _array, params, JNI_TRUE);
}
}
/* void glGetShaderSource ( GLuint shader, GLsizei bufsize, GLsizei *length, char *source ) */
static void
android_glGetShaderSource__IILjava_nio_IntBuffer_2B
(JNIEnv *_env, jobject _this, jint shader, jint bufsize, jobject length_buf, jbyte source) {
jarray _array = (jarray) 0;
jint _bufferOffset = (jint) 0;
jint _remaining;
GLsizei *length = (GLsizei *) 0;
length = (GLsizei *)getPointer(_env, length_buf, &_array, &_remaining, &_bufferOffset);
if (length == NULL) {
char * _lengthBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
length = (GLsizei *) (_lengthBase + _bufferOffset);
}
glGetShaderSource(
(GLuint)shader,
(GLsizei)bufsize,
(GLsizei *)length,
(char *)source
);
if (_array) {
releasePointer(_env, _array, length, JNI_TRUE);
}
}
/* void glDrawElementsInstancedBaseVertex ( GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instanceCount, GLint basevertex ) */
static void
android_glDrawElementsInstancedBaseVertex__IIILjava_nio_Buffer_2II
(JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf, jint instanceCount, jint basevertex) {
jint _exception = 0;
const char * _exceptionType = NULL;
const char * _exceptionMessage = NULL;
jarray _array = (jarray) 0;
jint _bufferOffset = (jint) 0;
jint _remaining;
void *indices = (void *) 0;
indices = (void *)getPointer(_env, indices_buf, &_array, &_remaining, &_bufferOffset);
if (_remaining < count-basevertex) {
_exception = 1;
_exceptionType = "java/lang/ArrayIndexOutOfBoundsException";
_exceptionMessage = "remaining() < count-basevertex < needed";
goto exit;
}
if (indices == NULL) {
char * _indicesBase = (char *)_env->GetPrimitiveArrayCritical(_array, (jboolean *) 0);
indices = (void *) (_indicesBase + _bufferOffset);
}
glDrawElementsInstancedBaseVertex(
(GLenum)mode,
(GLsizei)count,
(GLenum)type,
(void *)indices,
(GLsizei)instanceCount,
(GLint) basevertex
);
exit:
if (_array) {
releasePointer(_env, _array, indices, JNI_FALSE);
}
}
static void *
getDirectBufferPointer(JNIEnv *_env, jobject buffer) {
if (!buffer) {
return NULL;
}
void* buf = _env->GetDirectBufferAddress(buffer);
if (buf) {
jint position = _env->GetIntField(buffer, positionID);
jint elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID);
buf = ((char*) buf) + (position << elementSizeShift);
} else {
if (allowIndirectBuffers(_env)) {
jarray array = 0;
jint remaining;
buf = getPointer(_env, buffer, &array, &remaining);
if (array) {
releasePointer(_env, array, buf, 0);
}
} else {
_env->ThrowNew(IAEClass, "Must use a native order direct Buffer");
}
}
return buf;
}
