main.cpp

#include <FFGLFBO.h>
#include <math.h>
#include <GLUT/glut.h>

#include "FFDebugMessage.h"
#include "FFGLPluginInstance.h"
#include "Timer.h"

//this defines the size of the window when it is first opened
int WINDOWWIDTH = 640;
int WINDOWHEIGHT = 480;
int WindowClosed = 0; //set to 1 when the window closes, detected by the glutVisibilityFunc

FFGLViewportStruct fboViewport; //the viewport used when rendering into the FBO
FFGLViewportStruct windowViewport; //the viewport used when rendering into the output window
//they are the same, but seperated to emphasize the FFGL spec that requires maintaining
//the same viewport during the lifetime of a plugin. plugin1 always renders into the fboViewport,
//plugin2 always renders into the windowViewport

//these classes assist with handling the loading/unloading, and calling of plugins
FFGLPluginInstance *plugin1 = NULL;
FFGLPluginInstance *plugin2 = NULL;

//this represents the texture (in main system/CPU memory) that we feed to the plugins
//it is generated procedurally, a clever algorithm from Gabor Papp's minimal
//FreeFrame host for linux
unsigned char *inputImage = NULL;

//this represents the texture (on the GPU) that we feed to the plugins
FFGLTextureStruct inputTexture;

//this is a function to allocate the above inputTexture and inputImage
void AllocateInputTexture(int textureWidth, int textureHeight);

//this generates the inputImage (in CPU) memory at the
//specified "time" (it is a procedurally generated image), then
//uploads the image to the GPU texture, inputTexture
void UpdateInputTexture(double time);

//OSX supports many more opengl extension directly, by including
//<Opengl/gl_ext.h> - to be more portable to other platforms
//(like Windows, *ahem*), this class (FFGLExtensions) is used
//to provide a defined subset of the GL extensions to all the implementations
//of FFGL plugins / hosts in the FFGL SDK.
FFGLExtensions glExtensions;

//this represents a blank canvas on the GPU that we use to store temporary
//results of FFGL processing. the output from plugin #1 (brightness) is rendered
//to this FBO, then the FBO is bound as a texture and fed to plugin #2 (mirror, by default)
FFGLFBO fbo;

//this is a timer used to increment the procedurally generated input image
//smoothly over time (also used to ramp the brightness up and down)
Timer *timer = NULL;

//these are methods provided to GLUT that redraw the window
//and handle when the window is resized
void FFGLHostDisplay();
void FFGLHostReshape(int width, int height);

//GLUT calls this function so that we can respond to mouse movement
void FFGLHostMouseMove(int x, int y);

//GLUT calls this function so that we can respond to changes of the window's visibility
void FFGLHostVisibilityChange(int visible);

//when the mouse moves, these values are updated according to the
//x/y position of the mosue. (0,0) corresponds to the lower left
//corner of the window, (1,1) corresponds to the upper right. the
//mouse values are then assigned to the plugins each time they draw
//x -> plugin 1 parameter 0
//y -> plugin 2 parameter 0
float mouseX = 0.5;
float mouseY = 0.5;

//this locates the host binary and plugin binaries so that
//they can be found when the host is launched from the finder
void SetCorrectWorkingPath();


