ofGLProgrammableRenderer

class methods

variables

Extends

This class extends others, you can call their methods on an instance of ofGLProgrammableRenderer too:

The OpenGL programable renderer is a renderer for OF that is built specifically to support both newer versions of OpenGL (3+) as well as supporting GLES, which is what you'll be using if you're running OF on an ARM Linux (i.e. Raspberry Pi), Android, or iOS device. There are a few key differences between OpenGL 3 and OpenGL 2 that are largely hidden from you by OF. You can still use the same methods for drawing, making meshes, uploading textures, and other drawing operations on the programmable renderer as you could on the direct pipeline, so you're not missing anything if you stick to the older pipeline. The most significant difference probably comes in writing GLSL shaders, since the syntax changes between the older implementation and the newer. One of the important things that the ofGLProgrammableRenderer adds is default shaders. That's right: every time you run your OF application, shaders are created and uploaded to the GPU without you even knowing it. There's also addition parameters that are automatically passed to the shader program that you can leverage if you're writing your own. Check out this chapter about OpenGL in the ofBook and this blog post for more information on using different OpenGL versions.

To initialize the ofGLProgrammableRenderer call ofSetCurrentRenderer() before you call ofSetupOpenGL() in your main.cpp file:

// say that we're going to *use* the fancy new renderer
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(1024,768, OF_WINDOW);         // <-------- setup the GL context

After that, things should remain the same for you whether you're using the older ofGLRenderer or the newer ofGLProgrammableRenderer.

Alternatively, in openFrameworks 0.9 you can directly set the OpenGL version as follows: 

// main.cpp (openFrameworks 0.9)
int main(){
    ofGLWindowSettings settings;
    settings.setGLVersion(4,5); /// < select your GL Version here
    ofCreateWindow(settings); ///< create your window here
    ofRunApp(new ofApp());
}

ofGLProgrammableRenderer(...)

ofGLProgrammableRenderer::ofGLProgrammableRenderer(const ofAppBaseWindow *window)

background(...)

void ofGLProgrammableRenderer::background(const ofColor &c)

background(...)

void ofGLProgrammableRenderer::background(float brightness)

background(...)

void ofGLProgrammableRenderer::background(int hexColor, float _a=255.0f)

background(...)

void ofGLProgrammableRenderer::background(int r, int g, int b, int a=255)

begin(...)

void ofGLProgrammableRenderer::begin(const ofFbo &fbo, ofFboMode mode)

bind(...)

void ofGLProgrammableRenderer::bind(const ofBaseMaterial &material)

bind(...)

void ofGLProgrammableRenderer::bind(const ofBaseVideoDraws &video)

bind(...)

void ofGLProgrammableRenderer::bind(const ofCamera &camera, const ofRectangle &viewport)

bind(...)

void ofGLProgrammableRenderer::bind(const ofFbo &fbo)

bind(...)

void ofGLProgrammableRenderer::bind(const ofShader &shader)

bind(...)

void ofGLProgrammableRenderer::bind(const ofTexture &texture, int location)

bindForBlitting(...)

void ofGLProgrammableRenderer::bindForBlitting(const ofFbo &fboSrc, ofFbo &fboDst, int attachmentPoint)

clear()

void ofGLProgrammableRenderer::clear()

clear(...)

void ofGLProgrammableRenderer::clear(float brightness, float a)

clear(...)

void ofGLProgrammableRenderer::clear(float r, float g, float b, float a)

clearAlpha()

void ofGLProgrammableRenderer::clearAlpha()

defaultFragmentShaderHeader(...)

string ofGLProgrammableRenderer::defaultFragmentShaderHeader(GLenum textureTarget)

defaultVertexShaderHeader(...)

string ofGLProgrammableRenderer::defaultVertexShaderHeader(GLenum textureTarget)

disableAlphaMask()

void ofGLProgrammableRenderer::disableAlphaMask()

disableAntiAliasing()

void ofGLProgrammableRenderer::disableAntiAliasing()

disableLight(...)

void ofGLProgrammableRenderer::disableLight(int lightIndex)

disableLighting()

void ofGLProgrammableRenderer::disableLighting()

disablePointSprites()

void ofGLProgrammableRenderer::disablePointSprites()

disableSeparateSpecularLight()

void ofGLProgrammableRenderer::disableSeparateSpecularLight()

disableTextureTarget(...)

void ofGLProgrammableRenderer::disableTextureTarget(int textureTarget, int textureLocation)

draw(...)

void ofGLProgrammableRenderer::draw(const of3dPrimitive &model, ofPolyRenderMode renderType)

draw(...)

void ofGLProgrammableRenderer::draw(const ofBaseVideoDraws &video, float x, float y, float w, float h)

draw(...)

