//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button)
{
cout << "change renderer" << endl;
if (ofGetCurrentRenderer() == _defaultRenderer)
{
ofSetCurrentRenderer(_shivaVGRenderer);
}
else
{
ofSetCurrentRenderer(_defaultRenderer);
}
}
void ofSetCurrentRenderer(const string & rendererType,bool setDefaults){
if(rendererType==ofGLProgrammableRenderer::TYPE){
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLProgrammableRenderer),setDefaults);
}else if(rendererType==ofGLRenderer::TYPE){
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLRenderer),setDefaults);
#if !defined(TARGET_OF_IOS) && !defined(TARGET_ANDROID)
}else if(rendererType==ofCairoRenderer::TYPE){
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofCairoRenderer),setDefaults);
#endif
}else{
ofLogError("ofGraphics") << "ofSetCurrentRenderer(): unknown renderer type " << rendererType << ", setting an ofGLRenderer";
ofLogError("ofGraphics") << "if you want to use a custom renderer, pass an ofPtr to a new instance of it";
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLRenderer),setDefaults);
}
}
void setDesiredRenderer(const CX_WindowConfiguration& config, bool setDefaultRendererIfNoneDesired, ofAppBaseWindow* window) {
if (config.desiredRenderer != nullptr) {
if (config.desiredRenderer->getType() == ofGLProgrammableRenderer::TYPE) {
if (Private::glCompareVersions(config.desiredOpenGLVersion, Private::CX_GLVersion(3, 2, 0)) >= 0) {
ofSetCurrentRenderer(config.desiredRenderer, true);
} else {
CX::Instances::Log.warning("CX_EntryPoint") << "Desired renderer could not be used: "
"High enough version of OpenGL is not available (requires OpenGL >= 3.2). Falling back on ofGLRenderer.";
#if OF_VERSION_MAJOR == 0 && OF_VERSION_MINOR == 9 && OF_VERSION_PATCH >= 0
std::shared_ptr<ofBaseRenderer> newRenderer = std::shared_ptr<ofBaseRenderer>(new ofGLRenderer(window));
std::dynamic_pointer_cast<ofGLRenderer>(newRenderer)->setup();
ofSetCurrentRenderer(newRenderer, true);
window->renderer() = newRenderer;
#else
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLRenderer), true);
#endif
}
} else {
ofSetCurrentRenderer(config.desiredRenderer, true);
}
return;
}
if (!setDefaultRendererIfNoneDesired) {
return;
}
//Check to see if the OpenGL version is high enough to fully support ofGLProgrammableRenderer. If not, fall back on ofGLRenderer.
if (Private::glCompareVersions(config.desiredOpenGLVersion, Private::CX_GLVersion(3, 2, 0)) >= 0) {
#if OF_VERSION_MAJOR == 0 && OF_VERSION_MINOR == 9 && OF_VERSION_PATCH >= 0
std::shared_ptr<ofBaseRenderer> newRenderer = std::shared_ptr<ofBaseRenderer>(new ofGLProgrammableRenderer(window));
std::dynamic_pointer_cast<ofGLProgrammableRenderer>(newRenderer)->setup(config.desiredOpenGLVersion.major, config.desiredOpenGLVersion.minor);
ofSetCurrentRenderer(newRenderer, true);
window->renderer() = newRenderer;
#else
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLProgrammableRenderer), true);
#endif
} else {
#if OF_VERSION_MAJOR == 0 && OF_VERSION_MINOR == 9 && OF_VERSION_PATCH >= 0
std::shared_ptr<ofBaseRenderer> newRenderer = std::shared_ptr<ofBaseRenderer>(new ofGLRenderer(window));
std::dynamic_pointer_cast<ofGLRenderer>(newRenderer)->setup();
ofSetCurrentRenderer(newRenderer, true);
window->renderer() = newRenderer;
#else
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLRenderer), true);
#endif
}
}
//========================================================================
int main( ){
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(1280, 720, OF_WINDOW);
ofRunApp( new ofApp());
}
int main(){
ofSetLogLevel(OF_LOG_VERBOSE);
#if defined(TARGET_OPENGLES)
#if (OF_VERSION_MINOR == 9)
ofGLESWindowSettings settings;
settings.width = 1280;
settings.height = 720;
settings.setGLESVersion(2);
ofCreateWindow(settings);
#else
ofSetLogLevel("ofThread", OF_LOG_ERROR);
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(1280, 720, OF_WINDOW);
#endif
#else
#ifdef FORCE_PROGRAMMMABLE
ofGLWindowSettings glWindowSettings;
glWindowSettings.width = 1280;
glWindowSettings.height = 720;
glWindowSettings.setGLVersion(3, 2);
ofCreateWindow(glWindowSettings);
#else
ofSetLogLevel("ofThread", OF_LOG_ERROR);
ofSetupOpenGL(1280, 720, OF_WINDOW);
#endif
#endif
//ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp( new ofApp() );
return 0;
}
// draws once at start
//--------------------------------------------------------------
void testApp::setup(){
// Replace the default ofGLRenderer with ofxSosoRenderer which has overriden setupScreen() and setupScreenPerspective().
// This lets us set up the scene graph how we want to.
// Warning: Up is up and down is down in this world.
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofxSosoRenderer(false)));
// Create a scene.
// The scene is a scene graph that renders objects added to its root and their children and their children's children and so on.
// When the render mode of the scene is set to RENDER_ALPHA_DEPTH_SORTED, it handles sorting of both transparent and opaque objects in the z-axis.
scene = new ofxScene(ofGetWidth(), ofGetHeight());
scene->setBackgroundColor(10, 10, 10);
// Display background image of Baccarat lobby
newLobbyImage = new bacLobbyObject(); //Call this with true to center it. Defaults to lower left origin.
scene->getRoot()->addChild(newLobbyImage); //Add the object to the scene's root.
// Display our fake people couple
peopleImage = new ofxImageObject("Lobby-Render-visualizer-people.png");
peopleImage->setTrans(0,0,2); // z-index is 2: above lobby image but beneath lights
peopleImage->setSpecialTransparency(true);
peopleImage->setCentered(true);
scene->getRoot()->addChild(peopleImage);
// Container for all light objects
newLightsMatrix = new bacLightMatrix();
newLightsMatrix->setTrans(-225, -292.5, 1); // origin is at the bottom
scene->getRoot()->addChild(newLightsMatrix);
}
int main()
{
ofSetLogLevel(OF_LOG_VERBOSE);
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(768, 576, OF_FULLSCREEN);
ofRunApp( new multiPlayer());
}
int main( ){
#ifdef TARGET_OPENGLES
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
#endif
ofSetupOpenGL(1024, 768, OF_WINDOW);
ofRunApp(new pooksApp());
}
//--------------------------------------
void ofSetupOpenGL(ofPtr<ofAppBaseWindow> windowPtr, int w, int h, int screenMode){
if(!ofGetCurrentRenderer()) {
#ifdef USE_PROGRAMMABLE_GL
ofPtr<ofBaseRenderer> renderer(new ofGLProgrammableRenderer(false));
#else
ofPtr<ofBaseRenderer> renderer(new ofGLRenderer(false));
#endif
ofSetCurrentRenderer(renderer,false);
}
window = windowPtr;
if(ofIsGLProgrammableRenderer()){
#if defined(TARGET_RASPBERRY_PI)
static_cast<ofAppEGLWindow*>(window.get())->setGLESVersion(2);
#elif defined(TARGET_LINUX_ARM)
static_cast<ofAppGLFWWindow*>(window.get())->setOpenGLVersion(2,0);
#elif !defined(TARGET_OPENGLES)
static_cast<ofAppGLFWWindow*>(window.get())->setOpenGLVersion(3,2);
#endif
}else{
#if defined(TARGET_LINUX_ARM) && !defined(TARGET_RASPBERRY_PI)
static_cast<ofAppGLFWWindow*>(window.get())->setOpenGLVersion(1,0);
#endif
}
window->setupOpenGL(w, h, screenMode);
}
int main()
{
ofSetLogLevel(OF_LOG_VERBOSE);
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(1920, 1080, OF_FULLSCREEN);
ofRunApp( new testApp());
}
//========================================================================
int main( )
{
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(800,600,OF_WINDOW);
ofSetWindowTitle("RV TD1");
ofRunApp(new ofApp());
}
//========================================================================
int main( ){
ofSetLogLevel(OF_LOG_VERBOSE);
#ifdef TARGET_OPENGLES
#ifdef PROGRAMMABLE_PRESENT
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLProgrammableRenderer()));
#else
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLES2Renderer()));
#endif
#endif
ofSetupOpenGL(1280,720, OF_WINDOW); // <-------- setup the GL context
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp( new testApp());
}
//========================================================================
int main( ){
ofSetLogLevel(OF_LOG_VERBOSE);
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(640, 480, OF_WINDOW); // <-------- setup the GL context
ofRunApp( new testApp());
}
//========================================================================
int main( ){
//commenting this line will allow to work
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(1280, 720, OF_WINDOW);
ofRunApp( new ofApp());
}
//========================================================================
int main( ){
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(1024,768,OF_WINDOW);
ofSetCircleResolution(32);
ofRunApp(new testApp());
}
//========================================================================
int main()
{
ovr_InitializeRenderingShim();
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(1200, 800, OF_WINDOW);
ofRunApp( new ofApp()) ; // start the app
}
int main()
{
ofAppNoWindow w;
ofSetLogLevel(OF_LOG_VERBOSE);
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(&w,640, 480, OF_WINDOW);
ofRunApp( new pixelsApp());
}
//------------------------------------------------------------
void ofxAppNoWindow::runAppViaInfiniteLoop(ofBaseApp * appPtr){
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofNoopRenderer));
ofAppPtr = appPtr;
#if defined TARGET_OSX || defined TARGET_LINUX
// for keyboard
//set_conio_terminal_mode();
#endif
ofNotifySetup();
// ofLogNotice("ofxAppNoWindow")
// << "***" << endl
// << "***" << endl
// << "*** running a headless (no window) app" << endl
// << "***" << endl
// << "*** keyboard input works here" << endl
// << "***"<< endl
// << "*** press Esc or Ctrl-C to quit" << endl
// << "***" << endl;
while (true)
{
/// listen for escape
#ifdef TARGET_WIN32
if (GetAsyncKeyState(VK_ESCAPE))
ofNotifyKeyPressed(OF_KEY_ESC);
#endif
#if defined TARGET_OSX || defined TARGET_LINUX
while ( kbhit() )
{
int key = getch();
if ( key == 27 )
{
ofNotifyKeyPressed(OF_KEY_ESC);
}
else if ( key == /* ctrl-c */ 3 )
{
ofLogNotice("ofxAppNoWindow") << "Ctrl-C pressed" << endl;
OF_EXIT_APP(0);
}
else
{
ofNotifyKeyPressed(key);
}
}
#endif
ofNotifyUpdate();
ofNotifyDraw();
}
}
//========================================================================
int main( ){
#ifdef USE_PROGRAMMABLE_GL
// we are using the programmable gl renderer.
ofPtr<ofBaseRenderer> renderer(new ofGLProgrammableRenderer(false));
ofSetCurrentRenderer(renderer, false);
ofSetupOpenGL(1280,720,OF_WINDOW); // <-------- setup the GL context
#else
// we are not using the progammable gl renderer.
// when we are not using the programmable gl renderer it is not safe to assume
// out current gl context provides us with the necessary openGL extensions to
// run this example.
// let's check if the current openGL context provides us with glDrawElementsInstanced
// we do this after we have initialised our openGL context.
ofSetupOpenGL(1280,720,OF_WINDOW); // <-------- setup the GL context
ostringstream extStr;
extStr << (char*)glGetString(GL_EXTENSIONS); // first get all available extensions.
string extensionsAvailable = extStr.str();
if (ofStringTimesInString(extensionsAvailable, "GL_ARB_draw_instanced") == 0)
{
ofLogFatalError("App") << " GL_ARB_draw_instanced is needed for this example but it is not supported by your graphics card. Exiting App.";
return -1;
} else {
// GL_ARB_draw_instanced is available... so far so good.
// either one of these is needed, too:
if (ofStringTimesInString(extensionsAvailable, "GL_EXT_gpu_shader4") == 0 &&
ofStringTimesInString(extensionsAvailable, "NV_vertex_program4") == 0 )
{
ofLogFatalError("App") << " GL_EXT_gpu_shader4 or NV_vertex_program4 is needed for this example but it is not supported by your graphics card. Exiting App.";
return -1;
}
}
#endif
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp(new ofApp());
}
//========================================================================
int main( ){
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(800,600,OF_WINDOW); // <-------- setup the GL context
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp(new ofApp());
}
void setup() {
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLRenderer(false)));
ofSetFrameRate(60);
ofBackground(0, 0, 0);
ofSetVerticalSync(true);
ofEnableAlphaBlending();
ofSetWindowShape(640, 380);
ofSetWindowPosition(0,0);
}
int main(){
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLProgrammableRenderer()));
ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp( new testApp() );
return 0;
}
//========================================================================
int main( )
{
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE); // Turn on programmable render pipeline
// Setup and run OpenFrameworks app
ofSetupOpenGL(1024,768,OF_WINDOW);
ofRunApp(new ofApp());
}
//========================================================================
int main( )
{
// If we want shaders on the Pi, we need to set the renderer to the programmable renderer
#ifdef TARGET_OPENGLES
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(new ofGLProgrammableRenderer()));
#endif
ofSetupOpenGL(1280, 720, OF_WINDOW); // OF_WINDOW or OF_FULLSCREEN
ofRunApp( new testApp());
}
//========================================================================
int main( ){
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(1280, 800, OF_WINDOW);
//ofGetCurrentRenderer()->enableAntiAliasing();
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp(new testApp());
}
//-----------------------------------------------------------------------------------
void ofEndSaveScreenAsPDF(){
if( bScreenShotStarted ){
if( storedRenderer ){
ofSetCurrentRenderer(storedRenderer);
storedRenderer.reset();
}
bScreenShotStarted = false;
}
}
//========================================================================
int main( ){
#ifdef TARGET_LINUX_ARM
ofGLES2Renderer * renderer = new ofGLES2Renderer();
ofSetCurrentRenderer(ofPtr<ofBaseRenderer>(renderer));
#endif
ofSetupOpenGL(1024,768,OF_WINDOW);
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp( new testApp());
}
//========================================================================
int main( ) {
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(
gpgpuLifeApp::CELL_WIDTH*gpgpuLifeApp::SCALE,
gpgpuLifeApp::CELL_HEIGHT*gpgpuLifeApp::SCALE,
OF_WINDOW); // <-------- setup the GL context
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp(new gpgpuLifeApp());
}
//========================================================================
int main( ){
// say that we're going to *use* the fancy new renderer
ofSetCurrentRenderer(ofGLProgrammableRenderer::TYPE);
ofSetupOpenGL(800, 600, OF_WINDOW); // <-------- setup the GL context
// Holography note: press 'f' to enter fullscreen; screen fills, not stretches
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp( new ofApp());
}
//-----------------------------------------------------------------------------------
void ofBeginSaveScreenAsPDF(string filename, bool bMultipage, bool b3D, ofRectangle viewport){
if( bScreenShotStarted )ofEndSaveScreenAsPDF();
storedRenderer = ofGetCurrentRenderer();
rendererCollection = ofPtr<ofRendererCollection>(new ofRendererCollection);
rendererCollection->renderers.push_back(ofGetGLRenderer());
ofSetCurrentRenderer(rendererCollection);
bScreenShotStarted = true;
}
