void Particle::init(){
linkShader();
initBuffers();
GLuint gravity = glGetUniformLocation(program, "Gravity");
GLuint plt = glGetUniformLocation(program, "ParticleLifetime");
//GLuint ptex = glGetUniformLocation(program, "ParticleTex");
glUniform1f(plt, 5.0f);
//glUniform3f(gravity, 0.0f, -0.2f, 0.0f);
angle = half_pi<float>();
projection = mat4(1.0f);
model = mat4(1.0f);
view = lookAt(vec3(3.0f * cosf(angle), 1.5f, 3.0f * sinf(angle)), vec3(0.0f, 1.5f, 0.0f), vec3(0.0f, 1.0f, 0.0f));
// glUniform1f(gravity, 9.8);
mat4 mvpMatrix(1.0f);
starttimer = clock();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
void Model::Render(float elapsedTime)
{
glUseProgram(shader.GetProgram());
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), 0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Vertex), (const GLvoid*)12);
glUniformMatrix4fv(mvpMatrixHandle, 1, GL_FALSE, (GLfloat*)&mvpMatrix(0, 0));
glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_BYTE, 0);
}
// draw a zero to destination alpha
void AppLocal::DrawScreenMask( const ovrMatrix4f & mvp, const float fadeFracX, const float fadeFracY )
{
Matrix4f mvpMatrix( mvp );
glUseProgram( OverlayScreenFadeMaskProgram.program );
glUniformMatrix4fv( OverlayScreenFadeMaskProgram.uMvp, 1, GL_FALSE, mvpMatrix.Transposed().M[0] );
if ( FadedScreenMaskSquare.vertexArrayObject == 0 )
{
FadedScreenMaskSquare = BuildFadedScreenMask( fadeFracX, fadeFracY );
}
glColorMask( 0.0f, 0.0f, 0.0f, 1.0f );
FadedScreenMaskSquare.Draw();
glColorMask( 1.0f, 1.0f, 1.0f, 1.0f );
}
// draw a zero to destination alpha
void DrawScreenMask( const ovrMatrix4f & mvp, const float fadeFracX, const float fadeFracY )
{
OVR::Matrix4f mvpMatrix( mvp );
static OVR::GlProgram prog;
if ( !prog.program )
{
prog = OVR::BuildProgram(
"uniform mat4 Mvpm;\n"
"attribute vec4 VertexColor;\n"
"attribute vec4 Position;\n"
"varying lowp vec4 oColor;\n"
"void main()\n"
"{\n"
" gl_Position = Mvpm * Position;\n"
" oColor = vec4( 1.0, 1.0, 1.0, 1.0 - VertexColor.x );\n"
"}\n"
,
"varying lowp vec4 oColor;\n"
"void main()\n"
"{\n"
" gl_FragColor = oColor;\n"
"}\n"
);
}
glUseProgram( prog.program );
glUniformMatrix4fv( prog.uMvp, 1, GL_FALSE, mvpMatrix.Transposed().M[0] );
static OVR::GlGeometry VignetteSquare;
if ( VignetteSquare.vertexArrayObject == 0 )
{
VignetteSquare = BuildFadedScreenMask( fadeFracX, fadeFracY );
}
glColorMask( 0, 0, 0, 1 );
VignetteSquare.Draw();
glColorMask( 1, 1, 1, 1 );
}
//--------------------------------------------------------------
// render the planet
void Planet::render(
int graphicsWidth,
int graphicsHeight,
double angle)
{
// if shader didn't compile, nothing we can do
if (m_planetShader == 0)
return;
double atmos = 20.0;
double radius = 1200.0;
double eyeDist = m_eyePt.length()/radius;
double a = 1.0;
if (eyeDist < a)
return; // below surface, nothing to do
double b = sqrt(eyeDist*eyeDist - a*a);
double h = (a*b)/eyeDist;
double m = (a*a)/eyeDist;
h += atmos/radius;
// x axis from planet center towards eye
mgPoint3 xaxis(m_eyePt);
xaxis.normalize();
// build y axis
mgPoint3 yaxis(xaxis);
yaxis.cross(mgPoint3(0.0, 1.0, 0.0));
yaxis.normalize();
mgPoint3 zaxis(yaxis);
zaxis.cross(xaxis);
zaxis.normalize();
mgMatrix4 transform;
transform._11 = xaxis.x;
transform._12 = xaxis.y;
transform._13 = xaxis.z;
transform._21 = yaxis.x;
transform._22 = yaxis.y;
transform._23 = yaxis.z;
transform._31 = zaxis.x;
transform._32 = zaxis.y;
transform._33 = zaxis.z;
VertexPlanet tl, tr, bl, br;
mgPoint3 pt;
transform.mapPt(m, -h, h, pt.x, pt.y, pt.z);
tl.setPoint(radius*pt.x, radius*pt.y, radius*pt.z);
transform.mapPt(m, h, h, pt.x, pt.y, pt.z);
tr.setPoint(radius*pt.x, radius*pt.y, radius*pt.z);
transform.mapPt(m, -h, -h, pt.x, pt.y, pt.z);
bl.setPoint(radius*pt.x, radius*pt.y, radius*pt.z);
transform.mapPt(m, h, -h, pt.x, pt.y, pt.z);
br.setPoint(radius*pt.x, radius*pt.y, radius*pt.z);
// inverse of world transform
mgMatrix4 model;
model.rotateYDeg(-angle);
mgPoint3 lightDir(1.0, 0.25, 0.0);
lightDir.normalize();
mgPoint3 modelLightDir;
model.mapPt(lightDir, modelLightDir);
transform.multiply(model);
mgPoint3 modelEye;
transform.mapPt(eyeDist, 0.0, 0.0, modelEye.x, modelEye.y, modelEye.z);
transform.mapPt(m, -h, h, pt.x, pt.y, pt.z);
tl.setModelPoint(pt.x, pt.y, pt.z);
transform.mapPt(m, h, h, pt.x, pt.y, pt.z);
tr.setModelPoint(pt.x, pt.y, pt.z);
transform.mapPt(m, -h, -h, pt.x, pt.y, pt.z);
bl.setModelPoint(pt.x, pt.y, pt.z);
transform.mapPt(m, h, -h, pt.x, pt.y, pt.z);
br.setModelPoint(pt.x, pt.y, pt.z);
mgMatrix4 viewMatrix;
viewMatrix.translate(-m_eyePt.x, -m_eyePt.y, -m_eyePt.z);
viewMatrix.multiply(m_eyeMatrix);
mgMatrix4 worldProjection;
createProjection(worldProjection, graphicsWidth, graphicsHeight);
mgMatrix4 mvpMatrix(viewMatrix);
mvpMatrix.multiply(worldProjection);
setupShader(mvpMatrix, modelEye, modelLightDir);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_surfaceTexture);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_CUBE_MAP, m_cloudsTexture);
glBindVertexArray(m_vertexArray);
glBindBuffer(GL_ARRAY_BUFFER, m_vertexBuffer);
VertexPlanet data[6];
data[0] = tl;
data[1] = tr;
data[2] = bl;
data[3] = bl;
data[4] = tr;
data[5] = br;
int vertexSize = sizeof(VertexPlanet);
int count = 6;
glBufferData(GL_ARRAY_BUFFER, vertexSize * count, data, GL_DYNAMIC_DRAW);
glDrawArrays(GL_TRIANGLES, 0, count);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
glActiveTexture(GL_TEXTURE0);
}
//-----------------------------------------------------------------------------
// set standard variables for shader
void mgGL33Services::setShaderStdUniforms(
mgShaderHandle shader)
{
mgMatrix4 mvpMatrix(m_worldMatrix);
mvpMatrix.multiply(m_worldProjection);
GLint index;
GLfloat matrix[16];
CHECK_THREAD();
index = glGetUniformLocation(shader, "mgMVPMatrix");
if (index != -1)
{
matrix4toGL(mvpMatrix, matrix);
glUniformMatrix4fv(index, 1, GL_FALSE, matrix);
}
index = glGetUniformLocation(shader, "mgMVMatrix");
if (index != -1)
{
matrix4toGL(m_worldMatrix, matrix);
glUniformMatrix4fv(index, 1, GL_FALSE, matrix);
}
index = glGetUniformLocation(shader, "mgModelMatrix");
if (index != -1)
{
matrix4toGL(m_modelMatrix, matrix);
glUniformMatrix4fv(index, 1, GL_FALSE, matrix);
}
index = glGetUniformLocation(shader, "mgNormalMatrix");
if (index != -1)
{
normalMatrix(m_worldMatrix, matrix);
glUniformMatrix3fv(index, 1, GL_FALSE, matrix);
}
index = glGetUniformLocation(shader, "mgVPMatrix");
if (index != -1)
{
mgMatrix4 vpMatrix;
vpMatrix.translate(-m_eyePt.x, -m_eyePt.y, -m_eyePt.z);
vpMatrix.multiply(m_eyeMatrix);
vpMatrix.multiply(m_worldProjection);
matrix4toGL(vpMatrix, matrix);
glUniformMatrix4fv(index, 1, GL_FALSE, matrix);
}
index = glGetUniformLocation(shader, "mgEyePt");
if (index != -1)
{
glUniform3f(index, (GLfloat) m_eyePt.x, (GLfloat) m_eyePt.y, (GLfloat) m_eyePt.z);
}
// transform the light dir by eye matrix. negate, since we want vector from point to light
index = glGetUniformLocation(shader, "mgLightDir");
if (index != -1)
{
mgPoint3 eyeLightDir;
m_eyeMatrix.mapPt(m_lightDir, eyeLightDir);
glUniform3f(index, (GLfloat) eyeLightDir.x, (GLfloat) eyeLightDir.y, (GLfloat) eyeLightDir.z);
}
index = glGetUniformLocation(shader, "mgLightColor");
if (index != -1)
{
glUniform3f(index, (GLfloat) m_lightColor.x, (GLfloat) m_lightColor.y, (GLfloat) m_lightColor.z);
}
index = glGetUniformLocation(shader, "mgLightAmbient");
if (index != -1)
{
glUniform3f(index, (GLfloat) m_lightAmbient.x, (GLfloat) m_lightAmbient.y, (GLfloat) m_lightAmbient.z);
}
index = glGetUniformLocation(shader, "mgMatColor");
if (index != -1)
{
glUniform4f(index, (GLfloat) m_matColor.x, (GLfloat) m_matColor.y, (GLfloat) m_matColor.z, (GLfloat) m_matColor.w);
}
char varName[128];
for (int unit = 0; ; unit++)
{
sprintf(varName, "mgTextureUnit%d", unit);
index = glGetUniformLocation(shader, varName);
if (index != -1)
glUniform1i(index, unit);
else break;
}
// vars up to date
m_updateShaderVars = false;
}