render_particles.cpp

/*
 * Copyright 1993-2006 NVIDIA Corporation.  All rights reserved.
 *
 * NOTICE TO USER:   
 *
 * This source code is subject to NVIDIA ownership rights under U.S. and 
 * international Copyright laws.  
 *
 * NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE 
 * CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR 
 * IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH 
 * REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF 
 * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.   
 * IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, 
 * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS 
 * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE 
 * OR PERFORMANCE OF THIS SOURCE CODE.  
 *
 * U.S. Government End Users.  This source code is a "commercial item" as 
 * that term is defined at 48 C.F.R. 2.101 (OCT 1995), consisting  of 
 * "commercial computer software" and "commercial computer software 
 * documentation" as such terms are used in 48 C.F.R. 12.212 (SEPT 1995) 
 * and is provided to the U.S. Government only as a commercial end item.  
 * Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through 
 * 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the 
 * source code with only those rights set forth herein.
 */

/*
 * Slightly adapted 2009 by Ph. Robert wrt the Equalizer port
 */

#include "render_particles.h"
#include <eq/eq.h>

#include <math.h>
#include <assert.h>

#define GL_POINT_SPRITE_ARB               0x8861
#define GL_COORD_REPLACE_ARB              0x8862
#define GL_VERTEX_PROGRAM_POINT_SIZE_NV   0x8642
#define glewContext glewGetContext() 

namespace eqNbody
{
void _checkGLErrors(char const* s)
{
    GLenum error;
    while ((error = glGetError()) != GL_NO_ERROR) 
    {
        EQERROR << s << "error - " << std::endl; // << (char *) gluErrorString(error)
        exit(EXIT_FAILURE);
    }
}


ParticleRenderer::~ParticleRenderer()
{
    m_pos = 0;
}

void ParticleRenderer::setPositions(float *pos, int numParticles)
{
    m_pos = pos;
    m_numParticles = numParticles;
}

void ParticleRenderer::setColors(float *color, int numParticles)
{
    glBindBuffer(GL_ARRAY_BUFFER_ARB, m_vboColor);
    glBufferData(GL_ARRAY_BUFFER_ARB, numParticles * 4 * sizeof(float), color, GL_STATIC_DRAW_ARB);
    glBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
}

void ParticleRenderer::setPBO(unsigned int pbo, int numParticles)
{
    m_pbo = pbo;
    m_numParticles = numParticles;
}

void ParticleRenderer::_drawPoints(bool color)
{
    if (!m_pbo)
    {
        glBegin(GL_POINTS);
        {
            int k = 0;
            for (int i = 0; i < m_numParticles; ++i)
            {
                glVertex3fv(&m_pos[k]);
                k += 4;
            }
        }
        glEnd();
    }
    else
    {
        glEnableClientState(GL_VERTEX_ARRAY);                
            
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_pbo);
        glVertexPointer(4, GL_FLOAT, 0, 0);

        if (color)
        {
            glEnableClientState(GL_COLOR_ARRAY);
            glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_vboColor);
            glColorPointer(4, GL_FLOAT, 0, 0);
        }

        glDrawArrays(GL_POINTS, 0, m_numParticles);
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
        glDisableClientState(GL_VERTEX_ARRAY); 

        if (color)
           glDisableClientState(GL_COLOR_ARRAY); 

    }
}

void ParticleRenderer::draw(DisplayMode mode)
{
    switch (mode)
    {
        case PARTICLE_POINTS:
            glColor3f(1, 1, 1);
            glPointSize(m_pointSize);
            _drawPoints();
            break;
        case PARTICLE_SPRITES_COLOR:
        {
            // setup point sprites
            glEnable(GL_POINT_SPRITE_ARB);
            glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
            glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
            glPointSize(m_spriteSize);
            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
            glEnable(GL_BLEND);
            glDepthMask(GL_FALSE);

            glUseProgram(m_program);
            GLuint texLoc = glGetUniformLocation(m_program, "splatTexture");
            glUniform1i(texLoc, 0);

            glActiveTextureARB(GL_TEXTURE0_ARB);
            glBindTexture(GL_TEXTURE_2D, m_texture);

            glColor3f(1, 1, 1);
            _drawPoints(true);

            glUseProgram(0);
            glDisable(GL_POINT_SPRITE_ARB);
            glDisable(GL_BLEND);
            glDepthMask(GL_TRUE);
            break;
        }
        case PARTICLE_SPRITES:
        default:
        {
            // setup point sprites
            glEnable(GL_POINT_SPRITE_ARB);
            glTexEnvi(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
            glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_NV);
            glPointSize(m_spriteSize);
            glBlendFunc(GL_SRC_ALPHA, GL_ONE);
            glEnable(GL_BLEND);
            glDepthMask(GL_FALSE);

            glUseProgram(m_program);
            GLuint texLoc = glGetUniformLocation(m_program, "splatTexture");
            glUniform1i(texLoc, 0);
                
            glActiveTextureARB(GL_TEXTURE0_ARB);
            glBindTexture(GL_TEXTURE_2D, m_texture);
                                
            glColor3f(1, 1, 1);
            
            _drawPoints();
            glUseProgram(0);
                                
            glDisable(GL_POINT_SPRITE_ARB);
            glDisable(GL_BLEND);
            glDepthMask(GL_TRUE);
            break;
        }
    }
        
    _checkGLErrors("GL error in draw");
}

