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; }