int main(int argc, char **argv)
{
    if (argc != 3)
    {
        FFDebugMessage("Please provide two plugin arguments");
        exit(EXIT_FAILURE);
    }
    char *PluginFilename1 = argv[1];
    char *PluginFilename2 = argv[2];

    //this sets the 'working' path to the folder that
    //contains the plugins, for some reason this is necessary
    //in order for the host to run when launched from the finder
    //(but not necessary when launched from the terminal)
    SetCorrectWorkingPath();

    //load first plugin (does not instantiate!)
    plugin1 = FFGLPluginInstance::New();
    if (plugin1->Load(PluginFilename1)==FF_FAIL)
    {
        FFDebugMessage("Couldn't open plugin 1");
        return 0;
    }

    //init second plugin (does not instantiate!)
    plugin2 = FFGLPluginInstance::New();
    if (plugin2->Load(PluginFilename2)==FF_FAIL)
    {
        FFDebugMessage("Couldn't open plugin 2");
        return 0;
    }

    //init OpenGL/GLUT
    glutInit(&argc, argv);
    glutInitWindowSize(WINDOWWIDTH, WINDOWHEIGHT);
    glutInitDisplayString("double rgb depth");
    glutCreateWindow("FFGLHost");
    glutReshapeFunc(FFGLHostReshape);
    glutPassiveMotionFunc(FFGLHostMouseMove);
    glutVisibilityFunc(FFGLHostVisibilityChange);

    //this allocates the CPU inputImage and GPU inputTexture
    //(they must be the same size)
    AllocateInputTexture(320,240);

    if (inputTexture.Handle==0 || inputImage==NULL)
    {
        FFDebugMessage("Texture allocation failed");
        return 0;
    }

    //init gl extensions
    glExtensions.Initialize();
    if (glExtensions.EXT_framebuffer_object==0)
    {
        FFDebugMessage("FBO not detected, cannot continue");
        return 0;
    }

    //allocate fbo, same size as window
    if (!fbo.Create(WINDOWWIDTH, WINDOWHEIGHT, glExtensions))
    {
        FFDebugMessage("Framebuffer Object Init Failed");
        return 0;
    }

    //instantiate the first plugin passing a viewport that matches
    //the FBO (plugin1 is rendered into our FBO)
    fboViewport.x = 0;
    fboViewport.y = 0;
    fboViewport.width = WINDOWWIDTH;
    fboViewport.height = WINDOWHEIGHT;
    if (plugin1->InstantiateGL(&fboViewport)!=FF_SUCCESS)
    {
        FFDebugMessage("plugin1->InstantiateGL failed");
        return 0;
    }

    //plugin2 renders into the window viewport, which is the
    //same as the FBO viewport, but the viewport structures are seperated
    //here to emphasize the FFGL spec requirement of maintaining a consistent
    //output viewport for the lifetime of a plugin
    windowViewport = fboViewport;
    if (plugin2->InstantiateGL(&windowViewport)!=FF_SUCCESS)
    {
        FFDebugMessage("plugin2->InstantiateGL failed");
        return 0;
    }

    //tell GLUT about our display functions
    glutDisplayFunc(FFGLHostDisplay);

    //start the timer and the glut main loop
    timer = Timer::New();

    //loop as long as the window is open
    while (WindowClosed==0)
    {
        glutCheckLoop();
    }

    plugin1->Unload();
    delete plugin1;

    plugin2->Unload();
    delete plugin2;

    delete [] inputImage;

    delete timer;

    //...GL texture is left allocated?
    return 0;
}

//glut is not clear in its specification about whether or not
//an opengl context is active during this call. GLUT doesn't seem to
//be designed to gracefully exit the application freeing opengl resources
//appropriately. since the FFGL spec requires an active opengl context
//during the call to DeInstantiateGL (so that plugins can release their OpenGL
//resources) this is the best place I can think to put it.
void FFGLHostVisibilityChange(int visible)
{
    if (visible==0)
    {
        //free all of the gl resources we've allocated and mark our WindowClosed variable
        WindowClosed = 1;
        fbo.FreeResources(glExtensions);
        plugin1->DeInstantiateGL();
        plugin2->DeInstantiateGL();
        glDeleteTextures(1,&inputTexture.Handle);
    }
}