void ofGLProgrammableRenderer::draw(const ofFloatImage &image, float x, float y, float z, float w, float h, float sx, float sy, float sw, float sh)

draw(...)

void ofGLProgrammableRenderer::draw(const ofImage &image, float x, float y, float z, float w, float h, float sx, float sy, float sw, float sh)

draw(...)

void ofGLProgrammableRenderer::draw(const ofMesh &vertexData, ofPolyRenderMode renderType, bool useColors, bool useTextures, bool useNormals)

draw(...)

void ofGLProgrammableRenderer::draw(const ofNode &node)

draw(...)

void ofGLProgrammableRenderer::draw(const ofPath &path)

draw(...)

void ofGLProgrammableRenderer::draw(const ofPolyline &poly)

draw(...)

void ofGLProgrammableRenderer::draw(const ofShortImage &image, float x, float y, float z, float w, float h, float sx, float sy, float sw, float sh)

draw(...)

void ofGLProgrammableRenderer::draw(const ofTexture &image, float x, float y, float z, float w, float h, float sx, float sy, float sw, float sh)

draw(...)

void ofGLProgrammableRenderer::draw(const ofVbo &vbo, GLuint drawMode, int first, int total)

draw(...)

void ofGLProgrammableRenderer::draw(const ofVboMesh &mesh, ofPolyRenderMode renderType)

drawCircle(...)

void ofGLProgrammableRenderer::drawCircle(float x, float y, float z, float radius)

drawElements(...)

void ofGLProgrammableRenderer::drawElements(const ofVbo &vbo, GLuint drawMode, int amt, int offsetelements=0)

drawElementsInstanced(...)

void ofGLProgrammableRenderer::drawElementsInstanced(const ofVbo &vbo, GLuint drawMode, int amt, int primCount)

drawEllipse(...)

void ofGLProgrammableRenderer::drawEllipse(float x, float y, float z, float width, float height)

drawInstanced(...)

void ofGLProgrammableRenderer::drawInstanced(const ofVbo &vbo, GLuint drawMode, int first, int total, int primCount)

drawInstanced(...)

void ofGLProgrammableRenderer::drawInstanced(const ofVboMesh &mesh, ofPolyRenderMode renderType, int primCount)

drawLine(...)

void ofGLProgrammableRenderer::drawLine(float x1, float y1, float z1, float x2, float y2, float z2)

drawRectangle(...)

void ofGLProgrammableRenderer::drawRectangle(float x, float y, float z, float w, float h)

drawString(...)

void ofGLProgrammableRenderer::drawString(const ofTrueTypeFont &font, string text, float x, float y)

drawString(...)

void ofGLProgrammableRenderer::drawString(string text, float x, float y, float z)

drawTriangle(...)

void ofGLProgrammableRenderer::drawTriangle(float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3)

enableAntiAliasing()

void ofGLProgrammableRenderer::enableAntiAliasing()

enableLight(...)

void ofGLProgrammableRenderer::enableLight(int lightIndex)

enableLighting()

void ofGLProgrammableRenderer::enableLighting()

enablePointSprites()

void ofGLProgrammableRenderer::enablePointSprites()

enableSeparateSpecularLight()

void ofGLProgrammableRenderer::enableSeparateSpecularLight()

enableTextureTarget(...)

void ofGLProgrammableRenderer::enableTextureTarget(const ofTexture &tex, int textureLocation)

end(...)

void ofGLProgrammableRenderer::end(const ofFbo &fbo)

finishRender()

void ofGLProgrammableRenderer::finishRender()

get3dGraphics()

const of3dGraphics & ofGLProgrammableRenderer::get3dGraphics()

get3dGraphics()

of3dGraphics & ofGLProgrammableRenderer::get3dGraphics()

getBackgroundAuto()

bool ofGLProgrammableRenderer::getBackgroundAuto()

getBackgroundColor()

ofColor ofGLProgrammableRenderer::getBackgroundColor()

getCoordHandedness()

ofHandednessType ofGLProgrammableRenderer::getCoordHandedness()

getCurrentMatrix(...)

glm::mat4 ofGLProgrammableRenderer::getCurrentMatrix(ofMatrixMode matrixMode_)

Documentation from code comments


Queries the current OpenGL matrix state

Returns the specified matrix as held by the renderer's current matrix stack.

You can query one of the following:

[OF_MATRIX_MODELVIEW | OF_MATRIX_PROJECTION | OF_MATRIX_TEXTURE]

Each query will return the state of the matrix as it was uploaded to the shader currently bound.

\param matrixMode_ Which matrix mode to query \note If an invalid matrixMode is queried, this method will return the identity matrix, and print an error message.

getCurrentNormalMatrix()

glm::mat4 ofGLProgrammableRenderer::getCurrentNormalMatrix()

