void GLES2HardwareIndexBuffer::unlockImpl(void) { if (mLockedToScratch) { if (mScratchUploadOnUnlock) { // have to write the data back to vertex buffer writeData(mScratchOffset, mScratchSize, mScratchPtr, mScratchOffset == 0 && mScratchSize == getSizeInBytes()); } static_cast<GLES2HardwareBufferManager*>( HardwareBufferManager::getSingletonPtr())->deallocateScratch(mScratchPtr); mLockedToScratch = false; } else { #if GL_OES_mapbuffer dynamic_cast<GLES2RenderSystem*>(Root::getSingleton().getRenderSystem())->_bindGLBuffer(GL_ELEMENT_ARRAY_BUFFER, mBufferId); if(!glUnmapBufferOES(GL_ELEMENT_ARRAY_BUFFER)) { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Buffer data corrupted, please reload", "GLES2HardwareIndexBuffer::unlock"); } #else OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Lock to scratch is only supported", "GLES2HardwareIndexBuffer::unlockImpl"); #endif } mIsLocked = false; }
void GLESHardwareVertexBuffer::unlockImpl(void) { if (mLockedToScratch) { if (mScratchUploadOnUnlock) { // have to write the data back to vertex buffer writeData(mScratchOffset, mScratchSize, mScratchPtr, mScratchOffset == 0 && mScratchSize == getSizeInBytes()); } static_cast<GLESHardwareBufferManager*>( HardwareBufferManager::getSingletonPtr())->deallocateScratch(mScratchPtr); mLockedToScratch = false; } else { #if defined(GL_GLEXT_PROTOTYPES) glBindBuffer(GL_ARRAY_BUFFER, mBufferId); if(!glUnmapBufferOES( GL_ARRAY_BUFFER )) { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Buffer data corrupted, please reload", "GLESHardwareVertexBuffer::unlock"); } #else OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Only locking to scratch is supported", "GLESHardwareVertexBuffer::unlockImpl"); #endif } mIsLocked = false; }
GLboolean rglUnmapBuffer( GLenum target) { #if defined(HAVE_OPENGLES) return glUnmapBufferOES(target); #else return glUnmapBuffer(target); #endif }
void gl_vertex_buffer::unlock() { #if GL_OES_mapbuffer assert(glIsBuffer(_buffer_id) == GL_TRUE); glBindBuffer(GL_ARRAY_BUFFER, _buffer_id); glUnmapBufferOES(GL_ARRAY_BUFFER); GLNOERROR; #else assert(0); #endif }
void GLES2RendererVertexBuffer::unlock(void) { if(m_vbo) { /* TODO: print out if format is USHORT4 */ glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_vbo); glUnmapBufferOES(GL_ARRAY_BUFFER); glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0); } }
inline GLboolean VL_glUnmapBuffer(GLenum target) { if (glUnmapBufferOES) return glUnmapBufferOES(target); else { VL_TRAP(); return GL_FALSE; } }
void AEVAUnmap(AEVA* va){ if(va->format.storageType){ unsigned int arrayType=va->format.indexType?GL_ELEMENT_ARRAY_BUFFER:GL_ARRAY_BUFFER; glBindBuffer(arrayType, va->data.vbo); #ifdef AEiOS glUnmapBufferOES(arrayType); #else glUnmapBuffer(arrayType); #endif } }
void BufferObj::unmap() const { ScopedBuffer bufferBind( mTarget, mId ); #if defined( CINDER_GL_ES_2 ) GLboolean result = glUnmapBufferOES( mTarget ); #else GLboolean result = glUnmapBuffer( mTarget ); #endif if ( result != GL_TRUE ) { //throw BufferFailedUnmapExc(); } }
void OpenGLESVertexBuffer::unlock() { MYGUI_PLATFORM_ASSERT(mBufferID, "Vertex buffer in not created"); glBindBuffer(GL_ARRAY_BUFFER, mBufferID); CHECK_GL_ERROR_DEBUG(); GLboolean result = glUnmapBufferOES(GL_ARRAY_BUFFER); CHECK_GL_ERROR_DEBUG(); glBindBuffer(GL_ARRAY_BUFFER, 0); CHECK_GL_ERROR_DEBUG(); MYGUI_PLATFORM_ASSERT(result, "Error unlock vertex buffer"); }
void GLES2HardwareIndexBuffer::unlockImpl(void) { static_cast<GLES2HardwareBufferManagerBase*>(mMgr)->getStateCacheManager()->bindGLBuffer(GL_ELEMENT_ARRAY_BUFFER, mBufferId); #if OGRE_NO_GLES3_SUPPORT == 0 || defined(GL_EXT_map_buffer_range) if (mUsage & HBU_WRITE_ONLY) { OGRE_CHECK_GL_ERROR(glFlushMappedBufferRangeEXT(GL_ELEMENT_ARRAY_BUFFER, mLockStart, mLockSize)); } #endif GLboolean mapped; OGRE_CHECK_GL_ERROR(mapped = glUnmapBufferOES(GL_ELEMENT_ARRAY_BUFFER)); if(!mapped) { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Buffer data corrupted, please reload", "GLES2HardwareIndexBuffer::unlock"); } mIsLocked = false; }
void GLES2HardwareIndexBuffer::readData(size_t offset, size_t length, void* pDest) { if(mUseShadowBuffer) { // Get data from the shadow buffer void* srcData = mShadowBuffer->lock(offset, length, HBL_READ_ONLY); memcpy(pDest, srcData, length); mShadowBuffer->unlock(); } else { if(getGLES2SupportRef()->checkExtension("GL_EXT_map_buffer_range") || gleswIsSupported(3, 0)) { // Map the buffer range then copy out of it into our destination buffer void* srcData; OGRE_CHECK_GL_ERROR(srcData = glMapBufferRangeEXT(GL_ELEMENT_ARRAY_BUFFER, offset, length, GL_MAP_READ_BIT_EXT)); memcpy(pDest, srcData, length); // Unmap the buffer since we are done. GLboolean mapped; OGRE_CHECK_GL_ERROR(mapped = glUnmapBufferOES(GL_ELEMENT_ARRAY_BUFFER)); if(!mapped) { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Buffer data corrupted, please reload", "GLES2HardwareIndexBuffer::readData"); } } else { OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Reading hardware buffer is not supported", "GLES2HardwareIndexBuffer::readData"); } } }
GLboolean glUnmapBufferOESLogged(GLenum target) { printf("glUnmapBufferOES(%s)\n", GLEnumName(target)); return glUnmapBufferOES(target); }
void VertexArrayObject::freeDataPointer() { glUnmapBufferOES(GL_ARRAY_BUFFER); // unmap it after use }
JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengles_OESMapbuffer_glUnmapBufferOES(JNIEnv *__env, jclass clazz, jint target) { glUnmapBufferOESPROC glUnmapBufferOES = (glUnmapBufferOESPROC)tlsGetFunction(790); UNUSED_PARAM(clazz) return (jboolean)glUnmapBufferOES(target); }
bool AppCore::render() { #if !DISCARD_SKYBOX // Try to load textures if not already completed if (_staticTextureCompleteCount <= 6) loadStaticTextureIfAvailable(); #endif APIFactory::GetInstance().lock(OPENGL_LOCK); double timestamp = APIFactory::GetInstance().getTimeInMS(); #if !(RENDER_OCTREE_DEBUG_VOXELS || USE_STATIC_POINT_CLOUD) if ( !(_currentCameraParameterRequest & 1) && (timestamp - _lastCameraParameterChangeTimestamp > WVS_RELOAD_DELAY[0])) { // Request 1/4 of screen resolution from WVS requestPointCloudForCurrentView(4); _currentCameraParameterRequest |= 1; } else if ( !(_currentCameraParameterRequest & 2) && (timestamp - _lastCameraParameterChangeTimestamp > WVS_RELOAD_DELAY[1])) { // Request full screen resolution from WVS requestPointCloudForCurrentView(1); _currentCameraParameterRequest |= 3; } #endif if (_isUserInputMode) _renderingRequired = true; if (_renderQuality < 1.0f) _renderingRequired = true; #if !(RENDER_OCTREE_DEBUG_VOXELS || USE_STATIC_POINT_CLOUD) if (_isNewDataAvialable) { _renderingRequired = true; _isNewDataAvialable = false; } #endif if (!_renderingRequired) { APIFactory::GetInstance().unlock(OPENGL_LOCK); APIFactory::GetInstance().processUserInterfaceEvents(); return false; } _renderingRequired = false; // Updates the view frustum that is used for culling etc. based on the current // camera parameters _viewFrustum->updateCameraViewParameterCache(); // Clear context glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); #if !DISCARD_SKYBOX // Render Skybox and ground plane if (_staticTextureCompleteCount > 0) { glUseProgram(_textureShaderProgram.handle); glUniformMatrix4fv( _textureShaderProgram.uniforms[SHADER_UNIFORM_VIEW_PROJECTION_MATRIX], 1, GL_FALSE, _viewFrustum->getViewProjectionMatrixCachePtr()->f); MATRIX model; MatrixTranslation(model, _viewFrustum->getCameraPostionCachePtr()->x, _viewFrustum->getCameraPostionCachePtr()->y, _viewFrustum->getCameraPostionCachePtr()->z); glUniformMatrix4fv( _textureShaderProgram.uniforms[SHADER_UNIFORM_MODEL_MATRIX], 1, GL_FALSE, model.f); _skybox->render(); } #endif // Render points glUseProgram(_pointShaderProgram.handle); glUniform3fv( _pointShaderProgram.uniforms[POINT_SHADER_UNIFORM_REGION_ORIGIN], OCTREE_LEAF_LEVEL + 1, _octree->getRegionOrginArray()); glUniform1fv( _pointShaderProgram.uniforms[POINT_SHADER_UNIFORM_VOXEL_INCIRCLE_DIAMETER], OCTREE_LEAF_LEVEL + 1, _octree->getVoxelIncircleDiameterArray()); glUniform1fv( _pointShaderProgram.uniforms[POINT_SHADER_UNIFORM_NODE_INCIRCLE_DIAMETER], OCTREE_LEAF_LEVEL + 1, _octree->getNodeIncircleDiameterArray()); glUniform1fv( _pointShaderProgram.uniforms[POINT_SHADER_UNIFORM_VOXEL_SCREENSIZE_CIRCUMCIRCLE_RADIUS], OCTREE_LEAF_LEVEL + 1, _voxelScreensizeCircumcircleRadius); // Set camera position (necessary for backface culling) glUniform3fv( _pointShaderProgram.uniforms[POINT_SHADER_UNIFORM_CAMERA_POSITION], 1, (GLfloat*)(_viewFrustum->getCameraPostionCachePtr())); glUniformMatrix4fv( _pointShaderProgram.uniforms[POINT_SHADER_UNIFORM_PROJECTION_MATRIX], 1, GL_FALSE, _viewFrustum->getProjectionMatrixCachePtr()->f); glUniformMatrix4fv( _pointShaderProgram.uniforms[POINT_SHADER_UNIFORM_VIEW_MATRIX], 1, GL_FALSE, _viewFrustum->getViewMatrixCachePtr()->f); #if COMPACT_NODE_REGION_ENCODING const uint32_t regionVoxelFactor = 1; const uint8_t regionLevelStride = 4; const uint32_t regionLevelDataType = GL_UNSIGNED_BYTE; #else const uint32_t regionVoxelFactor = 2; const uint8_t regionLevelStride = 8; const uint32_t regionLevelDataType = GL_UNSIGNED_SHORT; #endif #if DIRECT_VBO #if DIRECT_VBO_DOUBLE_BUFFERED if (bufferID == 0) bufferID = 1; else bufferID = 0; #endif glBindBuffer(GL_ARRAY_BUFFER, _dataVBO[bufferID]); uint32_t* const gpuBuffer = (uint32_t*)glMapBufferOES(GL_ARRAY_BUFFER, GL_WRITE_ONLY_OES); uint32_t* const regionLevelBuffer = gpuBuffer; uint32_t* const voxelBuffer = gpuBuffer + GPU_MAX_POINTS * regionVoxelFactor; glVertexAttribPointer( POINT_SHADER_ATTRIBUTE_DATA1, 4, GL_UNSIGNED_BYTE, GL_FALSE, 0, (void *)(GPU_MAX_POINTS * regionLevelStride)); glVertexAttribPointer( POINT_SHADER_ATTRIBUTE_DATA2, 4, regionLevelDataType, GL_FALSE, 0, 0); glEnableVertexAttribArray(POINT_SHADER_ATTRIBUTE_DATA1); glEnableVertexAttribArray(POINT_SHADER_ATTRIBUTE_DATA2); // Traverse octree, copy points into buffer and call rendering callback _octree->copyPointsToBuffer( _renderQuality, !_isInteractiveMode, regionLevelBuffer, voxelBuffer, &_pointsToRenderCount, &_renderingRequired); glDisableVertexAttribArray(POINT_SHADER_ATTRIBUTE_DATA1); glDisableVertexAttribArray(POINT_SHADER_ATTRIBUTE_DATA2); glUnmapBufferOES(GL_ARRAY_BUFFER); #elif NO_VBO uint32_t* const regionLevelBuffer = _gpuBuffer; uint32_t* const voxelBuffer = _gpuBuffer + GPU_MAX_POINTS * regionVoxelFactor; glVertexAttribPointer( POINT_SHADER_ATTRIBUTE_DATA1, 4, GL_UNSIGNED_BYTE, GL_FALSE, 4, voxelBuffer); glVertexAttribPointer( POINT_SHADER_ATTRIBUTE_DATA2, 4, regionLevelDataType, GL_FALSE, regionLevelStride, regionLevelBuffer); glEnableVertexAttribArray(POINT_SHADER_ATTRIBUTE_DATA1); glEnableVertexAttribArray(POINT_SHADER_ATTRIBUTE_DATA2); // Traverse octree, copy points into buffer and call rendering callback _octree->copyPointsToBuffer( _renderQuality, !_isInteractiveMode, regionLevelBuffer, voxelBuffer, &_pointsToRenderCount, &_renderingRequired); glDisableVertexAttribArray(POINT_SHADER_ATTRIBUTE_DATA1); glDisableVertexAttribArray(POINT_SHADER_ATTRIBUTE_DATA2); #endif #ifdef OPENGL_ES const GLenum discard_attachments[] = { GL_DEPTH_ATTACHMENT }; glDiscardFramebufferEXT(GL_FRAMEBUFFER, 1, discard_attachments); #endif if (_renderingRequired & Octree::OCTREE_RENDERING_CANCELED) { APIFactory::GetInstance().unlock(OPENGL_LOCK); //TODO: In case we overestimate the render quality by far this becomes a stupid loop _octree->estimateInteractiveRenderQuality(&_renderQuality, OCTREE_INTERACTIVE_RENDERING_POINT_THRESHOLD); return false; } #if BENCHMARK_1_MILLION if (_pointsToRenderCount >= 1000000) { _renderingRequired = true; double time = APIFactory::GetInstance().getTimeInMS(); printf("%f\n", time - _lastFrame); _lastFrame = time; } #endif if (_isUserInputMode || ((timestamp - _lastCameraParameterChangeTimestamp) < 500)) { // Within 500ms we consider any input as movement double_t renderingTimeInMS = APIFactory::GetInstance().getTimeInMS() - timestamp; if (renderingTimeInMS > (1000.0 / MINIMUM_FRAMERATE)) { // Time to render last frame took longer than target framerate. // Lower render quality to speed up framerate. _renderQuality -= RENDER_QUALITY_FINE_ADJUSTMENT; _nodeRestoreQuota = 0; } else if (renderingTimeInMS < (1000.0 / MAXIMUM_FRAMERATE)) { _renderQuality += RENDER_QUALITY_FINE_ADJUSTMENT; _nodeRestoreQuota = 32; } _renderingRequired = true; } else { // No movement with in the last 500ms. Increase render quality _renderQuality += RENDER_QUALITY_COARSE_ADJUSTMENT; _isInteractiveMode = false; } // Check range of render quality if (_renderQuality > 1.0f) _renderQuality = 1.0f; else if (_renderQuality < RENDER_QUALITY_FINE_ADJUSTMENT) _renderQuality = RENDER_QUALITY_FINE_ADJUSTMENT; APIFactory::GetInstance().unlock(OPENGL_LOCK); return true; }