void renderScene(void) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setCamera(10,2,10,0,2,-5);
glUseProgram(p);
setUniforms();
//glBindVertexArray(vao[0]);
glBindBuffer(GL_ARRAY_BUFFER, vbos[0]);
glVertexAttribPointer(vertexLoc, 4, GL_FLOAT, 0, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, vbos[1]);
glVertexAttribPointer(colorLoc, 4, GL_FLOAT, 0, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
//glBindVertexArray(vao[1]);
glBindBuffer(GL_ARRAY_BUFFER, vbos[2]);
glVertexAttribPointer(vertexLoc, 4, GL_FLOAT, 0, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, vbos[3]);
glVertexAttribPointer(colorLoc, 4, GL_FLOAT, 0, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);
//glBindVertexArray(vao[2]);
glBindBuffer(GL_ARRAY_BUFFER, vbos[4]);
glVertexAttribPointer(vertexLoc, 4, GL_FLOAT, 0, 0, 0);
glBindBuffer(GL_ARRAY_BUFFER, vbos[5]);
glVertexAttribPointer(colorLoc, 4, GL_FLOAT, 0, 0, 0);
glDrawArrays(GL_LINES, 0, 6);
glutSwapBuffers();
}
void renderScene(void) {
frame++;
time=glutGet(GLUT_ELAPSED_TIME);
if (MoveLight && (time - timebase2 > 10))
{
lightAngle = PI/36;
myMulti(lightPosition, rotationMatrix(0.0, 1.0, 0.0, lightAngle));
timebase2 = time;
}
if (time - timebase > 1000) {
sprintf(s,"FPS:%4.2f",
frame*1000.0/(time-timebase));
timebase = time;
frame = 0;
}
glutSetWindowTitle(s);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//placeCam(10,2,10,0,2,-5);
placeCam(viewPosition[0],viewPosition[1],viewPosition[2],0,0,-5);
multiplyMatrix(viewMatrix, rotationMatrix(0.0,1.0,0.0, angle));
multiplyMatrix(viewMatrix, rotationMatrix(1.0,0.0,0.0, angle2));
glUseProgram(p);
setUniforms();
glBindVertexArray(vert[0]);
glDrawArrays(GL_TRIANGLES, 0, sizeof(vertices1));
float T[16];
setScale(T,0.5,0.5,0.5);
multiplyMatrix(viewMatrix, T);
setTransMatrix(T,4,0,0);
multiplyMatrix(viewMatrix, T);
setUniforms();
glBindVertexArray(vert[1]);
glDrawArrays(GL_TRIANGLES, 0, sizeof(vertices1));
glutSwapBuffers();
}
void GpuParticles::draw()
{
drawShader.begin();
ofNotifyEvent(drawEvent, drawShader, this);
setUniforms(drawShader);
mesh.draw();
drawShader.end();
}
Render::Render(Init *init){
this->init = init;
init->SDL();
init->OpenGL();
cameraX = 0;
cameraY = 0;
ledR = ledG = ledB = 1;
//loop = &Render::mainMenu;
menuObjects = new vector<button>;
pauseObjects = new vector<button>;
scoreButtons = new vector<button>;
scoreTexts = new vector<button>;
settingsButtons = new vector<button>;
//popupButtons = new vector<button>;
TTF_Init();
screenHeight = init->getScreenHeight();
screenWidth = init->getScreenWidth();
float scale = 1080.0 / screenHeight;
font = TTF_OpenFont("./Font/CaviarDreams.ttf", 42 / scale);
menuFont = TTF_OpenFont("./Font/CaviarDreams.ttf", 60 / scale);
titleFont = TTF_OpenFont("./Font/CaviarDreams.ttf", 80 / scale);
popupFont = TTF_OpenFont("./Font/CaviarDreams.ttf", 20 / scale);
renderNow = false;
shutDown = false;
platformVBO = new PlatformVBO();
particleVBO = new ParticleVBO();
backgroundVBO = new PlatformVBO();
//pauseVBO = new PlatformVBO();
mainCharParticleVBO = new ParticleVBO();
b2Vec2 vx[4];
vx[0].x = 0;
vx[0].y = 0;
vx[1].x = screenWidth;
vx[1].y = 0;
vx[2].x = screenWidth;
vx[2].y = screenHeight;
vx[3].x = 0;
vx[3].y = screenHeight;
//pauseVBO->pushBackground(vx, b2Vec2(screenHeight / 2, screenWidth / 2), b2Vec3(255, 0, 255));
// setBackgroundSquare(0, 0, screenWidth, screenHeight, b2Vec3(0, 0, 0), pauseVBO);
setBackgroundSquare(0, 0, screenWidth, screenHeight, b2Vec3(0, 255, 255), backgroundVBO);
shader = new Shader("./Shaders/ligthShader.vert", "./Shaders/ligthShader.frag");
platformShader = new Shader("./Shaders/platformShader.vert", "./Shaders/platformShader.frag");
// colorShader = new Shader("./Shaders/colorShader.vert", "./Shaders/colorShader.frag");
setUniforms(shader);
}
void Shader::Bind()
{
if (Game->getCurrentShader() == id)
return;
Game->setCurrentShader(id);
glUseProgram(id);
setUniforms();
}
void Shader::bind()
{
string err = checkProgram();
if (err == "")
{
glUseProgram(*program);
setUniforms();
}
else
LOG << "OpenGL Shader " << err << "\n";
}
void RenderContext::draw(const DrawDataList& drawDataList, ShaderUniforms shaderUniforms) {
//Set all global uniforms.
for(ShaderProgramPtr shader : drawDataList.shaders()) {
//Bind shader program if changed
if(shader) {
shader->bind();
setUniforms(shader, shaderUniforms);
}
}
m_currentSP = nullptr;
//Draw all objects.
for(DrawDataList::value_type dd : drawDataList) {
draw(dd);
}
}
void Camera::drawScene( const Program & program)
{
if (m_activeCamera == nullptr)
return;
if(m_invalidated)
update(); // refresh matrices
// do not call glClear here, as it is not needed in all implementations
glViewport(0, 0, m_viewport.x, m_viewport.y);
glError();
setUniforms(program);
m_activeCamera->drawScene(program);
}
//--------------------------------------------------------------
void ofShader::setUniforms(const ofParameterGroup & parameters) const{
for(int i=0;i<parameters.size();i++){
if(parameters[i].type()==typeid(ofParameter<int>).name()){
setUniform1i(parameters[i].getEscapedName(),parameters[i].cast<int>());
}else if(parameters[i].type()==typeid(ofParameter<float>).name()){
setUniform1f(parameters[i].getEscapedName(),parameters[i].cast<float>());
}else if(parameters[i].type()==typeid(ofParameter<ofVec2f>).name()){
setUniform2f(parameters[i].getEscapedName(),parameters[i].cast<ofVec2f>());
}else if(parameters[i].type()==typeid(ofParameter<ofVec3f>).name()){
setUniform3f(parameters[i].getEscapedName(),parameters[i].cast<ofVec3f>());
}else if(parameters[i].type()==typeid(ofParameter<ofVec4f>).name()){
setUniform4f(parameters[i].getEscapedName(),parameters[i].cast<ofVec4f>());
}else if(parameters[i].type()==typeid(ofParameterGroup).name()){
setUniforms((ofParameterGroup&)parameters[i]);
}
}
}
void GAFSprite::draw(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, bool transformUpdated)
{
(void)transformUpdated;
#else
void GAFSprite::draw(cocos2d::Renderer *renderer, const cocos2d::Mat4 &transform, uint32_t flags)
{
(void)flags;
#endif
if (m_isLocator)
{
return;
}
_insideBounds = (flags & FLAGS_TRANSFORM_DIRTY) ? renderer->checkVisibility(transform, _contentSize) : _insideBounds;
if (!_insideBounds)
return;
uint32_t id = setUniforms();
if (m_useSeparateBlendFunc || (m_blendEquation != -1))
{
m_customCommand.init(_globalZOrder);
m_customCommand.func = CC_CALLBACK_0(GAFSprite::customDraw, this, transform);
renderer->addCommand(&m_customCommand);
}
else
{
m_quad = _quad;
transform.transformPoint(&m_quad.tl.vertices);
transform.transformPoint(&m_quad.tr.vertices);
transform.transformPoint(&m_quad.bl.vertices);
transform.transformPoint(&m_quad.br.vertices);
m_quadCommand.init(_globalZOrder, _texture->getName(), getGLProgramState(), _blendFunc, &m_quad, 1, Mat4::IDENTITY, id);
renderer->addCommand(&m_quadCommand);
}
}
void GpuParticles::update()
{
fbos[1 - currentReadFbo].begin(false);
glPushAttrib(GL_ENABLE_BIT);
// we set up no camera model and ignore the modelview and projection matrices
// in the vertex shader, we make a viewport large enought to ensure the shader
// is executed for each pixel
glViewport(0, 0, width, height);
glDisable(GL_BLEND);
ofSetColor(255, 255, 255);
fbos[1 - currentReadFbo].activateAllDrawBuffers();
updateShader.begin();
ofNotifyEvent(updateEvent, updateShader, this);
setUniforms(updateShader);
texturedQuad(-1, -1, 2, 2, width, height);
updateShader.end();
glPopAttrib();
fbos[1 - currentReadFbo].end();
currentReadFbo = 1 - currentReadFbo;
}
void Camera::draw( const Program & program, const glm::mat4 & transform)
{
if (m_activeRenderTechnique == m_rasterizer)
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setUniforms(program);
}
void CCFilter::draw()
{
setUniforms(getProgram());
}
void display()
{
track* tracks[2] = { trackOne, trackTwo };
sphere* lights[2] = { lightOne, lightTwo };
/* Define the background colour */
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
/* Clear the colour and frame buffers */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
/* Enable depth test */
glEnable(GL_DEPTH_TEST);
/* Make the compiled shader program current */
glUseProgram(program);
glUniform3fv(global_ambientID, 1, &global_ambient[0]);
// Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
projection = glm::perspective(30.0f, aspect_ratio, 0.1f, 100.0f);
glUniformMatrix4fv(projectionID, 1, GL_FALSE, &projection[0][0]);
glm::mat4 view = glm::lookAt(
glm::vec3(0, 0, -7), // Camera is at (0,0,4), in World Space
glm::vec3(0, 0, 0), // and looks at the origin
glm::vec3(0, 1, 0) // Head is up (set to 0,-1,0 to look upside-down)
);
glm::mat4 model = glm::mat4(1.0f);
model = globalTransform->getModel(); //global transformations
glUniform1ui(numberOfLightsID, numberOfLights);
glm::vec3 lightPosition_p;
GLfloat lightsPositions[2 * 3];//number of lights
for (int i = 0; i < numberOfLights; i++)
{
int step = i * 3;
if (light_mode)
{
glm::mat4 lightModel = model * lights[i]->transform->getModel();
setUniforms(view, lightModel, lights[i]->light);
lights[i]->drawSphere();
glm::vec4 lightPosition_h = view * lightModel * glm::vec4(lights[i]->transform->getCoords(), 1.0);
lightPosition_p = glm::vec3(lightPosition_h.x, lightPosition_h.y, lightPosition_h.z);
lightsPositions[step] = lightPosition_p.x;
lightsPositions[step + 1] = lightPosition_p.y;
lightsPositions[step + 2] = lightPosition_p.z;
glUniform3fv(light_posID, i + 1, &lightsPositions[0]);
}
else
{
lightPosition = glm::vec3(fixedLight_x, fixedLight_y, fixedLight_z);
lightsPositions[step] = lightPosition.x;
lightsPositions[step + 1] = lightPosition.y;
lightsPositions[step + 2] = lightPosition.z;
glUniform3fv(light_posID, i + 1, &lightsPositions[0]);
}
}
glUniform1ui(lightModeID, light_mode);
glm::mat4 tankModel = model * tankBody->transform->getModel(); //tank body transforms
setUniforms(view, tankModel, tankBody->light);
tankBody->drawBody();
glm::mat4 turretModel = tankBody->spinTurret(turret_spin);
for (int i = 0; i < 3; i++) //3 parts to gun
{
glm::mat4 guntransform = turretModel * tankBody->getGunTransformations()[i]->getModel();
guntransform = tankModel * guntransform;
setUniforms(view, guntransform, tankBody->light);
tankBody->getBaseCylider()->drawCyclinder();
}
for (int j = 0; j < 2; j++)
{
glm::mat4 trackModel = tankModel * tracks[j]->getTrack()->transform->getModel(); //track transforms
for (int i = 0; i < tracks[j]->getTracks().size(); i++)
{
model = trackModel * tracks[j]->getTracks()[i]->getModel(); //individual tracks
setUniforms(view, model, tracks[j]->getTrack()->light);
tracks[j]->getTrack()->drawTrack();
}
for (int i = 0; i < 4; i++)
{
model = trackModel * tracks[j]->getWheels()[i]->getModel(); //wheels
setUniforms(view, model, tracks[j]->getBaseWheel()->light);
tracks[j]->getBaseWheel()->drawCyclinder();
}
}
trackOne->move(speed_r);
trackTwo->move(speed_l);
glDisableVertexAttribArray(0);
glUseProgram(0);
}
void CCWaveFilter::draw()
{
setUniforms(m_sprite->getShaderProgram());
}
void RenderContext::draw(DrawData drawData) {
glClearColor(0, 0, 0.0, 1);
glViewport(0, 0, m_width, m_height);
//if(static_cast<int>(drawData.IsTwoSided) != m_currentIsTwoSided)
{
if(drawData.IsTwoSided)
glDisable(GL_CULL_FACE);
else
glEnable(GL_CULL_FACE);
m_currentIsTwoSided = static_cast<int>(drawData.IsTwoSided);
}
if(drawData.BlendingFunction == Blending::Normal)
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
else if (drawData.BlendingFunction == Blending::Addative)
{
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
}
else if( drawData.BlendingFunction == Blending::SRC_ALPHA_ONE) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
}
else {
glDisable(GL_BLEND);
}
if(drawData.PolygonDrawMode == PolygonMode::Fill)
{
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL);
}
else {
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE);
}
//Bind the texture units
for(int i = 0; i < DrawData::NUM_TEX_UNITS; ++i)
{
//if(drawData.TEX[i] != m_currentTEX[i])
{
if(drawData.TEX[i]) {
drawData.TEX[i]->bind(i);
drawData.TEX[i]->bind();
m_currentTEX[i] = drawData.TEX[i];
/*glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
*/
}
}
}
//Bind shader program if changed
//if(drawData.SP != m_currentSP)
{
if(drawData.Current_SP)
drawData.Current_SP->bind();
m_currentSP = drawData.Current_SP;
}
//Set shader uniforms. This is usually cheap operation and therefore all uniforms
//are written. Not just the ones that have changed.
setUniforms(m_currentSP, drawData.Uniforms);
//Bind the vertex array if changed.
//if(drawData.VAO != m_currentVAO)
{
if(drawData.VAO)
drawData.VAO->bind();
m_currentVAO = drawData.VAO;
}
if(drawData.IB)
{
//Bind the index array if changed.
if(drawData.IB != m_currentIB)
{
drawData.IB->bind();
m_currentIB = drawData.IB;
}
if(drawData.IsVisible) {
if(drawData.Primitive == DrawPrimitive::Triangles)
glDrawElements(GL_TRIANGLES, drawData.IB->numberOfIndices(), GL_UNSIGNED_INT, 0);
else
glDrawElements(GL_TRIANGLE_STRIP, drawData.IB->numberOfIndices(), GL_UNSIGNED_INT, 0);
}
}
else {
//No index buffer. Draw using the number of triangles attribute instead.
if(drawData.IsVisible) {
if(drawData.Primitive == DrawPrimitive::Triangles)
glDrawArrays(GL_TRIANGLES, 0, drawData.NumberOfTrianglesToDraw);
else
glDrawArrays(GL_TRIANGLE_STRIP, 0, drawData.NumberOfTrianglesToDraw);
}
}
}
void renderScene(void)
{
int i;
int count;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
setCamera(1.5,1.5,3.5,1.5,1.5,0);
glUseProgram(p);
setUniforms();
for (count = 0; count < 3; ++count)
{
glBindVertexArray(vao[count]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, tfbuf[count]);
glEnable(GL_RASTERIZER_DISCARD);
glBeginTransformFeedback(GL_TRIANGLES);
glDrawArrays(GL_TRIANGLES, 0, 3);
glEndTransformFeedback();
glDisable(GL_RASTERIZER_DISCARD);
glBindBuffer(GL_ARRAY_BUFFER, tfbuf[count]);
glDrawArrays(GL_TRIANGLES, 0, 3);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, tfbuf[count]);
float *pos = (float *)glMapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, GL_READ_WRITE);
int i;
if (pos != NULL)
{
printf("Triangle #%d\n", count + 1);
for (i = 0; i < 3; ++i)
{
printf(" Vertex #%d\n", i);
printf(" Color: \t%f %f %f %f\n", pos[8 * i], pos[8 * i + 1], pos[8 * i + 2], pos[8 * i + 3]);
printf(" Pos: \t%f %f %f %f\n", pos[8 * i + 4], pos[8 * i + 5], pos[8 * i + 6], pos[8 * i + 7]);
}
}
if (pos != NULL && dump_vertex)
{
FILE * pFile;
int n;
pFile = fopen ("glsl_solid_triangles_overlap_vertex.txt","w");
fprintf(pFile, "Triangle #%d\n", count + 1);
for (n=0 ; n<3 ; n++)
{
fprintf(pFile, " Vertex #%d\n", i);
fprintf(pFile, " Color: \t%f %f %f %f\n", pos[8 * i], pos[8 * i + 1], pos[8 * i + 2], pos[8 * i + 3]);
fprintf(pFile, " Pos: \t%f %f %f %f\n", pos[8 * i + 4], pos[8 * i + 5], pos[8 * i + 6], pos[8 * i + 7]);
}
fclose (pFile);
}
}
glutSwapBuffers();
}
void Shader::build()
{
if (Code.size() == reqArr.size())
{
for (size_t i = 0; i < Code.size(); i++)
{
Code[i] = *((ShaderCode*)reqArr[i].get());
Code[i].makeShader();
vector<Uniform>& t = Code[i].getUniforms();
for (Uniform& temp : t)
Uniforms.insert(Uniforms.begin() + findUniform(temp.getName(), 0, Uniforms.size()), temp);
}
}
if (!program.get() || !glIsProgram(*program))
*program = glCreateProgram(); //no Program existent creating
int attached = 0;
glGetProgramiv(*program, GL_ATTACHED_SHADERS, &attached);
if (attached) //in case old Shaders are attached
{
vector<GLuint> shaders = vector<GLuint>();
for (char i = 0; i < 16; i++) //write invaid numbers to seperate them
shaders.push_back(-1);
glGetAttachedShaders(*program, 16, NULL, &shaders[0]); //get all Shaders attached to Program
for (GLuint shader : shaders)
if (shader != -1) //check if it is a valid shader
glDetachShader(*program, shader); //detaches Shader, DOES NO DELETE
attached = 0; //resets counter
}
for (ShaderCode& shader : Code)
{
//should check Shader values
glAttachShader(*program, shader.getPos());
int ShaderCount = 0;
glGetProgramiv( *program, GL_ATTACHED_SHADERS, &ShaderCount); //might turn out t be slow since it querries operations and wait for them
if (ShaderCount > attached) //used for Error catching
attached++;
}
if (attached > 0)
glLinkProgram(*program);
else
LOG << "OpenGL Program " << "NO SHADERS ATTACHED." << "\n";
int isLinked = 0;
glGetProgramiv(*program, GL_LINK_STATUS, &isLinked);
if (!isLinked)
{
GLint maxLength = 0;
glGetProgramiv(*program, GL_INFO_LOG_LENGTH, &maxLength);
if (maxLength > 1)
{
//The maxLength includes the NULL character
vector<GLchar> infoLog = vector<GLchar>(maxLength);
glGetProgramInfoLog(*program, maxLength, NULL, &infoLog[0]);
LOG << "OpenGL Program " << infoLog.data() << "\n";
}
}
//Uniform Phase
setUniforms();
}
/**
* @brief draw particles
*/
void ParticleSystem::drawPoints() {
// glEnable(GL_PROGRAM_POINT_SZE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
updateParticles();
// --------------------------------------------------
// transform feedback
// --------------------------------------------------
glUseProgram(program_transform);
glEnable(GL_RASTERIZER_DISCARD);
setUniforms();
glBindBuffer(GL_ARRAY_BUFFER, vbo_position);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0,0);
glBindBuffer(GL_ARRAY_BUFFER, vbo_speed);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0,0);
glBindBuffer(GL_ARRAY_BUFFER, vbo_ID);
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 1, GL_FLOAT, GL_FALSE, 0,0);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0, vbo_draw);
glBeginTransformFeedback(GL_POINTS);
glDrawArrays(GL_POINTS, 0, num_points);
glEndTransformFeedback();
glBindBuffer(GL_ARRAY_BUFFER, 0);
glDisable(GL_RASTERIZER_DISCARD);
glUseProgram(0);
// --------------------------------------------------
// use the results from transformation to draw the particles
// --------------------------------------------------
srand (time(NULL));
glm::vec3 r = glm::vec3(static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
static_cast <float> (rand()) / static_cast <float> (RAND_MAX),
static_cast <float> (rand()) / static_cast <float> (RAND_MAX));
shaderCtrlPoints.Bind();
glUniform1f(shaderCtrlPoints.GetUniformLocation("pointSize"), (float)pointSize);
glUniform3f(shaderCtrlPoints.GetUniformLocation("rand"), r.x, r.y, r.z);
glUniformMatrix4fv(shaderCtrlPoints.GetUniformLocation("projMX"), 1, GL_FALSE,
glm::value_ptr(projMX));
glUniformMatrix4fv(shaderCtrlPoints.GetUniformLocation("viewMX"), 1, GL_FALSE,
glm::value_ptr(viewMX));
glUniform3f(shaderCtrlPoints.GetUniformLocation("translate"), 0.5f, 0.5f, 0.5f);
currentTime+=deltaT;
if(currentTime > 1000000.0f)
currentTime = 0.0f;
glUniform1f(shaderCtrlPoints.GetUniformLocation("time"), currentTime);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, randomTex);
glUniform1i(shaderCtrlPoints.GetUniformLocation("randomtex"), 0);
glBindBuffer(GL_ARRAY_BUFFER, vbo_draw);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0,0);
glBindBuffer(GL_ARRAY_BUFFER, vbo_speed);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0,0);
glDrawArraysInstanced(GL_POINTS, 0, num_points, num_instances);
glBindBuffer(GL_ARRAY_BUFFER, 0);
shaderCtrlPoints.Release();
// --------------------------------------------------
// swap buffers for particles position (ping-pong update model)
// --------------------------------------------------
std::swap(vbo_position, vbo_draw);
}