getCurrentOrientationMatrix()

glm::mat4 ofGLProgrammableRenderer::getCurrentOrientationMatrix()

getCurrentShader()

const ofShader & ofGLProgrammableRenderer::getCurrentShader()

getCurrentTextureTarget()

GLenum ofGLProgrammableRenderer::getCurrentTextureTarget()

getCurrentViewMatrix()

glm::mat4 ofGLProgrammableRenderer::getCurrentViewMatrix()

getCurrentViewport()

ofRectangle ofGLProgrammableRenderer::getCurrentViewport()

getFillMode()

ofFillFlag ofGLProgrammableRenderer::getFillMode()

getGLVersionMajor()

int ofGLProgrammableRenderer::getGLVersionMajor()

getGLVersionMinor()

int ofGLProgrammableRenderer::getGLVersionMinor()

getLightingEnabled()

bool ofGLProgrammableRenderer::getLightingEnabled()

getNativeViewport()

ofRectangle ofGLProgrammableRenderer::getNativeViewport()

getPath()

ofPath & ofGLProgrammableRenderer::getPath()

getRectMode()

ofRectMode ofGLProgrammableRenderer::getRectMode()

getStyle()

ofStyle ofGLProgrammableRenderer::getStyle()

getType()

const string & ofGLProgrammableRenderer::getType()

getVideoShader(...)

const ofShader * ofGLProgrammableRenderer::getVideoShader(const ofBaseVideoDraws &video)

getViewportHeight()

int ofGLProgrammableRenderer::getViewportHeight()

getViewportWidth()

int ofGLProgrammableRenderer::getViewportWidth()

isVFlipped()

bool ofGLProgrammableRenderer::isVFlipped()

loadIdentityMatrix()

void ofGLProgrammableRenderer::loadIdentityMatrix()

loadMatrix(...)

void ofGLProgrammableRenderer::loadMatrix(const float *m)

loadMatrix(...)

void ofGLProgrammableRenderer::loadMatrix(const glm::mat4 &m)

loadViewMatrix(...)

void ofGLProgrammableRenderer::loadViewMatrix(const glm::mat4 &m)

matrixMode(...)

void ofGLProgrammableRenderer::matrixMode(ofMatrixMode mode)

multMatrix(...)

void ofGLProgrammableRenderer::multMatrix(const float *m)

multMatrix(...)

void ofGLProgrammableRenderer::multMatrix(const glm::mat4 &m)

multViewMatrix(...)

void ofGLProgrammableRenderer::multViewMatrix(const glm::mat4 &m)

popMatrix()

void ofGLProgrammableRenderer::popMatrix()

popStyle()

void ofGLProgrammableRenderer::popStyle()

popView()

void ofGLProgrammableRenderer::popView()

pushMatrix()

void ofGLProgrammableRenderer::pushMatrix()

pushStyle()

void ofGLProgrammableRenderer::pushStyle()

pushView()

void ofGLProgrammableRenderer::pushView()

rotateRad(...)

void ofGLProgrammableRenderer::rotateRad(float radians)

rotateRad(...)

void ofGLProgrammableRenderer::rotateRad(float radians, float vecX, float vecY, float vecZ)

rotateXRad(...)

void ofGLProgrammableRenderer::rotateXRad(float radians)

rotateYRad(...)

void ofGLProgrammableRenderer::rotateYRad(float radians)

rotateZRad(...)

void ofGLProgrammableRenderer::rotateZRad(float radians)

saveFullViewport(...)

void ofGLProgrammableRenderer::saveFullViewport(ofPixels &pixels)

saveScreen(...)

void ofGLProgrammableRenderer::saveScreen(int x, int y, int w, int h, ofPixels &pixels)

scale(...)

void ofGLProgrammableRenderer::scale(float xAmnt, float yAmnt, float zAmnt)

setAlphaMaskTex(...)

void ofGLProgrammableRenderer::setAlphaMaskTex(const ofTexture &tex)

setBackgroundAuto(...)

void ofGLProgrammableRenderer::setBackgroundAuto(bool bManual)

setBackgroundColor(...)

void ofGLProgrammableRenderer::setBackgroundColor(const ofColor &c)

setBitmapTextMode(...)

void ofGLProgrammableRenderer::setBitmapTextMode(ofDrawBitmapMode mode)

setBlendMode(...)

void ofGLProgrammableRenderer::setBlendMode(ofBlendMode blendMode)

setCircleResolution(...)

void ofGLProgrammableRenderer::setCircleResolution(int res)

setColor(...)

void ofGLProgrammableRenderer::setColor(const ofColor &color)

setColor(...)

void ofGLProgrammableRenderer::setColor(const ofColor &color, int _a)

setColor(...)

void ofGLProgrammableRenderer::setColor(int gray)