const char vertexShader[] = 
{    
    "void main()                                                            \n"
    "{                                                                      \n"
    "    float pointSize = 500.0 * gl_Point.size;                           \n"
    "    vec4 vert = gl_Vertex;                                             \n"
    "    vert.w = 1.0;                                                      \n"
    "    vec3 pos_eye = vec3 (gl_ModelViewMatrix * vert);                   \n"
    "    gl_PointSize = max(1.0, pointSize / (1.0 - pos_eye.z));            \n"
    "    gl_TexCoord[0] = gl_MultiTexCoord0;                                \n"
    "    gl_Position = ftransform();                                        \n"
    "    gl_FrontColor = gl_Color;                                          \n"
    "}                                                                      \n"
    };
    
    const char pixelShader[] =
    {
    "uniform sampler2D splatTexture;                                        \n"
    
    "void main()                                                            \n"
    "{                                                                      \n"
    "    vec4 color = (0.6 + 0.4 * gl_Color) * texture2D(splatTexture, gl_TexCoord[0].st); \n"
    "    gl_FragColor =                                                     \n"
    "         color * mix(vec4(0.1, 0.0, 0.0, color.w), vec4(1.0, 0.7, 0.3, color.w), color.w);\n"
    "}                                                                      \n"
    };

    void ParticleRenderer::init()
    {
        m_vertexShader = glCreateShader(GL_VERTEX_SHADER);
        m_pixelShader = glCreateShader(GL_FRAGMENT_SHADER);

        const char* v = vertexShader;
        const char* p = pixelShader;

        glShaderSource(m_vertexShader, 1, &v, 0);
        glShaderSource(m_pixelShader, 1, &p, 0);

        glCompileShader(m_vertexShader);
        glCompileShader(m_pixelShader);

        m_program = glCreateProgram();

        glAttachShader(m_program, m_vertexShader);
        glAttachShader(m_program, m_pixelShader);

        glLinkProgram(m_program);

        _createTexture(32);

        glGenBuffers(1, (GLuint*)&m_vboColor);
        glBindBuffer( GL_ARRAY_BUFFER_ARB, m_vboColor);
        glBufferData( GL_ARRAY_BUFFER_ARB, m_numParticles * 4 * sizeof(float), 0, GL_STATIC_DRAW_ARB);
        glBindBuffer( GL_ARRAY_BUFFER_ARB, 0);
    }

    //------------------------------------------------------------------------------
    // Function           : EvalHermite
    // Description        : 
    //------------------------------------------------------------------------------
    inline float evalHermite(float pA, float pB, float vA, float vB, float u)
    {
        float u2=(u*u), u3=u2*u;
        float B0 = 2*u3 - 3*u2 + 1;
        float B1 = -2*u3 + 3*u2;
        float B2 = u3 - 2*u2 + u;
        float B3 = u3 - u;
        return( B0*pA + B1*pB + B2*vA + B3*vB );
    }

    unsigned char* createGaussianMap(int N)
    {
        float *M = new float[2*N*N];
        unsigned char *B = new unsigned char[4*N*N];
        float X,Y,Y2,Dist;
        float Incr = 2.0f/N;
        int i=0;  
        int j = 0;
        Y = -1.0f;
        //float mmax = 0;
        for (int y=0; y<N; y++, Y+=Incr)
        {
            Y2=Y*Y;
            X = -1.0f;
            for (int x=0; x<N; x++, X+=Incr, i+=2, j+=4)
            {
                Dist = (float)sqrtf(X*X+Y2);
                if (Dist>1) Dist=1;
                M[i+1] = M[i] = evalHermite(1.0f,0,0,0,Dist);
                B[j+3] = B[j+2] = B[j+1] = B[j] = (unsigned char)(M[i] * 255);
            }
        }
        delete [] M;
        return(B);
    }    

    void ParticleRenderer::_createTexture(int resolution)
    {
        unsigned char* data = createGaussianMap(resolution);
        glGenTextures(1, (GLuint*)&m_texture);
        glBindTexture(GL_TEXTURE_2D, m_texture);
        glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP_SGIS, GL_TRUE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, resolution, resolution, 0, 
                     GL_RGBA, GL_UNSIGNED_BYTE, data);

    }
}