void SonarPointCloud::update()
{
if (m_bLoaded && (refreshNeeded || previewRefreshNeeded))
{
// Sub buffer data for colors...
glNamedBufferSubData(m_glPointsBufferVBO, m_vvec3AdjustedPointsPositions.size() * sizeof(glm::vec3), m_vvec4PointsColors.size() * sizeof(glm::vec4), m_vvec4PointsColors.data());
refreshNeeded = false;
previewRefreshNeeded = false;
}
}
void glBufferImpl::zeroMem(size_t offsetInBytes, size_t rangeInBytes) {
if (_mappedBuffer) {
clearData(offsetInBytes, rangeInBytes);
} else {
vector<Byte> newData(rangeInBytes, 0);
//if (offsetInBytes == 0 && rangeInBytes == _alignedSize) {
// glNamedBufferData(_handle, _alignedSize, newData.data(), _usage);
//} else
{
glNamedBufferSubData(_handle, offsetInBytes, rangeInBytes, newData.data());
}
}
}
void SuzanneGL::Render()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
for (ModelGL model : models)
{
glProgramUniformMatrix4fv(shaderProgram, modelMatrixIndex, 1, GL_FALSE, glm::value_ptr(model.modelMatrix));
glNamedBufferSubData(materialBuffer, 0, sizeof(Material), &model.material);
glBindVertexArray(model.vertexArray);
glUseProgram(shaderProgram);
glDrawArrays(GL_TRIANGLES, 0, model.vertexCount);
}
}
//[-------------------------------------------------------]
//[ Public virtual Renderer::ITextureBuffer methods ]
//[-------------------------------------------------------]
void TextureBufferDsa::copyDataFrom(uint32_t numberOfBytes, const void *data)
{
if (static_cast<OpenGLRenderer&>(getRenderer()).getExtensions().isGL_ARB_direct_state_access())
{
// Upload the data
glNamedBufferSubData(mOpenGLTextureBuffer, 0, static_cast<GLsizeiptr>(numberOfBytes), data);
}
else
{
// Upload the data
glNamedBufferSubDataEXT(mOpenGLTextureBuffer, 0, static_cast<GLsizeiptr>(numberOfBytes), data);
}
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
int x0 = piglit_width / 4;
int x1 = piglit_width * 3 / 4;
int y0 = piglit_height / 4;
int y1 = piglit_height * 3 / 4;
int i;
glViewport(0, 0, piglit_width, piglit_height);
glClear(GL_COLOR_BUFFER_BIT);
for (i = 0; i < NUM_SQUARES; i++) {
/* Load UBO data, at offset=alignment */
glNamedBufferSubData(buffers[0], alignment, sizeof(pos_size[0]),
pos_size[i]);
glNamedBufferSubData(buffers[1], alignment, sizeof(color[0]),
color[i]);
glNamedBufferSubData(buffers[2], alignment, sizeof(rotation[0]),
&rotation[i]);
if (!piglit_check_gl_error(GL_NO_ERROR))
return PIGLIT_FAIL;
piglit_draw_rect(-1, -1, 2, 2);
}
pass = probe(x0, y0, 0) && pass;
pass = probe(x1, y0, 1) && pass;
pass = probe(x0, y1, 2) && pass;
pass = probe(x1, y1, 3) && pass;
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
UnmappableBuffer::UnmappableBuffer(GLsizeiptr size, void *data, GLenum usage) :
mSize(nextPowerOfTwo(size)),
mUsage(usage) {
glCreateBuffers(1, &mId);
glNamedBufferData(mId, mSize, nullptr, mUsage);
if(data != nullptr) {
glNamedBufferSubData(mId, 0, size, data);
mOffset = size;
}
else
mOffset = 0;
}
void ofBufferObject::updateData(GLintptr offset, GLsizeiptr bytes, const void * data){
if(!this->data) return;
#ifdef GLEW_ARB_direct_state_access
if(GLEW_ARB_direct_state_access){
glNamedBufferSubData(this->data->id,offset,bytes,data);
return;
}
#endif
/// --------| invariant: direct state access is not available
bind(this->data->lastTarget);
glBufferSubData(this->data->lastTarget,offset,bytes,data);
unbind(this->data->lastTarget);
}
void glBufferImpl::writeData(size_t offsetInBytes, size_t rangeInBytes, const bufferPtr data)
{
if (_mappedBuffer) {
waitRange(offsetInBytes, rangeInBytes, true);
std::memcpy(((Byte*)_mappedBuffer) + offsetInBytes, data, rangeInBytes);
if (_useExplicitFlush) {
glFlushMappedNamedBufferRange(_handle, offsetInBytes, rangeInBytes);
}
} else {
clearData(offsetInBytes, rangeInBytes);
if (offsetInBytes == 0 && rangeInBytes == _alignedSize) {
glNamedBufferData(_handle, _alignedSize, data, _usage);
} else {
glNamedBufferSubData(_handle, offsetInBytes, rangeInBytes, data);
}
}
}
bufferPtr glPixelBuffer::begin() const {
GL_API::getStateTracker().setPixelPackUnpackAlignment();
glNamedBufferSubData(_pixelBufferHandle, 0, _bufferSize, NULL);
GL_API::getStateTracker().setActiveBuffer(GL_PIXEL_UNPACK_BUFFER, _pixelBufferHandle);
switch (_pbtype) {
case PBType::PB_TEXTURE_1D:
glTextureSubImage1D(_textureID,
0,
0,
_width,
_format,
_dataType,
NULL);
break;
case PBType::PB_TEXTURE_2D:
glTextureSubImage2D(_textureID,
0,
0,
0,
_width,
_height,
_format,
_dataType,
NULL);
break;
case PBType::PB_TEXTURE_3D:
glTextureSubImage3D(_textureID,
0,
0,
0,
0,
_width,
_height,
_depth,
_format,
_dataType,
NULL);
break;
};
return glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
}
void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
{
glNamedBufferSubData((GLuint) boundBuffer, offset, size, data);
}
void UnmappableBuffer::changeData(void *data, GLsizeiptr offset, GLsizeiptr size) {
if(offset + size > mSize)
resizeBuffer(offset + size);
glNamedBufferSubData(mId, offset, size, data);
}
void UnmappableBuffer::pushData(void *data, GLsizeiptr size) {
if(mOffset + size > mSize)
resizeBuffer(mOffset + size);
glNamedBufferSubData(mId, mOffset, size, data);
mOffset += size;
}
void SuzanneGL::RenderShadowMaps()
{
GLuint FramebufferName = 0;
glCreateFramebuffers(1, &FramebufferName);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glm::mat4 depthViewProjectionMatrices[NUMBER_OF_LIGHTS];
for (int i = 0; i < NUMBER_OF_LIGHTS; ++i)
{
glCreateTextures(GL_TEXTURE_2D, 1, &shadowMaps[i]);
glTextureImage2DEXT(shadowMaps[i], GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, SHADOW_RESOLUTION, SHADOW_RESOLUTION, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTextureParameteri(shadowMaps[i], GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, shadowMaps[i], 0);
glDrawBuffer(GL_NONE);
if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
return;
glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT);
glViewport(0, 0, SHADOW_RESOLUTION, SHADOW_RESOLUTION);
glm::vec3 lightDir = glm::normalize(glm::vec3(lighting.lights[i].position.x, lighting.lights[i].position.y, lighting.lights[i].position.z));
glm::mat4 depthProjectionMatrix = glm::ortho<float>(-10, 10, -10, 10, -10, 20);
glm::mat4 depthViewMatrix = glm::lookAt(lightDir, glm::vec3(0, 0, 0), glm::vec3(0, 1, 0));
depthViewProjectionMatrices[i] = depthProjectionMatrix * depthViewMatrix;
shadowModelMatrixIndex = glGetUniformLocation(shadowShaderProgram, "modelMatrix");
shadowViewProjectionMatrixIndex = glGetUniformLocation(shadowShaderProgram, "viewProjectionMatrix");
glProgramUniformMatrix4fv(shadowShaderProgram, shadowViewProjectionMatrixIndex, 1, GL_FALSE, glm::value_ptr(depthViewProjectionMatrices[i]));
for (ModelGL model : models)
{
glProgramUniformMatrix4fv(shadowShaderProgram, shadowModelMatrixIndex, 1, GL_FALSE, glm::value_ptr(model.modelMatrix));
glNamedBufferSubData(materialBuffer, 0, sizeof(Material), &model.material);
glBindVertexArray(model.vertexArray);
glUseProgram(shadowShaderProgram);
glDrawArrays(GL_TRIANGLES, 0, model.vertexCount);
}
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glm::mat4 biasMatrix(
0.5, 0.0, 0.0, 0.0,
0.0, 0.5, 0.0, 0.0,
0.0, 0.0, 0.5, 0.0,
0.5, 0.5, 0.5, 1.0
);
shadowViewProjectionMatrixIndex = glGetUniformLocation(shaderProgram, "shadowViewProjectionMatrix");
shadowBiasMatrixIndex = glGetUniformLocation(shaderProgram, "shadowBiasMatrix");
glProgramUniformMatrix4fv(shaderProgram, shadowViewProjectionMatrixIndex, 2, GL_FALSE, glm::value_ptr(depthViewProjectionMatrices[0]));
glProgramUniformMatrix4fv(shaderProgram, shadowBiasMatrixIndex, 1, GL_FALSE, glm::value_ptr(biasMatrix));
}
void BufferImplementation_DirectStateAccessARB::setSubData(const Buffer * buffer, GLintptr offset, GLsizeiptr size, const GLvoid * data) const
{
glNamedBufferSubData(buffer->id(), offset, static_cast<GLsizei>(size), data);
}