setColor(...)

void ofGLProgrammableRenderer::setColor(int r, int g, int b)

setColor(...)

void ofGLProgrammableRenderer::setColor(int r, int g, int b, int a)

setCoordHandedness(...)

void ofGLProgrammableRenderer::setCoordHandedness(ofHandednessType handedness)

setCurveResolution(...)

void ofGLProgrammableRenderer::setCurveResolution(int resolution)

setDepthTest(...)

void ofGLProgrammableRenderer::setDepthTest(bool depthTest)

setFillMode(...)

void ofGLProgrammableRenderer::setFillMode(ofFillFlag fill)

setGlobalAmbientColor(...)

void ofGLProgrammableRenderer::setGlobalAmbientColor(const ofColor &c)

setHexColor(...)

void ofGLProgrammableRenderer::setHexColor(int hexColor)

setLightAmbientColor(...)

void ofGLProgrammableRenderer::setLightAmbientColor(int lightIndex, const ofFloatColor &c)

setLightAttenuation(...)

void ofGLProgrammableRenderer::setLightAttenuation(int lightIndex, float constant, float linear, float quadratic)

setLightDiffuseColor(...)

void ofGLProgrammableRenderer::setLightDiffuseColor(int lightIndex, const ofFloatColor &c)

setLightPosition(...)

void ofGLProgrammableRenderer::setLightPosition(int lightIndex, const glm::vec4 &position)

setLightSpecularColor(...)

void ofGLProgrammableRenderer::setLightSpecularColor(int lightIndex, const ofFloatColor &c)

setLightSpotConcentration(...)

void ofGLProgrammableRenderer::setLightSpotConcentration(int lightIndex, float exponent)

setLightSpotDirection(...)

void ofGLProgrammableRenderer::setLightSpotDirection(int lightIndex, const glm::vec4 &direction)

setLightSpotlightCutOff(...)

void ofGLProgrammableRenderer::setLightSpotlightCutOff(int lightIndex, float spotCutOff)

setLineSmoothing(...)

void ofGLProgrammableRenderer::setLineSmoothing(bool smooth)

setLineWidth(...)

void ofGLProgrammableRenderer::setLineWidth(float lineWidth)

setOrientation(...)

void ofGLProgrammableRenderer::setOrientation(ofOrientation orientation, bool vFlip)

setPolyMode(...)

void ofGLProgrammableRenderer::setPolyMode(ofPolyWindingMode mode)

setRectMode(...)

void ofGLProgrammableRenderer::setRectMode(ofRectMode mode)

setSmoothLighting(...)

void ofGLProgrammableRenderer::setSmoothLighting(bool b)

setStyle(...)

void ofGLProgrammableRenderer::setStyle(const ofStyle &style)

setVideoShaderUniforms(...)

void ofGLProgrammableRenderer::setVideoShaderUniforms(const ofBaseVideoDraws &video, const ofShader &shader)

setup(...)

void ofGLProgrammableRenderer::setup(int glVersionMajor, int glVersionMinor)

setupGraphicDefaults()

void ofGLProgrammableRenderer::setupGraphicDefaults()

setupScreen()

void ofGLProgrammableRenderer::setupScreen()

setupScreenOrtho(...)

void ofGLProgrammableRenderer::setupScreenOrtho(float width, float height, float nearDist, float farDist)

setupScreenPerspective(...)

void ofGLProgrammableRenderer::setupScreenPerspective(float width, float height, float fov, float nearDist, float farDist)

startRender()

void ofGLProgrammableRenderer::startRender()

translate(...)

void ofGLProgrammableRenderer::translate(const glm::vec3 &p)

translate(...)

void ofGLProgrammableRenderer::translate(float x, float y, float z)

unbind(...)

void ofGLProgrammableRenderer::unbind(const ofBaseMaterial &material)

unbind(...)

void ofGLProgrammableRenderer::unbind(const ofBaseVideoDraws &video)

unbind(...)

void ofGLProgrammableRenderer::unbind(const ofCamera &camera)

unbind(...)

void ofGLProgrammableRenderer::unbind(const ofFbo &fbo)

unbind(...)

void ofGLProgrammableRenderer::unbind(const ofShader &shader)

unbind(...)

void ofGLProgrammableRenderer::unbind(const ofTexture &texture, int location)

viewport(...)

void ofGLProgrammableRenderer::viewport(float x, float y, float width, float height, bool vflip=true)

viewport(...)

void ofGLProgrammableRenderer::viewport(ofRectangle viewport)

const string TYPE

const string ofGLProgrammableRenderer::TYPE

If you have any doubt about the usage of this module you can ask in the forum.

If you want to contribute better documentation or start documenting this section you can do so here

If you find anything wrong with this docs you can report any error by opening an issue