void SurfaceSdlGraphicsManager::updateScreen() {
#ifdef USE_OPENGL
if (_opengl) {
if (_overlayVisible) {
if (_overlayDirty) {
// remove if already exist
if (_overlayNumTex > 0) {
glDeleteTextures(_overlayNumTex, _overlayTexIds);
delete[] _overlayTexIds;
_overlayNumTex = 0;
}
_overlayNumTex = ((_overlayWidth + (BITMAP_TEXTURE_SIZE - 1)) / BITMAP_TEXTURE_SIZE) *
((_overlayHeight + (BITMAP_TEXTURE_SIZE - 1)) / BITMAP_TEXTURE_SIZE);
_overlayTexIds = new GLuint[_overlayNumTex];
glGenTextures(_overlayNumTex, _overlayTexIds);
for (int i = 0; i < _overlayNumTex; i++) {
glBindTexture(GL_TEXTURE_2D, _overlayTexIds[i]);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, BITMAP_TEXTURE_SIZE, BITMAP_TEXTURE_SIZE, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
glPixelStorei(GL_UNPACK_ROW_LENGTH, _overlayWidth);
int curTexIdx = 0;
for (int y = 0; y < _overlayHeight; y += BITMAP_TEXTURE_SIZE) {
for (int x = 0; x < _overlayWidth; x += BITMAP_TEXTURE_SIZE) {
int t_width = (x + BITMAP_TEXTURE_SIZE >= _overlayWidth) ? (_overlayWidth - x) : BITMAP_TEXTURE_SIZE;
int t_height = (y + BITMAP_TEXTURE_SIZE >= _overlayHeight) ? (_overlayHeight - y) : BITMAP_TEXTURE_SIZE;
glBindTexture(GL_TEXTURE_2D, _overlayTexIds[curTexIdx]);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, t_width, t_height, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, (byte *)_overlayscreen->pixels + (y * 2 * _overlayWidth) + (2 * x));
curTexIdx++;
}
}
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
}
// Save current state
glPushAttrib(GL_TRANSFORM_BIT | GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_SCISSOR_BIT);
// prepare view
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, _overlayWidth, _overlayHeight, 0, 0, 1);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glEnable(GL_SCISSOR_TEST);
glScissor(0, 0, _overlayWidth, _overlayHeight);
int curTexIdx = 0;
for (int y = 0; y < _overlayHeight; y += BITMAP_TEXTURE_SIZE) {
for (int x = 0; x < _overlayWidth; x += BITMAP_TEXTURE_SIZE) {
glBindTexture(GL_TEXTURE_2D, _overlayTexIds[curTexIdx]);
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2i(x, y);
glTexCoord2f(1.0f, 0.0f);
glVertex2i(x + BITMAP_TEXTURE_SIZE, y);
glTexCoord2f(1.0f, 1.0f);
glVertex2i(x + BITMAP_TEXTURE_SIZE, y + BITMAP_TEXTURE_SIZE);
glTexCoord2f(0.0f, 1.0f);
glVertex2i(x, y + BITMAP_TEXTURE_SIZE);
glEnd();
curTexIdx++;
}
}
// Restore previous state
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glPopAttrib();
}
SDL_GL_SwapBuffers();
} else
#endif
{
if (_overlayVisible) {
SDL_LockSurface(_screen);
SDL_LockSurface(_overlayscreen);
Graphics::PixelBuffer srcBuf(_overlayFormat, (byte *)_overlayscreen->pixels);
Graphics::PixelBuffer dstBuf(_screenFormat, (byte *)_screen->pixels);
int h = _overlayHeight;
do {
dstBuf.copyBuffer(0, _overlayWidth, srcBuf);
srcBuf.shiftBy(_overlayWidth);
dstBuf.shiftBy(_overlayWidth);
} while (--h);
SDL_UnlockSurface(_screen);
SDL_UnlockSurface(_overlayscreen);
}
SDL_Flip(_screen);
}
}
int main()
{
glfwInit();
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
GLFWwindow* window = glfwCreateWindow(screenWidth, screenHeight, "LearnOpenGL", nullptr, nullptr);
glfwMakeContextCurrent(window);
// Set the required callback functions
glfwSetKeyCallback(window, key_callback);
glfwSetCursorPosCallback(window, mouse_callback);
glfwSetScrollCallback(window, scroll_callback);
// Options
glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
// Initialize GLEW to setup the OpenGL Function pointers
glewExperimental = GL_TRUE;
glewInit();
// Define the viewport dimensions
glViewport(0, 0, screenWidth, screenHeight);
// Setup some OpenGL options
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// Setup and compile our shaders
Shader shader("./advanced.vs", "./advanced.frag");
Shader skyboxShader("./skybox.vs", "./skybox.frag");
#pragma region "object_initialization"
// Set the object data (buffers, vertex attributes)
GLfloat vertices[] = {
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
-0.5f, -0.5f, -0.5f, 0.0f, 0.0f, -1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
-0.5f, -0.5f, 0.5f, 0.0f, 0.0f, 1.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
-0.5f, 0.5f, 0.5f, -1.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
0.5f, 0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, -0.5f, 1.0f, 0.0f, 0.0f,
0.5f, -0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
0.5f, 0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
-0.5f, -0.5f, 0.5f, 0.0f, -1.0f, 0.0f,
-0.5f, -0.5f, -0.5f, 0.0f, -1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, 0.5f, 0.0f, 1.0f, 0.0f,
-0.5f, 0.5f, -0.5f, 0.0f, 1.0f, 0.0f
};
GLfloat skyboxVertices[] = {
// Positions
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, 1.0f
};
// Setup cube VAO
GLuint cubeVAO, cubeVBO;
glGenVertexArrays(1, &cubeVAO);
glGenBuffers(1, &cubeVBO);
glBindVertexArray(cubeVAO);
glBindBuffer(GL_ARRAY_BUFFER, cubeVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), &vertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
glBindVertexArray(0);
// Setup skybox VAO
GLuint skyboxVAO, skyboxVBO;
glGenVertexArrays(1, &skyboxVAO);
glGenBuffers(1, &skyboxVBO);
glBindVertexArray(skyboxVAO);
glBindBuffer(GL_ARRAY_BUFFER, skyboxVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), &skyboxVertices, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
glBindVertexArray(0);
// Load textures
GLuint cubeTexture = loadTexture("./container.jpg");
#pragma endregion
// Cubemap (Skybox)
vector<const GLchar*> faces;
faces.push_back("skybox/right.jpg");
faces.push_back("skybox/left.jpg");
faces.push_back("skybox/top.jpg");
faces.push_back("skybox/bottom.jpg");
faces.push_back("skybox/back.jpg");
faces.push_back("skybox/front.jpg");
GLuint cubemapTexture = loadCubemap(faces);
while (!glfwWindowShouldClose(window))
{
// Set frame time
GLfloat currentFrame = glfwGetTime();
deltaTime = currentFrame - lastFrame;
lastFrame = currentFrame;
// Check and call events
glfwPollEvents();
Do_Movement();
// Clear buffers
glClearColor(0.1f, 0.1f, 0.1f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Draw skybox first
glDepthMask(GL_FALSE);// Remember to turn depth writing off
skyboxShader.Use();
glm::mat4 view = glm::mat4(glm::mat3(camera.GetViewMatrix())); // Remove any translation component of the view matrix
glm::mat4 projection = glm::perspective(camera.Zoom, (float)screenWidth/(float)screenHeight, 0.1f, 100.0f);
glUniformMatrix4fv(glGetUniformLocation(skyboxShader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(skyboxShader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
// skybox cube
glBindVertexArray(skyboxVAO);
glActiveTexture(GL_TEXTURE0);
glUniform1i(glGetUniformLocation(shader.Program, "skybox"), 0);
glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapTexture);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
glDepthMask(GL_TRUE);
// Then draw scene as normal
shader.Use();
glm::mat4 model;
view = camera.GetViewMatrix();
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "model"), 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "view"), 1, GL_FALSE, glm::value_ptr(view));
glUniformMatrix4fv(glGetUniformLocation(shader.Program, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
// Cubes
glBindVertexArray(cubeVAO);
glActiveTexture(GL_TEXTURE0);
glUniform1i(glGetUniformLocation(shader.Program, "skybox"), 0);
glUniform3f(glGetUniformLocation(shader.Program, "cameraPos"), camera.Position.x, camera.Position.y, camera.Position.z);
glBindTexture(GL_TEXTURE_2D, cubeTexture);
glDrawArrays(GL_TRIANGLES, 0, 36);
glBindVertexArray(0);
// Swap the buffers
glfwSwapBuffers(window);
}
return 0;
}
void Camera::clearBackground(float depth)
{
GLboolean oldDepthTest;
GLint oldDepthFunc;
GLboolean oldDepthMask;
{
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glStencilMask(0);
oldDepthTest = glIsEnabled(GL_DEPTH_TEST);
glGetIntegerv(GL_DEPTH_FUNC, &oldDepthFunc);
glGetBooleanv(GL_DEPTH_WRITEMASK, &oldDepthMask);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
}
//draw
static V3F_C4B_T2F_Quad quad;
quad.bl.vertices = Vec3(-1,-1,0);
quad.br.vertices = Vec3(1,-1,0);
quad.tl.vertices = Vec3(-1,1,0);
quad.tr.vertices = Vec3(1,1,0);
quad.bl.colors = quad.br.colors = quad.tl.colors = quad.tr.colors = Color4B(0,0,0,1);
quad.bl.texCoords = Tex2F(0,0);
quad.br.texCoords = Tex2F(1,0);
quad.tl.texCoords = Tex2F(0,1);
quad.tr.texCoords = Tex2F(1,1);
auto shader = GLProgramCache::getInstance()->getGLProgram(GLProgram::SHADER_CAMERA_CLEAR);
auto programState = GLProgramState::getOrCreateWithGLProgram(shader);
programState->setUniformFloat("depth", 1.0);
programState->apply(Mat4());
GLshort indices[6] = {0, 1, 2, 3, 2, 1};
{
GL::bindVAO(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
GL::enableVertexAttribs(GL::VERTEX_ATTRIB_FLAG_POS_COLOR_TEX);
// vertices
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_POSITION, 3, GL_FLOAT, GL_FALSE, sizeof(V3F_C4B_T2F), &quad.tl.vertices);
// colors
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(V3F_C4B_T2F), &quad.tl.colors);
// tex coords
glVertexAttribPointer(GLProgram::VERTEX_ATTRIB_TEX_COORD, 2, GL_FLOAT, GL_FALSE, sizeof(V3F_C4B_T2F), &quad.tl.texCoords);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
}
{
if(GL_FALSE == oldDepthTest)
{
glDisable(GL_DEPTH_TEST);
}
glDepthFunc(oldDepthFunc);
if(GL_FALSE == oldDepthMask)
{
glDepthMask(GL_FALSE);
}
/* IMPORTANT: We only need to update the states that are not restored.
Since we don't know what was the previous value of the mask, we update the RenderState
after setting it.
The other values don't need to be updated since they were restored to their original values
*/
glStencilMask(0xFFFFF);
// RenderState::StateBlock::_defaultState->setStencilWrite(0xFFFFF);
/* BUG: RenderState does not support glColorMask yet. */
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
}
void SampleGLView::gInit(void)
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
}
void SkyBox::draw(float x,float y,float z) {
//Turn our world a bit, but first push the matrixes so others won't get into a strange position :P
glPushMatrix();
glPushAttrib(GL_ENABLE_BIT);
//Disable the depth test so we can draw this in infinity
glDepthMask(false);
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_BLEND);
glTranslatef(0.0f, y, 0.0f);
//Draw some nice _large_ sky (the 100.0f scale might seem a bit large, but you have to prepare for odd camera settings too)
glEnable(GL_TEXTURE_2D);
glScalef(100.0f, 100.0f, 100.0f);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
const float cz = -0.0f;
const float cx = 1.0f;
const float r = 1.0f;
// FRONT Side
glBindTexture(GL_TEXTURE_2D,textures[0]);
glBegin(GL_QUADS);
glTexCoord2f(cx, cz); glVertex3f( -r, r, r);
glTexCoord2f(cz, cz); glVertex3f( r, r, r);
glTexCoord2f(cz, cx); glVertex3f( r, -r, r);
glTexCoord2f(cx, cx); glVertex3f( -r, -r, r);
glEnd();
// BACK side
glBindTexture(GL_TEXTURE_2D,textures[2]);
glBegin(GL_QUADS);
glTexCoord2f(cx, cz); glVertex3f( r, r, -r);
glTexCoord2f(cz, cz); glVertex3f( -r, r, -r);
glTexCoord2f(cz, cx); glVertex3f( -r, -r, -r);
glTexCoord2f(cx, cx); glVertex3f( r, -r, -r);
glEnd();
// Left side
glBindTexture(GL_TEXTURE_2D,textures[3]);
glBegin(GL_QUADS);
glTexCoord2f(cx,cz); glVertex3f( -r, r, -r);
glTexCoord2f(cz,cz); glVertex3f( -r, r, r);
glTexCoord2f(cz,cx); glVertex3f( -r, -r, r);
glTexCoord2f(cx,cx); glVertex3f( -r, -r, -r);
glEnd();
// Right side
glBindTexture(GL_TEXTURE_2D,textures[1]);
glBegin(GL_QUADS);
glTexCoord2f(cx, cz); glVertex3f( r, r, r);
glTexCoord2f(cz, cz); glVertex3f( r, r, -r);
glTexCoord2f(cz, cx); glVertex3f( r, -r, -r);
glTexCoord2f(cx, cx); glVertex3f( r, -r, r);
glEnd();
// Up side
glBindTexture(GL_TEXTURE_2D,textures[4]);
glBegin(GL_QUADS);
glTexCoord2f(cx, cz); glVertex3f( -r, r, -r);
glTexCoord2f(cz, cz); glVertex3f( r, r, -r);
glTexCoord2f(cz, cx); glVertex3f( r, r, r);
glTexCoord2f(cx, cx); glVertex3f( -r, r, r);
glEnd();
// Down side
glBindTexture(GL_TEXTURE_2D,textures[5]);
glBegin(GL_QUADS);
glTexCoord2f(cx, cz); glVertex3f( -r, -r, r);
glTexCoord2f(cz, cz); glVertex3f( r, -r, r);
glTexCoord2f(cz, cx); glVertex3f( r, -r, -r);
glTexCoord2f(cx, cx); glVertex3f( -r, -r, -r);
glEnd();
//Back to where we were
glDepthMask(true);
glPopAttrib();
glPopMatrix();
}
static void draw_galaxy(int i, int j, int f, float a)
{
struct galaxy *g = get_galaxy(i);
float V[6][4];
float p[4] = { 0.0, 0.0, 0.0, 1.0 };
init_galaxy(i);
glPushMatrix();
{
/* Apply the local coordinate system transformation. */
transform_entity(j);
get_viewfrust(V);
get_viewpoint(p);
/* Supply the view position as a vertex program parameter. */
if (GL_has_vertex_program)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 0,
p[0], p[1], p[2], p[3]);
glPushAttrib(GL_ENABLE_BIT |
GL_TEXTURE_BIT |
GL_DEPTH_BUFFER_BIT |
GL_COLOR_BUFFER_BIT);
glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);
{
/* Set up the GL state for star rendering. */
draw_brush(g->brush, a * get_entity_alpha(j));
glBindTexture(GL_TEXTURE_2D, g->texture);
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
glDepthMask(GL_FALSE);
glBlendFunc(GL_ONE, GL_ONE);
if (GL_has_vertex_program)
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE_ARB);
if (GL_has_point_sprite)
{
glEnable(GL_POINT_SPRITE_ARB);
glTexEnvi(GL_POINT_SPRITE_ARB,
GL_COORD_REPLACE_ARB, GL_TRUE);
}
draw_arrays(i);
/* Render all stars. */
node_draw(g->N, 0, 0, V);
}
glPopClientAttrib();
glPopAttrib();
/* Render all child entities in this coordinate system. */
draw_entity_tree(j, f, a * get_entity_alpha(j));
}
glPopMatrix();
}
// Draws the FBO texture for Oculus rift.
void ApplicationOverlay::displayOverlayTextureOculus(Camera& whichCamera) {
if (_alpha == 0.0f) {
return;
}
glEnable(GL_TEXTURE_2D);
glActiveTexture(GL_TEXTURE0);
_overlays.bindTexture();
glEnable(GL_BLEND);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDisable(GL_LIGHTING);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.01f);
//Update and draw the magnifiers
MyAvatar* myAvatar = Application::getInstance()->getAvatar();
const glm::quat& orientation = myAvatar->getOrientation();
const glm::vec3& position = myAvatar->getDefaultEyePosition();
const float scale = myAvatar->getScale() * _oculusUIRadius;
glMatrixMode(GL_MODELVIEW);
glPushMatrix(); {
glTranslatef(position.x, position.y, position.z);
glm::mat4 rotation = glm::toMat4(orientation);
glMultMatrixf(&rotation[0][0]);
glScalef(scale, scale, scale);
for (int i = 0; i < NUMBER_OF_RETICLES; i++) {
if (_magActive[i]) {
_magSizeMult[i] += MAG_SPEED;
if (_magSizeMult[i] > 1.0f) {
_magSizeMult[i] = 1.0f;
}
} else {
_magSizeMult[i] -= MAG_SPEED;
if (_magSizeMult[i] < 0.0f) {
_magSizeMult[i] = 0.0f;
}
}
if (_magSizeMult[i] > 0.0f) {
//Render magnifier, but dont show border for mouse magnifier
glm::vec2 projection = screenToOverlay(glm::vec2(_reticlePosition[MOUSE].x(),
_reticlePosition[MOUSE].y()));
renderMagnifier(projection, _magSizeMult[i], i != MOUSE);
}
}
glDepthMask(GL_FALSE);
glDisable(GL_ALPHA_TEST);
glColor4f(1.0f, 1.0f, 1.0f, _alpha);
static float textureFOV = 0.0f, textureAspectRatio = 1.0f;
if (textureFOV != _textureFov ||
textureAspectRatio != _textureAspectRatio) {
textureFOV = _textureFov;
textureAspectRatio = _textureAspectRatio;
_overlays.buildVBO(_textureFov, _textureAspectRatio, 80, 80);
}
_overlays.render();
renderPointersOculus(myAvatar->getDefaultEyePosition());
glDepthMask(GL_TRUE);
_overlays.releaseTexture();
glDisable(GL_TEXTURE_2D);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
glEnable(GL_LIGHTING);
} glPopMatrix();
}
void CShadowHandler::CreateShadows()
{
fb.Bind();
glDisable(GL_BLEND);
glDisable(GL_LIGHTING);
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_FLAT);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glViewport(0, 0, shadowMapSize, shadowMapSize);
// glClearColor(0, 0, 0, 0);
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClear(GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, 1, 0, 1, 0, -1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
const ISkyLight* L = sky->GetLight();
// sun direction is in world-space, invert it
sunDirZ = -L->GetLightDir();
sunDirX = (sunDirZ.cross(UpVector)).ANormalize();
sunDirY = (sunDirX.cross(sunDirZ)).ANormalize();
SetShadowMapSizeFactors();
// NOTE:
// the xy-scaling factors from CalcMinMaxView do not change linearly
// or smoothly with camera movements, creating visible artefacts (eg.
// large jumps in shadow resolution)
//
// therefore, EITHER use "fixed" scaling values such that the entire
// map barely fits into the sun's frustum (by pretending it is embedded
// in a sphere and taking its diameter), OR variable scaling such that
// everything that can be seen by the camera maximally fills the sun's
// frustum (choice of projection-style is left to the user and can be
// changed at run-time)
//
// the first option means larger maps will have more blurred/aliased
// shadows if the depth buffer is kept at the same size, but no (map)
// geometry is ever omitted
//
// the second option means shadows have higher average resolution, but
// become less sharp as the viewing volume increases (through eg.camera
// rotations) and geometry can be omitted in some cases
//
// NOTE:
// when DynamicSun is enabled, the orbit is always circular in the xz
// plane, instead of elliptical when the map has an aspect-ratio != 1
//
const float xyScale =
(shadowProMode == SHADOWPROMODE_CAM_CENTER)? GetOrthoProjectedFrustumRadius(camera, centerPos):
(shadowProMode == SHADOWPROMODE_MAP_CENTER)? GetOrthoProjectedMapRadius(-sunDirZ, centerPos):
1.0f;
const float xScale = xyScale;
const float yScale = xyScale;
const float zScale = globalRendering->viewRange;
shadowMatrix[ 0] = sunDirX.x / xScale;
shadowMatrix[ 1] = sunDirY.x / yScale;
shadowMatrix[ 2] = sunDirZ.x / zScale;
shadowMatrix[ 4] = sunDirX.y / xScale;
shadowMatrix[ 5] = sunDirY.y / yScale;
shadowMatrix[ 6] = sunDirZ.y / zScale;
shadowMatrix[ 8] = sunDirX.z / xScale;
shadowMatrix[ 9] = sunDirY.z / yScale;
shadowMatrix[10] = sunDirZ.z / zScale;
// rotate the target position into sun-space for the translation
shadowMatrix[12] = (-sunDirX.dot(centerPos) / xScale);
shadowMatrix[13] = (-sunDirY.dot(centerPos) / yScale);
shadowMatrix[14] = (-sunDirZ.dot(centerPos) / zScale) + 0.5f;
glLoadMatrixf(shadowMatrix.m);
// set the shadow-parameter registers
// NOTE: so long as any part of Spring rendering still uses
// ARB programs at run-time, these lines can not be removed
// (all ARB programs share the same environment)
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 16, shadowTexProjCenter.x, shadowTexProjCenter.y, 0.0f, 0.0f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 17, shadowTexProjCenter.z, shadowTexProjCenter.z, 0.0f, 0.0f);
glProgramEnvParameter4fARB(GL_VERTEX_PROGRAM_ARB, 18, shadowTexProjCenter.w, shadowTexProjCenter.w, 0.0f, 0.0f);
if (globalRendering->haveGLSL) {
for (int i = 0; i < SHADOWGEN_PROGRAM_LAST; i++) {
shadowGenProgs[i]->Enable();
shadowGenProgs[i]->SetUniform4fv(0, &shadowTexProjCenter.x);
shadowGenProgs[i]->Disable();
}
}
if (L->GetLightIntensity() > 0.0f) {
// move view into sun-space
const float3 oldup = camera->up;
camera->right = sunDirX;
camera->up = sunDirY;
DrawShadowPasses();
camera->up = oldup;
}
glShadeModel(GL_SMOOTH);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// we do this later to save render context switches (this is one of the slowest opengl operations!)
// fb.Unbind();
// glViewport(globalRendering->viewPosX,0,globalRendering->viewSizeX,globalRendering->viewSizeY);
}
void DrawModels()
{
GLint r, g, b;
occlucedCount = 0;
DrawOccluder();
if (occlusionDetection)
{
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glDepthMask(GL_FALSE);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
for (r = 0; r < 3; r++)
{
for (g = 0; g < 3; g++)
{
for (b = 0; b < 3; b++)
{
glPushMatrix();
glTranslatef(100.0f * r - 100.0f,
100.0f * g - 100.0f,
100.0f * b - 100.0f);
glBeginQuery(GL_SAMPLES_PASSED, queryIDs[(r*9)+(g*3)+b]);
glutSolidCube(100.0f);
glEndQuery(GL_SAMPLES_PASSED);
glPopMatrix();
}
}
}
glDepthMask(GL_TRUE);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glEnable(GL_LIGHTING);
glEnable(GL_COLOR_MATERIAL);
}
glEnable(GL_TEXTURE_2D);
glEnable(GL_TEXTURE_GEN_S);;
glEnable(GL_TEXTURE_GEN_T);
for(r = 0; r < 3; r++)
{
for (g = 0; g < 3; g++)
{
for (b = 0; b < 3; b++)
{
glColor3f(r * 1.0f/3, g * 1.0f/3, b * 1.0f/3);
glPushMatrix();
glTranslatef(100.0f * r - 100.0f,
100.0f * g - 100.0f,
100.0f * b - 100.0f);
DrawSphere((r*9)+(g*3)+b);
glPopMatrix();
}
}
}
printf("occluced count is %d\n", occlucedCount);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_S);
}
void CRender::enableDepthMask(void) {
glDepthMask(GL_TRUE);
}
void glPopAttrib() {
ERROR_IN_BLOCK();
glstack_t *cur = tack_pop(&state.stack.attrib);
if (cur == NULL) {
ERROR(GL_STACK_UNDERFLOW);
}
if (cur->mask & GL_COLOR_BUFFER_BIT) {
#ifndef USE_ES2
enable_disable(GL_ALPHA_TEST, cur->alpha_test);
glAlphaFunc(cur->alpha_test_func, cur->alpha_test_ref);
#endif
enable_disable(GL_BLEND, cur->blend);
glBlendFunc(cur->blend_src_func, cur->blend_dst_func);
enable_disable(GL_DITHER, cur->dither);
#ifndef USE_ES2
enable_disable(GL_COLOR_LOGIC_OP, cur->color_logic_op);
glLogicOp(cur->logic_op);
#endif
GLfloat *c;
glClearColor(v4(cur->clear_color));
glColorMask(v4(cur->color_mask));
}
if (cur->mask & GL_CURRENT_BIT) {
glColor4f(v4(cur->color));
#ifndef USE_ES2
glNormal3f(v3(cur->normal));
#endif
for (int i = 0; i < MAX_TEX; i++) {
glMultiTexCoord2f(GL_TEXTURE0 + i, v2(cur->tex[i]));
}
}
if (cur->mask & GL_DEPTH_BUFFER_BIT) {
enable_disable(GL_DEPTH_TEST, cur->depth_test);
glDepthFunc(cur->depth_func);
glClearDepth(cur->clear_depth);
glDepthMask(cur->depth_mask);
}
if (cur->mask & GL_ENABLE_BIT) {
int i;
GLint max_clip_planes;
glGetIntegerv(GL_MAX_CLIP_PLANES, &max_clip_planes);
for (i = 0; i < max_clip_planes; i++) {
enable_disable(GL_CLIP_PLANE0 + i, *(cur->clip_planes_enabled + i));
}
GLint max_lights;
glGetIntegerv(GL_MAX_LIGHTS, &max_lights);
for (i = 0; i < max_lights; i++) {
enable_disable(GL_LIGHT0 + i, *(cur->lights_enabled + i));
}
enable_disable(GL_ALPHA_TEST, cur->alpha_test);
enable_disable(GL_BLEND, cur->blend);
enable_disable(GL_CULL_FACE, cur->cull_face);
enable_disable(GL_DEPTH_TEST, cur->depth_test);
enable_disable(GL_DITHER, cur->dither);
enable_disable(GL_FOG, cur->fog);
enable_disable(GL_LIGHTING, cur->lighting);
enable_disable(GL_LINE_SMOOTH, cur->line_smooth);
enable_disable(GL_LINE_STIPPLE, cur->line_stipple);
enable_disable(GL_COLOR_LOGIC_OP, cur->color_logic_op);
enable_disable(GL_MULTISAMPLE, cur->multisample);
enable_disable(GL_NORMALIZE, cur->normalize);
enable_disable(GL_POINT_SMOOTH, cur->point_smooth);
enable_disable(GL_POLYGON_OFFSET_FILL, cur->polygon_offset_fill);
enable_disable(GL_SAMPLE_ALPHA_TO_COVERAGE, cur->sample_alpha_to_coverage);
enable_disable(GL_SAMPLE_ALPHA_TO_ONE, cur->sample_alpha_to_one);
enable_disable(GL_SAMPLE_COVERAGE, cur->sample_coverage);
enable_disable(GL_SCISSOR_TEST, cur->scissor_test);
enable_disable(GL_STENCIL_TEST, cur->stencil_test);
enable_disable(GL_TEXTURE_2D, cur->texture_2d);
}
#ifndef USE_ES2
if (cur->mask & GL_FOG_BIT) {
enable_disable(GL_FOG, cur->fog);
glFogfv(GL_FOG_COLOR, cur->fog_color);
glFogf(GL_FOG_DENSITY, cur->fog_density);
glFogf(GL_FOG_START, cur->fog_start);
glFogf(GL_FOG_END, cur->fog_end);
glFogf(GL_FOG_MODE, cur->fog_mode);
}
#endif
if (cur->mask & GL_HINT_BIT) {
enable_disable(GL_PERSPECTIVE_CORRECTION_HINT, cur->perspective_hint);
enable_disable(GL_POINT_SMOOTH_HINT, cur->point_smooth_hint);
enable_disable(GL_LINE_SMOOTH_HINT, cur->line_smooth_hint);
enable_disable(GL_FOG_HINT, cur->fog_hint);
enable_disable(GL_GENERATE_MIPMAP_HINT, cur->mipmap_hint);
}
if (cur->mask & GL_LINE_BIT) {
enable_disable(GL_LINE_SMOOTH, cur->line_smooth);
// TODO: stipple stuff here
glLineWidth(cur->line_width);
}
if (cur->mask & GL_MULTISAMPLE_BIT) {
enable_disable(GL_MULTISAMPLE, cur->multisample);
enable_disable(GL_SAMPLE_ALPHA_TO_COVERAGE, cur->sample_alpha_to_coverage);
enable_disable(GL_SAMPLE_ALPHA_TO_ONE, cur->sample_alpha_to_one);
enable_disable(GL_SAMPLE_COVERAGE, cur->sample_coverage);
}
#ifndef USE_ES2
if (cur->mask & GL_POINT_BIT) {
enable_disable(GL_POINT_SMOOTH, cur->point_smooth);
glPointSize(cur->point_size);
}
#endif
if (cur->mask & GL_SCISSOR_BIT) {
enable_disable(GL_SCISSOR_TEST, cur->scissor_test);
glScissor(v4(cur->scissor_box));
}
if (cur->mask & GL_TEXTURE_BIT) {
glBindTexture(GL_TEXTURE_2D, cur->texture);
}
free(cur->clip_planes_enabled);
free(cur->clip_planes);
free(cur->lights_enabled);
free(cur->lights);
free(cur);
}
void CRender::disableDepthMask(void) {
glDepthMask(GL_FALSE);
}
bool TextFont::PrepareForRender()
{
if (!texture){
std::cout<<"\nERROR: Texture not allocated in Font::RenderText";
return false;
}
if (!whitened && false){ // Change so whitening process is executed only for those fonts which need it.
MakeTextureWhite();
}
/// Bufferize texture as needed.
if (texture->glid == -1)
{
texture->releaseOnBufferization = false;
TexMan.BufferizeTexture(texture);
}
/// Prepare shader.
if (shaderBased)
{
// Load shader.
shader = ShadeMan.SetActiveShader("Font");
if (!shader)
return false;
// Enable texture
glEnable(GL_TEXTURE_2D);
// Set matrices.
shader->SetProjectionMatrix(graphicsState->projectionMatrixF);
shader->SetViewMatrix(graphicsState->viewMatrixF);
shader->SetModelMatrix(graphicsState->modelMatrixF);
// Set text color
glUniform4f(shader->uniformPrimaryColorVec4, color.x, color.y, color.z, color.w);
// set hover state
glUniform1i(shader->uniformHoveredOver, hoveredOver? 1 : 0);
// Set some color.. hmm.
// glColor4f(color[0], color[1], color[2], color[3]);
glEnable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Don't write depth to depth buffer.
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
// Set texture in shader? hm.
glBindTexture(GL_TEXTURE_2D, texture->glid);
// Fetch and bufferizes model.
if (!model)
model = ModelMan.GetModel("sprite.obj");
model->BufferizeIfNeeded();
}
else
{
// Enable textures if it wasn't already
glEnable(GL_TEXTURE_2D);
PrintGLError("Font.h: glEnable(GL_TEXTURE_2D) error");
/// Set fill mode!
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
ShadeMan.SetActiveShader(0);
glEnable(GL_TEXTURE_2D);
// glEnable(GL_LIGHTING);
glDisable(GL_COLOR_MATERIAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glLoadMatrixf(graphicsState->projectionMatrixF.getPointer());
Matrix4f modelView = graphicsState->viewMatrixF * graphicsState->modelMatrixF;
glMatrixMode(GL_MODELVIEW);
glLoadMatrixf(modelView.getPointer());
glColor4f(color[0], color[1], color[2], color[3]);
glEnable(GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_LIGHTING);
// Disable depth test.. lol no?
// glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glBindTexture(GL_TEXTURE_2D, texture->glid);
// when texture area is small, bilinear filter the closest mipmap
// when texture area is large, bilinear filter the original
bool linear = false;
if (linear){
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
else {
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
// glUseProgram(shader->shaderProgram);
/// Begin the QUADS!
glBegin(GL_QUADS);
}
return true;
}
/*
==============
RenderBumpFlat_f
==============
*/
void RenderBumpFlat_f( const idCmdArgs &args ) {
int width, height;
idStr source;
int i;
idBounds bounds;
srfTriangles_t *mesh;
float boundsScale;
// update the screen as we print
common->SetRefreshOnPrint( true );
width = height = 256;
boundsScale = 0;
// check options
for ( i = 1 ; i < args.Argc() - 1; i++ ) {
const char *s;
s = args.Argv( i );
if ( s[0] == '-' ) {
i++;
s = args.Argv( i );
}
if ( !idStr::Icmp( s, "size" ) ) {
if ( i + 2 >= args.Argc() ) {
i = args.Argc();
break;
}
width = atoi( args.Argv( i + 1 ) );
height = atoi( args.Argv( i + 2 ) );
i += 2;
} else {
common->Printf( "WARNING: Unknown option \"%s\"\n", s );
break;
}
}
if ( i != ( args.Argc() - 1 ) ) {
common->Error( "usage: renderBumpFlat [-size width height] asefile" );
}
common->Printf( "Final image size: %i, %i\n", width, height );
// load the source in "fastload" mode, because we don't
// need tangent and shadow information
source = args.Argv( i );
idRenderModel *highPolyModel = renderModelManager->AllocModel();
highPolyModel->PartialInitFromFile( source );
if ( highPolyModel->IsDefaultModel() ) {
common->Error( "failed to load %s", source.c_str() );
}
// combine the high poly model into a single polyset
if ( highPolyModel->NumSurfaces() != 1 ) {
highPolyModel = CombineModelSurfaces( highPolyModel );
}
// create normals if not present in file
const modelSurface_t *surf = highPolyModel->Surface( 0 );
mesh = surf->geometry;
// bound the entire file
R_BoundTriSurf( mesh );
bounds = mesh->bounds;
SaveWindow();
ResizeWindow( width, height );
// for small images, the viewport may be less than the minimum window
glViewport( 0, 0, width, height );
glEnable( GL_CULL_FACE );
glCullFace( GL_FRONT );
glDisable( GL_STENCIL_TEST );
glDisable( GL_SCISSOR_TEST );
glDisable( GL_ALPHA_TEST );
glDisable( GL_BLEND );
glEnable( GL_DEPTH_TEST );
glDisable( GL_TEXTURE_2D );
glDepthMask( GL_TRUE );
glDepthFunc( GL_LEQUAL );
glColor3f( 1, 1, 1 );
GL_ProjectionMatrix.LoadIdentity();
GL_ProjectionMatrix.Ortho(bounds[0][0], bounds[1][0], bounds[0][2],
bounds[1][2], -(bounds[0][1] - 1), -(bounds[1][1] + 1));
GL_ModelViewMatrix.LoadIdentity();
// flat maps are automatically anti-aliased
idStr filename;
int j, k, c;
byte *buffer;
int *sumBuffer, *colorSumBuffer;
bool flat;
int sample;
sumBuffer = (int *)Mem_Alloc( width * height * 4 * 4 );
memset( sumBuffer, 0, width * height * 4 * 4 );
buffer = (byte *)Mem_Alloc( width * height * 4 );
colorSumBuffer = (int *)Mem_Alloc( width * height * 4 * 4 );
memset( sumBuffer, 0, width * height * 4 * 4 );
flat = false;
//flat = true;
for ( sample = 0 ; sample < 16 ; sample++ ) {
float xOff, yOff;
xOff = ( ( sample & 3 ) / 4.0 ) * ( bounds[1][0] - bounds[0][0] ) / width;
yOff = ( ( sample / 4 ) / 4.0 ) * ( bounds[1][2] - bounds[0][2] ) / height;
for ( int colorPass = 0 ; colorPass < 2 ; colorPass++ ) {
glClearColor(0.5,0.5,0.5,0);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glBegin( GL_TRIANGLES );
for ( i = 0 ; i < highPolyModel->NumSurfaces() ; i++ ) {
const modelSurface_t *surf = highPolyModel->Surface( i );
mesh = surf->geometry;
if ( colorPass ) {
// just render the surface color for artist visualization
for ( j = 0 ; j < mesh->numIndexes ; j+=3 ) {
for ( k = 0 ; k < 3 ; k++ ) {
int v;
float *a;
v = mesh->indexes[j+k];
glColor3ubv( mesh->verts[v].color );
a = mesh->verts[v].xyz.ToFloatPtr();
glVertex3f( a[0] + xOff, a[2] + yOff, a[1] );
}
}
} else {
// render as normal map
// we can either flat shade from the plane,
// or smooth shade from the vertex normals
for ( j = 0 ; j < mesh->numIndexes ; j+=3 ) {
if ( flat ) {
idPlane plane;
idVec3 *a, *b, *c;
int v1, v2, v3;
v1 = mesh->indexes[j+0];
v2 = mesh->indexes[j+1];
v3 = mesh->indexes[j+2];
a = &mesh->verts[ v1 ].xyz;
b = &mesh->verts[ v2 ].xyz;
c = &mesh->verts[ v3 ].xyz;
plane.FromPoints( *a, *b, *c );
// NULLNORMAL is used by the artists to force an area to reflect no
// light at all
if ( surf->shader->GetSurfaceFlags() & SURF_NULLNORMAL ) {
glColor3f( 0.5, 0.5, 0.5 );
} else {
glColor3f( 0.5 + 0.5*plane[0], 0.5 - 0.5*plane[2], 0.5 - 0.5*plane[1] );
}
glVertex3f( (*a)[0] + xOff, (*a)[2] + yOff, (*a)[1] );
glVertex3f( (*b)[0] + xOff, (*b)[2] + yOff, (*b)[1] );
glVertex3f( (*c)[0] + xOff, (*c)[2] + yOff, (*c)[1] );
} else {
for ( k = 0 ; k < 3 ; k++ ) {
int v;
float *n;
float *a;
v = mesh->indexes[j+k];
n = mesh->verts[v].normal.ToFloatPtr();
// NULLNORMAL is used by the artists to force an area to reflect no
// light at all
if ( surf->shader->GetSurfaceFlags() & SURF_NULLNORMAL ) {
glColor3f( 0.5, 0.5, 0.5 );
} else {
// we are going to flip the normal Z direction
glColor3f( 0.5 + 0.5*n[0], 0.5 - 0.5*n[2], 0.5 - 0.5*n[1] );
}
a = mesh->verts[v].xyz.ToFloatPtr();
glVertex3f( a[0] + xOff, a[2] + yOff, a[1] );
}
}
}
}
}
glEnd();
glFlush();
GLimp_SwapBuffers();
glReadPixels( 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, buffer );
if ( colorPass ) {
// add to the sum buffer
for ( i = 0 ; i < c ; i++ ) {
colorSumBuffer[i*4+0] += buffer[i*4+0];
colorSumBuffer[i*4+1] += buffer[i*4+1];
colorSumBuffer[i*4+2] += buffer[i*4+2];
colorSumBuffer[i*4+3] += buffer[i*4+3];
}
} else {
// normalize
c = width * height;
for ( i = 0 ; i < c ; i++ ) {
idVec3 v;
v[0] = ( buffer[i*4+0] - 128 ) / 127.0;
v[1] = ( buffer[i*4+1] - 128 ) / 127.0;
v[2] = ( buffer[i*4+2] - 128 ) / 127.0;
v.Normalize();
buffer[i*4+0] = 128 + 127 * v[0];
buffer[i*4+1] = 128 + 127 * v[1];
buffer[i*4+2] = 128 + 127 * v[2];
}
// outline into non-drawn areas
for ( i = 0 ; i < 8 ; i++ ) {
OutlineNormalMap( buffer, width, height, 128, 128, 128 );
}
// add to the sum buffer
for ( i = 0 ; i < c ; i++ ) {
sumBuffer[i*4+0] += buffer[i*4+0];
sumBuffer[i*4+1] += buffer[i*4+1];
sumBuffer[i*4+2] += buffer[i*4+2];
sumBuffer[i*4+3] += buffer[i*4+3];
}
}
}
}
c = width * height;
// save out the color map
for ( i = 0 ; i < c ; i++ ) {
buffer[i*4+0] = colorSumBuffer[i*4+0] / 16;
buffer[i*4+1] = colorSumBuffer[i*4+1] / 16;
buffer[i*4+2] = colorSumBuffer[i*4+2] / 16;
buffer[i*4+3] = colorSumBuffer[i*4+3] / 16;
}
filename = source;
filename.StripFileExtension();
filename.Append( "_color.tga" );
R_VerticalFlip( buffer, width, height );
R_WriteTGA( filename, buffer, width, height );
// save out the local map
// scale the sum buffer back down to the sample buffer
// we allow this to denormalize
for ( i = 0 ; i < c ; i++ ) {
buffer[i*4+0] = sumBuffer[i*4+0] / 16;
buffer[i*4+1] = sumBuffer[i*4+1] / 16;
buffer[i*4+2] = sumBuffer[i*4+2] / 16;
buffer[i*4+3] = sumBuffer[i*4+3] / 16;
}
filename = source;
filename.StripFileExtension();
filename.Append( "_local.tga" );
common->Printf( "writing %s (%i,%i)\n", filename.c_str(), width, height );
R_VerticalFlip( buffer, width, height );
R_WriteTGA( filename, buffer, width, height );
// free the model
renderModelManager->FreeModel( highPolyModel );
// free our work buffer
Mem_Free( buffer );
Mem_Free( sumBuffer );
Mem_Free( colorSumBuffer );
RestoreWindow();
// stop updating the screen as we print
common->SetRefreshOnPrint( false );
common->Error( "Completed." );
}
static void draw_particles(GLFWwindow* window, double t, float dt)
{
int i, particle_count;
Vertex vertex_array[BATCH_PARTICLES * PARTICLE_VERTS];
Vertex* vptr;
float alpha;
GLuint rgba;
Vec3 quad_lower_left, quad_lower_right;
GLfloat mat[16];
PARTICLE* pptr;
// Here comes the real trick with flat single primitive objects (s.c.
// "billboards"): We must rotate the textured primitive so that it
// always faces the viewer (is coplanar with the view-plane).
// We:
// 1) Create the primitive around origo (0,0,0)
// 2) Rotate it so that it is coplanar with the view plane
// 3) Translate it according to the particle position
// Note that 1) and 2) is the same for all particles (done only once).
// Get modelview matrix. We will only use the upper left 3x3 part of
// the matrix, which represents the rotation.
glGetFloatv(GL_MODELVIEW_MATRIX, mat);
// 1) & 2) We do it in one swift step:
// Although not obvious, the following six lines represent two matrix/
// vector multiplications. The matrix is the inverse 3x3 rotation
// matrix (i.e. the transpose of the same matrix), and the two vectors
// represent the lower left corner of the quad, PARTICLE_SIZE/2 *
// (-1,-1,0), and the lower right corner, PARTICLE_SIZE/2 * (1,-1,0).
// The upper left/right corners of the quad is always the negative of
// the opposite corners (regardless of rotation).
quad_lower_left.x = (-PARTICLE_SIZE / 2) * (mat[0] + mat[1]);
quad_lower_left.y = (-PARTICLE_SIZE / 2) * (mat[4] + mat[5]);
quad_lower_left.z = (-PARTICLE_SIZE / 2) * (mat[8] + mat[9]);
quad_lower_right.x = (PARTICLE_SIZE / 2) * (mat[0] - mat[1]);
quad_lower_right.y = (PARTICLE_SIZE / 2) * (mat[4] - mat[5]);
quad_lower_right.z = (PARTICLE_SIZE / 2) * (mat[8] - mat[9]);
// Don't update z-buffer, since all particles are transparent!
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
// Select particle texture
if (!wireframe)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, particle_tex_id);
}
// Set up vertex arrays. We use interleaved arrays, which is easier to
// handle (in most situations) and it gives a linear memeory access
// access pattern (which may give better performance in some
// situations). GL_T2F_C4UB_V3F means: 2 floats for texture coords,
// 4 ubytes for color and 3 floats for vertex coord (in that order).
// Most OpenGL cards / drivers are optimized for this format.
glInterleavedArrays(GL_T2F_C4UB_V3F, 0, vertex_array);
// Wait for particle physics thread to be done
mtx_lock(&thread_sync.particles_lock);
while (!glfwWindowShouldClose(window) &&
thread_sync.p_frame <= thread_sync.d_frame)
{
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_nsec += 100000000;
cnd_timedwait(&thread_sync.p_done, &thread_sync.particles_lock, &ts);
}
// Store the frame time and delta time for the physics thread
thread_sync.t = t;
thread_sync.dt = dt;
// Update frame counter
thread_sync.d_frame++;
// Loop through all particles and build vertex arrays.
particle_count = 0;
vptr = vertex_array;
pptr = particles;
for (i = 0; i < MAX_PARTICLES; i++)
{
if (pptr->active)
{
// Calculate particle intensity (we set it to max during 75%
// of its life, then it fades out)
alpha = 4.f * pptr->life;
if (alpha > 1.f)
alpha = 1.f;
// Convert color from float to 8-bit (store it in a 32-bit
// integer using endian independent type casting)
((GLubyte*) &rgba)[0] = (GLubyte)(pptr->r * 255.f);
((GLubyte*) &rgba)[1] = (GLubyte)(pptr->g * 255.f);
((GLubyte*) &rgba)[2] = (GLubyte)(pptr->b * 255.f);
((GLubyte*) &rgba)[3] = (GLubyte)(alpha * 255.f);
// 3) Translate the quad to the correct position in modelview
// space and store its parameters in vertex arrays (we also
// store texture coord and color information for each vertex).
// Lower left corner
vptr->s = 0.f;
vptr->t = 0.f;
vptr->rgba = rgba;
vptr->x = pptr->x + quad_lower_left.x;
vptr->y = pptr->y + quad_lower_left.y;
vptr->z = pptr->z + quad_lower_left.z;
vptr ++;
// Lower right corner
vptr->s = 1.f;
vptr->t = 0.f;
vptr->rgba = rgba;
vptr->x = pptr->x + quad_lower_right.x;
vptr->y = pptr->y + quad_lower_right.y;
vptr->z = pptr->z + quad_lower_right.z;
vptr ++;
// Upper right corner
vptr->s = 1.f;
vptr->t = 1.f;
vptr->rgba = rgba;
vptr->x = pptr->x - quad_lower_left.x;
vptr->y = pptr->y - quad_lower_left.y;
vptr->z = pptr->z - quad_lower_left.z;
vptr ++;
// Upper left corner
vptr->s = 0.f;
vptr->t = 1.f;
vptr->rgba = rgba;
vptr->x = pptr->x - quad_lower_right.x;
vptr->y = pptr->y - quad_lower_right.y;
vptr->z = pptr->z - quad_lower_right.z;
vptr ++;
// Increase count of drawable particles
particle_count ++;
}
// If we have filled up one batch of particles, draw it as a set
// of quads using glDrawArrays.
if (particle_count >= BATCH_PARTICLES)
{
// The first argument tells which primitive type we use (QUAD)
// The second argument tells the index of the first vertex (0)
// The last argument is the vertex count
glDrawArrays(GL_QUADS, 0, PARTICLE_VERTS * particle_count);
particle_count = 0;
vptr = vertex_array;
}
// Next particle
pptr++;
}
// We are done with the particle data
mtx_unlock(&thread_sync.particles_lock);
cnd_signal(&thread_sync.d_done);
// Draw final batch of particles (if any)
glDrawArrays(GL_QUADS, 0, PARTICLE_VERTS * particle_count);
// Disable vertex arrays (Note: glInterleavedArrays implicitly called
// glEnableClientState for vertex, texture coord and color arrays)
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
}
SideScroller::~SideScroller() {
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
SDL_Quit();
}
static void draw_scene(GLFWwindow* window, double t)
{
double xpos, ypos, zpos, angle_x, angle_y, angle_z;
static double t_old = 0.0;
float dt;
// Calculate frame-to-frame delta time
dt = (float) (t - t_old);
t_old = t;
glClearColor(0.1f, 0.1f, 0.1f, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(65.0, aspect_ratio, 1.0, 60.0);
// Setup camera
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Rotate camera
angle_x = 90.0 - 10.0;
angle_y = 10.0 * sin(0.3 * t);
angle_z = 10.0 * t;
glRotated(-angle_x, 1.0, 0.0, 0.0);
glRotated(-angle_y, 0.0, 1.0, 0.0);
glRotated(-angle_z, 0.0, 0.0, 1.0);
// Translate camera
xpos = 15.0 * sin((M_PI / 180.0) * angle_z) +
2.0 * sin((M_PI / 180.0) * 3.1 * t);
ypos = -15.0 * cos((M_PI / 180.0) * angle_z) +
2.0 * cos((M_PI / 180.0) * 2.9 * t);
zpos = 4.0 + 2.0 * cos((M_PI / 180.0) * 4.9 * t);
glTranslated(-xpos, -ypos, -zpos);
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
setup_lights();
glEnable(GL_LIGHTING);
glEnable(GL_FOG);
glFogi(GL_FOG_MODE, GL_EXP);
glFogf(GL_FOG_DENSITY, 0.05f);
glFogfv(GL_FOG_COLOR, fog_color);
draw_floor();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDepthMask(GL_TRUE);
draw_fountain();
glDisable(GL_LIGHTING);
glDisable(GL_FOG);
// Particles must be drawn after all solid objects have been drawn
draw_particles(window, t, dt);
// Z-buffer not needed anymore
glDisable(GL_DEPTH_TEST);
}
void SteamPass::Advance(double _dt)
{
for (auto node : m_nodeGroup.Nodes())
{
auto& terrainGeom = *node->terrainGeom;
auto& particleGeom = *node->particleGeom;
auto& material = *node->material;
// Update
{
glBindProgramPipeline(GL_NONE);
m_updateShader.BindPerPass();
if (particleGeom.Switch())
{
GL_CHECK(glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, particleGeom.TransformFeedbackObjB()));
GL_CHECK(glBindVertexArray(particleGeom.VertexArrayA()));
}
else
{
GL_CHECK(glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, particleGeom.TransformFeedbackObjA()));
GL_CHECK(glBindVertexArray(particleGeom.VertexArrayB()));
}
GL_CHECK(glBeginTransformFeedback(GL_POINTS));
GL_CHECK(glEnable(GL_RASTERIZER_DISCARD));
auto& vs = m_updateShader.VertexShader();
vs.SetTexture("s_heightData", terrainGeom.HeightData().GetRead());
vs.SetTexture("s_smudgeData", terrainGeom.SmudgeData().GetRead());
GL_CHECK(glDrawArrays(GL_POINTS, 0, particleGeom.NumParticles()));
GL_CHECK(glDisable(GL_RASTERIZER_DISCARD));
GL_CHECK(glEndTransformFeedback());
glUseProgram(GL_NONE);
particleGeom.Switch(!particleGeom.Switch());
}
// Draw
{
m_drawShader.BindPerPass();
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(GL_FALSE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glPointSize(16.0f);
RenderParams::SetModelMatrix(node->transform->matrix);
GLuint vertexArray = particleGeom.Switch() ? particleGeom.VertexArrayA() : particleGeom.VertexArrayB();
GL_CHECK(glBindVertexArray(vertexArray));
m_drawShader.BindPerPass();
auto& vs = m_drawShader.VertexShader();
vs.SetUniform("u_mvpMatrix", RenderParams::ModelViewProjectionMatrix());
vs.SetUniform("u_cameraPos", RenderParams::CameraPosition());
vs.SetUniform("u_lightDir", -glm::euclidean(vec2(material.lightAltitude, material.lightAzimuth)));
vs.SetUniform("u_moltenColor", material.moltenColor);
vs.SetTexture("s_miscData", terrainGeom.MiscData().GetRead());
m_drawShader.FragmentShader().SetTexture( "s_texture", material.smokeTexture );
m_drawShader.FragmentShader().SetUniform("u_moltenColor", material.moltenColor);
//vs.SetUniform("u_lightDir", -glm::euclidean(vec2(material.lightAltitude, material.lightAzimuth)));
//vs.SetUniform("u_lightIntensity", material.directLightIntensity);
//vs.SetUniform("u_ambientLightIntensity", material.ambientLightIntensity);
glEnable(GL_PROGRAM_POINT_SIZE);
GL_CHECK(glDrawArrays(GL_POINTS, 0, particleGeom.NumParticles()));
glDisable(GL_PROGRAM_POINT_SIZE);
glBindVertexArray(GL_NONE);
//glDepthMask(GL_TRUE);
//glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
}
}
//--------------------------------------------------------------
void ofApp::draw3d(){
//ofEnableDepthTest();
points.clear();
sizes.clear();
points2.clear();
sizes2.clear();
//カメラ設定
int cx,cy;
cameraCount++;
cameraMoving = ofVec3f(0,objRoad.count*objRoad.speed,0);
camera2.setPosition(camera.getPosition()+cameraMoving);
camera2.lookAt(cameraMoving,ofVec3f(0,0,1));
switch (cameraId) {
case 1:
camera.setPosition(0, -1000, 400);
camera.lookAt(ofVec3f(0,0,0),ofVec3f(0,0,1));
break;
case 2:
camera.setPosition(800, -800, 300);
//camera.setPosition(1500, -3000, 800);
camera.lookAt(ofVec3f(0,0,0),ofVec3f(0,0,1));
break;
case 3:
camera.setPosition(0, 1500, 500);
camera.lookAt(ofVec3f(0,0,0),ofVec3f(0,0,1));
break;
case 4:
cx = 1200*cos( cameraCount/200.0 );
cy = 1200*sin( cameraCount/200.0 );
camera.setPosition(cx, cy, 400);
camera.lookAt(ofVec3f(0,0,0),ofVec3f(0,0,1));
break;
case 5:
cx = -1200*cos( cameraCount/100.0 )*(cos(cameraCount/100.0)+2)/3;
cy = 1200*sin( cameraCount/100.0 )*(cos(cameraCount/100.0)+2)/3;
camera.setPosition(cx, cy, 400*(cos(cameraCount/100.0)+2)/3);
camera.lookAt(ofVec3f(0,0,0),ofVec3f(0,0,1));
break;
default:
break;
}
glDepthMask(GL_FALSE);//デプスバッファに書き込むのを禁止する
ofEnableBlendMode(OF_BLENDMODE_ADD);//加算描画 this makes everything look glowy
ofEnablePointSprites();
//道路表示
//shader2.begin();
camera2.begin();
ofVec4f bufpos,bufpos_1f;
for(int i=objRoad.getIdxStart();i<objRoad.getIdxEnd();i++){
bufpos = objRoad.getLeftPos(i);
int roadwidth = objRoad.getRoadWidth(i);
if(i==objRoad.getIdxStart()){
continue;
}
//ofSetColor(rainbow[(i/10)%7][0],rainbow[(i/10)%7][1],rainbow[(i/10)%7][2],bufpos.w);
ofSetColor(0,200,0,bufpos.w);
ofBoxPrimitive buf_box;
buf_box = ofBoxPrimitive(roadwidth, objRoad.width, 1);
buf_box.setPosition(bufpos_1f.x, bufpos_1f.y+objRoad.width/2, bufpos.z);
buf_box.draw();
if(i%20==0){
ofSetColor(255,0,0,255);
ofSpherePrimitive a;
a = ofSpherePrimitive(10, 20);
a.setPosition(bufpos_1f.x, bufpos_1f.y, 0);
a.draw();
ofBoxPrimitive b;
b = ofBoxPrimitive(roadwidth, 3, 20);
b.setPosition(bufpos_1f.x, bufpos_1f.y, bufpos.z);
b.draw();
}
bufpos_1f = bufpos;
}
camera2.end();
//shader2.end();
ofDisablePointSprites();
ofDisableBlendMode();
glDepthMask(GL_TRUE);
//観客描画
//ofEnableBlendMode(OF_BLENDMODE_ADD);//加算描画 this makes everything look glowy
if(bDraw3d){
int buf_x,buf_y,buf_z,buf_speed;
for (int i = 0; i < ObjHumans.size(); i++) {
buf_x = ObjHumans[i].position.x;
buf_x = ((buf_x - 512 - objFrameOffsetx)*scalex)>>5; //32等倍
buf_y = ObjHumans[i].position.y;
buf_y = ((buf_y - 512 - objFrameOffsety)*scaley)>>5; //32等倍
buf_z = (ObjHumans[i].positionz * scalez) >>5;//32等倍
buf_speed = (int)(ObjHumans[i].speed*humanscale/50+humansizeoffset);
if(ObjHumans[i].humanStd <= ObjHumans[i].objMissThr){
if(ObjHumans[i].humanStd>=0){
addPoint(buf_x, buf_y, buf_z,buf_speed*2);
}
addPoint(buf_x, buf_y, buf_z,buf_speed*2);
boxScale.push_back(buf_speed);
}else{
addPoint2(buf_x, buf_y, buf_z,buf_speed*2);
boxScale2.push_back(buf_speed);
}
}
}
glDepthMask(GL_FALSE);
// this makes everything look glowy :)
ofEnablePointSprites();
//ofEnableBlendMode(OF_BLENDMODE_ADD);
ofEnableAlphaBlending();
shader.begin();
camera.begin();
glPointSize(20);
//観客ノード
texture.bind();
//texture2.bind();
//ofSetColor(255);
ofSetColor(0, 100, 255);
int total = (int)points.size();
vbo.setVertexData(&points[0], total, GL_STATIC_DRAW);
vbo.setNormalData(&sizes[0], total, GL_STATIC_DRAW);
vbo.draw(GL_POINTS, 0, (int)points.size());
ofSetColor(255, 100, 90);
total = (int)points2.size();
vbo.setVertexData(&points2[0], total, GL_STATIC_DRAW);
vbo.setNormalData(&sizes2[0], total, GL_STATIC_DRAW);
vbo.draw(GL_POINTS, 0,(int)points2.size());
texture.unbind();
//texture2.unbind();
//ライブハウスグリッド描画
objFrame.draw();
camera.end();
shader.end();
ofDisablePointSprites();
//ofDisableBlendMode();
ofDisableAlphaBlending();
//基準座標
camera2.begin();
ofSetLineWidth(1);
/*ofSetColor(255,0,0);
ofLine(ofVec3f(0,0,0), ofVec3f(300,0,0));
ofSetColor(0,255,0);
ofLine(ofVec3f(0,0,0), ofVec3f(0,300,0));
ofSetColor(0,0,255);
ofLine(ofVec3f(0,0,0), ofVec3f(0,0,300));*/
//ここから松
ofEnableAlphaBlending();
// bind the shader so that wee can change the
// size of the points via the vert shader
billboardShader.begin();
ofEnablePointSprites(); // not needed for GL3/4
texture_.getTextureReference().bind();
billboards.draw();
texture_.getTextureReference().unbind();
ofDisablePointSprites(); // not needed for GL3/4
billboardShader.end();
ofDisableAlphaBlending();
//ここまで松
camera2.end();
/*float boxSize = 100;
ofFill();
ofSetColor(255);
ofDrawBox(boxSize);
ofNoFill();*/
//ba.drawNormals(1000);
//texture3.getTextureReference().unbind();
ofEnableAlphaBlending();
camera2.begin();
objTorii.draw(texTorii);
for(int i =0 ;i< objClouds.size();i++){
if(objClouds[i].visible(cameraMoving.y)){
objClouds[i].draw(texCloud);
}
}
for(int i =0 ;i< objLibs.size();i++){
if(objLibs[i].visible(cameraMoving.y)){
objLibs[i].draw(texLibs[objLibs[i].texidi*TEXLIBNUM+objLibs[i].texidj]);
}else{
if(objLibs[i].killmyself(cameraMoving.y)){
objLibs.erase(objLibs.begin()+i);
}
}
}
camera2.end();
//ここから応援コメント
camera.begin();
ofSetColor(255,255,255);
for (int i = 0; i < 3 ;i++){
for(int j = 0;j < 2; j++){
for(int k =0; k < 2; k++){
if(commentdraw[i][j][k]){
objTexts[i*4+j*2+k].draw(texTexts[i*4+j*2+k]);
}
}
}
}
camera.end();
ofDisableAlphaBlending();
glDepthMask(GL_TRUE);
}
void GPU_select_begin(unsigned int *buffer, unsigned int bufsize, rctf *input, char mode, int oldhits)
{
g_query_state.select_is_active = true;
g_query_state.query_issued = false;
g_query_state.active_query = 0;
g_query_state.use_gpu_select = GPU_select_query_check_active();
g_query_state.num_of_queries = 0;
g_query_state.bufsize = bufsize;
g_query_state.buffer = buffer;
g_query_state.mode = mode;
g_query_state.index = 0;
g_query_state.oldhits = oldhits;
if (!g_query_state.use_gpu_select) {
glSelectBuffer(bufsize, (GLuint *)buffer);
glRenderMode(GL_SELECT);
glInitNames();
glPushName(-1);
}
else {
float viewport[4];
g_query_state.num_of_queries = ALLOC_QUERIES;
g_query_state.queries = MEM_mallocN(g_query_state.num_of_queries * sizeof(*g_query_state.queries), "gpu selection queries");
g_query_state.id = MEM_mallocN(g_query_state.num_of_queries * sizeof(*g_query_state.id), "gpu selection ids");
glGenQueries(g_query_state.num_of_queries, g_query_state.queries);
glPushAttrib(GL_DEPTH_BUFFER_BIT | GL_VIEWPORT_BIT);
/* disable writing to the framebuffer */
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
/* In order to save some fill rate we minimize the viewport using rect.
* We need to get the region of the scissor so that our geometry doesn't
* get rejected before the depth test. Should probably cull rect against
* scissor for viewport but this is a rare case I think */
glGetFloatv(GL_SCISSOR_BOX, viewport);
if (!input || input->xmin == input->xmax) {
glViewport(viewport[0], viewport[1], 24, 24);
}
else {
glViewport(viewport[0], viewport[1], (int)(input->xmax - input->xmin), (int)(input->ymax - input->ymin));
}
/* occlusion queries operates on fragments that pass tests and since we are interested on all
* objects in the view frustum independently of their order, we need to disable the depth test */
if (mode == GPU_SELECT_ALL) {
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
}
else if (mode == GPU_SELECT_NEAREST_FIRST_PASS) {
glClear(GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDepthFunc(GL_LEQUAL);
}
else if (mode == GPU_SELECT_NEAREST_SECOND_PASS) {
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDepthFunc(GL_EQUAL);
}
}
}
// Draws the FBO texture for 3DTV.
void ApplicationOverlay::displayOverlayTexture3DTV(Camera& whichCamera, float aspectRatio, float fov) {
if (_alpha == 0.0f) {
return;
}
Application* application = Application::getInstance();
MyAvatar* myAvatar = application->getAvatar();
const glm::vec3& viewMatrixTranslation = application->getViewMatrixTranslation();
glActiveTexture(GL_TEXTURE0);
glEnable(GL_BLEND);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
_overlays.bindTexture();
glEnable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
// Transform to world space
glm::quat rotation = whichCamera.getRotation();
glm::vec3 axis2 = glm::axis(rotation);
glRotatef(-glm::degrees(glm::angle(rotation)), axis2.x, axis2.y, axis2.z);
glTranslatef(viewMatrixTranslation.x, viewMatrixTranslation.y, viewMatrixTranslation.z);
// Translate to the front of the camera
glm::vec3 pos = whichCamera.getPosition();
glm::quat rot = myAvatar->getOrientation();
glm::vec3 axis = glm::axis(rot);
glTranslatef(pos.x, pos.y, pos.z);
glRotatef(glm::degrees(glm::angle(rot)), axis.x, axis.y, axis.z);
glColor4f(1.0f, 1.0f, 1.0f, _alpha);
//Render
const GLfloat distance = 1.0f;
const GLfloat halfQuadHeight = distance * tan(fov);
const GLfloat halfQuadWidth = halfQuadHeight * aspectRatio;
const GLfloat quadWidth = halfQuadWidth * 2.0f;
const GLfloat quadHeight = halfQuadHeight * 2.0f;
GLfloat x = -halfQuadWidth;
GLfloat y = -halfQuadHeight;
glDisable(GL_DEPTH_TEST);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 1.0f); glVertex3f(x, y + quadHeight, -distance);
glTexCoord2f(1.0f, 1.0f); glVertex3f(x + quadWidth, y + quadHeight, -distance);
glTexCoord2f(1.0f, 0.0f); glVertex3f(x + quadWidth, y, -distance);
glTexCoord2f(0.0f, 0.0f); glVertex3f(x, y, -distance);
glEnd();
if (_crosshairTexture == 0) {
_crosshairTexture = Application::getInstance()->getGLWidget()->bindTexture(QImage(Application::resourcesPath() + "images/sixense-reticle.png"));
}
//draw the mouse pointer
glBindTexture(GL_TEXTURE_2D, _crosshairTexture);
const float reticleSize = 40.0f / application->getGLWidget()->width() * quadWidth;
x -= reticleSize / 2.0f;
y += reticleSize / 2.0f;
const float mouseX = (application->getMouseX() / (float)application->getGLWidget()->width()) * quadWidth;
const float mouseY = (1.0 - (application->getMouseY() / (float)application->getGLWidget()->height())) * quadHeight;
glBegin(GL_QUADS);
glColor3f(RETICLE_COLOR[0], RETICLE_COLOR[1], RETICLE_COLOR[2]);
glTexCoord2d(0.0f, 0.0f); glVertex3f(x + mouseX, y + mouseY, -distance);
glTexCoord2d(1.0f, 0.0f); glVertex3f(x + mouseX + reticleSize, y + mouseY, -distance);
glTexCoord2d(1.0f, 1.0f); glVertex3f(x + mouseX + reticleSize, y + mouseY - reticleSize, -distance);
glTexCoord2d(0.0f, 1.0f); glVertex3f(x + mouseX, y + mouseY - reticleSize, -distance);
glEnd();
glEnable(GL_DEPTH_TEST);
glPopMatrix();
glDepthMask(GL_TRUE);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
glEnable(GL_LIGHTING);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
void CSm3GroundDrawer::Draw(bool drawWaterReflection, bool drawUnitReflection)
{
if (wireframe) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
terrain::RenderContext* currc = rc;
tr->SetShaderParams(sky->GetLight()->GetLightDir(), currc->cam->pos);
if (shadowHandler->shadowsLoaded) {
terrain::ShadowMapParams params;
params.mid[0] = shadowHandler->GetShadowParams().x;
params.mid[1] = shadowHandler->GetShadowParams().y;
params.f_a = shadowHandler->GetShadowParams().z;
params.f_b = shadowHandler->GetShadowParams().w;
params.shadowMap = shadowHandler->shadowTexture;
for (int a = 0; a < 16; a++)
params.shadowMatrix[a] = shadowHandler->shadowMatrix[a];
tr->SetShadowParams(¶ms);
}
tr->SetActiveContext(currc);
glEnable(GL_CULL_FACE);
glFrontFace(GL_CW);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glEnable(GL_LIGHTING);
glLightfv(GL_LIGHT0, GL_POSITION, sky->GetLight()->GetLightDir());
float d[4] = {0.0f, 0.0f, 0.0f, 1.0f};
const float z[] = {0.0f, 0.0f, 0.0f, 1.0f};
for (int a = 0; a < 3; a++)
d[a] = mapInfo->light.groundSunColor[a];
glLightfv(GL_LIGHT0, GL_DIFFUSE, d);
for (int a = 0; a < 3; a++)
d[a] = mapInfo->light.groundAmbientColor[a];
glLightfv(GL_LIGHT0, GL_AMBIENT, d);
for (int a = 0; a < 3; a++)
d[a] = mapInfo->light.groundSpecularColor[a];
glLightfv(GL_LIGHT0, GL_SPECULAR, d);
for (int a = 0; a < 4; a++)
d[a] = 0.0f;
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, d);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, z);
glDisable(GL_LIGHT1);
glEnable(GL_LIGHT0);
glEnable(GL_RESCALE_NORMAL);
// glLightfv (GL_LIGHT0, GL_SPOT_DIRECTION,dir.getf());
// glLightf (GL_LIGHT0, GL_SPOT_CUTOFF, 90.0f);
/* const float ambient[] = { 0.4f, 0.4f, 0.4f, 1.0f };
const float diffuse[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glLightfv (GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv (GL_LIGHT0, GL_AMBIENT, ambient);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
const float md[] = { 1.0f, 1.0f, 1.0f, 1.0f };
glMaterialfv (GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, md);
glMaterialfv (GL_FRONT_AND_BACK, GL_SPECULAR, md);
glMaterialf (GL_FRONT_AND_BACK, GL_SHININESS, 10.0f);*/
/////////////////////
tr->Draw();
glDisable(GL_LIGHT0);
glDisable(GL_LIGHTING);
if (wireframe) {
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
if (drawMode != drawNormal) {
glEnable(GL_BLEND);
glDepthMask(GL_FALSE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(0.0f, -10.0f);
glColor4f(1.0f, 1.0f, 1.0f, 0.5f);
tr->DrawOverlayTexture(infoTex);
glDisable(GL_POLYGON_OFFSET_FILL);
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
}
glFrontFace(GL_CCW);
glDisable(GL_CULL_FACE);
glColor3ub(255, 255, 255);
DrawObjects(drawWaterReflection, drawUnitReflection);
glActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
}
static void DrawFire(ModeInfo * mi)
{
int j;
firestruct *fs = &fire[MI_SCREEN(mi)];
Bool wire = MI_IS_WIREFRAME(mi);
mi->polygon_count = 0;
if (do_wander && !fs->button_down_p)
{
GLfloat x, y, z;
# define SINOID(SCALE,SIZE) \
((((1 + sin((fs->frame * (SCALE)) / 2 * M_PI)) / 2.0) * (SIZE)) - (SIZE)/2)
x = SINOID(0.031, 0.85);
y = SINOID(0.017, 0.25);
z = SINOID(0.023, 0.85);
fs->frame++;
fs->obs[0] = x + DEF_OBS[0];
fs->obs[1] = y + DEF_OBS[1];
fs->obs[2] = z + DEF_OBS[2];
fs->dir[1] = y;
fs->dir[2] = z;
}
glEnable(GL_DEPTH_TEST);
if (fs->fog)
glEnable(GL_FOG);
else
glDisable(GL_FOG);
glDepthMask(GL_TRUE);
glClearColor(0.5, 0.5, 0.8, 1.0); /* sky in the distance */
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
calcposobs(fs);
gltrackball_rotate (fs->trackball);
gluLookAt(fs->obs[0], fs->obs[1], fs->obs[2],
fs->obs[0] + fs->dir[0],
fs->obs[1] + fs->dir[1],
fs->obs[2] + fs->dir[2],
0.0, 1.0, 0.0);
glEnable(GL_TEXTURE_2D);
/* draw ground using the computed texture */
if (do_texture) {
glColor4f(1.0,1.0,1.0,1.0); /* white to get texture in it's true color */
#ifdef HAVE_GLBINDTEXTURE
glBindTexture(GL_TEXTURE_2D, fs->groundid);
#endif /* HAVE_GLBINDTEXTURE */
}
else
glColor4f(0.54, 0.27, 0.07, 1.0); /* untextured ground color */
glBegin(GL_QUADS);
glTexCoord2fv(qt[0]);
glVertex3fv(q[0]);
glTexCoord2fv(qt[1]);
glVertex3fv(q[1]);
glTexCoord2fv(qt[2]);
glVertex3fv(q[2]);
glTexCoord2fv(qt[3]);
glVertex3fv(q[3]);
mi->polygon_count++;
glEnd();
glAlphaFunc(GL_GEQUAL, 0.9);
if (fs->num_trees)
{
/* here do_texture IS True - and color used is white */
glEnable(GL_ALPHA_TEST);
#ifdef HAVE_GLBINDTEXTURE
glBindTexture(GL_TEXTURE_2D,fs->treeid);
#endif /* HAVE_GLBINDTEXTURE */
for(j=0;j<fs->num_trees;j++)
mi->polygon_count += drawtree(fs->treepos[j].x ,fs->treepos[j].y ,fs->treepos[j].z );
glDisable(GL_ALPHA_TEST);
}
glDisable(GL_TEXTURE_2D);
glDepthMask(GL_FALSE);
if (fs->shadows) {
/* draw shadows with black color */
glBegin(wire ? GL_LINE_STRIP : GL_TRIANGLES);
for (j = 0; j < fs->np; j++) {
glColor4f(black[0], black[1], black[2], fs->p[j].c[0][3]);
glVertex3f(fs->p[j].p[0][0], 0.1, fs->p[j].p[0][2]);
glColor4f(black[0], black[1], black[2], fs->p[j].c[1][3]);
glVertex3f(fs->p[j].p[1][0], 0.1, fs->p[j].p[1][2]);
glColor4f(black[0], black[1], black[2], fs->p[j].c[2][3]);
glVertex3f(fs->p[j].p[2][0], 0.1, fs->p[j].p[2][2]);
mi->polygon_count++;
}
glEnd();
}
glBegin(wire ? GL_LINE_STRIP : GL_TRIANGLES);
for (j = 0; j < fs->np; j++) {
/* draw particles: colors are computed in setpart */
glColor4fv(fs->p[j].c[0]);
glVertex3fv(fs->p[j].p[0]);
glColor4fv(fs->p[j].c[1]);
glVertex3fv(fs->p[j].p[1]);
glColor4fv(fs->p[j].c[2]);
glVertex3fv(fs->p[j].p[2]);
mi->polygon_count++;
setpart(fs, &fs->p[j]);
}
glEnd();
/* draw rain particles if no fire particles */
if (!fs->np)
{
float timeused = gettimerain();
glDisable(GL_TEXTURE_2D);
glShadeModel(GL_SMOOTH);
glBegin(GL_LINES);
for (j = 0; j < NUMPART; j++) {
glColor4f(0.7f,0.95f,1.0f,0.0f);
glVertex3fv(fs->r[j].oldpos);
glColor4f(0.3f,0.7f,1.0f,1.0f);
glVertex3fv(fs->r[j].pos);
setpartrain(fs, &fs->r[j],timeused);
mi->polygon_count++;
}
glEnd();
glShadeModel(GL_FLAT);
}
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glDisable(GL_DEPTH_TEST);
glDisable(GL_FOG);
/* manage framerate display */
if (MI_IS_FPS(mi)) do_fps (mi);
glPopMatrix();
}
void display()
{ glClearColor(0.6, 0.75, 0.85, 1); // sky color is light blue
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* Clear The Screen And The Depth Buffer */
if(view==0)
{
display1();
}
else if (view==1)
{
display2();
}
else if(view==2)
{
// Erase the window and the depth buffer
glClearColor(0.6, 0.75, 0.85, 1); // sky color is light blue
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// Enable Z-buffering in OpenGL
glEnable(GL_DEPTH_TEST);
glCullFace(GL_BACK);
glLoadIdentity();
// Set the look at position for perspective projection
gluLookAt(
Ex, Ey, Ez,
Ex + lx, Ey, Ez+lz,
0.0, 1, 0.0);
glShadeModel(GL_SMOOTH);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glPushMatrix();
glTranslatef( Ex + lx, 0, Ez+lz-4);
Sky(1000);
glPopMatrix();
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
// Light switch
if (light)
{
// Translate intensity to color vectors
float Ambient[] = {0.01*ambient ,0.01*ambient ,0.01*ambient ,1.0};
float Diffuse[] = {0.01*diffuse ,0.01*diffuse ,0.01*diffuse ,1.0};
float Specular[] = {0.01*specular,0.01*specular,0.01*specular,1.0};
// Light position
float Position[]={0,1000,5000};
// Draw light position as ball (still no lighting here)
glColor3f(1,1,1);
ball(Position[0],Position[1],Position[2] , 0.2);
// OpenGL should normalize normal vectors
glEnable(GL_NORMALIZE);
// Enable lighting
glEnable(GL_LIGHTING);
// glColor sets ambient and diffuse color materials
glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
// Enable light 0
glEnable(GL_LIGHT0);
// Set ambient, diffuse, specular components and position of light 0
glLightfv(GL_LIGHT0,GL_AMBIENT ,Ambient);
glLightfv(GL_LIGHT0,GL_DIFFUSE ,Diffuse);
glLightfv(GL_LIGHT0,GL_SPECULAR,Specular);
glLightfv(GL_LIGHT0,GL_POSITION,Position);
}
else
glDisable(GL_LIGHTING);
if(opt==1)
{
glPushMatrix();
glTranslatef( Ex + lx,0, Ez+lz-4);
glRotatef(90, 1, 0, 0);
glRotatef(180, 0, 1, 0);
glColor3f(1,1,1);
glCallList(car1);
glPopMatrix();
int E=Ez+lz-4;
if(E<=40)
{
Ex=0;
Ez=1000;
lx=0;
lz=-1;
}
}
else if(opt==2)
{
glPushMatrix();
glTranslatef( Ex + lx, 0, Ez+lz-4);
glRotatef(90, 1, 0, 0);
glRotatef(180, 0, 1, 0);
glColor3f(1,1,1);
glCallList(car2);
glPopMatrix();
int E=Ez+lz-4;
if(E<=40)
{
Ex=0;
Ez=1000;
lx=0;
lz=-1;
}
}
cylinder();
Road();
for(i=0; i<=1000; i+=40)
{
glPushMatrix();
glTranslated(-50,10,i);
glScaled(50,50,50);
Tree();
glPopMatrix();
}
for(i=0; i<=1000; i+=40)
{
glPushMatrix();
glTranslated(170,10,i);
glScaled(50,50,50);
Tree();
glPopMatrix();
}
for(i=0; i<=1000; i+=60)
{
glPushMatrix();
glTranslated(-70,-10,i);
glScaled(2,10,10);
Lamp();
glPopMatrix();
}
for(i=0; i<=1000; i+=60)
{
glPushMatrix();
glTranslated(70,-10,i);
glRotated(90,0,1,0);
glScaled(2,10,10);
Lamp();
glPopMatrix();
}
for(i=-60; i<=1000; i+=60)
{
glPushMatrix();
glTranslated(-38,86.5,i+43);
glScaled(5,5,5);
lights();
glPopMatrix();
}
for(i=-60; i<=1000; i+=60)
{
glPushMatrix();
glTranslated(55,87,i+30);
glScaled(5,5,5);
lights();
glPopMatrix();
}
for(i=0; i<=1000; i+=400)
{
glPushMatrix();
glTranslated(-50,-10,i);
glScaled(10,10,10);
trafficsignal();
glPopMatrix();
}
for(i=0; i<=1000; i+=400)
{
glPushMatrix();
glTranslated(0,0,i+40);
zebracrossing();
glPopMatrix();
}
for(i=-60; i<=1000; i+=100)
{
glPushMatrix();
glTranslated(200,-15,i+30);
glScaled(10,15,10);
buildings();
glPopMatrix();
}
for(i=-60; i<=1000; i+=100)
{
glPushMatrix();
glTranslated(-250,-15,i+30);
glScaled(10,15,10);
buildings();
glPopMatrix();
}
for(i=-60; i<=1000; i+=100)
{
glPushMatrix();
glTranslated(350,-15,i+30);
glScaled(10,30,10);
buildings();
glPopMatrix();
}
for(i=-60; i<=1000; i+=100)
{
glPushMatrix();
glTranslated(-400,-15,i+30);
glScaled(10,30,10);
buildings();
glPopMatrix();
}
for(e=0; e<=1000; e+=155)
{
if(e%2==0)
{
glPushMatrix();
glTranslated(-16,-10,e);
glScaled(6,6,6);
roadpylon();
glPopMatrix();
}
else
{
glPushMatrix();
glTranslated(16,-10,e);
glScaled(6,6,6);
roadpylon();
glPopMatrix();
}
}
for(i=0; i<=1000; i+=400)
{
glPushMatrix();
glTranslated(65,0,i);
glScaled(10,10,10);
roadsign();
glPopMatrix();
}
xpos = xpos + xvel;
if(xpos >= 30)
{
xvel = -xvel;
}
if( xpos <2)
{
xvel = -xvel;
}
glPushMatrix();
glTranslated(0,xpos,900);
glRotated(-90,0,0,1);
glRotated(-90,0,1,0);
glScaled(2,2,2);
glColor3f(1,1,1);
glCallList(dragon);
glPopMatrix();
glWindowPos2i(5,5);
glColor3f(1,1,1);
Print("Speed=%f",1,jump);
}
// Render the scene and make it visible
ErrCheck("display");
glFlush();
glutSwapBuffers();
}
void OpenGLState::Apply() const {
// Culling
if (cull.enabled != cur_state.cull.enabled) {
if (cull.enabled) {
glEnable(GL_CULL_FACE);
} else {
glDisable(GL_CULL_FACE);
}
}
if (cull.mode != cur_state.cull.mode) {
glCullFace(cull.mode);
}
if (cull.front_face != cur_state.cull.front_face) {
glFrontFace(cull.front_face);
}
// Depth test
if (depth.test_enabled != cur_state.depth.test_enabled) {
if (depth.test_enabled) {
glEnable(GL_DEPTH_TEST);
} else {
glDisable(GL_DEPTH_TEST);
}
}
if (depth.test_func != cur_state.depth.test_func) {
glDepthFunc(depth.test_func);
}
// Depth mask
if (depth.write_mask != cur_state.depth.write_mask) {
glDepthMask(depth.write_mask);
}
// Color mask
if (color_mask.red_enabled != cur_state.color_mask.red_enabled ||
color_mask.green_enabled != cur_state.color_mask.green_enabled ||
color_mask.blue_enabled != cur_state.color_mask.blue_enabled ||
color_mask.alpha_enabled != cur_state.color_mask.alpha_enabled) {
glColorMask(color_mask.red_enabled, color_mask.green_enabled,
color_mask.blue_enabled, color_mask.alpha_enabled);
}
// Stencil test
if (stencil.test_enabled != cur_state.stencil.test_enabled) {
if (stencil.test_enabled) {
glEnable(GL_STENCIL_TEST);
} else {
glDisable(GL_STENCIL_TEST);
}
}
if (stencil.test_func != cur_state.stencil.test_func ||
stencil.test_ref != cur_state.stencil.test_ref ||
stencil.test_mask != cur_state.stencil.test_mask) {
glStencilFunc(stencil.test_func, stencil.test_ref, stencil.test_mask);
}
if (stencil.action_depth_fail != cur_state.stencil.action_depth_fail ||
stencil.action_depth_pass != cur_state.stencil.action_depth_pass ||
stencil.action_stencil_fail != cur_state.stencil.action_stencil_fail) {
glStencilOp(stencil.action_stencil_fail, stencil.action_depth_fail, stencil.action_depth_pass);
}
// Stencil mask
if (stencil.write_mask != cur_state.stencil.write_mask) {
glStencilMask(stencil.write_mask);
}
// Blending
if (blend.enabled != cur_state.blend.enabled) {
if (blend.enabled) {
glEnable(GL_BLEND);
cur_state.logic_op = GL_COPY;
glLogicOp(cur_state.logic_op);
glDisable(GL_COLOR_LOGIC_OP);
} else {
glDisable(GL_BLEND);
glEnable(GL_COLOR_LOGIC_OP);
}
}
if (blend.color.red != cur_state.blend.color.red ||
blend.color.green != cur_state.blend.color.green ||
blend.color.blue != cur_state.blend.color.blue ||
blend.color.alpha != cur_state.blend.color.alpha) {
glBlendColor(blend.color.red, blend.color.green,
blend.color.blue, blend.color.alpha);
}
if (blend.src_rgb_func != cur_state.blend.src_rgb_func ||
blend.dst_rgb_func != cur_state.blend.dst_rgb_func ||
blend.src_a_func != cur_state.blend.src_a_func ||
blend.dst_a_func != cur_state.blend.dst_a_func) {
glBlendFuncSeparate(blend.src_rgb_func, blend.dst_rgb_func,
blend.src_a_func, blend.dst_a_func);
}
if (blend.rgb_equation != cur_state.blend.rgb_equation ||
blend.a_equation != cur_state.blend.a_equation) {
glBlendEquationSeparate(blend.rgb_equation, blend.a_equation);
}
if (logic_op != cur_state.logic_op) {
glLogicOp(logic_op);
}
// Textures
for (unsigned i = 0; i < ARRAY_SIZE(texture_units); ++i) {
if (texture_units[i].texture_2d != cur_state.texture_units[i].texture_2d) {
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, texture_units[i].texture_2d);
}
if (texture_units[i].sampler != cur_state.texture_units[i].sampler) {
glBindSampler(i, texture_units[i].sampler);
}
}
// Lighting LUTs
for (unsigned i = 0; i < ARRAY_SIZE(lighting_luts); ++i) {
if (lighting_luts[i].texture_1d != cur_state.lighting_luts[i].texture_1d) {
glActiveTexture(GL_TEXTURE3 + i);
glBindTexture(GL_TEXTURE_1D, lighting_luts[i].texture_1d);
}
}
// Fog LUT
if (fog_lut.texture_1d != cur_state.fog_lut.texture_1d) {
glActiveTexture(GL_TEXTURE9);
glBindTexture(GL_TEXTURE_1D, fog_lut.texture_1d);
}
// Framebuffer
if (draw.read_framebuffer != cur_state.draw.read_framebuffer) {
glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
}
if (draw.draw_framebuffer != cur_state.draw.draw_framebuffer) {
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw.draw_framebuffer);
}
// Vertex array
if (draw.vertex_array != cur_state.draw.vertex_array) {
glBindVertexArray(draw.vertex_array);
}
// Vertex buffer
if (draw.vertex_buffer != cur_state.draw.vertex_buffer) {
glBindBuffer(GL_ARRAY_BUFFER, draw.vertex_buffer);
}
// Uniform buffer
if (draw.uniform_buffer != cur_state.draw.uniform_buffer) {
glBindBuffer(GL_UNIFORM_BUFFER, draw.uniform_buffer);
}
// Shader program
if (draw.shader_program != cur_state.draw.shader_program) {
glUseProgram(draw.shader_program);
}
cur_state = *this;
}
void ofxSpriteRenderer::Render()
{
//printf("--------------RENDER--------------\n");
for(ofxBaseCommands::iterator it = m_Commands.begin();it != m_Commands.end();it++)
{
ofxBaseCommand* item = *it;
delete item;
}
m_Commands.clear();
//unsigned long long time_start_build = ofGetSystemTime();
sort(m_Sprites.begin(), m_Sprites.end(), QuadCompare);
for(int i=0;i<m_Sprites.size();i++)
{
m_Sprites[i]->SetID(i);
}
//unsigned long long time_finish_sort = ofGetSystemTime();
//printf("sort time = %llu\n", time_finish_sort - time_start_build);
bool is_custom_command = false;
for(ofxBaseSprites::iterator it = m_Sprites.begin();it != m_Sprites.end();it++)
{
ofxBaseSprite* sprite = *it;
if(!(sprite->GetOcclusion() == SPRITE_OCCLUSION_IN_SCREEN || sprite->GetOcclusion() == SPRITE_OCCLUSION_UNKNOWN) ||
!sprite->IsVisible())
{
continue;
}
if(sprite->IsCustomRendered())
{
ofxBaseCommand* command = (ofxBaseCommand*)sprite;
m_Commands.push_back(command);
is_custom_command = true;
continue;
}
ofxSpriteCommand* command;
if(m_Commands.size() == 0 || is_custom_command)
{
command = new ofxSpriteCommand();
command->SetShader(sprite->GetShader());
command->SetTexture(sprite->GetTexture());
bool push_success = command->PushSprite(sprite);
assert(push_success);
m_Commands.push_back(command);
is_custom_command = false;
}
else
{
command = (ofxSpriteCommand*)m_Commands.back();
bool push_success = command->PushSprite(sprite);
if(command->GetShader() != sprite->GetShader()
|| command->GetTexture() != sprite->GetTexture()
|| !push_success)
{
command = new ofxSpriteCommand();
command->SetShader(sprite->GetShader());
command->SetTexture(sprite->GetTexture());
push_success = command->PushSprite(sprite);
m_Commands.push_back(command);
assert(push_success);
}
}
}
//unsigned long long time_finish_build = ofGetSystemTime();
//printf("build time = %llu\n", time_finish_build - time_start_build);
#ifdef _DEBUG
m_DrawnBatches = 0;
m_DrawnVertices = 0;
unsigned long long time_start_render = ofGetSystemTime();
#endif
m_TransformMatrix = ofGetCurrentMatrix(OF_MATRIX_MODELVIEW)*ofGetCurrentMatrix(OF_MATRIX_PROJECTION);
//m_Camera->begin();
{
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
//glDisable(GL_DEPTH_TEST);// transparent isn't work well with depth test
glDepthMask(GL_FALSE);
for(ofxBaseCommands::iterator it = m_Commands.begin();it != m_Commands.end();it++)
{
ofxBaseCommand* cmd = *it;
cmd->Render();
#ifdef _DEBUG
m_DrawnBatches++;
m_DrawnVertices += cmd->GetRenderedVertices();
#endif
}
//glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
}
//m_Camera->end();
#ifdef _DEBUG
unsigned long long time_finish_render = ofGetSystemTime();
m_RenderTimeMilisecond = time_finish_render - time_start_render;
#endif
}
/*-----------------------------------------------------------------------------
Name : RenderNAVLights
Description : TODO: render sorted by projected depth value so alpha sorts correctly
Inputs : ship - the ship whose navlights we are to render
Outputs :
Return :
----------------------------------------------------------------------------*/
void RenderNAVLights(Ship *ship)
{
sdword i;
NAVLight *navLight;
NAVLightInfo *navLightInfo;
ShipStaticInfo *shipStaticInfo;
NAVLightStatic *navLightStatic;
vector origin = {0.0f, 0.0f, 0.0f};
NAVLightStaticInfo *navLightStaticInfo;
real32 fade;
bool lightOn;
extern bool bFade;
extern real32 meshFadeAlpha;
fade = bFade ? meshFadeAlpha : 1.0f;
shipStaticInfo = (ShipStaticInfo *)ship->staticinfo;
navLightInfo = ship->navLightInfo;
if(shipStaticInfo->navlightStaticInfo && navLightInfo != NULL)
{
glDepthMask(GL_FALSE);
rndAdditiveBlends(TRUE);
lightOn = rndLightingEnable(FALSE);
navLightStaticInfo = shipStaticInfo->navlightStaticInfo;
navLightStatic = navLightStaticInfo->navlightstatics;
navLight = navLightInfo->navLights;
for( i=0 ; i<navLightStaticInfo->numNAVLights ; i++, navLight ++, navLightStatic ++)
{
// Account for the startdelay.
if(navLight->lastTimeFlashed == navLightStatic->startdelay)
{
navLight->lastTimeFlashed = universe.totaltimeelapsed + navLightStatic->startdelay;
}
if(universe.totaltimeelapsed > navLight->lastTimeFlashed)
{
if(navLight->lightstate == 1)
{
navLight->lastTimeFlashed = universe.totaltimeelapsed + navLightStatic->flashrateoff;
}
else
{
navLight->lastTimeFlashed = universe.totaltimeelapsed + navLightStatic->flashrateon;
}
navLight->lightstate = 1 - navLight->lightstate;
}
if(navLight->lightstate)
{
if (ship->currentLOD <= (sdword)navLightStatic->minLOD)
{
navLightBillboardEnable(ship, navLightStatic);
if(navLightStatic->texturehandle == TR_InvalidHandle)
{
primCircleSolid3Fade(&origin, navLightStatic->size, 10, navLightStatic->color, fade);
}
else
{
primSolidTexture3Fade(&origin, navLightStatic->size, navLightStatic->color, navLightStatic->texturehandle, fade);
}
navLightBillboardDisable();
}
else
{
color tempColor;
tempColor = colRGB(colRed(navLightStatic->color) * 2 / 3,
colGreen(navLightStatic->color) * 2 / 3,
colBlue(navLightStatic->color) * 2 / 3);
rndTextureEnable(FALSE);
if (RGL)
{
if (glCapFastFeature(GL_BLEND))
{
rndAdditiveBlends(TRUE);
primPointSize3(&navLightStatic->position, 2.0f, tempColor);
}
else
{
primPointSize3(&navLightStatic->position, 1.0f, tempColor);
}
}
else
{
rndAdditiveBlends(TRUE);
glEnable(GL_POINT_SMOOTH);
primPointSize3Fade(&navLightStatic->position, 2.0f, tempColor, fade);
glDisable(GL_POINT_SMOOTH);
}
}
}
}
rndLightingEnable(lightOn);
rndAdditiveBlends(FALSE);
glDepthMask(GL_TRUE);
}
}
void WebGraphicsContext3DDefaultImpl::reshape(int width, int height)
{
m_cachedWidth = width;
m_cachedHeight = height;
makeContextCurrent();
GLenum target = GL_TEXTURE_2D;
if (!m_texture) {
// Generate the texture object
m_texture = createTextureObject(target);
// Generate the framebuffer object
glGenFramebuffersEXT(1, &m_fbo);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
m_boundFBO = m_fbo;
if (m_attributes.depth || m_attributes.stencil)
glGenRenderbuffersEXT(1, &m_depthStencilBuffer);
// Generate the multisample framebuffer object
if (m_attributes.antialias) {
glGenFramebuffersEXT(1, &m_multisampleFBO);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
m_boundFBO = m_multisampleFBO;
glGenRenderbuffersEXT(1, &m_multisampleColorBuffer);
if (m_attributes.depth || m_attributes.stencil)
glGenRenderbuffersEXT(1, &m_multisampleDepthStencilBuffer);
}
}
GLint internalColorFormat, colorFormat, internalDepthStencilFormat = 0;
if (m_attributes.alpha) {
internalColorFormat = GL_RGBA8;
colorFormat = GL_RGBA;
} else {
internalColorFormat = GL_RGB8;
colorFormat = GL_RGB;
}
if (m_attributes.stencil || m_attributes.depth) {
// We don't allow the logic where stencil is required and depth is not.
// See GraphicsContext3DInternal constructor.
if (m_attributes.stencil && m_attributes.depth)
internalDepthStencilFormat = GL_DEPTH24_STENCIL8_EXT;
else
internalDepthStencilFormat = GL_DEPTH_COMPONENT;
}
bool mustRestoreFBO = false;
// Resize multisampling FBO
if (m_attributes.antialias) {
GLint maxSampleCount;
glGetIntegerv(GL_MAX_SAMPLES_EXT, &maxSampleCount);
GLint sampleCount = std::min(8, maxSampleCount);
if (m_boundFBO != m_multisampleFBO) {
mustRestoreFBO = true;
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
}
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalColorFormat, width, height);
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_RENDERBUFFER_EXT, m_multisampleColorBuffer);
if (m_attributes.stencil || m_attributes.depth) {
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT, sampleCount, internalDepthStencilFormat, width, height);
if (m_attributes.stencil)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
if (m_attributes.depth)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_multisampleDepthStencilBuffer);
}
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("GraphicsContext3D: multisampling framebuffer was incomplete\n");
// FIXME: cleanup.
notImplemented();
}
}
// Resize regular FBO
if (m_boundFBO != m_fbo) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_fbo);
mustRestoreFBO = true;
}
glBindTexture(target, m_texture);
glTexImage2D(target, 0, internalColorFormat, width, height, 0, colorFormat, GL_UNSIGNED_BYTE, 0);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, target, m_texture, 0);
glBindTexture(target, 0);
if (!m_attributes.antialias && (m_attributes.stencil || m_attributes.depth)) {
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, internalDepthStencilFormat, width, height);
if (m_attributes.stencil)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_STENCIL_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
if (m_attributes.depth)
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, m_depthStencilBuffer);
glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
}
GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
printf("WebGraphicsContext3DDefaultImpl: framebuffer was incomplete\n");
// FIXME: cleanup.
notImplemented();
}
if (m_attributes.antialias) {
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_multisampleFBO);
if (m_boundFBO == m_multisampleFBO)
mustRestoreFBO = false;
}
// Initialize renderbuffers to 0.
GLboolean colorMask[] = {GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE}, depthMask = GL_TRUE, stencilMask = GL_TRUE;
GLboolean isScissorEnabled = GL_FALSE;
GLboolean isDitherEnabled = GL_FALSE;
GLbitfield clearMask = GL_COLOR_BUFFER_BIT;
glGetBooleanv(GL_COLOR_WRITEMASK, colorMask);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
if (m_attributes.depth) {
glGetBooleanv(GL_DEPTH_WRITEMASK, &depthMask);
glDepthMask(GL_TRUE);
clearMask |= GL_DEPTH_BUFFER_BIT;
}
if (m_attributes.stencil) {
glGetBooleanv(GL_STENCIL_WRITEMASK, &stencilMask);
glStencilMask(GL_TRUE);
clearMask |= GL_STENCIL_BUFFER_BIT;
}
isScissorEnabled = glIsEnabled(GL_SCISSOR_TEST);
glDisable(GL_SCISSOR_TEST);
isDitherEnabled = glIsEnabled(GL_DITHER);
glDisable(GL_DITHER);
glClear(clearMask);
glColorMask(colorMask[0], colorMask[1], colorMask[2], colorMask[3]);
if (m_attributes.depth)
glDepthMask(depthMask);
if (m_attributes.stencil)
glStencilMask(stencilMask);
if (isScissorEnabled)
glEnable(GL_SCISSOR_TEST);
else
glDisable(GL_SCISSOR_TEST);
if (isDitherEnabled)
glEnable(GL_DITHER);
else
glDisable(GL_DITHER);
if (mustRestoreFBO)
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, m_boundFBO);
#ifdef FLIP_FRAMEBUFFER_VERTICALLY
if (m_scanline) {
delete[] m_scanline;
m_scanline = 0;
}
m_scanline = new unsigned char[width * 4];
#endif // FLIP_FRAMEBUFFER_VERTICALLY
}
/*!****************************************************************************
@Function DoStencilTest
@Description Performs the Stencil test
******************************************************************************/
void OGLES2ShadowVolumes::DoStencilTest()
{
/*
For a detailed explanation on how to use the Stencil Buffer see the training course
Stencil Buffer.
*/
// Use the shader program that is used for the shadow volumes
glUseProgram(m_ShadowVolShader.uiId);
// Set the VolumeScale variable in the shader to say how much to extrude the volume by
glUniform1f(m_ShadowVolShader.auiLoc[eVolumeScale], 1000.0f);
const float afColor[] = { 0.4f, 1.0f, 0.0f, 0.2f };
glUniform4fv(m_ShadowVolShader.auiLoc[eColor], 1, afColor);
//If we want to display the shadow volumes don't disable the colour mask and enable blending
if(m_bDisplayVolumes)
{
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
else // Disable the colour mask so we don't draw to the colour buffer
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
// Disable writing to the depth buffer
glDepthMask(GL_FALSE);
// disable culling as we will want the front and back faces
glDisable(GL_CULL_FACE);
// Setup the stencil function
glStencilFunc(GL_ALWAYS, 1, 0xFFFFFFFF);
/*
Setup the stencil operations for front facing triangles and for the back facing triangles
Note:
We are using INCR_WRAP and DECR_WRAP since we are submitting the front and back faces
together so we won't be rendering all the INCR faces first. This way it stops the
stencil value getting clamped at 0 or the maximum possible value.
*/
glStencilOpSeparate(GL_FRONT, GL_KEEP, GL_KEEP, GL_INCR_WRAP);
glStencilOpSeparate(GL_BACK, GL_KEEP, GL_KEEP, GL_DECR_WRAP);
DrawShadowVolumes(&m_vLightPosWorld);
// Enable Culling as we would like it back
glEnable(GL_CULL_FACE);
// Set the stencil function so we only draw where the stencil buffer isn't 0
glStencilFunc(GL_NOTEQUAL, 0, 0xFFFFFFFF);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
// Enable writing to the depth buffer
glDepthMask(GL_TRUE);
// If we're displaying the volumes disable blending else enable the colour buffer
if(m_bDisplayVolumes)
glDisable(GL_BLEND);
else
#if defined(__PALMPDK__)
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE); // The alpha part is false as we don't want to blend with the video layer on the Palm Pre
#else
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
#endif
}
static void
redraw(void)
{
int i;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glRotatef(15.0, 1.0, 0.0, 0.0);
glRotatef(angle, 0.0, 1.0, 0.0);
glDepthMask(GL_FALSE);
/* Draw the floor. */
/* glEnable(GL_TEXTURE_2D);*/
glColor3f(0.1, 0.5, 1.0);
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0);
glVertex3f(-EDGE, -0.05, -EDGE);
glTexCoord2f(20.0, 0.0);
glVertex3f(EDGE, -0.05, -EDGE);
glTexCoord2f(20.0, 20.0);
glVertex3f(EDGE, -0.05, EDGE);
glTexCoord2f(0.0, 20.0);
glVertex3f(-EDGE, -0.05, EDGE);
glEnd();
/* Allow particles to blend with each other. */
glDepthMask(GL_TRUE);
if (blend)
glEnable(GL_BLEND);
if (sprite) {
glEnable(GL_TEXTURE_2D);
#ifdef GL_ARB_point_sprite
glEnable(GL_POINT_SPRITE_ARB);
#endif
}
glColor3f(1,1,1);
glBegin(GL_POINTS);
for (i=0; i<numPoints; i++) {
/* Draw alive particles. */
if (colorList[i] != DEAD) {
if (!sprite) glColor4fv(colorSet[colorList[i]]);
glVertex3fv(pointList[i]);
}
}
glEnd();
glDisable(GL_TEXTURE_2D);
#ifdef GL_ARB_point_sprite
glDisable(GL_POINT_SPRITE_ARB);
#endif
glDisable(GL_BLEND);
glPopMatrix();
glutSwapBuffers();
}
