void BufferRAM2GLConverter::update(const DataRepresentation* source, DataRepresentation* destination) { const BufferRAM* src = static_cast<const BufferRAM*>(source); BufferGL* dst = static_cast<BufferGL*>(destination); dst->setSize(src->getSize()); dst->upload(src->getData(), src->getSize() * src->getSizeOfElement()); }
DataRepresentation* BufferRAM2GLConverter::createFrom(const DataRepresentation* source) { const BufferRAM* bufferRAM = static_cast<const BufferRAM*>(source); BufferGL* buffer = new BufferGL(bufferRAM->getSize(), bufferRAM->getDataFormat(), bufferRAM->getBufferType(), bufferRAM->getBufferUsage()); buffer->upload(bufferRAM->getData(), bufferRAM->getSize()*bufferRAM->getSizeOfElement()); return buffer; }
gl::Error BufferGL::copySubData(BufferImpl* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size) { BufferGL *sourceGL = GetAs<BufferGL>(source); mStateManager->bindBuffer(DestBufferOperationTarget, mBufferID); mStateManager->bindBuffer(SourceBufferOperationTarget, sourceGL->getBufferID()); mFunctions->copyBufferSubData(SourceBufferOperationTarget, DestBufferOperationTarget, sourceOffset, destOffset, size); return gl::Error(GL_NO_ERROR); }
gl::Error BufferGL::copySubData(BufferImpl* source, GLintptr sourceOffset, GLintptr destOffset, GLsizeiptr size) { BufferGL *sourceGL = GetAs<BufferGL>(source); mStateManager->bindBuffer(DestBufferOperationTarget, mBufferID); mStateManager->bindBuffer(SourceBufferOperationTarget, sourceGL->getBufferID()); mFunctions->copyBufferSubData(SourceBufferOperationTarget, DestBufferOperationTarget, sourceOffset, destOffset, size); if (mShadowBufferData && size > 0) { ASSERT(sourceGL->mShadowBufferData); memcpy(mShadowCopy.data() + destOffset, sourceGL->mShadowCopy.data() + sourceOffset, size); } return gl::Error(GL_NO_ERROR); }
void VertexAttributeCache<VertexCacheVBO>::updateGeometryInstanceCacheEntry( GeometryInstanceGLHandle gi, GeometryInstanceCacheEntry& geometryInstanceCacheEntry, AttributeCacheEntry* attributeCacheEntry ) { VertexAttributesGLSharedHandle const& vertexAttributes = gi->getGeometry()->getVertexAttributes(); VertexDataGLHandle vertexData = vertexAttributes->getVertexDataGLHandle(); geometryInstanceCacheEntry.m_formatId = registerVertexFormat( vertexAttributes.get(), gi->m_programPipeline->m_activeAttributeMask ); const VertexFormat &vertexFormat = m_vertexFormats[geometryInstanceCacheEntry.m_formatId]; for ( unsigned int index = 0; index < vertexFormat.m_numStreams; ++index ) { unsigned int streamId = vertexFormat.m_streamIds[index]; AttributeCacheEntry& cacheEntry = attributeCacheEntry[index]; BufferGL *buffer = vertexData->m_data[streamId].m_buffer; if ( buffer ) { DP_ASSERT( buffer->getBuffer() ); cacheEntry.vbo = buffer->getBuffer()->getGLId(); cacheEntry.offset = reinterpret_cast<GLvoid *>(vertexData->m_data[streamId].m_offset); } else { cacheEntry.vbo = 0; cacheEntry.offset = 0; } } // update indices data IndicesGLSharedHandle const& indices = gi->getGeometry()->getIndices(); if ( indices && indices->getBufferHandle() ) { DP_ASSERT( indices->getBufferHandle()->getBuffer() ); geometryInstanceCacheEntry.m_attributeCacheIndices.vbo = indices->getBufferHandle()->getBuffer()->getGLId(); geometryInstanceCacheEntry.m_attributeCacheIndices.offset = 0; } else { geometryInstanceCacheEntry.m_attributeCacheIndices.vbo = 0; geometryInstanceCacheEntry.m_attributeCacheIndices.offset = 0; } geometryInstanceCacheEntry.m_drawCall.updateDrawCall( gi ); geometryInstanceCacheEntry.m_attributeCacheEntry = attributeCacheEntry; geometryInstanceCacheEntry.m_vertexAttributesHandle = vertexAttributes.get(); geometryInstanceCacheEntry.m_indicesHandle = indices.get(); }
void MeshGL::update(bool editable) { attributesGL_.clear(); Mesh* owner = this->getOwner(); attributesArray_->bind(); // Have to call bind before clear. attributesArray_->clear(); if (editable) { for (Buffer* buf : owner->getBuffers()) { BufferGL* bufGL = buf->getEditableRepresentation<BufferGL>(); attributesGL_.push_back(bufGL); attributesArray_->attachBufferObject(bufGL->getBufferObject().get()); } } else { for (Buffer* buf : owner->getBuffers()) { const BufferGL* bufGL = buf->getRepresentation<BufferGL>(); attributesGL_.push_back(bufGL); attributesArray_->attachBufferObject(bufGL->getBufferObject().get()); } } attributesArray_->unbind(); }
gl::Error StateManagerGL::setGenericDrawState(const gl::Data &data) { const gl::State &state = *data.state; // If the context has changed, pause the previous context's transform feedback and queries if (data.context != mPrevDrawContext) { if (mPrevDrawTransformFeedback != nullptr) { mPrevDrawTransformFeedback->syncPausedState(true); } for (QueryGL *prevQuery : mPrevDrawQueries) { prevQuery->pause(); } } mPrevDrawTransformFeedback = nullptr; mPrevDrawQueries.clear(); mPrevDrawContext = data.context; // Sync the current program state const gl::Program *program = state.getProgram(); const ProgramGL *programGL = GetImplAs<ProgramGL>(program); useProgram(programGL->getProgramID()); for (size_t uniformBlockIndex = 0; uniformBlockIndex < program->getActiveUniformBlockCount(); uniformBlockIndex++) { GLuint binding = program->getUniformBlockBinding(static_cast<GLuint>(uniformBlockIndex)); const OffsetBindingPointer<gl::Buffer> &uniformBuffer = data.state->getIndexedUniformBuffer(binding); if (uniformBuffer.get() != nullptr) { BufferGL *bufferGL = GetImplAs<BufferGL>(uniformBuffer.get()); if (uniformBuffer.getSize() == 0) { bindBufferBase(GL_UNIFORM_BUFFER, binding, bufferGL->getBufferID()); } else { bindBufferRange(GL_UNIFORM_BUFFER, binding, bufferGL->getBufferID(), uniformBuffer.getOffset(), uniformBuffer.getSize()); } } } const std::vector<SamplerBindingGL> &appliedSamplerUniforms = programGL->getAppliedSamplerUniforms(); for (const SamplerBindingGL &samplerUniform : appliedSamplerUniforms) { GLenum textureType = samplerUniform.textureType; for (GLuint textureUnitIndex : samplerUniform.boundTextureUnits) { const gl::Texture *texture = state.getSamplerTexture(textureUnitIndex, textureType); if (texture != nullptr) { const TextureGL *textureGL = GetImplAs<TextureGL>(texture); if (mTextures[textureType][textureUnitIndex] != textureGL->getTextureID()) { activeTexture(textureUnitIndex); bindTexture(textureType, textureGL->getTextureID()); } textureGL->syncState(textureUnitIndex, texture->getTextureState()); } else { if (mTextures[textureType][textureUnitIndex] != 0) { activeTexture(textureUnitIndex); bindTexture(textureType, 0); } } const gl::Sampler *sampler = state.getSampler(textureUnitIndex); if (sampler != nullptr) { const SamplerGL *samplerGL = GetImplAs<SamplerGL>(sampler); samplerGL->syncState(sampler->getSamplerState()); bindSampler(textureUnitIndex, samplerGL->getSamplerID()); } else { bindSampler(textureUnitIndex, 0); } } } const gl::Framebuffer *framebuffer = state.getDrawFramebuffer(); const FramebufferGL *framebufferGL = GetImplAs<FramebufferGL>(framebuffer); bindFramebuffer(GL_DRAW_FRAMEBUFFER, framebufferGL->getFramebufferID()); framebufferGL->syncDrawState(); // Seamless cubemaps are required for ES3 and higher contexts. setTextureCubemapSeamlessEnabled(data.clientVersion >= 3); // Set the current transform feedback state gl::TransformFeedback *transformFeedback = state.getCurrentTransformFeedback(); if (transformFeedback) { TransformFeedbackGL *transformFeedbackGL = GetImplAs<TransformFeedbackGL>(transformFeedback); bindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedbackGL->getTransformFeedbackID()); transformFeedbackGL->syncActiveState(transformFeedback->isActive(), transformFeedback->getPrimitiveMode()); transformFeedbackGL->syncPausedState(transformFeedback->isPaused()); mPrevDrawTransformFeedback = transformFeedbackGL; } else { bindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); mPrevDrawTransformFeedback = nullptr; } // Set the current query state for (GLenum queryType : QueryTypes) { gl::Query *query = state.getActiveQuery(queryType); if (query != nullptr) { QueryGL *queryGL = GetImplAs<QueryGL>(query); queryGL->resume(); mPrevDrawQueries.insert(queryGL); } } return gl::Error(GL_NO_ERROR); }