nystep

#include "renderBuffer.h"
#include <glew.h>
#include <assert.h>


renderBuffer::renderBuffer( bool canHasDepthBuffer )
{
    hasDepth = canHasDepthBuffer;

    glGenFramebuffersEXT(1, &fb);
    if (hasDepth)
        glGenRenderbuffersEXT(1, &depthbuff);
}


renderBuffer::~renderBuffer()
{
    if (hasDepth)
        glDeleteRenderbuffersEXT(1, &depthbuff);
    glDeleteFramebuffersEXT(1, &fb);
}


void renderBuffer::renderConfig( texture **tt, int n_textures, int layerStart, int layerEnd )
{
    int maxTargets;
    int attachement = GL_COLOR_ATTACHMENT0_EXT;
    int nTargets = (layerEnd - layerStart + 1) * n_textures;
    glGetIntegerv( GL_MAX_DRAW_BUFFERS_ARB, &maxTargets );

    assert( nTargets <= maxTargets );

    GLenum drawbuffers[16] =
    { GL_COLOR_ATTACHMENT0_EXT, GL_COLOR_ATTACHMENT1_EXT, GL_COLOR_ATTACHMENT2_EXT, GL_COLOR_ATTACHMENT3_EXT,
      GL_COLOR_ATTACHMENT4_EXT, GL_COLOR_ATTACHMENT5_EXT, GL_COLOR_ATTACHMENT6_EXT, GL_COLOR_ATTACHMENT7_EXT,
      GL_COLOR_ATTACHMENT8_EXT, GL_COLOR_ATTACHMENT9_EXT, GL_COLOR_ATTACHMENT10_EXT, GL_COLOR_ATTACHMENT11_EXT,
      GL_COLOR_ATTACHMENT12_EXT, GL_COLOR_ATTACHMENT13_EXT, GL_COLOR_ATTACHMENT14_EXT, GL_COLOR_ATTACHMENT15_EXT };

    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);

    for (int i=0; i<n_textures; i++)
    {
        int target = tt[i]->target;

        if (target == GL_TEXTURE_2D)
        {
            glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, attachement++, target, tt[i]->textureId, 0 );
        }
        else if (target == GL_TEXTURE_CUBE_MAP_ARB)
        {
            int target = GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB;
            for (int j=layerStart; j<=layerEnd; j++)
            {
                glFramebufferTexture2DEXT( GL_FRAMEBUFFER_EXT, attachement++, target+j, tt[i]->textureId, 0 );
            }
        }
        else if (target == GL_TEXTURE_3D)
        {
            for (int j=layerStart; j<=layerEnd; j++)
            {
                glFramebufferTexture3DEXT( GL_FRAMEBUFFER_EXT, attachement++, target, tt[i]->textureId, 0, j );
            }
        }
    }

    if (hasDepth)
    {
        glBindRenderbufferEXT( GL_RENDERBUFFER_EXT, depthbuff );
        glRenderbufferStorageEXT( GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, (*tt)->sx, (*tt)->sy );
        glFramebufferRenderbufferEXT( GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthbuff );
    }

    glDrawBuffersARB( nTargets, drawbuffers );
    assert( glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT) == GL_FRAMEBUFFER_COMPLETE_EXT );
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
    assert( glGetError() == GL_NO_ERROR );
}


void renderBuffer::startRender()
{
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb);
}


void renderBuffer::endRender()
{
    glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
}



static void setViewport2D()
{
    glMatrixMode( GL_PROJECTION );
    glPushMatrix();
    glLoadIdentity();
    glOrtho( 0.0, 1.0, 0.0, 1.0, -1.0, 1.0 );
    glMatrixMode( GL_MODELVIEW );
    glPushMatrix();
    glLoadIdentity();
}


static void restoreViewport()
{
    glMatrixMode( GL_PROJECTION );
    glPopMatrix();
    glMatrixMode( GL_MODELVIEW );
    glPopMatrix();
}


static void drawScreenQuad()
{
    glBegin( GL_QUADS );
    glTexCoord2f( 0.f, 0.f ); glVertex3f( 0.f, 0.f, 0.f );
    glTexCoord2f( 0.f, 1.f ); glVertex3f( 0.f, 1.0, 0.f );
    glTexCoord2f( 1.f, 1.f ); glVertex3f( 1.0, 1.0, 0.f );
    glTexCoord2f( 1.f, 0.f ); glVertex3f( 1.0, 0.f, 0.f );
    glEnd();
}


void renderTo3DTexture( shader *sh, char *layerUniformName, char* nLayersUniformName, char* layerInvSizeUniformName, texture3d *tex )
{
    int maxTargets;
    float *layerUniform;
    //float *nLayersUniform;
    float *layerInvSizeUniform;

    glGetIntegerv( GL_MAX_DRAW_BUFFERS_ARB, &maxTargets );

    layerUniform = sh->GetUniform( layerUniformName );
    //nLayersUniform = sh->GetUniform( nLayersUniformName );
    layerInvSizeUniform = sh->GetUniform( layerInvSizeUniformName );

    //if (nLayersUniform) *nLayersUniform = float(maxTargets);
    if (layerInvSizeUniform) *layerInvSizeUniform = 1.0f / tex->sz;

    renderBuffer *rb = new renderBuffer( false );

    for (int i=0; i<tex->sz; i+=maxTargets)
    {
        rb->renderConfig( (texture**) &tex, 1, i, i+maxTargets-1 );
        if (layerUniform) *layerUniform = float(i);

        glPushAttrib( GL_VIEWPORT_BIT );
        glViewport( 0, 0, tex->sx, tex->sy );
        rb->startRender();
        glClear( GL_COLOR_BUFFER_BIT );

        setViewport2D();
        sh->Bind();
        drawScreenQuad();
        sh->unBind();
        restoreViewport();

        rb->endRender();
        glPopAttrib();
    }

    delete rb;
}