void alien::draw()
{
glUseProgram(p);
glEnable(GL_LIGHTING);
glColor3f(1.0f, 1.0f, 1.0f);
for (std::vector<alienParam>::iterator it = aliens.begin(); it != aliens.end(); it++)
{
glPushMatrix();
glColor3f(1.0f, 1.0f, 1.0f);
glTranslated(it->position.x, it->position.y, it->position.z );
glScalef(0.007f, 0.007f, 0.01f);
if (it->type == 0) glUniform1f(getUniLoc(p, "type"), 0.0);
else if (it->type == 1) glUniform1f(getUniLoc(p, "type"), 1.0);
else glUniform1f(getUniLoc(p, "type"), 2.0);
glUniform1f(getUniLoc(p, "time"), glutGet(GLUT_ELAPSED_TIME));
int temp = it->position.x + 40; //some random offset so no artifacts at x = -1,0,1
if (it->type == 0)
{
if (temp % 2 == 0)
al1->batchDraw();
else
al1_1->batchDraw();
}
else if (it->type == 1)
{
if (temp % 2 == 0)
al2->batchDraw();
else
al2_1->batchDraw();
}
else
{
if (temp % 2 == 0)
al3->batchDraw();
else
al3_1->batchDraw();
}
glColor3f(1.0f, 1.0f, 1.0f);
glPopMatrix();
}
glColor3f(1.0f, 1.0f, 1.0f);
glDisable(GL_LIGHTING);
glUseProgram(0);
}
/*
* sendUniform4iv
*
* parameter name - char*
* parameter count - GLsizei
* parameter values - GLint*
* return - bool
*/
bool ShaderObject::sendUniform4iv(const char * name, GLsizei count, GLint* values) {
GLint location = getUniLoc(name);
if (location == -1)
return false;
glUniform4ivARB(location, count, values);
return true;
} // end sendUniform4iv()
/*
* sendUniformMatrix4fv
*
* parameter name - char*
* parameter count - GLsizei
* parameter transpose - GLboolean
* parameter values - GLfloat*
* return - bool
*/
bool ShaderObject::sendUniformMatrix4fv(const char * name, GLsizei count, GLboolean transpose, GLfloat* values) {
GLint location = getUniLoc(name);
if (location == -1)
return false;
glUniformMatrix4fvARB(location, count, transpose, values);
return true;
} // end sendUniformMatrix4fv()
/*
* sendUniform4i
*
* parameter name - char*
* parameter value0 - GLint
* parameter value1 - GLint
* parameter value2 - GLint
* parameter value3 - GLint
* return - bool
*/
bool ShaderObject::sendUniform4i(const char * name, GLint value0, GLint value1, GLint value2, GLint value3) {
GLint location = getUniLoc(name);
if (location == -1)
return false;
glUniform4iARB(location, value0, value1, value2, value3);
return true;
} // end sendUniform4i()
/*
* sendUniform2f
*
* parameter name - char*
* parameter value0 - GLfloat
* parameter value1 - GLfloat
* return - bool
*/
bool ShaderObject::sendUniform2f(const char * name, GLfloat value0, GLfloat value1) {
GLint location = getUniLoc(name);
if (location == -1)
return false;
glUniform2fARB(location, value0, value1);
return true;
} // end sendUniform2f()
void updateShader() {
glUseProgram(currentShader);
glUniform1i(getUniLoc(currentShader,"uGpuGenShape") ,uGpuGenShape);
glUniform1i(getUniLoc(currentShader,"uInnerShapeType"),uInnerShapeType);
glUniform1i(getUniLoc(currentShader,"uLocalViewer") ,uLocalViewer);
if(options[OPT_SHADER_BUMPMAP] == TRUE || options[OPT_SHADER_DISPMAP] == TRUE)
{
glUniform1i(getUniLoc(currentShader,"uNumOfBumps") ,uNumOfBumps);
glUniform1i(getUniLoc(currentShader,"uCurrBumpSize"),uCurrBumpSize);
}
// glUniform1i(getUniLoc(currentShader,"uTessellation"),uTessellation);
}
void updateAnim()
{
int location;
location = getUniLoc(ProgramObject, "currentTime");
ParticleTime += 0.002f;
if (ParticleTime > 15.0)
ParticleTime = 0.0;
glUniform1fARB(location, ParticleTime);
printOpenGLError();
}
void XGLShader::setUniFloat( const char *name, float fV ) {
glUniform1fARB( getUniLoc(this->sp, name), fV );
//printf("set uni float %s to: %f\n", name, fV);
}
void Shader::SetUniVar(char* sVarName, int nValue0)
{
//设置初始一致变量值
glUniform1i(getUniLoc(m_Program, sVarName), nValue0);
}
void Shader::SetUniVar(char* sVarName, float fValue0)
{
//设置初始一致变量值
glUniform1f(getUniLoc(m_Program, sVarName), fValue0);
}
void Shader::SetUniVar(char* sVarName, float fValue0, float fValue1, float fValue2)
{
//设置初始一致变量值
glUniform3fARB(getUniLoc(m_Program, sVarName), fValue0, fValue1, fValue2);
}
/*public*/
int installBrickShaders(const GLchar *brickVertex,
const GLchar *brickFragment)
{
GLuint brickVS, brickFS, brickProg; // handles to objects
GLint vertCompiled, fragCompiled; // status values
GLint linked;
// Create a vertex shader object and a fragment shader object
brickVS = glCreateShader(GL_VERTEX_SHADER);
brickFS = glCreateShader(GL_FRAGMENT_SHADER);
// Load source code strings into shaders
glShaderSource(brickVS, 1, &brickVertex, NULL);
glShaderSource(brickFS, 1, &brickFragment, NULL);
// Compile the brick vertex shader, and print out
// the compiler log file.
glCompileShader(brickVS);
printOpenGLError(); // Check for OpenGL errors
glGetShaderiv(brickVS, GL_COMPILE_STATUS, &vertCompiled);
printShaderInfoLog(brickVS);
// Compile the brick vertex shader, and print out
// the compiler log file.
glCompileShader(brickFS);
printOpenGLError(); // Check for OpenGL errors
glGetShaderiv(brickFS, GL_COMPILE_STATUS, &fragCompiled);
printShaderInfoLog(brickFS);
if (!vertCompiled || !fragCompiled)
return 0;
// Create a program object and attach the two compiled shaders
brickProg = glCreateProgram();
glAttachShader(brickProg, brickVS);
glAttachShader(brickProg, brickFS);
// Link the program object and print out the info log
glLinkProgram(brickProg);
printOpenGLError(); // Check for OpenGL errors
glGetProgramiv(brickProg, GL_LINK_STATUS, &linked);
printProgramInfoLog(brickProg);
if (!linked)
return 0;
// Install program object as part of current state
glUseProgram(brickProg);
// Set up initial uniform values
glUniform3f(getUniLoc(brickProg, "BrickColor"), 1.0, 0.3, 0.2);
glUniform3f(getUniLoc(brickProg, "MortarColor"), 0.85, 0.86, 0.84);
glUniform2f(getUniLoc(brickProg, "BrickSize"), 0.30, 0.15);
glUniform2f(getUniLoc(brickProg, "BrickPct"), 0.90, 0.85);
glUniform3f(getUniLoc(brickProg, "LightPosition"), 0.0, 0.0, 4.0);
return 1;
}
/// Set up view matrices, then draw scene
void OculusAppSkeleton::display(bool useOculus) const
{
/// This may save us some frame rate
if (!useOculus && !m_displaySceneInControl)
{
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
return;
}
glEnable(GL_DEPTH_TEST);
m_ok.BindRenderBuffer();
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
const int fboWidth = m_ok.GetRenderBufferWidth();
const int fboHeight = m_ok.GetRenderBufferHeight();
const int halfWidth = fboWidth/2;
if (useOculus)
{
const OVR::HMDInfo& hmd = m_ok.GetHMD();
// Compute Aspect Ratio. Stereo mode cuts width in half.
float aspectRatio = float(hmd.HResolution * 0.5f) / float(hmd.VResolution);
// Compute Vertical FOV based on distance.
float halfScreenDistance = (hmd.VScreenSize / 2);
float yfov = 2.0f * atan(halfScreenDistance/hmd.EyeToScreenDistance);
// Post-projection viewport coordinates range from (-1.0, 1.0), with the
// center of the left viewport falling at (1/4) of horizontal screen size.
// We need to shift this projection center to match with the lens center.
// We compute this shift in physical units (meters) to correct
// for different screen sizes and then rescale to viewport coordinates.
float viewCenterValue = hmd.HScreenSize * 0.25f;
float eyeProjectionShift = viewCenterValue - hmd.LensSeparationDistance * 0.5f;
float projectionCenterOffset = 4.0f * eyeProjectionShift / hmd.HScreenSize;
// Projection matrix for the "center eye", which the left/right matrices are based on.
OVR::Matrix4f projCenter = OVR::Matrix4f::PerspectiveRH(yfov, aspectRatio, 0.3f, 1000.0f);
OVR::Matrix4f projLeft = OVR::Matrix4f::Translation(projectionCenterOffset, 0, 0) * projCenter;
OVR::Matrix4f projRight = OVR::Matrix4f::Translation(-projectionCenterOffset, 0, 0) * projCenter;
// m_oculusView transformation translation in world units.
float halfIPD = hmd.InterpupillaryDistance * 0.5f;
OVR::Matrix4f viewLeft = OVR::Matrix4f::Translation(halfIPD, 0, 0) * m_oculusView;
OVR::Matrix4f viewRight= OVR::Matrix4f::Translation(-halfIPD, 0, 0) * m_oculusView;
glViewport(0 ,0,(GLsizei)halfWidth, (GLsizei)fboHeight);
glScissor (0 ,0,(GLsizei)halfWidth, (GLsizei)fboHeight);
m_scene.RenderForOneEye(viewLeft, projLeft);
glViewport(halfWidth,0,(GLsizei)halfWidth, (GLsizei)fboHeight);
glScissor (halfWidth,0,(GLsizei)halfWidth, (GLsizei)fboHeight);
m_scene.RenderForOneEye(viewRight, projRight);
}
else
{
/// Set up our 3D transformation matrices
/// Remember DX and OpenGL use transposed conventions. And doesn't DX use left-handed coords?
OVR::Matrix4f mview = m_controlView;
OVR::Matrix4f persp = OVR::Matrix4f::PerspectiveRH(
m_viewAngleDeg * M_PI / 180.0f,
(float)m_windowWidth/(float)m_windowHeight,
0.004f,
500.0f);
glViewport(0,0,(GLsizei)fboWidth, (GLsizei)fboHeight);
m_scene.RenderForOneEye(mview, persp);
/// Render avatar of Oculus user
//if (UseFollowCam)
const GLuint prog = m_avatarProg;
glUseProgram(prog);
{
OVR::Matrix4f rollPitchYaw = GetRollPitchYaw();
OVR::Matrix4f eyetx = mview
* OVR::Matrix4f::Translation(EyePos.x, EyePos.y, EyePos.z)
* rollPitchYaw;
glUniformMatrix4fv(getUniLoc(prog, "mvmtx"), 1, false, &eyetx.Transposed().M[0][0]);
glUniformMatrix4fv(getUniLoc(prog, "prmtx"), 1, false, &persp.Transposed().M[0][0]);
glLineWidth(4.0f);
DrawOrigin2();
const float aspect = (float)GetOculusWidth() / (float)GetOculusHeight();
DrawViewFrustum(aspect);
glLineWidth(1.0f);
}
}
}
m_ok.UnBindRenderBuffer();
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
const OVRkill::PostProcessType post = useOculus ? OVRkill::PostProcess_Distortion : OVRkill::PostProcess_None;
m_ok.PresentFbo(post);
}
