globjects is a cross-platform C++ wrapper for OpenGL API objects.
globjects is a cross-platform C++ wrapper for OpenGL API objects.
globjects provides object-oriented interfaces to the OpenGL API (3.0 and higher). It reduces the amount of OpenGL code required for rendering and facilitates coherent OpenGL use by means of an additional abstraction layer to glbinding and GLM. Common rendering tasks and processes are automated and missing features of specific OpenGL drivers are partially simulated or even emulated at run-time.
The following code snippet shows an exemplary use of the OpenGL API:
// OpenGL API
auto program = glCreateProgram();
auto vertexShader = glCreateShader(GL_VERTEX_SHADER);
auto fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, nullptr);
glCompileShader(vertexShader);
glCompileShader(fragmentShader);
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
glLinkProgram(program);
glUseProgram(program);
glUniform2f(glGetUniformLocation(program, "extent"), 1.0f, 0.5f);
Using globjects, this can be reduced to the following code:
// globjects API
auto program = new Program();
program->attach(
Shader::fromString(GL_VERTEX_SHADER, vertexShaderSource),
Shader::fromString(GL_FRAGMENT_SHADER, fragmentShaderSource)
);
program->setUniform("extent", glm::vec2(1.0f, 0.5f)));
If enabled, this code checks (1) for GL errors (glGetError) after each call, (2) shaders for compilation errors, and (3) the program for linker errors.
globjects is available for different platforms using different distribution channels. You can either download the source and manually compile it or use one of the pre-compiled releases of this repository. For systems providing package managers, we generally strive for packages in these package managers.
The various globjects packages can be installed either by downloading an installer, e.g., the latest x64 installer for Microsoft Visual Studio 2015, or downloading and extracting one of the precompiled archives, e.g. runtime, examples, and dev. Alternatively, download the source code and commence building from source.
globjects is provided on Ubuntu using PPAs. For Ubuntu 16.04 (xenial), 15.10 (wily), and 15.04 (vivid) use the current PPA, for Ubuntu 14.04 (trusty) use the backports PPA. Using the current PPA as example, the following lines install globjects including the GLFW examples:
> sudo apt-add repository ppa:cginternals/ppa
> sudo apt-get update
> sudo apt-get install libglobjects-examples-glfw
> # start example
> /usr/share/globjects/computeshader
To use globjects as dependency, install the development package:
> sudo apt-get install libglobjects-dev libglobjects-dbg
Alternatively, download the source code and commence building from source.
The package manager on OS X we depend on is homebrew. The package there is called globjects. To install globjects using homebrew, execute the following line:
> brew install globjects
Alternatively, download the source code and commence building from source.
There is currently no precompiled package maintained. Please download the source code and commence building from source.
The only mandatory run-time dependencies of globjects are the STL of the used compiler, glbinding, and an OpenGL driver library, dynamically linked with your application. However, compiling globjects requires the following required and optional dependencies:
For compilation, a C++11 compliant compiler, e.g., GCC 4.8, Clang 3.3, MSVC 2013 Update 3, is required.
First, download the source code as archive or via git:
> git clone https://github.com/cginternals/globjects.git
> cd globjects
Then, depending on the version of globjects you want to build, choose the appropriate tag or branch, e.g., for the 1.0.0 release:
> git fetch --tags
> git checkout v1.0.0
The actual compilation can be done using CMake and your favorite compiler and IDE.
For building globjects CMake via command line can be used (should work on all systems):
First create a build directory (we do not recommend in-source builds):
> mkdir build
> cd build
Configure globjects with your prefered or default generator, e.g., for Visual Studio 2015 in x64 use (note: some IDEs have integrated support for CMake projects, e.g., Qt Creator, and allow you to skip the manual project configuration):
> cmake .. -G "Visual Studio 14 2015 Win64"
In order to compile the project, either use you favorite Editor/IDE with the created project or use CMake as follows:
> cmake --build .
We suggest using the build system of globjects for a smooth integration: CMake
For it, globjects provides a find configuration script that should be installed into your system or at least accessible by CMake. In the projects CMakeLists.txt, add one of the following lines:
find_package(globjects QUIET) # if you want to check for existance
find_package(globjects REQUIRED) # if it is really required in your project
Finally, just link globjects to your own library or executable:
target_link_libraries(${target} ... PUBLIC globjects::globjects)
globjects can handle multiple OpenGL contexts. For each context, you have to initialize the globjects state. Further, you have to tell globjects which context is active on a per-thread basis.
#include <globjects/globjects.h>
// manage contexts
init();
// set explicit context active
setContext(contextID);
// set current context active
setCurrentContext();
You can also use glbinding to automatically sync OpenGL active contexts and their glbinding and globjects counterparts:
glbinding::Binding::addContextSwitchCallback([](glbinding::ContextHandle handle) {
setContext(handle);
}
The only additional thing to do is telling glbinding when a context is switched (per thread).
glbinding::Binding::useContext(handle);
Some often used functions are wrapped to ease the interface as proposed by the OpenGL API.
// somehow similar to glbinding
std::string extensions = getString(GL_EXTENSIONS);
int numExtensions = getInteger(GL_NUM_EXTENSIONS);
if (isCoreProfile())
{
return renderer(); // returns the GL_RENDERER string
}
A buffer in means of OpenGL can be used for vertex attributes, indices, uniform data, atomic counters, texture data, and shader storage data.
auto buffer = new Buffer();
// Using buffer data
buffer->setData({{ 0, 1, 2, 3, 4}}, GL_STATIC_DRAW);
// Using buffer storage
buffer->setStorage({{ 0, 1, 2, 3, 4}}, GL_MAP_READ_BIT | GL_MAP_PERSISTENT_BIT);
buffer->setSubData({{ 4, 3, 2 }}, 0);
buffer->bindBase(GL_SHADER_STORAGE_BUFFER, 0);
Texture supports both traditional interfaces and bindless support.
auto texture1 = new Texture(GL_TEXTURE_2D); // type has to be fix during lifetime
texture1->setParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
texture1->setParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
texture1->setParameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
texture1->setParameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
texture1->image2D(0, GL_RGBA8, glm::ivec2(512), 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
texture1->clearImage(0, GL_RGBA, GL_UNSIGNED_BYTE, glm::ivec4(255, 255, 255, 255));
texture1->generateMipMap();
auto texture2 = Texture::createDefault(); // creates a default-configured 2D texture
auto handle = texture2->textureHandle(); // for bindless texturing
texture2->bindActive(0); // For traditional texturing
OpenGL state is wrapped as States, StateSettings and Capabilities, where the latter two are mainly used internally.
auto currentState = State::currentState(); // full current state; usable for resetting
auto state1 = new State(State::ImmediateMode); // all changes are applied immediately
state1->enable(GL_RASTERIZER_DISCARD); // Configuring a Capability
state1->primitiveRestartIndex(static_cast<GLuint>(-1)); // Configuring a StateSetting
auto state2 = new State(State::DeferredMode); // changes has to be applied explicitly
state2->pointSize(10.0f);
state2->apply();
currentState->apply(); // Reset manipulated state
auto error = Error::get();
if (error)
{
std::cout << "Error " << std::hex << error.code() << ": " << error.name() << std::endl;
}
Enable DebugMessages to get performance hints, warnings and errors from your OpenGL driver.
DebugMessage::enable(); // enable automatic messages if KHR_debug is available
DebugMessage::setCallback([](const DebugMessage & message) {
std::cout << message.message() << std::endl;
}); // if you want to handle messages by yourself
Wraps a canvas with multiple render targets to render on.
auto fbo = new Framebuffer();
fbo->attachTexture(GL_COLOR_ATTACHMENT0, texture1);
fbo->attachTexture(GL_COLOR_ATTACHMENT1, texture2);
fbo->attachRenderbuffer(GL_DEPTH_ATTACHMENT, depthRenderbuffer);
fbo->setDrawBuffers({ GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_NONE });
fbo->printStatus(true); // Print errors if fbo is not complete
fbo->clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
fbo->clearBuffer(GL_COLOR, 0, glm::vec4(1.0f, 1.0f, 1.0f, 0.0f));
fbo->blit(GL_COLOR_ATTACHMENT0, {{ 0, 0, width, height }}, Framebuffer::defaultFBO(),
GL_BACK_LEFT, {{ 0, 0, width, height }}, GL_COLOR_BUFFER_BIT, GL_NEAREST);
Register compile-time shader replacements for shader includes.
// typically the only function call you'll need
auto namedString1 = new NamedString("/upNormal.glsl", "const vec3 up = vec3(0.0, 1.0, 0.0);");
// or reference an actual source file
auto namedString2 = new NamedString("/phong.glsl", new File("data/shaders/phong.glsl"));
The Program object can represent both render programs and compute programs. Prior usage it automatically relinks upon shader changes.
auto renderProgram = new Program();
renderProgram->attach(vertexShader, fragmentShader);
renderProgram->addUniform("viewProjection", glm::mat4(1.0));
renderProgram->use(); // compiles shaders, links and uses program
auto computeProgram = new Program();
computeProgram->attach(computeShader);
computeProgram->dispatchCompute(128, 1, 1);
auto pipeline = new ProgramPipeline();
pipeline->useStages(vertexProgram, gl::GL_VERTEX_SHADER_BIT);
pipeline->useStages(fragmentProgram, gl::GL_FRAGMENT_SHADER_BIT);
pipeline->use(); // as Program interface
Query and measure time and perform conditional rendering with passed samples.
auto query = new Query();
query->begin(GL_TIME_ELAPSED);
// calls
query->end(GL_TIME_ELAPSED);
if (!query->resultsAvailable())
{
query->wait();
}
auto elapsed = query->get(GL_QUERY_RESULT);
auto renderBuffer = new Renderbuffer();
renderBuffer->storage(GL_RGBA32F, 512, 512);
For temporary overrides of texture parameters. Note: a newly created sampler is not configured by default, and thus invalid.
auto sampler = new Sampler();
sampler->setParameter(GL_TEXTURE_MIN_FILTER, GL_LINEAR);
sampler->setParameter(GL_TEXTURE_MAG_FILTER, GL_LINEAR);
sampler->setParameter(GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
sampler->setParameter(GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
sampler->bind(0); // override sampler state for texture at binding point 0
auto shader1 = new Shader::fromFile(GL_VERTEX_SHADER, filename);
auto shader2 = new Shader::fromString(GL_FRAGMENT_SHADER, shaderSource);
Shader::globalReplace("#version 140", "#version 150"); // e.g., useful for OS X
shader1->setIncludePaths({ std::string("/data") });
shader2->compile();
std::cout << shader2->infoLog() << std::endl; // acess compile info log, although it's done automatically if there is a compile error
auto sync = Sync::fence(GL_SYNC_GPU_COMMANDS_COMPLETE);
sync->clientWait(GL_SYNC_FLUSH_COMMANDS_BIT, 2000000000); // wait on GPU; 2 secs
sync->waitSync(1000000); // wait on CPU; 1 millisecond
Connect shader outputs to buffers and restart drawing.
auto tf = new TransformFeedback();
tf->setVaryings(program, { { "next_position" } }, GL_INTERLEAVED_ATTRIBS);
tf->bind();
glEnable(GL_RASTERIZER_DISCARD);
program->use();
tf->begin(GL_TRIANGLES);
vao->drawArrays(GL_TRIANGLES, 0, 3);
tf->end();
glDisable(GL_RASTERIZER_DISCARD);
tf->draw(GL_TRIANGLE_STRIP);
Uniforms attached to Programs are updated automatically, even after relinking.
auto uniform1 = new Uniform<glm::vec3>("lightPos", glm::vec3(10.0f, 5.0f, 0.0f)); // name-based uniform binding
auto uniform2 = new Uniform<glm::mat4>(0, glm::mat4(1.0f)); // location-based uniform binding
program->addUniform(uniform1);
program->addUniform(uniform2);
program->use(); // uniform values are updated if required
Use uniform blocks for large, often switched chunks of uniforms.
auto block = program->uniformBlock("uniforms");
block->setBinding(0);
buffer->bindBase(GL_UNIFORM_BUFFER, 0);
Use to configure vertex shader inputs and trigger render pipeline processes.
auto vao = new VertexArray();
// configure bindings (see next section)
vao->enable(0);
vao->enable(1);
vao->drawArrays(GL_POINTS, 0, 10);
// For attribute pointers
auto binding1 = vao->binding(0);
binding1->setBuffer(vertexBuffer, 0, sizeof(glm::vec3));
binding1->setFormat(3, GL_FLOAT, GL_FALSE, 0);
// For static attributes for each vertex
auto binding2 = vao->binding(0);
binding2->setValue<float>(1.0f);
globjects uses the RAII (resource allocation is initialization) principle, meaning that created objects are also created on the GPU.
To effectively manage the dual-allocated memory, we use reference pointers.
We advise that every globjects Object pointer is stored in a ref_ptr.
{
ref_ptr<Query> query = new Query(); // allocate on CPU and GPU
// query is destructed and freed on GPU at the end of the block.
}
As the objects in globjects uses ref_ptr to store references, not using reference counting can lead to accidentally freed objects.
If you don't want to use smart pointers, you have to use the manual reference counting interface:
program->ref(); // increase reference count
program->unref(); // decreare reference count; potentially free program pointer and GPU program
The sources of Shaders (ShaderSource) can be configured and templated.
auto template = new StringTemplate(new File("fragmentShader.frag"));
template->replace("REPLACE", "WITH THIS");
auto shader = new Shader(template);
Although globjects tries to use most current OpenGL APIs, you can override this automatic process.
// Enable CPU shader includes (although supported, some drivers have problems, so disable it)
globjects::init(Shader::IncludeImplementation::Fallback);
// Update strategy at run-time
Buffer::hintBindlessImplementation(Buffer::BindlessImplementation::Legacy);
globjects provides logging interfaces to its objects as well as glm objects.
std::cout << Framebuffer::defaultFBO();
std::cout << glm::vec4(1.0, 0.0, 0.0, 1.0);
warning() << shader;
CG Internals offers computer graphics R&D as well as reliable technology and innovative concepts to support your computer graphics visions. We provide trainings and can help you integrate and customize cpplocate in your next project.
Visit Professional Support and Services for more details.