void CL::loadData(std::vector<Vec4> pos, std::vector<Vec4> vel, std::vector<Vec4> col)
{
//store the number of particles and the size in bytes of our arrays
num = pos.size();
array_size = num * sizeof(Vec4);
//create VBOs (defined in util.cpp)
p_vbo = createVBO(&pos[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
c_vbo = createVBO(&col[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
//make sure OpenGL is finished before we proceed
glFinish();
printf("gl interop!\n");
// create OpenCL buffer from GL VBO
cl_vbos.push_back(cl::BufferGL(context, CL_MEM_READ_WRITE, p_vbo, &err));
//printf("v_vbo: %s\n", oclErrorString(err));
cl_vbos.push_back(cl::BufferGL(context, CL_MEM_READ_WRITE, c_vbo, &err));
//we don't need to push any data here because it's already in the VBO
//create the OpenCL only arrays
cl_velocities = cl::Buffer(context, CL_MEM_WRITE_ONLY, array_size, NULL, &err);
cl_pos_gen = cl::Buffer(context, CL_MEM_WRITE_ONLY, array_size, NULL, &err);
cl_vel_gen = cl::Buffer(context, CL_MEM_WRITE_ONLY, array_size, NULL, &err);
printf("Pushing data to the GPU\n");
//push our CPU arrays to the GPU
//data is tightly packed in std::vector starting with the adress of the first element
err = queue.enqueueWriteBuffer(cl_velocities, CL_TRUE, 0, array_size, &vel[0], NULL, &event);
err = queue.enqueueWriteBuffer(cl_pos_gen, CL_TRUE, 0, array_size, &pos[0], NULL, &event);
err = queue.enqueueWriteBuffer(cl_vel_gen, CL_TRUE, 0, array_size, &vel[0], NULL, &event);
queue.finish();
}
bool EndPatchProgram::init()
{
if( ! ShaderProgram::init( true ) || ! loadShaders() )
{
return false;
}
createVBO( "in_position", ShaderProgram::gl_Vertex );
createVBO( "in_vertexID", ShaderProgram::gl_MultiTexCoord7 );
if( ! finalizeProgram() )
{
return false;
}
use();
ShaderProgram::createSBO( "valenceBuffer" );
ShaderProgram::createSBO( "neighborIndexBuffer" );
ShaderProgram::createSBO( "vertexData" );
// tell GL to only draw onto a pixel if the shape is closer to the viewer
glEnable( GL_DEPTH_TEST ); // enable depth-testing
glDepthFunc( GL_LESS ); // depth-testing interprets a smaller value as "closer"
return true;
}
void ParticleSystem::_initialize(int numParticles){
assert(!m_bInitialized);
m_numParticles = numParticles;
//Allocate host storage
m_hPos = (float *)malloc(m_numParticles * 4 * sizeof(float));
m_hVel = (float *)malloc(m_numParticles * 4 * sizeof(float));
m_hReorderedPos = (float *)malloc(m_numParticles * 4 * sizeof(float));
m_hReorderedVel = (float *)malloc(m_numParticles * 4 * sizeof(float));
m_hHash = (uint *)malloc(m_numParticles * sizeof(uint));
m_hIndex = (uint *)malloc(m_numParticles * sizeof(uint));
m_hCellStart = (uint *)malloc(m_numGridCells * sizeof(uint));
m_hCellEnd = (uint *)malloc(m_numGridCells * sizeof(uint));
memset(m_hPos, 0, m_numParticles * 4 * sizeof(float));
memset(m_hVel, 0, m_numParticles * 4 * sizeof(float));
memset(m_hCellStart, 0, m_numGridCells * sizeof(uint));
memset(m_hCellEnd, 0, m_numGridCells * sizeof(uint));
//Allocate GPU data
shrLog("Allocating GPU Data buffers...\n\n");
allocateArray(&m_dPos, m_numParticles * 4 * sizeof(float));
allocateArray(&m_dVel, m_numParticles * 4 * sizeof(float));
allocateArray(&m_dReorderedPos, m_numParticles * 4 * sizeof(float));
allocateArray(&m_dReorderedVel, m_numParticles * 4 * sizeof(float));
allocateArray(&m_dHash, m_numParticles * sizeof(uint));
allocateArray(&m_dIndex, m_numParticles * sizeof(uint));
allocateArray(&m_dCellStart, m_numGridCells * sizeof(uint));
allocateArray(&m_dCellEnd, m_numGridCells * sizeof(uint));
if (!m_bQATest)
{
//Allocate VBO storage
m_posVbo = createVBO(m_numParticles * 4 * sizeof(float));
m_colorVBO = createVBO(m_numParticles * 4 * sizeof(float));
//Fill color buffer
glBindBufferARB(GL_ARRAY_BUFFER, m_colorVBO);
float *data = (float *)glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
float *ptr = data;
for(uint i = 0; i < m_numParticles; i++){
float t = (float)i / (float) m_numParticles;
#if 0
*ptr++ = rand() / (float) RAND_MAX;
*ptr++ = rand() / (float) RAND_MAX;
*ptr++ = rand() / (float) RAND_MAX;
#else
colorRamp(t, ptr);
ptr += 3;
#endif
*ptr++ = 1.0f;
}
glUnmapBufferARB(GL_ARRAY_BUFFER);
}
setParameters(&m_params);
setParametersHost(&m_params);
m_bInitialized = true;
}
void genMeshGridObject(MeshGridObject *meshGridObj)
{
createMeshGrid(&meshGridObj->u, &meshGridObj->v, &meshGridObj->uSize, &meshGridObj->vSize, 100, 100);
createMeshGridIndices(&meshGridObj->indices, &meshGridObj->indicesLen, &meshGridObj->indicesSize, 100, 100);
createVBO(GL_ARRAY_BUFFER, &meshGridObj->uID,meshGridObj->uSize,meshGridObj->u);
printf("uID: %i\n",meshGridObj->uID);
createVBO(GL_ARRAY_BUFFER, &meshGridObj->vID,meshGridObj->vSize,meshGridObj->v);
printf("vID: %i\n",meshGridObj->vID);
createVBO(GL_ELEMENT_ARRAY_BUFFER, &meshGridObj->iboID, meshGridObj->indicesSize, (GLfloat*)meshGridObj->indices);
printf("iboID: %i\n",meshGridObj->iboID);
}
void WaterPlaneCUDA::initBuffer()
{
//Start und Endkoordinaten für x-Richtung
float startX = this->uLeft.x;
float endX = this->lRight.x;
//Start und Endkoordinaten für x-Richtung
float startY = this->uLeft.z;
float endY = this->lRight.z;
cpu_newVertices = new float3[pointsX*pointsY];
cpu_oldVertices = new float3[pointsX*pointsY];
cpu_normals = new float3[pointsX*pointsY];
unsigned int count = 0;
for (float px = startX ; px< endX ; px+=stepSize){
for (float py = startY; py < endY; py+=stepSize){
cpu_newVertices[count].x = px;
cpu_newVertices[count].y = 0;
cpu_newVertices[count].z = py;
cpu_oldVertices[count].x = px;
cpu_oldVertices[count].y = 0;
cpu_oldVertices[count].z = py;
cpu_normals[count].x = 0;
cpu_normals[count].y = 1;
cpu_normals[count].z = 0;
count++;
}
}
createVBO(&newVertexBuffer, pointsX*pointsY*sizeof(float3));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_newVertex_resource, newVertexBuffer, cudaGraphicsMapFlagsNone));
createVBO(&oldVertexBuffer, pointsX*pointsY*sizeof(float3));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_oldVertex_resource, oldVertexBuffer, cudaGraphicsMapFlagsNone));
createVBO(&normalBuffer, pointsX*pointsY*sizeof(float3));
cutilSafeCall(cudaGraphicsGLRegisterBuffer(&cuda_normalsVB_resource, normalBuffer, cudaGraphicsMapFlagsNone));
createMeshIndexBuffer(&indexVertexBuffer, pointsX, pointsY);
createMeshIndexBuffer(&indexNormalBuffer, pointsX, pointsY);
glBindBuffer(GL_ARRAY_BUFFER, *&newVertexBuffer);
glBufferData( GL_ARRAY_BUFFER, pointsY*pointsX*sizeof(float3), cpu_newVertices, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, *&oldVertexBuffer);
glBufferData( GL_ARRAY_BUFFER, pointsY*pointsX*sizeof(float3), cpu_oldVertices, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, *&normalBuffer);
glBufferData( GL_ARRAY_BUFFER, pointsY*pointsX*sizeof(float3), cpu_normals, GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
/* Build VBOs for all geosets. */
void ModelGL::buildVBOs () {
// Reserve memory and loop over all geosets.
_VBOs = (GeosetVBO*) calloc (_nrGeosets, sizeof (GeosetVBO));
for (int g = 0; g < _nrGeosets; g ++) {
_VBOs[g].length = _geosets[g].nrG * 3; // Set vertex count.
if (_texture != NULL) _VBOs[g].textureID = _texture->id(); // Set texture ID.
// Build temporary arrays based on geometry definitions.
int vsize = _geosets[g].nrG * 3 * 3; //| 3 vertices per geometry
int nsize = _geosets[g].nrG * 3 * 3; //| with 3 points, 3 nv-points
int tsize = _geosets[g].nrG * 3 * 2; //| and 2 texture coords each.
float* vdata = new float [vsize];
float* ndata = new float [nsize];
float* tdata = new float [tsize];
// Extract data for each geoset.
int vIdx, nIdx, tIdx; // Storage for index shortening.
for (int i = 0; i < _geosets[g].nrG; i ++) { // i: Loop over geometries.
for (int c = 0; c < 3; c ++) { // c: Loop over geom indices.
vIdx = _geosets[g].geometries[i].vIdx[c];
nIdx = _geosets[g].geometries[i].nIdx[c];
tIdx = _geosets[g].geometries[i].tIdx[c];
vdata [i*9 + c*3 + 0] = _geosets[g].vertices[vIdx].x; // Outer offset: 9 (3*inner).
vdata [i*9 + c*3 + 1] = _geosets[g].vertices[vIdx].y; // Inner offset: 3 (3 runs each).
vdata [i*9 + c*3 + 2] = _geosets[g].vertices[vIdx].z;
ndata [i*9 + c*3 + 0] = _geosets[g].normals[nIdx].x;
ndata [i*9 + c*3 + 1] = _geosets[g].normals[nIdx].y;
ndata [i*9 + c*3 + 2] = _geosets[g].normals[nIdx].z;
tdata [i*6 + c*2 + 0] = _geosets[g].textures[tIdx].u; // OO: 6 (2*3)
tdata [i*6 + c*2 + 1] = _geosets[g].textures[tIdx].v;
}
}
// Create VBOs.
_VBOs[g].vVBO = createVBO (vdata, vsize * sizeof(float), GL_ARRAY_BUFFER, GL_STATIC_DRAW);
_VBOs[g].nVBO = createVBO (ndata, nsize * sizeof(float), GL_ARRAY_BUFFER, GL_STATIC_DRAW);
_VBOs[g].tVBO = createVBO (tdata, tsize * sizeof(float), GL_ARRAY_BUFFER, GL_STATIC_DRAW);
// Free temporary data.
delete [] vdata;
delete [] ndata;
delete [] tdata;
}
}
void RotatingCamera::load(){
//blakommentar
foreground_sh.load("shaders/lustigiSzene.vert","shaders/lustigiSzene.frag");
foreground_sh.use();
// Set model matrix
GLfloat model_mat[16] = {
1.000000f, 0.000000f, 0.000000f, 0.000000f,
0.000000f, 1.000000f, 0.000000f, 0.000000f,
0.000000f, 0.000000f, 1.000000f, 0.000000f,
0.000000f, 0.000000f, 0.000000f, 1.0000000f
};
GLint location = glGetUniformLocation(foreground_sh.getProgramId(), "Model_mat");
glUniformMatrix4fv(location, 1, false, model_mat);
// Set projection*view Matrix
// GLfloat projview_mat[16] = {
// 2.747478f, 0.000000f, 0.000000f, 0.000000f,
// 0.000000f, 2.457419f, 0.546594f, 0.447214f,
// 0.000000f, 1.228709f, -1.093189f, -0.894427f,
// 0.000000f, 0.000000f, 1.877236f, 3.354102f
// };
vmath::mat4 projview_mat = getProjectionViewMatrix(azimuth, polar, distance);
location = glGetUniformLocation(foreground_sh.getProgramId(), "ProjectView_mat");
glUniformMatrix4fv(location, 1, false, (float*)(projview_mat));
createVBO();
}
StreamlineEffect::StreamlineEffect(ShaderLibrary* lib, GLuint width, GLuint height, unsigned int maxLength
, unsigned int num, vector<unsigned int>& indices, CL* cli, RTPSSettings* settings):
ParticleEffect( lib, width, height)
{
m_maxSLLength=maxLength;
m_numSL = num;
m_curSLIndex = 1;
vector<float4> f4vec((m_maxSLLength+1)*m_numSL);
std::fill(f4vec.begin(), f4vec.end(), float4(0.0f, 0.0f, 0.0f, 0.0f));
m_streamLineCP = createVBO(&f4vec[0], f4vec.size()*sizeof(float4), GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
m_streamLineColor = createVBO(&f4vec[0], f4vec.size()*sizeof(float4), GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
m_clStreamLineCP=Buffer<float4>(cli,m_streamLineCP);
m_clStreamLineColor=Buffer<float4>(cli,m_streamLineColor);
m_clSampleIndices=Buffer<unsigned int>(cli,indices);
sample = Sample(settings->GetSettingAs<string>("rtps_path") + "/" + std::string(COMMON_CL_SOURCE_DIR), cli);
}
/*!
This constructor requires a valid openGL contex
*/
sgct_utils::SGCTPlane::SGCTPlane(float width, float height)
{
//init
mVBO = GL_FALSE;
mVAO = GL_FALSE;
mVerts = NULL;
mInternalDrawFn = &SGCTPlane::drawVBO;
mVerts = new sgct_helpers::SGCTVertexData[4];
memset(mVerts, 0, 4 * sizeof(sgct_helpers::SGCTVertexData));
//populate the array
mVerts[0].set(0.0f, 0.0f, 0.0f, 0.0f, 1.0f, -width / 2.0f, -height / 2.0f, 0.0f);
mVerts[1].set(1.0f, 0.0f, 0.0f, 0.0f, 1.0f, width / 2.0f, -height / 2.0f, 0.0f);
mVerts[2].set(0.0f, 1.0f, 0.0f, 0.0f, 1.0f, -width / 2.0f, height / 2.0f, 0.0f);
mVerts[3].set(1.0f, 1.0f, 0.0f, 0.0f, 1.0f, width / 2.0f, height / 2.0f, 0.0f);
createVBO();
if( !sgct::Engine::checkForOGLErrors() ) //if error occured
{
sgct::MessageHandler::instance()->print(sgct::MessageHandler::NOTIFY_ERROR, "SGCT Utils: Plane creation error!\n");
void cleanup();
}
//free data
if( mVerts != NULL )
{
delete [] mVerts;
mVerts = NULL;
}
}
////////////////////////////////////////////////////////////////////////////////
//! Run OpenGL
////////////////////////////////////////////////////////////////////////////////
bool runDisplay(int argc, char **argv)
{
// Create the CUTIL timer
sdkCreateTimer(&timer);
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
if (false == initGL(&argc, argv))
{
return false;
}
// register callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutIdleFunc(idle);
// create VBO
createVBO(&vbo, &cuda_vbo_resource, cudaGraphicsMapFlagsWriteDiscard);
// start rendering mainloop
glutMainLoop();
// run the cuda part
//refreshData(&cuda_vbo_resource);
atexit(cleanup);
return true;
}
Sphere::Sphere(Material* mat, Program* prog, vec3 pos, vec3 scale):
Object(mat, prog, pos, scale) {
vLoc = glGetAttribLocation(prog->getID(), "in_position");
nLoc = glGetAttribLocation(prog->getID(), "in_normal");
populate();
createVBO();
}
void btParticlesDynamicsWorld::postInitDeviceData()
{
m_hashSize = getMaxPowOf2(m_numParticles);
createVBO();
allocateBuffers();
adjustGrid();
grabSimulationData();
}
//----------------------------------------------------------------------
int main(int argc, char** argv)
{
printf("Hello\n");
//Setup our GLUT window and OpenGL related things
//glut callback functions are setup here too
init_gl(argc, argv);
//initialize our particle system with positions, velocities and color
int num = NUM_PARTICLES;
//create VBOs
//fill our vectors with initial data
for(int i = 0; i < num; i++)
{
//distribute the particles in a random circle around z axis
float rad = rand_float(.2, .5);
float x = rad*sin(2*3.14 * i/num);
float z = 0.0f;// -.1 + .2f * i/num;
float y = rad*cos(2*3.14 * i/num);
pos[i] = Vec4(x, y, z, 1.0f);
pos_gen[i]=pos[i];
//give some initial velocity
//float xr = rand_float(-.1, .1);
//float yr = rand_float(1.f, 3.f);
//the life is the lifetime of the particle: 1 = alive 0 = dead
//as you will see in part2.cl we reset the particle when it dies
float life_r = rand_float(0.f, 1.f);
vel[i] = Vec4(0.0, 0.0, 3.0f, life_r);
vel_gen[i]=vel[i];
//just make them red and full alpha
color[i] = Vec4(1.0f, 0.0f,0.0f, 1.0f);
}
p_vbo = createVBO(&pos[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
c_vbo = createVBO(&color[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
//this starts the GLUT program, from here on out everything we want
//to do needs to be done in glut callback functions
glutMainLoop();
}
////////////////////////////////////////////////////////////////////////////////
//! Run a simple test for CUDA
////////////////////////////////////////////////////////////////////////////////
CUTBoolean runTest(int argc, char** argv)
{
if (!cutCheckCmdLineFlag(argc, (const char **)argv, "noqatest") ||
cutCheckCmdLineFlag(argc, (const char **)argv, "noprompt"))
{
g_bQAReadback = true;
fpsLimit = frameCheckNumber;
}
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with OpenGL/CUDA interop.
if (CUTFalse == initGL(argc, argv)) {
return CUTFalse;
}
// use command-line specified CUDA device, otherwise use device with highest Gflops/s
if( cutCheckCmdLineFlag(argc, (const char**)argv, "device") )
cutilGLDeviceInit(argc, argv);
else {
cudaGLSetGLDevice( cutGetMaxGflopsDeviceId() );
}
// Create the CUTIL timer
cutilCheckError( cutCreateTimer( &timer));
// register callbacks
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
if (g_bQAReadback) {
g_CheckRender = new CheckBackBuffer(window_width, window_height, 4);
g_CheckRender->setPixelFormat(GL_RGBA);
g_CheckRender->setExecPath(argv[0]);
g_CheckRender->EnableQAReadback(true);
}
// create VBO
createVBO(&vbo);
// run the cuda part
runCuda(vbo);
// check result of Cuda step
checkResultCuda(argc, argv, vbo);
atexit(cleanup);
// start rendering mainloop
glutMainLoop();
cudaThreadExit();
return CUTTrue;
}
NiceGrid::NiceGrid(GLfloat size, GLfloat rep)
: m_size(size),
m_rep(rep),
m_backFaceAlpha(0.2),
m_ambient(0.12f, 0.12f, 0.1f),
m_diffuse(1.0f, 1.0f, 0.9f),
m_position(0.0f, 0.0f, 0.0f)
{
createVBO();
}
/////////////////////////////////////////////////////////
// render
//
/////////////////////////////////////////////////////////
void multimodel :: render(GemState *state)
{
if(!m_loader) {
return;
}
if ( !m_position.vbo || !m_texture.vbo || !m_color.vbo || !m_normal.vbo
|| m_size_change_flag ) {
createVBO();
m_size_change_flag = false;
}
getVBOarray();
std::vector<unsigned int> sizeList;
if(m_position.render()) {
glVertexPointer(m_position.dimen, GL_FLOAT, 0, 0);
glEnableClientState(GL_VERTEX_ARRAY);
sizeList.push_back(m_position.size);
}
if(m_texture.render()) {
glTexCoordPointer(m_texture.dimen, GL_FLOAT, 0, 0);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
sizeList.push_back(m_texture.size);
}
if(m_color.render()) {
glColorPointer(m_color.dimen, GL_FLOAT, 0, 0);
glEnableClientState(GL_COLOR_ARRAY);
sizeList.push_back(m_color.size);
}
if(m_normal.render()) {
glNormalPointer(GL_FLOAT, 0, 0);
glEnableClientState(GL_NORMAL_ARRAY);
sizeList.push_back(m_normal.size);
}
if ( sizeList.size() > 0 ) {
unsigned int npoints = *std::min_element(sizeList.begin(),sizeList.end());
glDrawArrays(m_drawType, 0, npoints);
}
if ( m_position.enabled ) {
glDisableClientState(GL_VERTEX_ARRAY);
}
if ( m_color.enabled ) {
glDisableClientState(GL_COLOR_ARRAY);
}
if ( m_texture.enabled ) {
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}
if ( m_normal.enabled ) {
glDisableClientState(GL_NORMAL_ARRAY);
}
}
RectMesh::RectMesh(Material* mat, Program* prog, vec3 pos, vec3 scale,
vec3* points, unsigned width, unsigned length):
Object(mat, prog, pos, scale), points(points), width(width), length(length) {
vertexCount = width * length;
indicesCount = (length * 2) * (width - 1);
vLoc = glGetAttribLocation(prog->getID(), "in_position");
nLoc = glGetAttribLocation(prog->getID(), "in_normal");
populate();
createVBO();
}
bool Mesh::updateContextItem(bool changed) {
if (_texture != NULL)
_texture->updateContext();
if (changed)
{
deleteVBO();
createVBO();
}
return true;
}
ParticleRenderer::ParticleRenderer(bool isGL)
: m_vbo(0)
, m_frameId(0)
, m_eboArray(NULL)
, m_eboCount(2)
, m_isGL(isGL)
{
m_particleSystem = new ParticleSystem();
createShaders();
createVBO();
createEBOs();
}
void CL::loadData(std::vector<Vec4> pos, std::vector<Vec4> vel, std::vector<Vec4> col)
{
static int do_init = 1;
num = pos.size();
array_size = num * sizeof(Vec4);
if (do_init)
{ do_init = 0;
// This is the first time we are loading particle data.
// VBOs and OpenCL arrays must be initiialized
// Create Position and Color VBOs for GL & CL
p_vbo = createVBO(&pos[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
c_vbo = createVBO(&col[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
glFinish();
// Create OpenCL buffer from GL VBO
cl_vbos.push_back(cl::BufferGL(context, CL_MEM_READ_WRITE, p_vbo, &err));
cl_vbos.push_back(cl::BufferGL(context, CL_MEM_READ_WRITE, c_vbo, &err));
//Create the OpenCL only arrays
cl_velocities = cl::Buffer(context, CL_MEM_WRITE_ONLY, array_size, NULL, &err);
cl_pos_gen = cl::Buffer(context, CL_MEM_WRITE_ONLY, array_size, NULL, &err);
cl_vel_gen = cl::Buffer(context, CL_MEM_WRITE_ONLY, array_size, NULL, &err);
} else {
// Reloading the position and color VBOs with new values.
reload_buffer(p_vbo, &pos[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
reload_buffer(c_vbo, &col[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
}
// Push data to the GPU
printf("Pushing data to the GPU\n");
err = queue.enqueueWriteBuffer(cl_velocities, CL_TRUE, 0, array_size, &vel[0], NULL, &event);
err = queue.enqueueWriteBuffer(cl_pos_gen, CL_TRUE, 0, array_size, &pos[0], NULL, &event);
err = queue.enqueueWriteBuffer(cl_vel_gen, CL_TRUE, 0, array_size, &vel[0], NULL, &event);
queue.finish();
}
void GameWindow::createVBOs() {
for(short c = 0; c < 100; c++) {
glGenBuffers(100, VBO[c]);
}
for(short c = 0; c < 100; c++) {
for(short i = 0; i < 100; i++) {
int id[2] = {c, i};
float x = c/100.0f*2.0f;
float y = -i/100.0f*2.0f;
createVBO(id, {x-1, y+1, 0.0f});
}
}
}
void MD::loadData(std::vector<cl_float4> pos, std::vector<cl_float4> force,
std::vector<cl_float4> vel, std::vector<cl_float4> col) {
// Store the number of particles and the size in bytes of our arrays.
num = pos.size();
array_size = num * sizeof(cl_float4);
// Create VBOs (defined in util.cpp).
pos_vbo = createVBO(&pos[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
col_vbo = createVBO(&col[0], array_size, GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
// Make sure OpenGL is finished before we proceed.
glFinish();
printf("Set up GL sharing.\n");
try {
// Create OpenCL buffer from GL VBO.
// We don't need to push any data here because it's already in the VBO.
cl_vbos.push_back(cl::BufferGL(context, CL_MEM_READ_WRITE, pos_vbo, &err));
cl_vbos.push_back(cl::BufferGL(context, CL_MEM_READ_WRITE, col_vbo, &err));
}
catch (cl::Error er) {
printf("ERROR: %s(%s)\n", er.what(), oclErrorString(er.err()));
exit(EXIT_FAILURE);
}
// Create the OpenCL only arrays.
cl_forces = cl::Buffer(context, CL_MEM_READ_WRITE, array_size, NULL, &err);
cl_vel = cl::Buffer(context, CL_MEM_READ_WRITE, array_size, NULL, &err);
printf("Pushing data to the GPU\n");
// Push our CPU arrays to the GPU.
// Data is tightly packed in std::vector starting with the adress of the first
// element.
err = queue.enqueueWriteBuffer(cl_forces, CL_TRUE, 0, array_size, &force[0],
NULL, &event);
err = queue.enqueueWriteBuffer(cl_vel, CL_TRUE, 0, array_size, &vel[0],
NULL, &event);
queue.finish();
}
int main(int argc, char** argv)
{
initGL(argc, argv);
initData(INPUTFILENAME);
//Create VBO
createVBO();
initializeVBOs();
glutMainLoop();
//Free CUDA variables
return 0;
}
void initObj(RenderObject *r)
{
if (r->vertices!=NULL)
{
createVBO(GL_ARRAY_BUFFER, &r->vboID,r->verticesSize,r->vertices);
printf("vboID: %i\n",r->vboID);
printf("Size of Vertices: %d\n",r->verticesSize);
}
if (r->u!=NULL)
{
createVBO(GL_ARRAY_BUFFER, &r->uID,r->uSize,r->u);
printf("uID: %i\n",r->uID);
printf("Size of u: %d\n",r->uSize);
}
if (r->v!=NULL)
{
createVBO(GL_ARRAY_BUFFER, &r->vID,r->vSize,r->v);
printf("vID: %i\n",r->vID);
printf("Size of v: %d\n",r->vSize);
}
if (r->normals!=NULL)
{
createVBO(GL_ARRAY_BUFFER, &r->nboID, r->normalsSize, r->normals);
printf("nboID: %i\n",r->nboID);
printf("Size of normals: %d\n",r->normalsSize);
}
if (r->texCoords!=NULL)
{
createVBO(GL_ARRAY_BUFFER, &r->tcoID, r->texCoordsSize, r->texCoords);
printf("tcoID: %i\n",r->tcoID);
printf("Size of texCoords: %d\n",r->texCoordsSize);
}
if (r->indices!=NULL)
{
createVBO(GL_ELEMENT_ARRAY_BUFFER, &r->iboID, r->indicesSize, (GLfloat*)r->indices);
printf("iboID: %i\n",r->iboID);
printf("Size of Indices: %d\n",r->indicesSize);
}
r->mProjHandle = glGetUniformLocation(r->shaderProgram,"mProj");
r->mViewHandle = glGetUniformLocation(r->shaderProgram,"mView");
r->mModelHandle = glGetUniformLocation(r->shaderProgram,"mModel");
r->colorHandle = glGetUniformLocation(r->shaderProgram,"color");
r->samplerHandle[0] = glGetUniformLocation(r->shaderProgram,"samp");
r->samplerHandle[1] = glGetUniformLocation(r->shaderProgram,"samp2");
}
Mesh MeshLoader::getSubPlane(int x, int y, int width, int height, int w,
int h) {
// Generate vertex array object
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
static constexpr int8_t vertices[4][3] = {
{0, -1, 0}, {1, -1, 0}, {1, 0, 0}, {0, 0, 0}
};
const float texCoords[4][2] = {
{static_cast<float>(x) / w, static_cast<float>(y) / h},
{static_cast<float>(x + width) / w, static_cast<float>(y) / h},
{static_cast<float>(x + width) / w, static_cast<float>(y + height) / h},
{static_cast<float>(x) / w, static_cast<float>(y + height) / h}
};
static constexpr uint8_t vi[6] = {0, 1, 3, 2, 3, 1}, ti[6] = {3, 2, 0, 1, 0, 2};
constexpr unsigned int vtxSize = 3 * sizeof(int8_t) + 2 * sizeof(float);
TightDataPacker data(6 * vtxSize);
for (int i = 0; i < 6; ++i) {
const int8_t *v = vertices[vi[i]];
data << v[0] << v[1] << v[2];
const float *t = texCoords[ti[i]];
data << t[0] << t[1];
}
assert(data.getSize() == 6 * vtxSize);
// Put the vertex buffer into the VAO
createVBO(GL_ARRAY_BUFFER, data.getSize(), data.getDataPtr(), vtxSize,
{ {0, 3, GL_BYTE, nullptr},
{1, 2, GL_FLOAT, reinterpret_cast<GLvoid *>(3 * sizeof(int8_t))} });
// Unbind VAO
glBindVertexArray(0);
// Store relevant data in the new mesh
return Mesh{static_cast<int>(vao), 2, {}};
}
//----------------------------------------------------------------------
void FLOCK::prepareSorted()
{
vector<int4> i4Vec(max_num);
vector<float4> f4Vec(max_num);
fill(i4Vec.begin(), i4Vec.end(), int4(0,0,0,0));
fill(f4Vec.begin(), f4Vec.end(), float4(0.0f, 0.0f, 0.0f, 1.0f));
rotationVBO = createVBO(&f4Vec[0], f4Vec.size()*sizeof(float4), GL_ARRAY_BUFFER, GL_DYNAMIC_DRAW);
cl_rotation_u = Buffer<float4>(cli,rotationVBO);
fill(f4Vec.begin(), f4Vec.end(), float4(0.0f, 0.0f, 0.0f, 0.0f));
cl_flockmates_s= Buffer<int4>(cli, i4Vec);
cl_separation_s = Buffer<float4>(cli, f4Vec);
cl_alignment_s = Buffer<float4>(cli, f4Vec);
cl_cohesion_s = Buffer<float4>(cli, f4Vec);
cl_goal_s = Buffer<float4>(cli, f4Vec);
cl_avoid_s = Buffer<float4>(cli, f4Vec);
cl_leaderfollowing_s = Buffer<float4>(cli, f4Vec);
cl_veleval_u = Buffer<float4>(cli,f4Vec);
cl_veleval_s = Buffer<float4>(cli,f4Vec);
//TODO make a helper constructor for buffer to make a cl_mem from a struct
//Setup Grid Parameter structs
vector<GridParams> gparams(0);
gparams.push_back(grid_params);
cl_GridParams = Buffer<GridParams>(cli, gparams);
//scaled Grid Parameters
vector<GridParams> sgparams(0);
sgparams.push_back(grid_params_scaled);
cl_GridParamsScaled = Buffer<GridParams>(cli, sgparams);
// Size is the grid size + 1, the last index is used to signify how many particles are within bounds
// That is a problem since the number of
// occupied cells could be much less than the number of grid elements.
dout<<"Number of Grid Cells: "<< grid_params.nb_cells<<endl;
vector<unsigned int> gcells(grid_params.nb_cells+1);
int minus = 0xffffffff;
std::fill(gcells.begin(), gcells.end(), 666);
cl_cell_indices_start = Buffer<unsigned int>(cli, gcells);
cl_cell_indices_end = Buffer<unsigned int>(cli, gcells);
}
void init() {
createVBO();
// Vertex Array Object
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
// Load shaders
GLuint program = InitShader("vshader.glsl", "fshader.glsl");
glUseProgram(program);
// Set position and color for single cube
glBindBuffer(GL_ARRAY_BUFFER, vbo);
GLuint vPosition = glGetAttribLocation(program, "vPosition");
glEnableVertexAttribArray(vPosition);
glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBindVertexArray(0);
// Handle depth info
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
glDepthRange(0.0, 1.0);
// Set up uniform variables
uRotationMat = glGetUniformLocation(program, "rotationMat");
uScale = glGetUniformLocation(program, "scale");
uPositions = glGetUniformLocation(program, "positions");
uCubeId = glGetUniformLocation(program, "cubeId");
uColors = glGetUniformLocation(program, "colors");
uRotationAxes = glGetUniformLocation(program, "rotationAxes");
uRotationProgress = glGetUniformLocation(program, "rotationProgress");
glutPostRedisplay();
glutSwapBuffers();
}
// create fixed vertex buffer to store mesh vertices
void createMeshPositionVBO(GLuint *id, int w, int h)
{
createVBO(id, w*h*4*sizeof(float));
glBindBuffer(GL_ARRAY_BUFFER, *id);
float *pos = (float *) glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
if (!pos) {
return;
}
for(int y=0; y<h; y++) {
for(int x=0; x<w; x++) {
float u = x / (float) (w-1);
float v = y / (float) (h-1);
*pos++ = u*2.0f-1.0f;
*pos++ = 0.0f;
*pos++ = v*2.0f-1.0f;
*pos++ = 1.0f;
}
}
glUnmapBuffer(GL_ARRAY_BUFFER);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}
void
ParticleSystem::_initialize(int numParticles)
{
assert(!m_bInitialized);
m_numParticles = numParticles;
// allocate host storage
m_hPos = new float[m_numParticles*4];
m_hVel = new float[m_numParticles*4];
memset(m_hPos, 0, m_numParticles*4*sizeof(float));
memset(m_hVel, 0, m_numParticles*4*sizeof(float));
m_hCellStart = new uint[m_numGridCells];
memset(m_hCellStart, 0, m_numGridCells*sizeof(uint));
m_hCellEnd = new uint[m_numGridCells];
memset(m_hCellEnd, 0, m_numGridCells*sizeof(uint));
// allocate GPU data
unsigned int memSize = sizeof(float) * 4 * m_numParticles;
if (m_bUseOpenGL)
{
m_posVbo = createVBO(memSize);
registerGLBufferObject(m_posVbo, &m_cuda_posvbo_resource);
}
else
{
checkCudaErrors(cudaMalloc((void **)&m_cudaPosVBO, memSize)) ;
}
allocateArray((void **)&m_dVel, memSize);
allocateArray((void **)&m_dSortedPos, memSize);
allocateArray((void **)&m_dSortedVel, memSize);
allocateArray((void **)&m_dGridParticleHash, m_numParticles*sizeof(uint));
allocateArray((void **)&m_dGridParticleIndex, m_numParticles*sizeof(uint));
allocateArray((void **)&m_dCellStart, m_numGridCells*sizeof(uint));
allocateArray((void **)&m_dCellEnd, m_numGridCells*sizeof(uint));
if (m_bUseOpenGL)
{
m_colorVBO = createVBO(m_numParticles*4*sizeof(float));
registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource);
// fill color buffer
glBindBufferARB(GL_ARRAY_BUFFER, m_colorVBO);
float *data = (float *) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
float *ptr = data;
for (uint i=0; i<m_numParticles; i++)
{
float t = i / (float) m_numParticles;
#if 0
*ptr++ = rand() / (float) RAND_MAX;
*ptr++ = rand() / (float) RAND_MAX;
*ptr++ = rand() / (float) RAND_MAX;
#else
colorRamp(t, ptr);
ptr+=3;
#endif
*ptr++ = 1.0f;
}
glUnmapBufferARB(GL_ARRAY_BUFFER);
}
else
{
checkCudaErrors(cudaMalloc((void **)&m_cudaColorVBO, sizeof(float)*numParticles*4));
}
sdkCreateTimer(&m_timer);
setParameters(&m_params);
m_bInitialized = true;
}
void PoiseuilleFlowSystem::_initialize(int numParticles){
assert(!IsInitialized);
numParticles = numParticles;
hPos = new float[numParticles*4];
hVel = new float[numParticles*4];
hVelLeapFrog = new float[numParticles*4];
hMeasures = new float[numParticles*4];
hAcceleration = new float[numParticles*4];
memset(hPos, 0, numParticles*4*sizeof(float));
memset(hVel, 0, numParticles*4*sizeof(float));
memset(hVelLeapFrog, 0, numParticles*4*sizeof(float));
memset(hAcceleration, 0, numParticles*4*sizeof(float));
memset(hMeasures, 0, numParticles*4*sizeof(float));
for(uint i = 0; i < numParticles; i++) //todo: check density approximation
hMeasures[4*i+0] = params.restDensity;
unsigned int memSize = sizeof(float) * 4 * numParticles;
if (IsOpenGL) {
posVbo = createVBO(memSize);
registerGLBufferObject(posVbo, &cuda_posvbo_resource);
} else {
checkCudaErrors( cudaMalloc( (void **)&cudaPosVBO, memSize )) ;
}
allocateArray((void**)&dVel, memSize);
allocateArray((void**)&dVelLeapFrog, memSize);
allocateArray((void**)&dAcceleration, memSize);
allocateArray((void**)&dMeasures, memSize);
allocateArray((void**)&dSortedPos, memSize);
allocateArray((void**)&dSortedVel, memSize);
allocateArray((void**)&dHash, numParticles*sizeof(uint));
allocateArray((void**)&dIndex, numParticles*sizeof(uint));
allocateArray((void**)&dCellStart, numGridCells*sizeof(uint));
allocateArray((void**)&dCellEnd, numGridCells*sizeof(uint));
if (IsOpenGL) {
colorVBO = createVBO(numParticles*4*sizeof(float));
registerGLBufferObject(colorVBO, &cuda_colorvbo_resource);
// fill color buffer
glBindBufferARB(GL_ARRAY_BUFFER, colorVBO);
float *data = (float *) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
float *ptr = data;
uint fluidParticles = params.fluidParticlesSize.x * params.fluidParticlesSize.y * params.fluidParticlesSize.z;
for(uint i=0; i < numParticles; i++) {
float t = 0.7f;
if(i < fluidParticles)
t = 0.5f;
if(((i % params.gridSize.x) == 0) && i < fluidParticles)
t = 0.2f;
colorRamp(t, ptr);
ptr+=3;
*ptr++ = 1.0f;
}
glUnmapBufferARB(GL_ARRAY_BUFFER);
} else {
checkCudaErrors( cudaMalloc( (void **)&cudaColorVBO, sizeof(float)*numParticles*4) );
}
setParameters(¶ms);
IsInitialized = true;
}
