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