shared_ptr<ofGLProgrammableRenderer> ofGetGLProgrammableRenderer(){
if(ofGetCurrentRenderer() && ofGetCurrentRenderer()->getType()==ofGLProgrammableRenderer::TYPE){
return (shared_ptr<ofGLProgrammableRenderer>&)ofGetCurrentRenderer();
}else{
return shared_ptr<ofGLProgrammableRenderer>();
}
}
//--------------------------------------
void ofSetOrientation(ofOrientation orientation, bool vFlip){
mainLoop->getCurrentWindow()->setOrientation(orientation);
// TODO: every window should set orientation on it's renderer
if(ofGetCurrentRenderer()){
ofGetCurrentRenderer()->setOrientation(orientation,vFlip);
}
}
void ofSetCurrentRenderer(shared_ptr<ofBaseRenderer> renderer,bool setDefaults) {
if(setDefaults) {
ofStyle style = ofGetCurrentRenderer()->getStyle();
renderer->setupGraphicDefaults();
renderer->setStyle(style);
}
ofGetCurrentRenderer() = renderer;
}
shared_ptr<ofBaseGLRenderer> ofGetGLRenderer(){
if(ofGetCurrentRenderer()->getType()==ofGLProgrammableRenderer::TYPE){
return (shared_ptr<ofBaseGLRenderer>&)ofGetCurrentRenderer();
}else if(ofGetCurrentRenderer()->getType()==ofRendererCollection::TYPE){
return ((shared_ptr<ofRendererCollection>&)ofGetCurrentRenderer())->getGLRenderer();
}else{
return shared_ptr<ofGLProgrammableRenderer>();
}
}
ofPtr<ofGLRenderer> ofGetGLRenderer(){
if(ofGetCurrentRenderer()->getType()=="GL"){
return (ofPtr<ofGLRenderer>&)ofGetCurrentRenderer();
}else if(ofGetCurrentRenderer()->getType()=="collection"){
return ((ofPtr<ofRendererCollection>&)ofGetCurrentRenderer())->getGLRenderer();
}else{
return ofPtr<ofGLRenderer>();
}
}
void ConnectionTracerRenderer::draw() {
if (!_params.enabled.get()) {
return;
}
auto renderer = ofGetCurrentRenderer();
renderer->pushStyle();
renderer->setFillMode(OF_OUTLINE);
for (const auto& entity : _context.observers) {
for (const auto& connection : entity->getObserverConnections()) {
drawTracer(*connection, renderer);
}
for (const auto& connection : entity->getOccurrenceConnections()) {
drawTracer(*connection, renderer);
}
}
for (const auto& entity : _context.occurrences) {
for (const auto& connection : entity->getObserverConnections()) {
drawTracer(*connection, renderer);
}
for (const auto& connection : entity->getOccurrenceConnections()) {
drawTracer(*connection, renderer);
}
}
renderer->popStyle();
}
//------------------------------------------
void ofNotifyDraw(){
if(ofGetCurrentRenderer()){
ofNotifyEvent( ofEvents().draw, voidEventArgs );
}
nFrameCount++;
}
//----------------------------------------
void ofNode::transformGL(ofBaseRenderer * renderer) const {
if( renderer == nullptr ) {
renderer = ofGetCurrentRenderer().get();
}
renderer->pushMatrix();
renderer->multMatrix( getGlobalTransformMatrix() );
}
//--------------------------------------
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);
}
//------------------------------------------
void ofNotifyUpdate(){
// update renderer, application and notify update event
ofGetCurrentRenderer()->update();
ofNotifyEvent( ofEvents().update, voidEventArgs );
}
void ofSetCurrentRenderer(shared_ptr<ofBaseRenderer> renderer_,bool setDefaults){
ofGetCurrentRenderer() = renderer_;
if(ofGetCurrentRenderer()->rendersPathPrimitives()){
shape.setMode(ofPath::COMMANDS);
}else{
shape.setMode(ofPath::POLYLINES);
}
shape.setUseShapeColor(false);
if(setDefaults){
ofGetCurrentRenderer()->setupGraphicDefaults();
ofSetStyle(currentStyle);
ofBackground(currentStyle.bgColor);
}
}
//--------------------------------------------------------------
void testApp::draw(){
fbo.draw(0, 0, ofGetWidth(), ofGetHeight());
ofDrawBitmapStringHighlight(ofGetCurrentRenderer()->getType()+"\nFPS: " + ofToString(ofGetFrameRate()), 100, 100, ofColor::black, ofColor::yellow);
}
//----------------------------------------------------------
void ofSetupScreenOrtho(float width, float height, ofOrientation orientation, bool vFlip, float nearDist, float farDist){
if(!setupScreenDeprecated){
ofLogError("ofGraphics") << "ofSetupScreenOrtho() with orientation and vflip is deprecated,";
ofLogError("ofGraphics") << "set them with ofSetOrientation() before calling ofSetupScreenPerspective()";
setupScreenDeprecated = true;
}
ofGetCurrentRenderer()->setupScreenOrtho(width,height,nearDist,farDist);
}
//-----------------------------------------------------------
void ofTrueTypeFont::drawString(const std::string & c, float x, float y) const{
if (!bLoadedOk){
ofLogError("ofTrueTypeFont") << "drawString(): font not allocated";
return;
}
ofGetCurrentRenderer()->drawString(*this,c,x,y);
}
void testApp::setup(){
ofSetFrameRate(60);
ofEnableAlphaBlending();
ofSetVerticalSync(true);
ofBackground(32, 32, 32);
ofEnableSmoothing();
tuioClient.start(3333);
ofAddListener(tuioClient.cursorAdded,this,&testApp::tuioAdded);
ofAddListener(tuioClient.cursorRemoved,this,&testApp::tuioRemoved);
ofAddListener(tuioClient.cursorUpdated,this,&testApp::tuioUpdated);
///////////////////////////////////////
_defaultRenderer = ofGetCurrentRenderer();
sceneManager = ofxSceneManager::instance();
cheapComm *myComm;
myComm=cheapComm::getInstance();
myComm->setup();
menu *m1=new menu();
m1->setTuio(&tuioClient);
sceneManager->addScene( m1, SCENE_MENU);
electromagnetica *electrom=new electromagnetica();
// electrom->setComm(&myComm);
sceneManager->addScene( electrom, SCENE_EM);
nuclear_debil *nuclear_d = new nuclear_debil();
// nuclear_d->setComm(&myComm);
sceneManager->addScene( nuclear_d, SCENE_NUC_D);
nuclear_fuerte *nuclear_f = new nuclear_fuerte();
// nuclear_d->setComm(&myComm);
sceneManager->addScene( nuclear_f , SCENE_NUC_F);
gravedad *grave=new gravedad();
// grave->setComm(&myComm);
sceneManager->addScene( grave, SCENE_GRAVEDAD);
sceneManager->setDrawDebug(false);
sceneManager->setCurtainDropTime(0.3);
sceneManager->setCurtainStayTime(0.1);
sceneManager->setCurtainRiseTime(0.3);
sceneManager->setOverlapUpdate(true);
// sceneManager->goToScene(SCENE_MENU);
timeToEndScene=-1;
// OSC
//ofAddListener(eventoOSC, this, &testApp::eventoOSC_Recibido );
if(ofToString(getenv("USER"))=="instalaciones" || ofToString(getenv("USER"))=="escaner" ){
ofLogToFile( ofToString (getenv("HOME") ) + "/machine_v_espejo_log.txt", true);
}
}
ofVec3f HypercubeScene::worldToScreen(ofVec3f WorldXYZ, ofMatrix4x4 additionalTransform) {
ofRectangle viewport = ofGetCurrentRenderer()->getCurrentViewport();
ofVec3f CameraXYZ = WorldXYZ * additionalTransform * cam.getModelViewProjectionMatrix(viewport);
ofVec3f ScreenXYZ;
ScreenXYZ.x = (CameraXYZ.x + 1.0f) / 2.0f * viewport.width + viewport.x;
ScreenXYZ.y = (1.0f - CameraXYZ.y) / 2.0f * viewport.height + viewport.y;
ScreenXYZ.z = CameraXYZ.z;
return ScreenXYZ;
}
//--------------------------------------------------------------
void of3dPrimitive::drawNormals(float length, bool bFaceNormals) const{
ofNode::transformGL(ofGetCurrentRenderer().get());
if(getMesh().usingNormals()) {
const vector<ofVec3f>& normals = getMesh().getNormals();
const vector<ofVec3f>& vertices = getMesh().getVertices();
ofVec3f normal;
ofVec3f vert;
normalsMesh.setMode( OF_PRIMITIVE_LINES );
normalsMesh.getVertices().resize( normals.size() * 2);
if(bFaceNormals) {
for(int i = 0; i < (int)normals.size(); i++ ) {
if(i % 3 == 0) {
vert = (vertices[i]+vertices[i+1]+vertices[i+2]) / 3;
} else if(i % 3 == 1) {
vert = (vertices[i-1]+vertices[i]+vertices[i+1]) / 3;
} else if ( i % 3 == 2) {
vert = (vertices[i-2]+vertices[i-1]+vertices[i]) / 3;
}
normalsMesh.setVertex(i*2, vert);
normal = normals[i].getNormalized();
normal *= length;
normalsMesh.setVertex(i*2+1, normal+vert);
}
} else {
for(int i = 0; i < (int)normals.size(); i++) {
vert = vertices[i];
normal = normals[i].getNormalized();
normalsMesh.setVertex( i*2, vert);
normal *= length;
normalsMesh.setVertex(i*2+1, normal+vert);
}
}
normalsMesh.draw();
} else {
ofLogWarning("of3dPrimitive") << "drawNormals(): mesh normals are disabled";
}
ofNode::restoreTransformGL(ofGetCurrentRenderer().get());
}
//------------------------------------------
void ofNotifyDraw(){
if(ofGetCurrentRenderer()){
ofNotifyEvent( ofEvents().draw, voidEventArgs );
}
nFrameCount++;
// calculate sleep time to adjust to target fps
unsigned long long timeNow = ofGetElapsedTimeMicros();
#ifndef TARGET_EMSCRIPTEN
if (nFrameCount != 0 && bFrameRateSet == true){
unsigned long long diffMicros = timeNow - prevMicrosForFPS;
prevMicrosForFPS = timeNow;
if(diffMicros < microsForFrame){
unsigned long long waitMicros = microsForFrame - diffMicros;
// Theoretical value to compensate for the extra time that it might sleep
prevMicrosForFPS += waitMicros;
#ifdef TARGET_WIN32
Sleep(waitMicros*MICROS_TO_MILLIS);
#else
usleep(waitMicros);
#endif
}
}else{
prevMicrosForFPS = timeNow;
}
#endif
// calculate fps
timeNow = ofGetElapsedTimeMicros();
if(nFrameCount==0){
timeThen = timeNow;
if(bFrameRateSet) fps = targetRate;
}else{
unsigned long long oneSecDiff = timeNow-oneSec;
if( oneSecDiff >= 1000000 ){
fps = nFramesForFPS/(oneSecDiff*MICROS_TO_SEC);
oneSec = timeNow;
nFramesForFPS = 0;
}else{
double deltaTime = ((double)oneSecDiff)*MICROS_TO_SEC;
if( deltaTime > 0.0 ){
fps = fps*0.99 + (nFramesForFPS/deltaTime)*0.01;
}
}
nFramesForFPS++;
lastFrameTime = timeNow-timeThen;
timeThen = timeNow;
}
}
//------------------------------------------
void ofNotifyUpdate(){
ofGetCurrentRenderer()->update();
ofBaseApp * ofAppPtr = ofGetAppPtr();
if(ofAppPtr){
ofAppPtr->update();
}
#ifdef OF_USING_POCO
ofNotifyEvent( ofEvents().update, voidEventArgs );
#endif
}
//-----------------------------------------------------------------------------------
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;
}
//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button)
{
cout << "change renderer" << endl;
if (ofGetCurrentRenderer() == _defaultRenderer)
{
ofSetCurrentRenderer(_shivaVGRenderer);
}
else
{
ofSetCurrentRenderer(_defaultRenderer);
}
}
//----------------------------------------------------------
void ofPath::draw(){
if(ofGetCurrentRenderer()->rendersPathPrimitives()){
ofGetCurrentRenderer()->draw(*this);
}else{
tessellate();
ofColor prevColor;
if(bUseShapeColor){
prevColor = ofGetStyle().color;
}
if(bFill){
if(bUseShapeColor){
ofSetColor(fillColor);
}
ofGetCurrentRenderer()->draw(cachedTessellation,bUseShapeColor,false,false);
}
if(hasOutline()){
float lineWidth = ofGetStyle().lineWidth;
if(bUseShapeColor){
ofSetColor(strokeColor);
}
ofSetLineWidth( strokeWidth );
vector<ofPolyline> & polys = getOutline();
for(int i=0;i<(int)polys.size();i++){
ofGetCurrentRenderer()->draw(polys[i]);
}
ofSetLineWidth(lineWidth);
}
if(bUseShapeColor){
ofSetColor(prevColor);
}
}
}
//-----------------------------------------------------------------------------------
void ofBeginSaveScreenAsPDF(string filename, bool bMultipage, bool b3D, ofRectangle viewport){
if( bScreenShotStarted )ofEndSaveScreenAsPDF();
storedRenderer = ofGetCurrentRenderer();
cairoScreenshot = ofPtr<ofCairoRenderer>(new ofCairoRenderer);
cairoScreenshot->setup(filename, ofCairoRenderer::PDF, bMultipage, b3D, viewport);
rendererCollection = ofPtr<ofRendererCollection>(new ofRendererCollection);
rendererCollection->renderers.push_back(ofGetGLRenderer());
rendererCollection->renderers.push_back(cairoScreenshot);
ofSetCurrentRenderer(cairoScreenshot, true);
bScreenShotStarted = true;
}
static void ofBeginSaveScreen(string filename, ofCairoRenderer::Type type, bool bMultipage, bool b3D, ofRectangle outputsize) {
if( bScreenShotStarted ) ofEndSaveScreen();
storedRenderer = ofGetCurrentRenderer();
cairoScreenshot = shared_ptr<ofCairoRenderer>(new ofCairoRenderer);
cairoScreenshot->setup(filename, type, bMultipage, b3D, outputsize);
rendererCollection = shared_ptr<ofRendererCollection>(new ofRendererCollection);
rendererCollection->renderers.push_back(storedRenderer);
rendererCollection->renderers.push_back(cairoScreenshot);
ofSetCurrentRenderer(rendererCollection, true);
cairoScreenshot->background(cairoScreenshot->getStyle().bgColor);
bScreenShotStarted = true;
}
void BoundsController::draw() {
if (!_debugParams.showBounds.get()) {
return;
}
auto renderer = ofGetCurrentRenderer();
renderer->pushStyle();
renderer->setFillMode(OF_OUTLINE);
renderer->setColor(_boundsColor);
renderer->drawBox(_params.size.get());
renderer->popStyle();
renderer->drawGrid(_params.size.get() / 2 / 4, // step size
4, // number of steps
true, // labels
true, true, true // x / y /z
);
}
/*! This function opens a GLFW window that can be rendered to. If another window was already
open by the application at the time this is called, that window will be closed. This is useful
if you want to control some of the parameters of the window that cannot be changed after the window
has been opened.
\param config Configuration options for the window to be opened.
\return `true` if reopening the window was successful, `false` otherwise.
*/
bool reopenWindow(CX_WindowConfiguration config) {
Private::setMsaaSampleCount(config.msaaSampleCount);
if (config.desiredOpenGLVersion.major <= 0) {
config.desiredOpenGLVersion = Private::getOpenGLVersion();
}
try {
#if OF_VERSION_MAJOR == 0 && OF_VERSION_MINOR == 9 && OF_VERSION_PATCH >= 0
CX::Private::reopenWindow090(config);
#elif OF_VERSION_MAJOR == 0 && OF_VERSION_MINOR == 8 && OF_VERSION_PATCH == 4
CX::Private::reopenWindow084(config);
#elif OF_VERSION_MAJOR == 0 && OF_VERSION_MINOR == 8 && OF_VERSION_PATCH == 0
CX::Private::reopenWindow080(config);
#else
CX::Instances::Log.error("CX_EntryPoint") << "reopenWindow(): The current version of openFrameworks is not supported by CX. "
"Version 0.9.8 of openFrameworks is recommended.";
return false;
#endif
} catch (std::exception& e) {
CX::Instances::Log.error("CX_EntryPoint") << "reopenWindow(): Exception caught while setting up window: " << e.what();
} catch (...) {
CX::Instances::Log.error("CX_EntryPoint") << "reopenWindow(): Unknown exception caught while setting up window.";
}
if (glfwGetCurrentContext() == nullptr) {
CX::Instances::Log.error("CX_EntryPoint") << "reopenWindow(): There was an error setting up the window.";
return false;
}
Private::glfwContext = glfwGetCurrentContext();
Private::glfwContextManager.setup(glfwGetCurrentContext(), std::this_thread::get_id());
//Setup the display for the new window
CX::Instances::Disp.setup();
#if !(OF_VERSION_MAJOR == 0 && OF_VERSION_MINOR == 9 && OF_VERSION_PATCH >= 0)
ofGetCurrentRenderer()->update(); //Only needed for ofGLRenderer, not for ofGLProgrammableRenderer, but there is no harm in calling it
CX::Private::appWindow->initializeWindow();
#endif
ofSetWindowTitle(config.windowTitle);
return true;
}
//--------------------------------------------------------------
void ofApp::setup()
{
ofSetFrameRate(100.0f);
ofSetCurveResolution(100);
_shapeSize = 160;
_defaultRenderer = ofGetCurrentRenderer();
_shivaVGRenderer = ofPtr<ofxShivaVGRenderer>(new ofxShivaVGRenderer);
ofSetCurrentRenderer(_shivaVGRenderer);
_shivaVGRenderer->setLineJoinStyle(VG_JOIN_ROUND);
_shivaVGRenderer->setLineCapStyle(VG_CAP_ROUND);
_createPolygon();
_createStar();
_createCurvedPath();
}
//----------------------------------------------------------
void ofPath::draw() const{
ofGetCurrentRenderer()->draw(*this);
}
//----------------------------------------------------------
void ofPath::draw(float x, float y) const{
ofGetCurrentRenderer()->draw(*this,x,y);
}
//--------------------------------------
void ofSetOrientation(ofOrientation orientation, bool vFlip){
window->setOrientation(orientation);
if(ofGetCurrentRenderer()){
ofGetCurrentRenderer()->setOrientation(orientation,vFlip);
}
}