void FFGLHostDisplay()
{
    if (WindowClosed)
        return;

    //whats the current time on the timer?
    double curFrameTime = timer->GetElapsedTime();

    UpdateInputTexture(curFrameTime);

    //activate the fbo as our render target
    if (!fbo.BindAsRenderTarget(glExtensions))
    {
        FFDebugMessage("FBO Bind As Render Target Failed");
        return;
    }

    //set the gl viewport to equal the size of the FBO
    glViewport(
            fboViewport.x,
            fboViewport.y,
            fboViewport.width,
            fboViewport.height);

    //prepare gl state for rendering the first plugin (brightness)

    //make sure all the matrices are reset
    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    //clear the depth and color buffers
    glClearColor(0,0,0,0);
    glClearDepth(1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //tell plugin 1 about the current time
    plugin1->SetTime(curFrameTime);

    //set plugin 1 parameter 0
    plugin1->SetFloatParameter(0, mouseX);

    //prepare the structure used to call
    //the plugin's ProcessOpenGL method
    ProcessOpenGLStructTag processStruct;

    //create the array of OpenGLTextureStruct * to be passed
    //to the plugin
    FFGLTextureStruct *inputTextures[1];
    inputTextures[0] = &inputTexture;

    //provide the 1 input texture we allocated above
    processStruct.numInputTextures = 1;
    processStruct.inputTextures = inputTextures;

    //specify our FBO's handle in the processOpenGLStruct
    processStruct.HostFBO = fbo.GetFBOHandle();

    //call the plugin's ProcessOpenGL
    if (plugin1->CallProcessOpenGL(processStruct)==FF_SUCCESS)
    {
        //if the plugin call succeeds, the drawning is complete
    }
    else
    {
        //the plugin call failed, exit
        FFDebugMessage("Plugin 1's ProcessOpenGL failed");
        return;
    }

    //deactivate rendering to the fbo
    //(this re-activates rendering to the window)
    fbo.UnbindAsRenderTarget(glExtensions);

    //set the gl viewport to equal the size of our output window
    glViewport(
            windowViewport.x,
            windowViewport.y,
            windowViewport.width,
            windowViewport.height);

    //prepare to render the 2nd plugin (the mirror effect or the custom plugin)

    //reset all matrices
    glMatrixMode(GL_TEXTURE);
    glLoadIdentity();
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    //clear the color and depth buffers
    glClearColor(0,0,0,0);
    glClearDepth(1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //now pass the contents of the FBO as a texture to the mirror plugin
    FFGLTextureStruct fboTexture = fbo.GetTextureInfo();

    //change processStruct to refer to the FBO texture
    inputTextures[0] = &fboTexture;

    //specify no FBO handle since we are rendering to the output window
    processStruct.HostFBO = 0;

    //tell plugin 2 about the current frame time
    plugin2->SetTime(curFrameTime);

    //set plugin 2 parameter 0
    plugin2->SetFloatParameter(0, mouseY);

    //call the mirror plugin's ProcessOpenGL
    if (plugin2->CallProcessOpenGL(processStruct)==FF_SUCCESS)
    {
        //if the plugin call succeeds, the drawning is complete
    }
    else
    {
        //the plugin call failed
        FFDebugMessage("Plugin 2's ProcessOpenGL failed");
    }

    glutSwapBuffers();
    glutPostRedisplay();
}

void FFGLHostMouseMove(int x, int y)
{
    if (x<0) x=0;
    else
    if (x>WINDOWWIDTH) x = WINDOWWIDTH;

    if (y<0) y = 0;
    else
    if (y>WINDOWHEIGHT) y = WINDOWHEIGHT;

    mouseX = ((double)x) / (double)WINDOWWIDTH;
    mouseY = 1.0 - ((double)y) / (double)WINDOWHEIGHT;
}

void FFGLHostReshape(int width, int height)
{
    //force GLUT to keep the window the same size as when we created it. this is
    //to avoid having to re-instantiate plugins
    if (width!=WINDOWWIDTH || height!=WINDOWHEIGHT)
    {
        glutReshapeWindow(WINDOWWIDTH,WINDOWHEIGHT);
    }
}

void UpdateInputTexture(double timeInSeconds)
{
    int time = (int)(timeInSeconds*160.0);

    unsigned char *p = inputImage;

    //this algorithm taken from Gabor Papp's minimal freeframe host for linux
    for (int y=0; y<inputTexture.Height; y++)
    {
        for (int x=0; x<inputTexture.Width; x++)
        {
            int r = ((x^(y+time)) & 0xFF);
            int g = (((x+time)^y) & 0xFF);
            int b = ((x^y) & 0xFF);

            *p = b;
            *(p+1) = g;
            *(p+2) = r;

            p += 4;
        }
    }

    //bind the gl texture so we can upload the next video frame
    glBindTexture(GL_TEXTURE_2D, inputTexture.Handle);

    //upload it to the gl texture. use subimage because
    //the video frame size is probably smaller than the
    //size of the texture on the gpu hardware
    glTexSubImage2D(
            GL_TEXTURE_2D,
            0,
            0, 0,
            inputTexture.Width,
            inputTexture.Height,
            GL_RGBA,
            GL_UNSIGNED_BYTE,
            inputImage);

    //unbind the gl texture
    glBindTexture(GL_TEXTURE_2D, 0);
}

void AllocateInputTexture(int textureWidth, int textureHeight)
{
    //first allocate CPU memory (32-bit RGBA)
    //(this MUST be the same size as the texture, otherwise there will probably be an error/crash
    //when it is uploaded to the GPU)
    inputImage = new unsigned char[textureWidth*textureHeight*4];
    if (inputImage==NULL)
        return;

    //now allocate the GPU texture

    //find smallest power of two sized
    //texture that can contain the texture
    int glTextureWidth = 1;
    while (glTextureWidth<textureWidth) glTextureWidth *= 2;

    int glTextureHeight = 1;
    while (glTextureHeight<textureHeight) glTextureHeight *= 2;

    //create and setup the gl texture
    GLuint glTextureHandle = 0;
    glGenTextures(1, &glTextureHandle);

    //bind this new texture so that glTex* calls apply to it
    glBindTexture(GL_TEXTURE_2D, glTextureHandle);

    //use bilinear interpolation when the texture is scaled larger
    //than its true size
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    //no mipmapping (for when the texture is scaled smaller than its
    //true size)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    //no wrapping (for when texture coordinates reference outside the
    //bounds of the texture)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

    //this allocates room for the gl texture, but doesn't fill it with any pixels
    //(the NULL would otherwise contain a pointer to the texture data)
    glTexImage2D(GL_TEXTURE_2D,
                 0, 4, //we are using a 32bit image, which has 4 bytes per pixel
                 glTextureWidth,
                 glTextureHeight,
                 0, GL_RGBA,
                 GL_UNSIGNED_BYTE,
                 NULL);

    //unbind the texture
    glBindTexture(GL_TEXTURE_2D, 0);

    //fill the inputTexture struct
    FFGLTextureStruct &t = inputTexture;

    t.Handle = glTextureHandle;

    t.Width = textureWidth;
    t.Height = textureHeight;

    t.HardwareWidth = glTextureWidth;
    t.HardwareHeight = glTextureHeight;
}

#include <CoreServices/CoreServices.h> //for CFBundle*
#include <unistd.h> //for chdir()

void SetCorrectWorkingPath()
{
    CFBundleRef mainBundle = CFBundleGetMainBundle();
    CFURLRef url = CFBundleCopyExecutableURL(mainBundle);
    if (!url)
        return;

    char binPath[1024];
    if (CFURLGetFileSystemRepresentation(url, true, (UInt8 *)binPath, sizeof(binPath)))
    {
#ifdef _DEBUG
        const char *binaryName = "FFGLHost_debug";
#else
        const char *binaryName = "FFGLHost";
#endif

        int chopLength = strlen(binaryName);

        //cut the binary name off the end of the binPath
        //string so that only the path remains
        binPath[strlen(binPath)-chopLength] = 0;

        chdir(binPath);
    }

    CFRelease(url);
}