void CWorldDrawer::Draw()
{
SCOPED_TIMER("WorldDrawer::Total");
CBaseGroundDrawer* gd = readmap->GetGroundDrawer();
if (globalRendering->drawSky) {
sky->Draw();
}
if (globalRendering->drawGround) {
SCOPED_TIMER("WorldDrawer::Terrain");
gd->Draw(DrawPass::Normal);
smoothHeightMeshDrawer->Draw(1.0f);
treeDrawer->DrawGrass();
gd->DrawTrees();
}
if (globalRendering->drawWater && !mapInfo->map.voidWater) {
SCOPED_TIMER("WorldDrawer::Water");
water->OcclusionQuery();
if (water->IsDrawSolid()) {
water->UpdateWater(game);
water->Draw();
}
}
selectedUnits.Draw();
eventHandler.DrawWorldPreUnit();
{
SCOPED_TIMER("WorldDrawer::Models");
DebugColVolDrawer::Draw();
unitDrawer->Draw(false);
modelDrawer->Draw();
featureDrawer->Draw();
pathDrawer->DrawAll();
}
//! transparent stuff
glEnable(GL_BLEND);
glDepthFunc(GL_LEQUAL);
const bool noAdvShading = shadowHandler->shadowsLoaded;
static const double plane_below[4] = {0.0f, -1.0f, 0.0f, 0.0f};
static const double plane_above[4] = {0.0f, 1.0f, 0.0f, 0.0f};
{
glClipPlane(GL_CLIP_PLANE3, plane_below);
glEnable(GL_CLIP_PLANE3);
//! draw cloaked objects below water surface
unitDrawer->DrawCloakedUnits(noAdvShading);
featureDrawer->DrawFadeFeatures(noAdvShading);
glDisable(GL_CLIP_PLANE3);
}
//! draw water
if (globalRendering->drawWater && !mapInfo->map.voidWater) {
SCOPED_TIMER("WorldDrawer::Water");
if (!water->IsDrawSolid()) {
//! Water rendering will overwrite features, so save them
featureDrawer->SwapFeatures();
water->UpdateWater(game);
water->Draw();
featureDrawer->SwapFeatures();
}
}
{
glClipPlane(GL_CLIP_PLANE3, plane_above);
glEnable(GL_CLIP_PLANE3);
//! draw cloaked objects above water surface
unitDrawer->DrawCloakedUnits(noAdvShading);
featureDrawer->DrawFadeFeatures(noAdvShading);
glDisable(GL_CLIP_PLANE3);
}
{
SCOPED_TIMER("WorldDrawer::Projectiles");
projectileDrawer->Draw(false);
}
if (globalRendering->drawSky) {
sky->DrawSun();
}
eventHandler.DrawWorld();
LuaUnsyncedCtrl::DrawUnitCommandQueues();
if (cmdColors.AlwaysDrawQueue() || guihandler->GetQueueKeystate()) {
selectedUnits.DrawCommands();
}
lineDrawer.DrawAll();
cursorIcons.Draw();
cursorIcons.Clear();
mouse->DrawSelectionBox();
guihandler->DrawMapStuff(false);
if (globalRendering->drawMapMarks && !game->hideInterface) {
inMapDrawerView->Draw();
}
//! underwater overlay
if (camera->pos.y < 0.0f) {
glEnableClientState(GL_VERTEX_ARRAY);
const float3& cpos = camera->pos;
const float vr = globalRendering->viewRange * 0.5f;
glDepthMask(GL_FALSE);
glDisable(GL_TEXTURE_2D);
glColor4f(0.0f, 0.5f, 0.3f, 0.50f);
{
float3 verts[] = {
float3(cpos.x - vr, 0.0f, cpos.z - vr),
float3(cpos.x - vr, 0.0f, cpos.z + vr),
float3(cpos.x + vr, 0.0f, cpos.z + vr),
float3(cpos.x + vr, 0.0f, cpos.z - vr)
};
glVertexPointer(3, GL_FLOAT, 0, verts);
glDrawArrays(GL_QUADS, 0, 4);
}
{
float3 verts[] = {
float3(cpos.x - vr, 0.0f, cpos.z - vr),
float3(cpos.x - vr, -vr, cpos.z - vr),
float3(cpos.x - vr, 0.0f, cpos.z + vr),
float3(cpos.x - vr, -vr, cpos.z + vr),
float3(cpos.x + vr, 0.0f, cpos.z + vr),
float3(cpos.x + vr, -vr, cpos.z + vr),
float3(cpos.x + vr, 0.0f, cpos.z - vr),
float3(cpos.x + vr, -vr, cpos.z - vr),
float3(cpos.x - vr, 0.0f, cpos.z - vr),
float3(cpos.x - vr, -vr, cpos.z - vr),
};
glVertexPointer(3, GL_FLOAT, 0, verts);
glDrawArrays(GL_QUAD_STRIP, 0, 10);
}
glDepthMask(GL_TRUE);
glDisableClientState(GL_VERTEX_ARRAY);
}
//reset fov
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,1,0,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// underwater overlay, part 2
if (camera->pos.y < 0.0f) {
glEnableClientState(GL_VERTEX_ARRAY);
glDisable(GL_TEXTURE_2D);
glColor4f(0.0f, 0.2f, 0.8f, 0.333f);
float3 verts[] = {
float3 (0.f, 0.f, -1.f),
float3 (1.f, 0.f, -1.f),
float3 (1.f, 1.f, -1.f),
float3 (0.f, 1.f, -1.f),
};
glVertexPointer(3, GL_FLOAT, 0, verts);
glDrawArrays(GL_QUADS, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
}
}
void CMiniMap::DrawButtons()
{
const int x = mouse->lastx;
const int y = mouse->lasty;
// update the showButtons state
if (!showButtons) {
if (mapBox.Inside(x, y) && (buttonSize > 0) && !globalRendering->dualScreenMode) {
showButtons = true;
} else {
return;
}
} else if (!mouseMove && !mouseResize &&
!mapBox.Inside(x, y) && !buttonBox.Inside(x, y)) {
showButtons = false;
return;
}
if (buttonsTexture) {
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, buttonsTexture);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
resizeBox.DrawTextureBox();
moveBox.DrawTextureBox();
maximizeBox.DrawTextureBox();
minimizeBox.DrawTextureBox();
glDisable(GL_TEXTURE_2D);
} else {
glColor4f(0.1f, 0.1f, 0.8f, 0.8f); resizeBox.DrawBox(); // blue
glColor4f(0.0f, 0.8f, 0.0f, 0.8f); moveBox.DrawBox(); // green
glColor4f(0.8f, 0.8f, 0.0f, 0.8f); maximizeBox.DrawBox(); // yellow
glColor4f(0.8f, 0.0f, 0.0f, 0.8f); minimizeBox.DrawBox(); // red
}
// highlight
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glColor4f(1.0f, 1.0f, 1.0f, 0.4f);
if (mouseResize || (!mouseMove && resizeBox.Inside(x, y))) {
if (!buttonsTexture) { glColor4f(0.3f, 0.4f, 1.0f, 0.9f); }
resizeBox.DrawBox();
}
else if (mouseMove || (!mouseResize && moveBox.Inside(x, y))) {
if (!buttonsTexture) { glColor4f(1.0f, 1.0f, 1.0f, 0.3f); }
moveBox.DrawBox();
}
else if (!mouseMove && !mouseResize) {
if (minimizeBox.Inside(x, y)) {
if (!buttonsTexture) { glColor4f(1.0f, 0.2f, 0.2f, 0.6f); }
minimizeBox.DrawBox();
} else if (maximizeBox.Inside(x, y)) {
if (!buttonsTexture) { glColor4f(1.0f, 1.0f, 1.0f, 0.3f); }
maximizeBox.DrawBox();
}
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// outline the button box
glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
glBegin(GL_LINE_LOOP);
glVertex2f(float(buttonBox.xmin - 1 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 2 - 0.5f) * globalRendering->pixelY);
glVertex2f(float(buttonBox.xmin - 1 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 2 + 0.5f) * globalRendering->pixelY);
glVertex2f(float(buttonBox.xmax + 2 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 2 + 0.5f) * globalRendering->pixelY);
glVertex2f(float(buttonBox.xmax + 2 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 2 - 0.5f) * globalRendering->pixelY);
glEnd();
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_LINE_LOOP);
glVertex2f(float(buttonBox.xmin - 0 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 3 - 0.5f) * globalRendering->pixelY);
glVertex2f(float(buttonBox.xmin - 0 - 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 1 + 0.5f) * globalRendering->pixelY);
glVertex2f(float(buttonBox.xmax + 1 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymax + 1 + 0.5f) * globalRendering->pixelY);
glVertex2f(float(buttonBox.xmax + 1 + 0.5f) * globalRendering->pixelX, 1.0f - float(buttonBox.ymin + 3 - 0.5f) * globalRendering->pixelY);
glEnd();
}
void intro_do(long t, long delta_time)
{
char errorText[MAX_ERROR_LENGTH + 1];
float ftime = 0.001f*(float)t;
float fdelta_time = 0.001f * (float)(delta_time);
GLuint textureID;
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
// Those are key-Press indicators. I only act on 0-to-1.
for (int i = 0; i < maxNumParameters; i++)
{
float destination_value = params.getParam(i, defaultParameters[i]);
interpolatedParameters[i] = expf(-2.5f*fdelta_time) * interpolatedParameters[i] +
(1.0f - expf(-2.5f*fdelta_time)) * destination_value;
}
// Update key press events.
for (int i = 0; i < NUM_KEYS; i++)
{
if (params.getParam(i, 0.0) > 0.5f) keyPressed[i]++;
else keyPressed[i] = 0;
}
// BPM => spike calculation
float BPS = BPM / 60.0f;
float jumpsPerSecond = BPS / 1.0f; // Jump on every fourth beat.
static float phase = 0.0f;
float jumpTime = (ftime * jumpsPerSecond) + phase;
jumpTime -= (float)floor(jumpTime);
if (keyPressed[41] == 1)
{
phase -= jumpTime;
jumpTime = 0.0f;
if (phase < 0.0f) phase += 1.0;
}
jumpTime = jumpTime * jumpTime;
// spike is between 0.0 and 1.0 depending on the position within whatever.
float spike = 0.5f * cosf(jumpTime * 3.1415926f * 1.5f) + 0.5f;
// blob is growing down from 1. after keypress
static float lastFTime = 0.f;
blob *= (float)exp(-(float)(ftime - lastFTime) * BLOB_FADE_SPEED);
lastFTime = ftime;
// Set the program uniforms
GLuint programID;
shaderManager.getProgramID(usedProgram[usedIndex], &programID, errorText);
glUseProgram(programID);
#if 1
GLuint loc = glGetUniformLocation(programID, "aspectRatio");
glUniform1f(loc, aspectRatio);
loc = glGetUniformLocation(programID, "time");
glUniform1f(loc, (float)(t * 0.001f));
// For now I am just sending the spike to the shader. I might need something better...
loc = glGetUniformLocation(programID, "spike");
glUniform1f(loc, spike);
loc = glGetUniformLocation(programID, "blob");
glUniform1f(loc, blob);
loc = glGetUniformLocation(programID, "knob1");
glUniform1f(loc, interpolatedParameters[14]);
loc = glGetUniformLocation(programID, "knob2");
glUniform1f(loc, interpolatedParameters[15]);
loc = glGetUniformLocation(programID, "knob3");
glUniform1f(loc, interpolatedParameters[16]);
loc = glGetUniformLocation(programID, "knob4");
glUniform1f(loc, interpolatedParameters[17]);
loc = glGetUniformLocation(programID, "knob5");
glUniform1f(loc, interpolatedParameters[18]);
loc = glGetUniformLocation(programID, "knob6");
glUniform1f(loc, interpolatedParameters[19]);
loc = glGetUniformLocation(programID, "knob7");
glUniform1f(loc, interpolatedParameters[20]);
loc = glGetUniformLocation(programID, "knob8");
glUniform1f(loc, interpolatedParameters[21]);
loc = glGetUniformLocation(programID, "knob9");
glUniform1f(loc, interpolatedParameters[22]);
loc = glGetUniformLocation(programID, "slider1");
glUniform1f(loc, interpolatedParameters[2]);
loc = glGetUniformLocation(programID, "slider2");
glUniform1f(loc, interpolatedParameters[3]);
loc = glGetUniformLocation(programID, "slider3");
glUniform1f(loc, interpolatedParameters[4]);
loc = glGetUniformLocation(programID, "slider4");
glUniform1f(loc, interpolatedParameters[5]);
loc = glGetUniformLocation(programID, "slider5");
glUniform1f(loc, interpolatedParameters[6]);
loc = glGetUniformLocation(programID, "slider6");
glUniform1f(loc, interpolatedParameters[8]);
loc = glGetUniformLocation(programID, "slider7");
glUniform1f(loc, interpolatedParameters[9]);
loc = glGetUniformLocation(programID, "slider8");
glUniform1f(loc, interpolatedParameters[12]);
loc = glGetUniformLocation(programID, "slider9");
glUniform1f(loc, interpolatedParameters[13]);
#endif
// Set texture identifiers
GLint texture_location;
texture_location = glGetUniformLocation(programID, "Noise3DTexture");
glUniform1i(texture_location, 0);
texture_location = glGetUniformLocation(programID, "DepthSensorTexture");
glUniform1i(texture_location, 1);
texture_location = glGetUniformLocation(programID, "BGTexture");
glUniform1i(texture_location, 2);
// render to larger offscreen texture
glActiveTexture(GL_TEXTURE2);
textureManager.getTextureID("hermaniak.tga", &textureID, errorText);
glBindTexture(GL_TEXTURE_2D, textureID);
glActiveTexture(GL_TEXTURE1);
//textureManager.getTextureID(TM_DEPTH_SENSOR_NAME, &textureID, errorText);
glBindTexture(GL_TEXTURE_2D, textureID);
glActiveTexture(GL_TEXTURE0);
textureManager.getTextureID(TM_NOISE3D_NAME, &textureID, errorText);
glBindTexture(GL_TEXTURE_3D, textureID);
#if 1
glViewport(0, 0, X_HIGHLIGHT, Y_HIGHLIGHT);
#endif
// TODO: Here is the rendering done!
interpolatedParameters[6] = 0.4f;
shaderManager.getProgramID("SimpleTexture.gprg", &programID, errorText);
glUseProgram(programID);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
//glDisable(GL_BLEND);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendFunc(GL_DST_COLOR, GL_ZERO);
// Texture for first pass is simply black
textureManager.getTextureID("black.tga", &textureID, errorText);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureID);
const int num_passes = 4;
// TODO: Make the first 1 or 2 passes to the smaller backbuffer
for (int pass = 0; pass < num_passes; pass++) {
// Set small
// In the first pass, use highlight
if (pass < num_passes - 3) {
glViewport(0, 0, X_HIGHLIGHT, Y_HIGHLIGHT);
} else if (pass < num_passes - 1) {
glViewport(0, 0, X_OFFSCREEN, Y_OFFSCREEN);
} else {
// Set the whole screen as viewport so that it is used in the last pass
int xres = windowRect.right - windowRect.left;
int yres = windowRect.bottom - windowRect.top;
glViewport(0, 0, xres, yres);
}
float red = 1.0f;
float green = 1.0f;
float blue = 1.0f;
glClearColor(red, green, blue, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Draw one iteration of the IFS
float transformation[2][3];
for (int i = 0; i < 20; i++) {
transformation[0][0] = 0.5f * sinf(ftime * 0.133f + 0.3f + 1.3f * i) * sinf(ftime * 0.051f + 2.8f + 4.2f * i);
transformation[0][1] = 0.5f * sinf(ftime * 0.051f + 2.8f + 4.2f * i) * sinf(ftime * 0.087f + 4.1f + 2.3f * i);
transformation[0][2] = 0.6f * sinf(ftime * 0.087f + 4.1f + 2.3f * i) * sinf(ftime * 0.077f + 3.2f + 6.1f * i);
transformation[1][0] = 0.5f * sinf(ftime * 0.077f + 3.2f + 6.1f * i) * sinf(ftime * 0.028f + 7.1f + 1.9f * i);
transformation[1][1] = 0.5f * sinf(ftime * 0.028f + 7.1f + 1.9f * i) * sinf(ftime * 0.095f + 2.3f + 0.7f * i);
transformation[1][2] = 0.6f * sinf(ftime * 0.095f + 2.3f + 0.7f * i) * sinf(ftime * 0.133f + 0.3f + 1.3f * i);
DrawQuad(transformation, 1.0f);
}
// Copy backbuffer to texture
if (pass < num_passes - 3) {
textureManager.getTextureID(TM_HIGHLIGHT_NAME, &textureID, errorText);
glBindTexture(GL_TEXTURE_2D, textureID);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, X_HIGHLIGHT, Y_HIGHLIGHT);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureID);
} else if (pass < num_passes - 1) {
textureManager.getTextureID(TM_OFFSCREEN_NAME, &textureID, errorText);
glBindTexture(GL_TEXTURE_2D, textureID);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, X_OFFSCREEN, Y_OFFSCREEN);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureID);
}
}
#if 0
// Copy backbuffer to front (so far no improvement)
int xres = windowRect.right - windowRect.left;
int yres = windowRect.bottom - windowRect.top;
glViewport(0, 0, xres, yres);
shaderManager.getProgramID("SimpleTexture.gprg", &programID, errorText);
glUseProgram(programID);
loc = glGetUniformLocation(programID, "time");
glUniform1f(loc, (float)(t * 0.001f));
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glDisable(GL_BLEND);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex2f(-1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex2f(1.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex2f(1.0f, 1.0f);
glTexCoord2f(0.0f, 1.0f);
glVertex2f(-1.0f, 1.0f);
glEnd();
#endif
}
int main(int argc, char *argv[])
{
// initialize sdl
int init_flags = SDL_INIT_VIDEO | SDL_INIT_TIMER;
int sdl_flags = SDL_OPENGL;// | SDL_FULLSCREEN;
if (SDL_Init(init_flags) != 0)
{
fprintf(stderr, "Error initializing SDL: %s\n", SDL_GetError());
return 1;
}
atexit(SDL_Quit);
SDL_EnableKeyRepeat(0, 0);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_Surface *screen = SDL_SetVideoMode(640, 480, 16, sdl_flags);
// initialize opengl
glEnable(GL_TEXTURE_2D);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glViewport(0, 0, 640, 480);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0f, 1.0f, 1.0f, 0.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// load images
const char * img_file = "vw_topview.png";
const char * bg_file = "400px-Trollface.jpg";
GLuint car = safeImgLoad(img_file);
GLuint bg = safeImgLoad(bg_file);
//create world
Car a;
// start main loop
SDL_Event event;
char * keyname;
int i = 0;
while(true)
{
glClear(GL_COLOR_BUFFER_BIT);
//printf("%lf, %lf, %lf\n", a.location.x, a.location.y, a.direction);
drawScene(a, car, bg);
SDL_GL_SwapBuffers();
SDL_Delay(50);
while(SDL_PollEvent(&event) == 1)
{
switch(event.type)
{
case SDL_KEYDOWN:
switch(event.key.keysym.sym)
{
case SDLK_q:
exit(0);
break;
case SDLK_a:
a.wheel(-1.5);
break;
case SDLK_d:
a.wheel(1.5);
break;
default:
keyname = SDL_GetKeyName(event.key.keysym.sym);
printf("key pressed: %s\n", keyname);
}
break;
case SDL_KEYUP:
switch(event.key.keysym.sym)
{
case SDLK_a:
a.wheel(0.0);
break;
case SDLK_d:
a.wheel(0.0);
break;
default:
keyname = SDL_GetKeyName(event.key.keysym.sym);
printf("key released: %s\n", keyname);
}
break;
default:
printf("other event\n");
}
}
for (int n = 0; n < 10; n++)
a.move(.005);
i++;
}
}
void IrrDriver::renderGLSL(float dt)
{
World *world = World::getWorld(); // Never NULL.
// Overrides
video::SOverrideMaterial &overridemat = m_video_driver->getOverrideMaterial();
overridemat.EnablePasses = scene::ESNRP_SOLID | scene::ESNRP_TRANSPARENT;
overridemat.EnableFlags = 0;
if (m_wireframe)
{
overridemat.Material.Wireframe = 1;
overridemat.EnableFlags |= video::EMF_WIREFRAME;
}
if (m_mipviz)
{
overridemat.Material.MaterialType = m_shaders->getShader(ES_MIPVIZ);
overridemat.EnableFlags |= video::EMF_MATERIAL_TYPE;
overridemat.EnablePasses = scene::ESNRP_SOLID;
}
// Get a list of all glowing things. The driver's list contains the static ones,
// here we add items, as they may disappear each frame.
std::vector<GlowData> glows = m_glowing;
std::vector<GlowNode *> transparent_glow_nodes;
ItemManager * const items = ItemManager::get();
const u32 itemcount = items->getNumberOfItems();
u32 i;
// For each static node, give it a glow representation
const u32 staticglows = glows.size();
for (i = 0; i < staticglows; i++)
{
scene::ISceneNode * const node = glows[i].node;
const float radius = (node->getBoundingBox().getExtent().getLength() / 2) * 2.0f;
GlowNode * const repnode = new GlowNode(irr_driver->getSceneManager(), radius);
repnode->setPosition(node->getTransformedBoundingBox().getCenter());
transparent_glow_nodes.push_back(repnode);
}
for (i = 0; i < itemcount; i++)
{
Item * const item = items->getItem(i);
if (!item) continue;
const Item::ItemType type = item->getType();
if (type != Item::ITEM_NITRO_BIG && type != Item::ITEM_NITRO_SMALL &&
type != Item::ITEM_BONUS_BOX && type != Item::ITEM_BANANA && type != Item::ITEM_BUBBLEGUM)
continue;
LODNode * const lod = (LODNode *) item->getSceneNode();
if (!lod->isVisible()) continue;
const int level = lod->getLevel();
if (level < 0) continue;
scene::ISceneNode * const node = lod->getAllNodes()[level];
node->updateAbsolutePosition();
GlowData dat;
dat.node = node;
dat.r = 1.0f;
dat.g = 1.0f;
dat.b = 1.0f;
const video::SColorf &c = ItemManager::getGlowColor(type);
dat.r = c.getRed();
dat.g = c.getGreen();
dat.b = c.getBlue();
glows.push_back(dat);
// Push back its representation too
const float radius = (node->getBoundingBox().getExtent().getLength() / 2) * 2.0f;
GlowNode * const repnode = new GlowNode(irr_driver->getSceneManager(), radius);
repnode->setPosition(node->getTransformedBoundingBox().getCenter());
transparent_glow_nodes.push_back(repnode);
}
// Start the RTT for post-processing.
// We do this before beginScene() because we want to capture the glClear()
// because of tracks that do not have skyboxes (generally add-on tracks)
m_post_processing->begin();
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false);
m_video_driver->beginScene(/*backBuffer clear*/ true, /*zBuffer*/ true,
world->getClearColor());
// Clear normal and depth to zero
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_NORMAL_AND_DEPTH), true, false, video::SColor(0,0,0,0));
irr_driver->getVideoDriver()->enableMaterial2D();
RaceGUIBase *rg = world->getRaceGUI();
if (rg) rg->update(dt);
for(unsigned int cam = 0; cam < Camera::getNumCameras(); cam++)
{
Camera * const camera = Camera::getCamera(cam);
scene::ICameraSceneNode * const camnode = camera->getCameraSceneNode();
#ifdef ENABLE_PROFILER
std::ostringstream oss;
oss << "drawAll() for kart " << cam << std::flush;
PROFILER_PUSH_CPU_MARKER(oss.str().c_str(), (cam+1)*60,
0x00, 0x00);
#endif
camera->activate();
rg->preRenderCallback(camera); // adjusts start referee
const u32 bgnodes = m_background.size();
/* if (bgnodes)
{
// If there are background nodes (3d skybox), draw them now.
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false);
m_renderpass = scene::ESNRP_SKY_BOX;
m_scene_manager->drawAll(m_renderpass);
const video::SOverrideMaterial prev = overridemat;
overridemat.Enabled = 1;
overridemat.EnableFlags = video::EMF_MATERIAL_TYPE;
overridemat.Material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
for (i = 0; i < bgnodes; i++)
{
m_background[i]->setPosition(camnode->getPosition() * 0.97f);
m_background[i]->updateAbsolutePosition();
m_background[i]->render();
}
overridemat = prev;
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, true);
}*/
// Fire up the MRT
irr_driver->getVideoDriver()->setRenderTarget(irr_driver->getRTT(RTT_NORMAL_AND_DEPTH), false, false);
PROFILER_PUSH_CPU_MARKER("- Solid Pass 1", 0xFF, 0x00, 0x00);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID;
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
irr_driver->setPhase(SOLID_NORMAL_AND_DEPTH_PASS);
m_scene_manager->drawAll(m_renderpass);
irr_driver->setProjMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_PROJECTION));
irr_driver->setViewMatrix(irr_driver->getVideoDriver()->getTransform(video::ETS_VIEW));
irr_driver->genProjViewMatrix();
PROFILER_POP_CPU_MARKER();
// Todo : reenable glow and shadows
//ShadowImportanceProvider * const sicb = (ShadowImportanceProvider *)
// irr_driver->getCallback(ES_SHADOW_IMPORTANCE);
//sicb->updateIPVMatrix();
// Used to cull glowing items & lights
const core::aabbox3df cambox = camnode->getViewFrustum()->getBoundingBox();
PROFILER_PUSH_CPU_MARKER("- Shadow", 0x30, 0x6F, 0x90);
// Shadows
if (!m_mipviz && !m_wireframe && UserConfigParams::m_shadows)
//&& World::getWorld()->getTrack()->hasShadows())
{
renderShadows(camnode, camera);
}
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Light", 0x00, 0xFF, 0x00);
// Lights
renderLights(cambox, camnode, overridemat, cam, dt);
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Solid Pass 2", 0x00, 0x00, 0xFF);
irr_driver->setPhase(SOLID_LIT_PASS);
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_BLEND);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_SOLID;
m_scene_manager->drawAll(m_renderpass);
PROFILER_POP_CPU_MARKER();
if (World::getWorld()->getTrack()->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
m_post_processing->renderFog(irr_driver->getInvProjMatrix());
PROFILER_POP_CPU_MARKER();
}
PROFILER_PUSH_CPU_MARKER("- Glow", 0xFF, 0xFF, 0x00);
// Render anything glowing.
if (!m_mipviz && !m_wireframe)
{
irr_driver->setPhase(GLOW_PASS);
renderGlow(overridemat, glows, cambox, cam);
} // end glow
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Skybox", 0xFF, 0x00, 0xFF);
renderSkybox();
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Lensflare/godray", 0x00, 0xFF, 0xFF);
// Is the lens flare enabled & visible? Check last frame's query.
const bool hasflare = World::getWorld()->getTrack()->hasLensFlare();
const bool hasgodrays = World::getWorld()->getTrack()->hasGodRays();
if (true)//hasflare || hasgodrays)
{
irr::video::COpenGLDriver* gl_driver = (irr::video::COpenGLDriver*)m_device->getVideoDriver();
GLuint res = 0;
if (m_query_issued)
gl_driver->extGlGetQueryObjectuiv(m_lensflare_query, GL_QUERY_RESULT, &res);
m_post_processing->setSunPixels(res);
// Prepare the query for the next frame.
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
gl_driver->extGlBeginQuery(GL_SAMPLES_PASSED_ARB, m_lensflare_query);
m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID);
m_scene_manager->drawAll(scene::ESNRP_CAMERA);
irr_driver->setPhase(GLOW_PASS);
m_sun_interposer->render();
gl_driver->extGlEndQuery(GL_SAMPLES_PASSED_ARB);
m_query_issued = true;
m_lensflare->setStrength(res / 4000.0f);
if (hasflare)
m_lensflare->OnRegisterSceneNode();
// Make sure the color mask is reset
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
}
PROFILER_POP_CPU_MARKER();
// We need to re-render camera due to the per-cam-node hack.
PROFILER_PUSH_CPU_MARKER("- Transparent Pass", 0xFF, 0x00, 0x00);
irr_driver->setPhase(TRANSPARENT_PASS);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT;
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
m_scene_manager->drawAll(m_renderpass);
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Particles", 0xFF, 0xFF, 0x00);
m_renderpass = scene::ESNRP_CAMERA | scene::ESNRP_TRANSPARENT_EFFECT;
glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
m_scene_manager->drawAll(m_renderpass);
PROFILER_POP_CPU_MARKER();
PROFILER_PUSH_CPU_MARKER("- Displacement", 0x00, 0x00, 0xFF);
// Handle displacing nodes, if any
const u32 displacingcount = m_displacing.size();
if (displacingcount)
{
renderDisplacement(overridemat, cam);
}
PROFILER_POP_CPU_MARKER();
// Drawing for this cam done, cleanup
const u32 glowrepcount = transparent_glow_nodes.size();
for (i = 0; i < glowrepcount; i++)
{
transparent_glow_nodes[i]->remove();
transparent_glow_nodes[i]->drop();
}
PROFILER_POP_CPU_MARKER();
// Note that drawAll must be called before rendering
// the bullet debug view, since otherwise the camera
// is not set up properly. This is only used for
// the bullet debug view.
if (UserConfigParams::m_artist_debug_mode)
World::getWorld()->getPhysics()->draw();
} // for i<world->getNumKarts()
PROFILER_PUSH_CPU_MARKER("Postprocessing", 0xFF, 0xFF, 0x00);
// Render the post-processed scene
m_post_processing->render();
PROFILER_POP_CPU_MARKER();
// Set the viewport back to the full screen for race gui
m_video_driver->setViewPort(core::recti(0, 0,
UserConfigParams::m_width,
UserConfigParams::m_height));
for(unsigned int i=0; i<Camera::getNumCameras(); i++)
{
Camera *camera = Camera::getCamera(i);
char marker_name[100];
sprintf(marker_name, "renderPlayerView() for kart %d", i);
PROFILER_PUSH_CPU_MARKER(marker_name, 0x00, 0x00, (i+1)*60);
rg->renderPlayerView(camera, dt);
PROFILER_POP_CPU_MARKER();
} // for i<getNumKarts
PROFILER_PUSH_CPU_MARKER("GUIEngine", 0x75, 0x75, 0x75);
// Either render the gui, or the global elements of the race gui.
GUIEngine::render(dt);
PROFILER_POP_CPU_MARKER();
// Render the profiler
if(UserConfigParams::m_profiler_enabled)
{
PROFILER_DRAW();
}
#ifdef DEBUG
drawDebugMeshes();
#endif
PROFILER_PUSH_CPU_MARKER("EndSccene", 0x45, 0x75, 0x45);
m_video_driver->endScene();
PROFILER_POP_CPU_MARKER();
getPostProcessing()->update(dt);
}
void App::Run() {
SDL_Init(SDL_INIT_EVERYTHING);
Engine::Get().Resize(Engine::Get().getWindowWidth(), Engine::Get().getWindowHeigth());
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
glClearColor(0.3, 0.66, 0.89, 0);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
const std::string atlas_filename = "data/tex.png";
Engine& engine = Engine::Get();
engine.Load();
engine.getRenderer()->LoadTexture(atlas_filename);
if (Engine::Get().getPlayerSprite() == PT::Ninja) {
m_player->setSprites(SpritePtr(new Sprite(engine.getSpriteConfig()->Get("ninja_right"))),
SpritePtr(new Sprite(engine.getSpriteConfig()->Get("ninja_left"))),
SpritePtr(new Sprite(engine.getSpriteConfig()->Get("ninja_stop"))));
}
else if (Engine::Get().getPlayerSprite() == PT::Samurai) {
m_player->setSprites(SpritePtr(new Sprite(engine.getSpriteConfig()->Get("samurai_right"))),
SpritePtr(new Sprite(engine.getSpriteConfig()->Get("samurai_left"))),
SpritePtr(new Sprite(engine.getSpriteConfig()->Get("samurai_stop"))));
}
in_game = true;
size_t last_ticks = SDL_GetTicks();
Engine::Get().setGameState(GS::Menu);
while (Engine::Get().getState() != GS::Quit) {
switch (Engine::Get().getState()) {
case GS::InGame:
ProcessEvents();
break;
case GS::HallOfFame:
if (!m_hall_of_fame->isActual())
m_hall_of_fame.reset(new HallOfFame());
m_hall_of_fame->proccessEvents();
break;
case GS::ScoreSubmit:
m_score_submit->ProcessEvents();
break;
case GS::Menu:
m_menu->ProcessEvents();
break;
case GS::Options:
m_options->processEvents();
}
size_t ticks = SDL_GetTicks();
delta_time = (ticks - last_ticks) / (CLOCKS_PER_SEC/10.0);
if ((delta_time*(CLOCKS_PER_SEC / 10.0)) < ((CLOCKS_PER_SEC / 10.0) / Engine::Get().fps))
SDL_Delay(((CLOCKS_PER_SEC / 10.0) / Engine::Get().fps) - (delta_time*(CLOCKS_PER_SEC / 10.0)));
delta_time = ((CLOCKS_PER_SEC / 10.0) / Engine::Get().fps)/ (CLOCKS_PER_SEC / 10.0);
last_ticks = ticks;
switch (Engine::Get().getState()) {
case GS::InGame:
if (delta_time > 0.0) {
Update(delta_time);
}
Draw();
break;
case GS::HallOfFame:
m_hall_of_fame->draw();
break;
case GS::ScoreSubmit:
m_score_submit->Draw();
break;
case GS::Menu:
m_menu->Draw();
break;
case GS::Options:
m_options->draw();
break;
}
}
SDL_Quit();
}
int main()
{
float retinaScale = 1.f;
b3gDefaultOpenGLWindow* window = new b3gDefaultOpenGLWindow();
b3gWindowConstructionInfo wci;
wci.m_width = sWidth;
wci.m_height = sHeight;
window->createWindow(wci);
window->setResizeCallback(MyResizeCallback);
window->setWindowTitle("render test");
#ifndef __APPLE__
glewInit();
#endif
retinaScale = window->getRetinaScale();
primRenderer = new GLPrimitiveRenderer(sWidth,sHeight);
sth_stash* font = initFont(primRenderer );
gwenRenderer = new GwenOpenGL3CoreRenderer(primRenderer,font,sWidth,sHeight,retinaScale);
//
// Create a GWEN OpenGL Renderer
//
// Gwen::Renderer::OpenGL_DebugFont * pRenderer = new Gwen::Renderer::OpenGL_DebugFont();
//
// Create a GWEN skin
//
#ifdef USE_TEXTURED_SKIN
Gwen::Skin::TexturedBase skin;
skin.SetRender( pRenderer );
skin.Init("DefaultSkin.png");
#else
Gwen::Skin::Simple skin;
skin.SetRender( gwenRenderer );
#endif
//
// Create a Canvas (it's root, on which all other GWEN panels are created)
//
pCanvas = new Gwen::Controls::Canvas( &skin );
pCanvas->SetSize( sWidth, sHeight);
pCanvas->SetDrawBackground( true );
pCanvas->SetBackgroundColor( Gwen::Color( 150, 170, 170, 255 ) );
window->setMouseButtonCallback(MyMouseButtonCallback);
window->setMouseMoveCallback(MyMouseMoveCallback);
//
// Create our unittest control (which is a Window with controls in it)
//
UnitTest* pUnit = new UnitTest( pCanvas );
pUnit->SetPos( 10, 10 );
//
// Create a Windows Control helper
// (Processes Windows MSG's and fires input at GWEN)
//
//Gwen::Input::Windows GwenInput;
//GwenInput.Initialize( pCanvas );
//
// Begin the main game loop
//
// MSG msg;
while( !window->requestedExit() )
{
// Skip out if the window is closed
//if ( !IsWindowVisible( g_pHWND ) )
//break;
// If we have a message from windows..
// if ( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
{
// .. give it to the input handler to process
// GwenInput.ProcessMessage( msg );
// if it's QUIT then quit..
// if ( msg.message == WM_QUIT )
// break;
// Handle the regular window stuff..
// TranslateMessage(&msg);
// DispatchMessage(&msg);
}
window->startRendering();
// Main OpenGL Render Loop
{
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glEnable(GL_BLEND);
GLint err = glGetError();
assert(err==GL_NO_ERROR);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glDisable(GL_DEPTH_TEST);
err = glGetError();
assert(err==GL_NO_ERROR);
//glColor4ub(255,0,0,255);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
// saveOpenGLState(width,height);//m_glutScreenWidth,m_glutScreenHeight);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
err = glGetError();
assert(err==GL_NO_ERROR);
err = glGetError();
assert(err==GL_NO_ERROR);
glEnable(GL_BLEND);
err = glGetError();
assert(err==GL_NO_ERROR);
pCanvas->RenderCanvas();
// SwapBuffers( GetDC( g_pHWND ) );
}
window->endRendering();
}
window->closeWindow();
delete window;
}
void ParticleSystem::drawHighlight()
{
/*
// just draw points:
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glColor4f(1,1,1,1);
glBegin(GL_POINTS);
for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) {
glVertex3fv(it->tpos);
}
glEnd();
glEnable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
*/
Vec3D bv0, bv1, bv2, bv3;
// setup blend mode
switch (blend) {
case 0:
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
break;
case 1:
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_COLOR, GL_ONE);
glDisable(GL_ALPHA_TEST);
break;
case 2:
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_ALPHA_TEST);
break;
case 3:
glDisable(GL_BLEND);
glEnable(GL_ALPHA_TEST);
break;
case 4:
glEnable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
break;
}
glDisable(GL_LIGHTING);
glDisable(GL_CULL_FACE);
glDepthMask(GL_FALSE);
// glPushName(texture);
_texture->bind();
Matrix mbb;
mbb.unit();
ModelHighlight(Vec4D(1.00, 0.25, 0.25, 0.50));
if (billboard) {
// get a billboard matrix
Matrix mtrans;
glGetFloatv(GL_MODELVIEW_MATRIX, &(mtrans.m[0][0]));
mtrans.transpose();
mtrans.invert();
Vec3D camera = mtrans * Vec3D(0, 0, 0);
Vec3D look = (camera - pos).normalize();
Vec3D up = ((mtrans * Vec3D(0, 1, 0)) - camera).normalize();
Vec3D right = (up % look).normalize();
up = (look % right).normalize();
// calculate the billboard matrix
mbb.m[0][1] = right.x;
mbb.m[1][1] = right.y;
mbb.m[2][1] = right.z;
mbb.m[0][2] = up.x;
mbb.m[1][2] = up.y;
mbb.m[2][2] = up.z;
mbb.m[0][0] = look.x;
mbb.m[1][0] = look.y;
mbb.m[2][0] = look.z;
}
if (type == 0 || type == 2) {
//! \todo figure out type 2 (deeprun tram subway sign)
// - doesn't seem to be any different from 0 -_-
// regular particles
float f = 0.707106781f; // sqrt(2)/2
if (billboard) {
bv0 = mbb * Vec3D(0, -f, +f);
bv1 = mbb * Vec3D(0, +f, +f);
bv2 = mbb * Vec3D(0, +f, -f);
bv3 = mbb * Vec3D(0, -f, -f);
}
else {
bv0 = Vec3D(-f, 0, +f);
bv1 = Vec3D(+f, 0, +f);
bv2 = Vec3D(+f, 0, -f);
bv3 = Vec3D(-f, 0, -f);
}
//! \todo per-particle rotation in a non-expensive way?? :|
glBegin(GL_QUADS);
for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) {
//glColor4fv(it->color);
glColor4f(1.0f, 0.25f, 0.25f, it->color.w*0.5f);
glTexCoord2fv(tiles[it->tile].tc[0]);
glVertex3fv(it->pos + bv0 * it->size);
glTexCoord2fv(tiles[it->tile].tc[1]);
glVertex3fv(it->pos + bv1 * it->size);
glTexCoord2fv(tiles[it->tile].tc[2]);
glVertex3fv(it->pos + bv2 * it->size);
glTexCoord2fv(tiles[it->tile].tc[3]);
glVertex3fv(it->pos + bv3 * it->size);
}
glEnd();
}
else if (type == 1) {
// particles from origin to position
bv0 = mbb * Vec3D(0, -1.0f, 0);
bv1 = mbb * Vec3D(0, +1.0f, 0);
glBegin(GL_QUADS);
for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) {
glColor4fv(it->color);
glTexCoord2fv(tiles[it->tile].tc[0]);
glVertex3fv(it->pos + bv0 * it->size);
glTexCoord2fv(tiles[it->tile].tc[1]);
glVertex3fv(it->pos + bv1 * it->size);
glTexCoord2fv(tiles[it->tile].tc[2]);
glVertex3fv(it->origin + bv1 * it->size);
glTexCoord2fv(tiles[it->tile].tc[3]);
glVertex3fv(it->origin + bv0 * it->size);
}
glEnd();
}
ModelUnhighlight();
glEnable(GL_LIGHTING);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDepthMask(GL_TRUE);
glColor4f(1, 1, 1, 1);
// glPopName();
}
void display(void)
{
curTime = timeGetTime();
float dt = (float)(curTime - lastTime) * 0.001;//secに変換
elapseTime1 += dt;
elapseTime2 += dt;
fps ++;
if(elapseTime1 >= 1.0)
{
printf("frame per sec = %d \n", fps);
elapseTime1 = 0.0;
fps = 0;
}
lastTime = curTime;
//カラーバッファ,デプスバッファのクリア
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();//視点を変えるときはこの位置に必要
if(cos(M_PI * view.theta /180.0) >= 0.0)//カメラ仰角90度でﾋﾞｭｰｱｯﾌﾟﾍﾞｸﾄﾙ切替
gluLookAt(view.pos[0], view.pos[1], view.pos[2], view.cnt[0], view.cnt[1], view.cnt[2], 0.0, 1.0, 0.0);
else
gluLookAt(view.pos[0], view.pos[1], view.pos[2], view.cnt[0], view.cnt[1], view.cnt[2], 0.0, -1.0, 0.0);
//光源設定//'l'を押した後光源位置可変
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
if(flagWireframe)//'w'でwireframeとsolid model切り替え
{
glPolygonMode(GL_FRONT,GL_LINE);
glPolygonMode(GL_BACK,GL_POINT);
}
else glPolygonMode(GL_FRONT_AND_BACK,GL_FILL);
//描画
// シェーダプログラムの適用
glUseProgram(shaderProg);
//テクスチャユニットをシェーダ側のサンプラに関連付け,レンダリング
//fragment shaderのユニフォーム変数texのインデックスを取得
GLint texLoc = glGetUniformLocation(shaderProg, "tex");
glUniform1i(texLoc, 0);//GL_TEXTURE0を適用
drawTerrain();
// シェーダプログラムの適用を解除
glUseProgram(0);
drawParticle(dt);
drawParticle2(dt);
//ﾃｸｽﾁｬ、半透明物体があるとき
glDepthMask(GL_FALSE); //ﾃﾞﾌﾟｽﾊﾞｯﾌｧを書き込み禁止
glEnable(GL_BLEND);//ｱﾙﾌｧﾌﾞﾚﾝﾃﾞｨﾝｸﾞを有効にする
glBlendFunc(GL_DST_ALPHA,GL_ONE_MINUS_SRC_ALPHA);//色混合係数を決める
//半透明描画
makeRiver(elapseTime2);
drawRiver();
//ﾃｸｽﾁｬ、半透明物体があるとき
glDepthMask(GL_TRUE); //ﾃﾞﾌﾟｽﾊﾞｯﾌｧの書き込みを許可
glDisable(GL_BLEND);
if(flagHelp)
{
printf("矢印キーによるアフィン変換/光源移動 \n");
printf(" →,←：x軸 \n");
printf(" ↑,↓：y軸 \n");
printf(" [Shift]＋↑,↓：z軸 \n");
printf(" 'r'を押した後:回転 \n");
printf(" 't'を押した後:平行移動 \n");
printf(" 's'を押した後:ｽｹｰﾘﾝｸﾞ \n");
printf(" 'l'を押した後、光源位置の移動可 \n");
printf("'w'でﾜｲﾔｰﾌﾚｰﾑとｿﾘｯﾄﾞﾓﾃﾞﾙ切り替え \n");
printf("マウス操作で視点変更可 \n");
printf(" dolly：中央付近を左ボタンクリックで近づき，右ボタンクリックで遠ざかる \n");
printf(" pan：左横および右横を右ボタンクリックで注視点が左右に変化する \n");
printf(" tilt：真上および真下を右ボタンクリックで注視点が上下に変化する \n");
printf(" tumble：左右にドラッグすると視点が左右に変化する \n");
printf(" crane：上下にドラッグすると視点が上下に変化する \n");
printf(" zoom：左下を右ボタンクリックでズームイン \n");
printf(" 右下を右ボタンクリックでズームアウト \n");
printf("[Shift]+'r'でリセット \n");
printf("[F1]キー：βの調整 \n");
printf("[F2]キー：σの調整 \n");
printf("[F3]キー：seedの変更 \n");
printf("[F4]キー：x方向の風力変更 \n");
flagHelp = false;
}
//終了
glutSwapBuffers();
}
void Building::RenderPorts()
{
START_PROFILE( "RenderPorts" );
int buildingDetail = g_prefsManager->GetInt( "RenderBuildingDetail" );
for( int i = 0; i < GetNumPorts(); ++i )
{
Vector3 portPos;
Vector3 portFront;
GetPortPosition( i, portPos, portFront );
//
// Render the port shape
portPos.y = g_app->m_location->m_landscape.m_heightMap->GetValue( portPos.x, portPos.z ) + 0.5;
Vector3 portUp = g_upVector;
Matrix34 mat( portFront, portUp, portPos );
if( buildingDetail < 3 )
{
g_app->m_renderer->SetObjectLighting();
s_controlPad->Render( 0.0, mat );
g_app->m_renderer->UnsetObjectLighting();
}
//
// Render the status light
double size = 6.0;
Vector3 camR = g_app->m_camera->GetRight() * size;
Vector3 camU = g_app->m_camera->GetUp() * size;
Vector3 statusPos = s_controlPadStatus->GetWorldMatrix( mat ).pos;
if( GetPortOccupant(i).IsValid() ) glColor4f( 0.3, 1.0, 0.3, 1.0 );
else glColor4f( 1.0, 0.3, 0.3, 1.0 );
glDisable ( GL_CULL_FACE );
glEnable ( GL_TEXTURE_2D );
glBindTexture ( GL_TEXTURE_2D, g_app->m_resource->GetTexture( "textures/starburst.bmp" ) );
glDepthMask ( false );
glEnable ( GL_BLEND );
glBlendFunc ( GL_SRC_ALPHA, GL_ONE );
glBegin( GL_QUADS );
glTexCoord2i( 0, 0 ); glVertex3dv( (statusPos - camR - camU).GetData() );
glTexCoord2i( 1, 0 ); glVertex3dv( (statusPos + camR - camU).GetData() );
glTexCoord2i( 1, 1 ); glVertex3dv( (statusPos + camR + camU).GetData() );
glTexCoord2i( 0, 1 ); glVertex3dv( (statusPos - camR + camU).GetData() );
glEnd();
glBlendFunc ( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glDisable ( GL_BLEND );
glDepthMask ( true );
glDisable ( GL_TEXTURE_2D );
glEnable ( GL_CULL_FACE );
}
END_PROFILE( "RenderPorts" );
}
void ParticleSystem::draw()
{
/*
// just draw points:
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glColor4f(1,1,1,1);
glBegin(GL_POINTS);
for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) {
glVertex3fv(it->tpos);
}
glEnd();
glEnable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);
*/
// setup blend mode
switch (blend) {
case 0:
glDisable(GL_BLEND);
glDisable(GL_ALPHA_TEST);
break;
case 1:
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_COLOR, GL_ONE);
glDisable(GL_ALPHA_TEST);
break;
case 2:
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_ALPHA_TEST);
break;
case 3:
glDisable(GL_BLEND);
glEnable(GL_ALPHA_TEST);
break;
case 4:
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
glDisable(GL_ALPHA_TEST);
break;
}
//glDisable(GL_LIGHTING);
//glDisable(GL_CULL_FACE);
//glDepthMask(GL_FALSE);
// glPushName(texture);
_texture->bind();
/*
if (supportPointSprites && rows==1 && cols==1) {
// This is how will our point sprite's size will be modified by
// distance from the viewer
float quadratic[] = {0.1f, 0.0f, 0.5f};
//float quadratic[] = {0.88f, 0.001f, 0.000004f};
glPointParameterfvARB( GL_POINT_DISTANCE_ATTENUATION_ARB, quadratic);
// Query for the max point size supported by the hardware
float maxSize = 512.0f;
//glGetFloatv(GL_POINT_SIZE_MAX_ARB, &maxSize );
// Clamp size to 100.0f or the sprites could get a little too big on some
// of the newer graphic cards. My ATI card at home supports a max point
// size of 1024.0f!
//if( maxSize > 100.0f )
// maxSize = 100.0f;
glPointSize(maxSize);
// The alpha of a point is calculated to allow the fading of points
// instead of shrinking them past a defined threshold size. The threshold
// is defined by GL_POINT_FADE_THRESHOLD_SIZE_ARB and is not clamped to
// the minimum and maximum point sizes.
glPointParameterfARB(GL_POINT_FADE_THRESHOLD_SIZE_ARB, 60.0f);
glPointParameterfARB(GL_POINT_SIZE_MIN_ARB, 1.0f );
glPointParameterfARB(GL_POINT_SIZE_MAX_ARB, maxSize );
// Specify point sprite texture coordinate replacement mode for each texture unit
glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_TRUE);
// Render point sprites...
glEnable(GL_POINT_SPRITE_ARB);
glBegin(GL_POINTS);
{
for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) {
glPointSize(it->size);
glTexCoord2fv(tiles[it->tile].tc[0]);
glColor4fv(it->color);
glVertex3fv(it->pos);
}
}
glEnd();
glDisable(GL_POINT_SPRITE_ARB);
glTexEnvf(GL_POINT_SPRITE_ARB, GL_COORD_REPLACE_ARB, GL_FALSE);
} else { // Old slow method */
Vec3D vRight(1, 0, 0);
Vec3D vUp(0, 1, 0);
// position stuff
const float f = 1;//0.707106781f; // sqrt(2)/2
Vec3D bv0 = Vec3D(-f, +f, 0);
Vec3D bv1 = Vec3D(+f, +f, 0);
Vec3D bv2 = Vec3D(+f, -f, 0);
Vec3D bv3 = Vec3D(-f, -f, 0);
if (billboard) {
float modelview[16];
glGetFloatv(GL_MODELVIEW_MATRIX, modelview);
vRight = Vec3D(modelview[0], modelview[4], modelview[8]);
vUp = Vec3D(modelview[1], modelview[5], modelview[9]); // Spherical billboarding
//vUp = Vec3D(0,1,0); // Cylindrical billboarding
}
/*
* type:
* 0 "normal" particle
* 1 large quad from the particle's origin to its position (used in Moonwell water effects)
* 2 seems to be the same as 0 (found some in the Deeprun Tram blinky-lights-sign thing)
*/
if (type == 0 || type == 2) {
//! \todo figure out type 2 (deeprun tram subway sign)
// - doesn't seem to be any different from 0 -_-
// regular particles
if (billboard) {
glBegin(GL_QUADS);
//! \todo per-particle rotation in a non-expensive way?? :|
for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) {
if (tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent
break;
const float size = it->size;// / 2;
glColor4fv(it->color);
glTexCoord2fv(tiles[it->tile].tc[0]);
glVertex3fv(it->pos - (vRight + vUp) * size);
glTexCoord2fv(tiles[it->tile].tc[1]);
glVertex3fv(it->pos + (vRight - vUp) * size);
glTexCoord2fv(tiles[it->tile].tc[2]);
glVertex3fv(it->pos + (vRight + vUp) * size);
glTexCoord2fv(tiles[it->tile].tc[3]);
glVertex3fv(it->pos - (vRight - vUp) * size);
}
glEnd();
}
else {
glBegin(GL_QUADS);
for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) {
if (tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent
break;
glColor4fv(it->color);
glTexCoord2fv(tiles[it->tile].tc[0]);
glVertex3fv(it->pos + it->corners[0] * it->size);
glTexCoord2fv(tiles[it->tile].tc[1]);
glVertex3fv(it->pos + it->corners[1] * it->size);
glTexCoord2fv(tiles[it->tile].tc[2]);
glVertex3fv(it->pos + it->corners[2] * it->size);
glTexCoord2fv(tiles[it->tile].tc[3]);
glVertex3fv(it->pos + it->corners[3] * it->size);
}
glEnd();
}
}
else if (type == 1) { // Sphere particles
// particles from origin to position
/*
bv0 = mbb * Vec3D(0,-1.0f,0);
bv1 = mbb * Vec3D(0,+1.0f,0);
bv0 = mbb * Vec3D(-1.0f,0,0);
bv1 = mbb * Vec3D(1.0f,0,0);
*/
glBegin(GL_QUADS);
for (ParticleList::iterator it = particles.begin(); it != particles.end(); ++it) {
if (tiles.size() - 1 < it->tile) // Alfred, 2009.08.07, error prevent
break;
glColor4fv(it->color);
glTexCoord2fv(tiles[it->tile].tc[0]);
glVertex3fv(it->pos + bv0 * it->size);
glTexCoord2fv(tiles[it->tile].tc[1]);
glVertex3fv(it->pos + bv1 * it->size);
glTexCoord2fv(tiles[it->tile].tc[2]);
glVertex3fv(it->origin + bv1 * it->size);
glTexCoord2fv(tiles[it->tile].tc[3]);
glVertex3fv(it->origin + bv0 * it->size);
}
glEnd();
}
//}
//glEnable(GL_LIGHTING);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glDepthMask(GL_TRUE);
//glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}
void GLCanvas::renderSkeleton()
{
Vector3 lookAt = _cameraPosition + _cameraFront;
gluLookAt(_cameraPosition.x(), _cameraPosition.y(), _cameraPosition.z(),
lookAt.x() , lookAt.y() , lookAt.z(),
_cameraUp.x() , _cameraUp.y() , _cameraUp.z());
if (_style & DRAW_GRID)
{
drawGrid();
}
if (_skeleton == nullptr)
{
return;
}
for (auto it = _skeleton->beginBones(); it != _skeleton->endBones(); ++it)
{
glPushMatrix();
Bone bone = *(it->second);
int boneId = bone.getId();
// don't draw any bone without valid id
if (boneId < 0)
{
continue;
}
// get the bone id as color for SELECTION_MODE
GLubyte boneIdColor[4] = {GLubyte((boneId >> 8) & 255), GLubyte((boneId >> 8) & 255), GLubyte(boneId & 255), 255};
const GLubyte* boneColor1 = boneStandardColor1;
const GLubyte* boneColor2 = boneStandardColor2;
if (_style & SELECTION_MODE)
{
boneColor1 = boneIdColor;
boneColor2 = boneIdColor;
}
else if (_style & HIGHLIGHT_SELECTED_BONE && bone.getId() == _skeleton->getSelectedBoneId())
{
boneColor1 = boneHighlightedColor1;
boneColor2 = boneHighlightedColor2;
}
Vector3 startPos = bone.getStartPos();
glTranslatef(startPos.x(), startPos.y(), startPos.z());
float length = bone.getLength();
Vector3 dir = bone.getDirection();
Vector3 up = bone.getUpDirection();
Vector3 right = bone.getRightDirection();
Vector3 endPos = dir*length;
startPos = Vector3(0, 0, 0);
float length_10 = length * 0.1f;
Vector3 endPos_10 = endPos * 0.1f;
Vector3 upPoint = up*length_10 + endPos_10;
Vector3 downPoint = - up*length_10 + endPos_10;
Vector3 rightPoint = right*length_10 + endPos_10;
Vector3 leftPoint = - right*length_10 + endPos_10;
if (!(_style & SELECTION_MODE))
{
//set point size to 10 pixels
glPointSize(10.0f);
glColor4ubv(pointColor);
// TODO(JK#9#): maybe don't draw points for bones (or add render style flag)
glBegin(GL_POINTS);
glVertex3f(endPos.x(), endPos.y(), endPos.z());
glEnd();
}
// set line width
glLineWidth(_lineWidth);
// draw local coordinate system
if (_style & DRAW_LOCAL_COORDINATE_SYSTEM)
{
glBegin(GL_LINES);
glColor4ubv(red);
glVertex3f(endPos.x(), endPos.y(), endPos.z());
glVertex3f(endPos.x() + dir.x()*0.1f, endPos.y() + dir.y()*0.1f, endPos.z() + dir.z()*0.1f);
glColor4ubv(green);
glVertex3f(endPos.x(), endPos.y(), endPos.z());
glVertex3f(endPos.x() + up.x()*0.1f, endPos.y() + up.y()*0.1f, endPos.z() + up.z()*0.1f);
glColor4ubv(blue);
glVertex3f(endPos.x(), endPos.y(), endPos.z());
glVertex3f(endPos.x() + right.x()*0.1f, endPos.y() + right.y()*0.1f, endPos.z() + right.z()*0.1f);
glEnd();
}
if (_style & DRAW_ROTATION_AXIS)
{
Vector3 rotAxis = bone.getRelOrientation().getRotationAxis();
glBegin(GL_LINES);
glColor4ubv(yellow);
glVertex3f(-rotAxis.x()*0.2f, -rotAxis.y()*0.2f, -rotAxis.z()*0.2f);
glVertex3f(rotAxis.x()*0.2f, rotAxis.y()*0.2f, rotAxis.z()*0.2f);
glEnd();
}
// draw bone
glPolygonMode(GL_FRONT, GL_FILL);
glColor4ubv(boneColor1);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(upPoint.x(), upPoint.y(), upPoint.z());
glVertex3f(leftPoint.x(), leftPoint.y(), leftPoint.z());
glVertex3f(downPoint.x(), downPoint.y(), downPoint.z());
glVertex3f(rightPoint.x(), rightPoint.y(), rightPoint.z());
glVertex3f(upPoint.x(), upPoint.y(), upPoint.z());
glEnd();
glColor4ubv(boneColor2);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(endPos.x(), endPos.y(), endPos.z());
glVertex3f(upPoint.x(), upPoint.y(), upPoint.z());
glVertex3f(rightPoint.x(), rightPoint.y(), rightPoint.z());
glVertex3f(downPoint.x(), downPoint.y(), downPoint.z());
glVertex3f(leftPoint.x(), leftPoint.y(), leftPoint.z());
glVertex3f(upPoint.x(), upPoint.y(), upPoint.z());
glEnd();
if (!(_style & SELECTION_MODE))
{
// draw black mesh lines around bones
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glColor4ubv(black);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(upPoint.x(), upPoint.y(), upPoint.z());
glVertex3f(leftPoint.x(), leftPoint.y(), leftPoint.z());
glVertex3f(downPoint.x(), downPoint.y(), downPoint.z());
glVertex3f(rightPoint.x(), rightPoint.y(), rightPoint.z());
glVertex3f(upPoint.x(), upPoint.y(), upPoint.z());
glEnd();
glBegin(GL_TRIANGLE_FAN);
glVertex3f(endPos.x(), endPos.y(), endPos.z());
glVertex3f(upPoint.x(), upPoint.y(), upPoint.z());
glVertex3f(rightPoint.x(), rightPoint.y(), rightPoint.z());
glVertex3f(downPoint.x(), downPoint.y(), downPoint.z());
glVertex3f(leftPoint.x(), leftPoint.y(), leftPoint.z());
glVertex3f(upPoint.x(), upPoint.y(), upPoint.z());
glEnd();
// draw labels
if (_style & DRAW_LABEL)
{
// glDisable(GL_DEPTH_TEST);
GLImage* image = _labels.find(boneId)->second;
image->setPosition(0.5f * bone.getLength() * dir - 0.06f * bone.getLength() * _cameraFront);
image->render();
// glEnable(GL_DEPTH_TEST);
}
}
// reset line width
glLineWidth(1.0f);
if (_style & DRAW_SPIN_ARROWS && bone.getId() == _skeleton->getSelectedBoneId())
{
drawSpinArrows(endPos - 0.2 * bone.getLength() * dir, dir, up, right);
}
glPopMatrix();
// append trace point and draw trace
if (_traceLength > 0)
{
Vector3 globalEndPos = bone.getEndPos();
std::map<int, std::vector<Vector3> >::iterator traceIt = _boneIdsWithTracePoints.find(boneId);
if (traceIt != _boneIdsWithTracePoints.end())
{
if (traceIt->second.size() < _traceLength)
{
traceIt->second.push_back(globalEndPos);
}
else
{
traceIt->second[_tracePos] = globalEndPos;
}
glBegin(GL_LINES);
glColor4ubv(yellow);
for (size_t i = 0; i < traceIt->second.size() - 1; ++i)
{
if (i != _tracePos)
{
glVertex3f(traceIt->second[i].x(), traceIt->second[i].y(), traceIt->second[i].z());
glVertex3f(traceIt->second[i+1].x(), traceIt->second[i+1].y(), traceIt->second[i+1].z());
}
}
// draw gab between end and beginning of the vector data
if (traceIt->second.size() > 1 && _tracePos != traceIt->second.size() - 1)
{
glVertex3f(traceIt->second.back().x(), traceIt->second.back().y(), traceIt->second.back().z());
glVertex3f(traceIt->second[0].x(), traceIt->second[0].y(), traceIt->second[0].z());
}
glEnd();
}
}
}
// draw joints (after everything else, as they are transparent and need everything else be rendered)
if (_style & DRAW_JOINT_CONSTRAINTS)
{
for (auto it = _skeleton->beginBones(); it != _skeleton->endBones(); ++it)
{
glPushMatrix();
Bone bone = *(it->second);
Vector3 startPos = bone.getStartPos();
glTranslatef(startPos.x(), startPos.y(), startPos.z());
JointConstraint constraint = bone.getJointConstraint();
drawJoint(constraint);
glPopMatrix();
}
}
// update trace position
if (++_tracePos >= _traceLength)
{
_tracePos = 0;
}
if (!(_style & SELECTION_MODE) && _style & DRAW_AABB)
{
drawAABB(_skeleton->getAABB());
}
}
void GLCanvas::drawSpinArrows(Vector3 pos, Vector3 dir, Vector3 up, Vector3 right) const
{
float length = 0.03f;
float offset = 0.05f;
GLubyte red[4] = {255, 0, 0, 255};
GLubyte green[4] = {0, 255, 0, 255};
GLubyte blue[4] = {0, 0, 255, 255};
GLubyte black[4] = {0, 0, 0, 255};
// set arroe ids to next available free ids
int idArrowDir = _skeleton->getNextFreeId();
int idArrowUp = _skeleton->getNextFreeId() + 1;
int idArrowRight = _skeleton->getNextFreeId() + 2;
GLubyte idArrowDirColor[4] = {GLubyte((idArrowDir >> 8) & 255), GLubyte((idArrowDir >> 8) & 255), GLubyte(idArrowDir & 255), 255};
GLubyte idArrowUpColor[4] = {GLubyte((idArrowUp >> 8) & 255), GLubyte((idArrowUp >> 8) & 255), GLubyte(idArrowUp & 255), 255};
GLubyte idArrowRightColor[4] = {GLubyte((idArrowRight >> 8) & 255), GLubyte((idArrowRight >> 8) & 255), GLubyte(idArrowRight & 255), 255};
const GLubyte* arrowDirColor = red;
const GLubyte* arrowUpColor = green;
const GLubyte* arrowRightColor = blue;
// base points of the arrow pyramids
Vector3 basePointUp = pos + up * offset;
Vector3 basePointRight = pos + right * offset;
Vector3 basePointDown = pos - up * offset;
Vector3 basePointLeft = pos - right * offset;
dir *= length;
up *= length;
right *= length;
Vector3 dirHalf = dir * 0.5;
Vector3 rightHalf = right * 0.5;
// base vertices of the circle like arrow
Vector3 upperCircle[4];
upperCircle[0] = basePointDown;
upperCircle[1] = basePointDown - right;
upperCircle[2] = basePointLeft - up;
upperCircle[3] = basePointLeft;
Vector3 lowerCircle[4];
lowerCircle[0] = basePointDown - up;
lowerCircle[1] = basePointDown - right*1.4 - up;
lowerCircle[2] = basePointLeft - right - up*1.4;
lowerCircle[3] = basePointLeft - right;
// the arrow rendering is done twice, one iteration for filling color, one for having black corner lines
int numIterations = 2;
if (_style & SELECTION_MODE)
{
// do not draw the corner lines in selection mode
numIterations = 1;
// draw the arrows with their id color
arrowDirColor = idArrowDirColor;
arrowUpColor = idArrowUpColor;
arrowRightColor = idArrowRightColor;
}
// draw vertices twice, one run with filling and one with black lines
for (int j = 0; j < numIterations; ++j)
{
if (j == 0)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glColor4f(0.0, 0.0, 0.0, 1.0);
arrowDirColor = arrowUpColor = arrowRightColor = black;
}
if (j == 0)
{
glColor4ubv(arrowUpColor);
}
glColor4ubv(arrowUpColor);
// arrow pointing upwards
glBegin(GL_TRIANGLE_FAN);
glVertex3f(basePointUp.x() + up.x()*2.0, basePointUp.y() + up.y()*2.0, basePointUp.z() + up.z()*2.0);
glVertex3f(basePointUp.x() + dir.x(), basePointUp.y() + dir.y(), basePointUp.z() + dir.z());
glVertex3f(basePointUp.x() + right.x(), basePointUp.y() + right.y(), basePointUp.z() + right.z());
glVertex3f(basePointUp.x() - dir.x(), basePointUp.y() - dir.y(), basePointUp.z() - dir.z());
glVertex3f(basePointUp.x() - right.x(), basePointUp.y() - right.y(), basePointUp.z() - right.z());
glVertex3f(basePointUp.x() + dir.x(), basePointUp.y() + dir.y(), basePointUp.z() + dir.z());
glEnd();
// arrow pointing downwards
/* glBegin(GL_TRIANGLE_FAN);
glVertex3f(basePointDown.x() - up.x(), basePointDown.y() - up.y(), basePointDown.z() - up.z());
glVertex3f(basePointDown.x() + dir.x(), basePointDown.y() + dir.y(), basePointDown.z() + dir.z());
glVertex3f(basePointDown.x() + right.x(), basePointDown.y() + right.y(), basePointDown.z() + right.z());
glVertex3f(basePointDown.x() - dir.x(), basePointDown.y() - dir.y(), basePointDown.z() - dir.z());
glVertex3f(basePointDown.x() - right.x(), basePointDown.y() - right.y(), basePointDown.z() - right.z());
glVertex3f(basePointDown.x() + dir.x(), basePointDown.y() + dir.y(), basePointDown.z() + dir.z());
glEnd();
*/
if (j == 0)
{
glColor4f(0.0, 0.0, 1.0, 1.0);
}
glColor4ubv(arrowRightColor);
// arrow pointing to the right
glBegin(GL_TRIANGLE_FAN);
glVertex3f(basePointRight.x() + right.x()*2.0, basePointRight.y() + right.y()*2.0, basePointRight.z() + right.z()*2.0);
glVertex3f(basePointRight.x() + dir.x(), basePointRight.y() + dir.y(), basePointRight.z() + dir.z());
glVertex3f(basePointRight.x() - up.x(), basePointRight.y() - up.y(), basePointRight.z() - up.z());
glVertex3f(basePointRight.x() - dir.x(), basePointRight.y() - dir.y(), basePointRight.z() - dir.z());
glVertex3f(basePointRight.x() + up.x(), basePointRight.y() + up.y(), basePointRight.z() + up.z());
glVertex3f(basePointRight.x() + dir.x(), basePointRight.y() + dir.y(), basePointRight.z() + dir.z());
glEnd();
// arrow pointing to the left
/* glBegin(GL_TRIANGLE_FAN);
glVertex3f(basePointLeft.x() - right.x(), basePointLeft.y() - right.y(), basePointLeft.z() - right.z());
glVertex3f(basePointLeft.x() + dir.x(), basePointLeft.y() + dir.y(), basePointLeft.z() + dir.z());
glVertex3f(basePointLeft.x() - up.x(), basePointLeft.y() - up.y(), basePointLeft.z() - up.z());
glVertex3f(basePointLeft.x() - dir.x(), basePointLeft.y() - dir.y(), basePointLeft.z() - dir.z());
glVertex3f(basePointLeft.x() + up.x(), basePointLeft.y() + up.y(), basePointLeft.z() + up.z());
glVertex3f(basePointLeft.x() + dir.x(), basePointLeft.y() + dir.y(), basePointLeft.z() + dir.z());
glEnd();
*/
if (j == 0)
{
glColor4f(1.0, 0.0, 0.0, 1.0);
}
glColor4ubv(arrowDirColor);
glBegin(GL_TRIANGLE_FAN);
// top of arrow
glVertex3f(basePointLeft.x() - rightHalf.x() + up.x()*2.0, basePointLeft.y() - rightHalf.y() + up.y()*2.0, basePointLeft.z() - rightHalf.z() + up.z()*2.0);
glVertex3f(basePointLeft.x() + rightHalf.x(), basePointLeft.y() + rightHalf.y(), basePointLeft.z() + rightHalf.z());
glVertex3f(basePointLeft.x() - rightHalf.x() + dir.x(), basePointLeft.y() - rightHalf.y() + dir.y(), basePointLeft.z() - rightHalf.z() + dir.z());
glVertex3f(basePointLeft.x() - right.x() - rightHalf.x(), basePointLeft.y() - right.y() - rightHalf.y(), basePointLeft.z() - right.z() - rightHalf.z());
glVertex3f(basePointLeft.x() - rightHalf.x() - dir.x(), basePointLeft.y() - rightHalf.y() - dir.y(), basePointLeft.z() - rightHalf.z() - dir.z());
glVertex3f(basePointLeft.x() + rightHalf.x(), basePointLeft.y() + rightHalf.y(), basePointLeft.z() + rightHalf.z());
glEnd();
// draw arrows base
glBegin(GL_QUAD_STRIP);
for (int i = 0; i < 4; ++i)
{
glVertex3f(upperCircle[i].x() + dirHalf.x(), upperCircle[i].y() + dirHalf.y(), upperCircle[i].z() + dirHalf.z());
glVertex3f(upperCircle[i].x() - dirHalf.x(), upperCircle[i].y() - dirHalf.y(), upperCircle[i].z() - dirHalf.z());
}
for (int i = 3; i >= 0; --i)
{
glVertex3f(lowerCircle[i].x() + dirHalf.x(), lowerCircle[i].y() + dirHalf.y(), lowerCircle[i].z() + dirHalf.z());
glVertex3f(lowerCircle[i].x() - dirHalf.x(), lowerCircle[i].y() - dirHalf.y(), lowerCircle[i].z() - dirHalf.z());
}
glVertex3f(upperCircle[0].x() + dirHalf.x(), upperCircle[0].y() + dirHalf.y(), upperCircle[0].z() + dirHalf.z());
glVertex3f(upperCircle[0].x() - dirHalf.x(), upperCircle[0].y() - dirHalf.y(), upperCircle[0].z() - dirHalf.z());
glEnd();
glBegin(GL_QUAD_STRIP);
for (int i = 0; i < 4; ++i)
{
glVertex3f(lowerCircle[i].x() + dirHalf.x(), lowerCircle[i].y() + dirHalf.y(), lowerCircle[i].z() + dirHalf.z());
glVertex3f(upperCircle[i].x() + dirHalf.x(), upperCircle[i].y() + dirHalf.y(), upperCircle[i].z() + dirHalf.z());
}
for (int i = 3; i >= 0; --i)
{
glVertex3f(lowerCircle[i].x() - dirHalf.x(), lowerCircle[i].y() - dirHalf.y(), lowerCircle[i].z() - dirHalf.z());
glVertex3f(upperCircle[i].x() - dirHalf.x(), upperCircle[i].y() - dirHalf.y(), upperCircle[i].z() - dirHalf.z());
}
glEnd();
}
/* glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glColor4f(0.0, 0.0, 0.0, 1.0);
// arrow pointing upwards
glBegin(GL_TRIANGLE_FAN);
glVertex3f(basePointUp.x() + up.x()*2.0, basePointUp.y() + up.y()*2.0, basePointUp.z() + up.z()*2.0);
glVertex3f(basePointUp.x() + dir.x(), basePointUp.y() + dir.y(), basePointUp.z() + dir.z());
glVertex3f(basePointUp.x() + right.x(), basePointUp.y() + right.y(), basePointUp.z() + right.z());
glVertex3f(basePointUp.x() - dir.x(), basePointUp.y() - dir.y(), basePointUp.z() - dir.z());
glVertex3f(basePointUp.x() - right.x(), basePointUp.y() - right.y(), basePointUp.z() - right.z());
glVertex3f(basePointUp.x() + dir.x(), basePointUp.y() + dir.y(), basePointUp.z() + dir.z());
glEnd();
// arrow pointing to the right
glBegin(GL_TRIANGLE_FAN);
glVertex3f(basePointRight.x() + right.x()*2.0, basePointRight.y() + right.y()*2.0, basePointRight.z() + right.z()*2.0);
glVertex3f(basePointRight.x() + dir.x(), basePointRight.y() + dir.y(), basePointRight.z() + dir.z());
glVertex3f(basePointRight.x() - up.x(), basePointRight.y() - up.y(), basePointRight.z() - up.z());
glVertex3f(basePointRight.x() - dir.x(), basePointRight.y() - dir.y(), basePointRight.z() - dir.z());
glVertex3f(basePointRight.x() + up.x(), basePointRight.y() + up.y(), basePointRight.z() + up.z());
glVertex3f(basePointRight.x() + dir.x(), basePointRight.y() + dir.y(), basePointRight.z() + dir.z());
glEnd();*/
}
void GLCanvas::renderSingleSensor() const
{
// Vector3 lookAt = Vector3(0.0f, 0.0f, 0.0f);
// Vector3 lookAt = _cameraPosition + _cameraFront;
// gluLookAt(_cameraPosition.x(), _cameraPosition.y(), _cameraPosition.z(),
// lookAt.x() , lookAt.y() , lookAt.z(),
// _cameraUp.x() , _cameraUp.y() , _cameraUp.z());
gluLookAt(0.0f, 0.0f, _cameraPosition.z(),
0.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
Vector3 dir = _sensorOrientation.rotate(Vector3(1.0f, 0.0f, 0.0f));
Vector3 up = 0.25 * _sensorOrientation.rotate(Vector3(0.0f, 1.0f, 0.0f));
Vector3 right = 0.5 * _sensorOrientation.rotate(Vector3(0.0f, 0.0f, 1.0f));
Vector3 frontUpRight = dir + up + right;
Vector3 frontDownRight = dir - up + right;
Vector3 frontUpLeft = dir + up - right;
Vector3 frontDownLeft = dir - up - right;
Vector3 backUpRight = -dir + up + right;
Vector3 backDownRight = -dir - up + right;
Vector3 backUpLeft = -dir + up - right;
Vector3 backDownLeft = -dir - up - right;
glBegin(GL_QUADS);
glColor3f(0.8, 0.5, 0.5);
glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z());
glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z());
glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z());
glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z());
glColor3f(0.5, 0.7, 0.5);
glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z());
glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z());
glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z());
glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z());
glColor3f(0.5, 0.5, 0.7);
glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z());
glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z());
glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z());
glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z());
glColor3f(0.7, 0.7, 0.7);
glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z());
glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z());
glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z());
glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z());
glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z());
glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z());
glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z());
glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z());
glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z());
glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z());
glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z());
glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z());
glEnd();
// scale slightly to ensure the lines are visible
glScalef(1.001f, 1.001f, 1.001f);
glLineWidth(1.0f);
glColor3f(0.0, 0.0, 0.0);
glBegin(GL_LINE_STRIP);
glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z());
glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z());
glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z());
glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z());
glVertex3f(backUpRight.x(), backUpRight.y(), backUpRight.z());
glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z());
glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z());
glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z());
glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z());
glVertex3f(frontUpRight.x(), frontUpRight.y(), frontUpRight.z());
glEnd();
glBegin(GL_LINES);
glVertex3f(backUpLeft.x(), backUpLeft.y(), backUpLeft.z());
glVertex3f(frontUpLeft.x(), frontUpLeft.y(), frontUpLeft.z());
glVertex3f(backDownLeft.x(), backDownLeft.y(), backDownLeft.z());
glVertex3f(frontDownLeft.x(), frontDownLeft.y(), frontDownLeft.z());
glVertex3f(backDownRight.x(), backDownRight.y(), backDownRight.z());
glVertex3f(frontDownRight.x(), frontDownRight.y(), frontDownRight.z());
glEnd();
glLineWidth(2.0f);
// draw global coordinate system
glBegin(GL_LINES);
glColor3f(1.0, 0.0, 0.0);
glVertex3f(-1.5, -1.0, -1.0);
glVertex3f(1.0, -1.0, -1.0);
glColor3f(0.0, 1.0, 0.0);
glVertex3f(-1.5, -1.0, -1.0);
glVertex3f(-1.5, 1.0, -1.0);
glColor3f(0.0, 0.0, 1.0);
glVertex3f(-1.5, -1.0, -1.0);
glVertex3f(-1.5, -1.0, 1.0);
glEnd();
// draw global coordinate system
// glBegin(GL_LINES);
// glColor3f(1.0, 0.0, 0.0);
// glVertex3f(0.0, 0.0, 0.0);
// glVertex3f(1.5, 00.0, 0.0);
//
// glColor3f(0.0, 1.0, 0.0);
// glVertex3f(0.0, 0.0, 0.0);
// glVertex3f(0.0, 1.5, 0.0);
//
// glColor3f(0.0, 0.0, 1.0);
// glVertex3f(0.0, 0.0, 0.0);
// glVertex3f(0.0, 0.0, 1.5);
// glEnd();
glLineWidth(1.0f);
}
void GLCanvas::renderSingleJoint() const
{
Vector3 lookAt = _cameraPosition + _cameraFront;
gluLookAt(_cameraPosition.x(), _cameraPosition.y(), _cameraPosition.z(),
lookAt.x() , lookAt.y() , lookAt.z(),
_cameraUp.x() , _cameraUp.y() , _cameraUp.z());
glBegin(GL_LINES);
glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(1.0f, 0.0f, 0.0f);
glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(0.0f, 1.0f, 0.0f);
glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(0.0f, 0.0f, 1.0f);
glEnd();
if (_constraint != nullptr)
{
drawJoint(*_constraint, 1.0f);
}
}
// Initialization of all OpenGL specific parameters.
void GLCanvas::InitGL()
{
SetCurrent(*_GLRC);
glClearColor(0.0, 0.0, 0.0, 0.0);
//glClearColor(1.0, 1.0, 1.0, 1.0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_BLEND);
glEnable(GL_CULL_FACE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glShadeModel(GL_SMOOTH);
}
void Scene::deferredRendering(RenderTarget * target)
{
if(target->isEnableClipPlane ())
{
glEnable(GL_CLIP_PLANE0);
glClipPlane(GL_CLIP_PLANE0, target->getClipPlane());
}
if(!this->spotLights.empty ())
{
this->shadowPassForSpot(spotLights[0],target);
}
if(this->directionLight.getIntensity ()>0)
{
this->shadowPassDirectional (target);
}
geometryPass(target);
if(target->isEnableClipPlane ())
{
glDisable(GL_CLIP_PLANE0);
}
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE);
target->getGBuffer ()->BindForReading(bloom_fbo1->buffer ());
lightPass(target);
bloom_fbo1->BindForReading (bloom_fbo2);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
pickBright();
bloom_fbo2->BindForReading (bloom_fbo3);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
gaussianBlur_H (2);
bloom_fbo3->BindForReading (NULL);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
gaussianBlur_V (2);
if(target->type () == RenderTarget::TargetType::ON_SCREEN)
{
bloom_fbo1->BindForReading (NULL);
}
else
{
bloom_fbo1->BindForReading (target->resultBuffer ());
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
ShaderProgram * shader =ShaderPool::getInstance ()->get("deffered_simple");
shader->use ();
QMatrix4x4 m;
m.setToIdentity ();
m_quad->setShaderProgram (shader);
auto camera =target->camera ();
shader->setUniformMat4v ("g_MVP_matrix",m.data ());
shader->setUniform2Float ("g_screen_size",1024,768);
shader->setUniformInteger ("g_color_map",0);
shader->setUniformInteger ("g_position_map",1);
shader->setUniformInteger ("g_normal_map",2);
if(camera)
{
shader->setUniform3Float ("g_eye_position",
camera->pos ().x(),
camera->pos ().y(),
camera->pos ().z());
}
m_quad->draw (true);
}
/**
* Called to draw scene
*/
void RenderScene(void)
{
// Bind the FBO with multisample buffers
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, msFBO);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// User selected order independant transparency
if (mode == USER_OIT)
{
// Use OIT, setup sample masks
glSampleMaski(0, 0x01);
glEnable(GL_SAMPLE_MASK);
// Prevent depth test from culling covered surfaces
glDepthFunc(GL_ALWAYS);
}
modelViewMatrix.push();
M3DMatrix44f mCamera;
cameraFrame.GetCameraMatrix(mCamera);
modelViewMatrix.MultMatrix(mCamera);
modelViewMatrix.push();
modelViewMatrix.moveTo(0.0f, -0.4f, -4.0f);
modelViewMatrix.rotateTo(worldAngle, 0.0, 1.0, 0.0);
// Draw the background and disk to the first sample
modelViewMatrix.push();
modelViewMatrix.moveTo(0.0f, 3.0f, 0.0f);
modelViewMatrix.rotateTo(90.0, 1.0, 0.0, 0.0);
modelViewMatrix.rotateTo(90.0, 0.0, 0.0, 1.0);
glBindTexture(GL_TEXTURE_2D, textures[1]);
shaderManager.useStockShader(GLT_SHADER_TEXTURE_REPLACE, transformPipeline.GetMVPMatrix(), 0);
bckgrndCylBatch.draw();
modelViewMatrix.pop();
modelViewMatrix.moveTo(0.0f, -0.3f, 0.0f);
modelViewMatrix.push();
modelViewMatrix.rotateTo(90.0, 1.0, 0.0, 0.0);
shaderManager.useStockShader(GLT_SHADER_FLAT, transformPipeline.GetMVPMatrix(), vGrey);
diskBatch.draw();
modelViewMatrix.pop();
modelViewMatrix.moveTo(0.0f, 0.1f, 0.0f);
// User selected blending
if (mode == USER_BLEND)
{
// Setup blend state
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
switch (blendMode)
{
case 1:
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
case 2:
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA);
break;
case 3:
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
break;
case 4:
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
break;
case 5:
glBlendFunc(GL_SRC_ALPHA, GL_DST_COLOR);
break;
case 6:
glBlendFuncSeparate(GL_SRC_ALPHA, GL_DST_ALPHA, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
case 7:
glBlendFuncSeparate(GL_SRC_COLOR, GL_DST_COLOR, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
break;
default:
glDisable(GL_BLEND);
}
}
// Now draw the glass pieces
DrawWorld();
modelViewMatrix.pop();
modelViewMatrix.pop();
// Clean up all state
glDepthFunc(GL_LEQUAL);
glDisable(GL_BLEND);
glDisable(GL_SAMPLE_MASK);
glSampleMaski(0, 0xffffffff);
// Resolve multisample buffer
projectionMatrix.push();
projectionMatrix.setMatrix(orthoMatrix);
modelViewMatrix.push();
modelViewMatrix.identity();
// Setup and Clear the default framebuffer
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glViewport(0, 0, screenWidth, screenHeight);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (mode == USER_OIT)
SetupOITResolveProg();
else if (mode == USER_BLEND)
SetupResolveProg();
// Draw a full-size quad to resolve the multisample surfaces
screenQuad.draw();
modelViewMatrix.pop();
projectionMatrix.pop();
// Reset texture state
glEnable(GL_DEPTH_TEST);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0);
// Perform the buffer swap to display back buffer
glutSwapBuffers();
glutPostRedisplay();
}
// Print the canvas contents to a bitmap:
void klsMiniMap::generateImage() {
//WARNING!!! Heavily platform-dependent code ahead! This only works in MS Windows because of the
// DIB Section OpenGL rendering.
wxSize sz = GetClientSize();
// Create a DIB section.
// (The Windows wxBitmap implementation will create a DIB section for a bitmap if you set
// a color depth of 24 or greater.)
wxBitmap theBM( sz.GetWidth(), sz.GetHeight(), 32 );
// Get a memory hardware device context for writing to the bitmap DIB Section:
wxMemoryDC myDC;
myDC.SelectObject(theBM);
WXHDC theHDC = myDC.GetHDC();
// The basics of setting up OpenGL to render to the bitmap are found at:
// http://www.nullterminator.net/opengl32.html
// http://www.codeguru.com/cpp/g-m/opengl/article.php/c5587/
PIXELFORMATDESCRIPTOR pfd;
int iFormat;
// set the pixel format for the DC
::ZeroMemory( &pfd, sizeof( pfd ) );
pfd.nSize = sizeof( pfd );
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_BITMAP | PFD_SUPPORT_OPENGL | PFD_SUPPORT_GDI;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 32;
pfd.cDepthBits = 16;
pfd.iLayerType = PFD_MAIN_PLANE;
iFormat = ::ChoosePixelFormat( (HDC) theHDC, &pfd );
::SetPixelFormat( (HDC) theHDC, iFormat, &pfd );
// create and enable the render context (RC)
HGLRC hRC = ::wglCreateContext( (HDC) theHDC );
HGLRC oldhRC = ::wglGetCurrentContext();
HDC oldDC = ::wglGetCurrentDC();
::wglMakeCurrent( (HDC) theHDC, hRC );
// Setup the viewport for rendering:
setViewport();
// Reset the glViewport to the size of the bitmap:
glViewport(0, 0, (GLint) sz.GetWidth(), (GLint) sz.GetHeight());
// Set the bitmap clear color:
glClearColor (1.0, 1.0, 1.0, 0.0);
glColor3b(0, 0, 0);
//TODO: Check if alpha is hardware supported, and
// don't enable it if not!
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
//*********************************
//Edit by Joshua Lansford 4/08/07
//The minimap could use some anti
//aleasing
glEnable( GL_LINE_SMOOTH );
//End of edit
// Load the font texture
guiText::loadFont(wxGetApp().appSettings.textFontFile);
// Do the rendering here.
renderMap();
// Flush the OpenGL buffer to make sure the rendering has happened:
glFlush();
// Destroy the OpenGL rendering context, release the memDC, and
// convert the DIB Section into a wxImage to return to the caller:
::wglMakeCurrent( oldDC, oldhRC );
//::wglMakeCurrent( NULL, NULL );
::wglDeleteContext( hRC );
myDC.SelectObject(wxNullBitmap);
mapImage = theBM.ConvertToImage();
}
void COGLGraphicsContext::InitState(void)
{
m_pRenderStr = glGetString(GL_RENDERER);
m_pExtensionStr = glGetString(GL_EXTENSIONS);
m_pVersionStr = glGetString(GL_VERSION);
m_pVendorStr = glGetString(GL_VENDOR);
glMatrixMode(GL_PROJECTION);
OPENGL_CHECK_ERRORS;
glLoadIdentity();
OPENGL_CHECK_ERRORS;
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
OPENGL_CHECK_ERRORS;
glClearDepth(1.0f);
OPENGL_CHECK_ERRORS;
#if SDL_VIDEO_OPENGL
glShadeModel(GL_SMOOTH);
OPENGL_CHECK_ERRORS;
//position viewer
//glMatrixMode(GL_MODELVIEW);
//glLoadIdentity();
glDisable(GL_ALPHA_TEST);
OPENGL_CHECK_ERRORS;
#endif
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
OPENGL_CHECK_ERRORS;
glDisable(GL_BLEND);
OPENGL_CHECK_ERRORS;
glFrontFace(GL_CCW);
OPENGL_CHECK_ERRORS;
glDisable(GL_CULL_FACE);
OPENGL_CHECK_ERRORS;
#if SDL_VIDEO_OPENGL
glDisable(GL_NORMALIZE);
OPENGL_CHECK_ERRORS;
#endif
glDepthFunc(GL_LEQUAL);
OPENGL_CHECK_ERRORS;
glEnable(GL_DEPTH_TEST);
OPENGL_CHECK_ERRORS;
#if SDL_VIDEO_OPENGL
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
OPENGL_CHECK_ERRORS;
#endif
glEnable(GL_BLEND);
OPENGL_CHECK_ERRORS;
#if SDL_VIDEO_OPENGL
glEnable(GL_ALPHA_TEST);
OPENGL_CHECK_ERRORS;
glMatrixMode(GL_PROJECTION);
OPENGL_CHECK_ERRORS;
glLoadIdentity();
OPENGL_CHECK_ERRORS;
glDepthRange(-1, 1);
#elif SDL_VIDEO_OPENGL_ES2
glDepthRangef(0.0f, 1.0f);
#endif
OPENGL_CHECK_ERRORS;
}
static void
beginRendering (SnowScreen *ss,
CompScreen *s)
{
const BananaValue *
option_use_blending = bananaGetOption (bananaIndex,
"use_blending",
-1);
const BananaValue *
option_use_textures = bananaGetOption (bananaIndex,
"use_textures",
-1);
const BananaValue *
option_num_snowflakes = bananaGetOption (bananaIndex,
"num_snowflakes",
-1);
const BananaValue *
option_snow_rotation = bananaGetOption (bananaIndex,
"snow_rotation",
-1);
if (option_use_blending->b)
glEnable (GL_BLEND);
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
if (ss->displayListNeedsUpdate)
{
setupDisplayList (ss);
ss->displayListNeedsUpdate = FALSE;
}
glColor4f (1.0, 1.0, 1.0, 1.0);
if (ss->snowTexturesLoaded && option_use_textures->b)
{
int j;
for (j = 0; j < ss->snowTexturesLoaded; j++)
{
SnowFlake *snowFlake = ss->allSnowFlakes;
int i, numFlakes = option_num_snowflakes->i;
Bool snowRotate = option_snow_rotation->b;
enableTexture (ss->s, &ss->snowTex[j].tex,
COMP_TEXTURE_FILTER_GOOD);
for (i = 0; i < numFlakes; i++)
{
if (snowFlake->tex == &ss->snowTex[j])
{
glTranslatef (snowFlake->x, snowFlake->y, snowFlake->z);
if (snowRotate)
glRotatef (snowFlake->ra, 0, 0, 1);
glCallList (ss->snowTex[j].dList);
if (snowRotate)
glRotatef (-snowFlake->ra, 0, 0, 1);
glTranslatef (-snowFlake->x, -snowFlake->y, -snowFlake->z);
}
snowFlake++;
}
disableTexture (ss->s, &ss->snowTex[j].tex);
}
}
else
{
SnowFlake *snowFlake = ss->allSnowFlakes;
int i, numFlakes = option_num_snowflakes->i;
for (i = 0; i < numFlakes; i++)
{
glTranslatef (snowFlake->x, snowFlake->y, snowFlake->z);
glRotatef (snowFlake->ra, 0, 0, 1);
glCallList (ss->displayList);
glRotatef (-snowFlake->ra, 0, 0, 1);
glTranslatef (-snowFlake->x, -snowFlake->y, -snowFlake->z);
snowFlake++;
}
}
glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
if (option_use_blending->b)
{
glDisable (GL_BLEND);
glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
}
void STKMeshSceneNode::render()
{
irr::video::IVideoDriver* driver = irr_driver->getVideoDriver();
if (!Mesh || !driver)
return;
++PassCount;
updateNoGL();
updateGL();
bool isTransparent;
for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i)
{
scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i);
if (!mb)
continue;
video::E_MATERIAL_TYPE type = mb->getMaterial().MaterialType;
video::IMaterialRenderer* rnd = driver->getMaterialRenderer(type);
isTransparent = rnd->isTransparent();
break;
}
if ((irr_driver->getPhase() == SOLID_NORMAL_AND_DEPTH_PASS) && immediate_draw && !isTransparent)
{
core::matrix4 invmodel;
AbsoluteTransformation.getInverse(invmodel);
glDisable(GL_CULL_FACE);
if (update_each_frame)
updatevbo();
glUseProgram(MeshShader::ObjectPass1Shader::getInstance()->Program);
// Only untextured
for (unsigned i = 0; i < GLmeshes.size(); i++)
{
irr_driver->IncreaseObjectCount();
GLMesh &mesh = GLmeshes[i];
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
if (UserConfigParams::m_azdo)
{
if (!mesh.TextureHandles[0])
mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]);
if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0]))
glMakeTextureHandleResidentARB(mesh.TextureHandles[0]);
MeshShader::ObjectPass1Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0]));
}
else
MeshShader::ObjectPass1Shader::getInstance()->SetTextureUnits(std::vector < GLuint > { getTextureGLuint(mesh.textures[0]) });
MeshShader::ObjectPass1Shader::getInstance()->setUniforms(AbsoluteTransformation, invmodel);
assert(mesh.vao);
glBindVertexArray(mesh.vao);
glDrawElements(ptype, count, itype, 0);
glBindVertexArray(0);
}
glEnable(GL_CULL_FACE);
return;
}
if (irr_driver->getPhase() == SOLID_LIT_PASS && immediate_draw && !isTransparent)
{
core::matrix4 invmodel;
AbsoluteTransformation.getInverse(invmodel);
glDisable(GL_CULL_FACE);
if (update_each_frame && !UserConfigParams::m_dynamic_lights)
updatevbo();
glUseProgram(MeshShader::ObjectPass2Shader::getInstance()->Program);
// Only untextured
for (unsigned i = 0; i < GLmeshes.size(); i++)
{
irr_driver->IncreaseObjectCount();
GLMesh &mesh = GLmeshes[i];
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
if (UserConfigParams::m_azdo)
{
GLuint64 DiffuseHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_DIFFUSE), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[0]);
if (!glIsTextureHandleResidentARB(DiffuseHandle))
glMakeTextureHandleResidentARB(DiffuseHandle);
GLuint64 SpecularHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_SPECULAR), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[1]);
if (!glIsTextureHandleResidentARB(SpecularHandle))
glMakeTextureHandleResidentARB(SpecularHandle);
GLuint64 SSAOHandle = glGetTextureSamplerHandleARB(irr_driver->getRenderTargetTexture(RTT_HALF1_R), MeshShader::ObjectPass2Shader::getInstance()->SamplersId[2]);
if (!glIsTextureHandleResidentARB(SSAOHandle))
glMakeTextureHandleResidentARB(SSAOHandle);
if (!mesh.TextureHandles[0])
mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]);
if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0]))
glMakeTextureHandleResidentARB(mesh.TextureHandles[0]);
MeshShader::ObjectPass2Shader::getInstance()->SetTextureHandles(createVector<uint64_t>(DiffuseHandle, SpecularHandle, SSAOHandle, mesh.TextureHandles[0]));
}
else
MeshShader::ObjectPass2Shader::getInstance()->SetTextureUnits(createVector<GLuint>(
irr_driver->getRenderTargetTexture(RTT_DIFFUSE),
irr_driver->getRenderTargetTexture(RTT_SPECULAR),
irr_driver->getRenderTargetTexture(RTT_HALF1_R),
getTextureGLuint(mesh.textures[0]),
getTextureGLuint(mesh.textures[1])));
MeshShader::ObjectPass2Shader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix);
assert(mesh.vao);
glBindVertexArray(mesh.vao);
glDrawElements(ptype, count, itype, 0);
glBindVertexArray(0);
}
glEnable(GL_CULL_FACE);
return;
}
if (irr_driver->getPhase() == GLOW_PASS)
{
glUseProgram(MeshShader::ColorizeShader::getInstance()->Program);
for (u32 i = 0; i < Mesh->getMeshBufferCount(); ++i)
{
scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i);
if (!mb)
continue;
if (irr_driver->hasARB_base_instance())
glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_STANDARD));
else
glBindVertexArray(GLmeshes[i].vao);
drawGlow(GLmeshes[i]);
}
}
if (irr_driver->getPhase() == TRANSPARENT_PASS && isTransparent)
{
ModelViewProjectionMatrix = computeMVP(AbsoluteTransformation);
if (immediate_draw)
{
if (update_each_frame)
updatevbo();
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
if (World::getWorld() && World::getWorld()->isFogEnabled())
{
glUseProgram(MeshShader::TransparentFogShader::getInstance()->Program);
for (unsigned i = 0; i < GLmeshes.size(); i++)
{
GLMesh &mesh = GLmeshes[i];
irr_driver->IncreaseObjectCount();
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
const Track * const track = World::getWorld()->getTrack();
// This function is only called once per frame - thus no need for setters.
const float fogmax = track->getFogMax();
const float startH = track->getFogStartHeight();
const float endH = track->getFogEndHeight();
const float start = track->getFogStart();
const float end = track->getFogEnd();
const video::SColor tmpcol = track->getFogColor();
video::SColorf col(tmpcol.getRed() / 255.0f,
tmpcol.getGreen() / 255.0f,
tmpcol.getBlue() / 255.0f);
compressTexture(mesh.textures[0], true);
if (UserConfigParams::m_azdo)
{
if (!mesh.TextureHandles[0])
mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentFogShader::getInstance()->SamplersId[0]);
if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0]))
glMakeTextureHandleResidentARB(mesh.TextureHandles[0]);
MeshShader::TransparentFogShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0]));
}
else
MeshShader::TransparentFogShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) });
MeshShader::TransparentFogShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix, fogmax, startH, endH, start, end, col);
assert(mesh.vao);
glBindVertexArray(mesh.vao);
glDrawElements(ptype, count, itype, 0);
glBindVertexArray(0);
}
}
else
{
glUseProgram(MeshShader::TransparentShader::getInstance()->Program);
for (unsigned i = 0; i < GLmeshes.size(); i++)
{
irr_driver->IncreaseObjectCount();
GLMesh &mesh = GLmeshes[i];
GLenum ptype = mesh.PrimitiveType;
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
compressTexture(mesh.textures[0], true);
if (UserConfigParams::m_azdo)
{
if (!mesh.TextureHandles[0])
mesh.TextureHandles[0] = glGetTextureSamplerHandleARB(getTextureGLuint(mesh.textures[0]), MeshShader::TransparentShader::getInstance()->SamplersId[0]);
if (!glIsTextureHandleResidentARB(mesh.TextureHandles[0]))
glMakeTextureHandleResidentARB(mesh.TextureHandles[0]);
MeshShader::TransparentShader::getInstance()->SetTextureHandles(createVector<uint64_t>(mesh.TextureHandles[0]));
}
else
MeshShader::TransparentShader::getInstance()->SetTextureUnits(std::vector<GLuint>{ getTextureGLuint(mesh.textures[0]) });
MeshShader::TransparentShader::getInstance()->setUniforms(AbsoluteTransformation, mesh.TextureMatrix);
assert(mesh.vao);
glBindVertexArray(mesh.vao);
glDrawElements(ptype, count, itype, 0);
glBindVertexArray(0);
}
}
return;
}
}
}
gboolean on_expose(GtkWidget *drawing, GdkEventExpose *event, gpointer _)
{
glClearColor(0.5, 0.5, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1,1, -1,1, 10,-10);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -5);
glEnable(GL_COLOR_MATERIAL);
glDisable(GL_TEXTURE_2D);
glColor3f(1.0, 1.0, 1.0);
glBegin(GL_QUADS);
glVertex3f(-0.25, -0.75, 0.0);
glVertex3f(-0.25, 0.75, 0.0);
glVertex3f( 0.25, 0.75, 0.0);
glVertex3f( 0.25, -0.75, 0.0);
glEnd();
/* Textures */
glDisable(GL_COLOR_MATERIAL);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
gdouble y = 0.875;
/* Left */
glBlendFunc(GL_ONE, GL_ZERO);
glBindTexture(GL_TEXTURE_2D, texl);
glBegin(GL_QUADS);
glTexCoord2f(0.0, y); glVertex3f(-0.75, 0.0, 0.0);
glTexCoord2f(0.0, 1.0); glVertex3f(-0.75, 0.5, 0.0);
glTexCoord2f(2.0, 1.0); glVertex3f( 0.75, 0.5, 0.0);
glTexCoord2f(2.0, y); glVertex3f( 0.75, 0.0, 0.0);
glEnd();
/* Right */
glBlendFunc(GL_ONE, GL_ONE);
glBindTexture(GL_TEXTURE_2D, texr);
glBegin(GL_QUADS);
glTexCoord2f(-1.0, y); glVertex3f(-0.75, 0.0, 0.0);
glTexCoord2f(-1.0, 1.0); glVertex3f(-0.75, 0.5, 0.0);
glTexCoord2f( 1.0, 1.0); glVertex3f( 0.75, 0.5, 0.0);
glTexCoord2f( 1.0, y); glVertex3f( 0.75, 0.0, 0.0);
glEnd();
/* Bottom */
glBlendFunc(GL_ONE, GL_ZERO);
glBindTexture(GL_TEXTURE_2D, tex);
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0); glVertex3f(-0.75, -0.5, 0.0);
glTexCoord2f(0.0, 1.0-y); glVertex3f(-0.75, -0.0, 0.0);
glTexCoord2f(1.0, 1.0-y); glVertex3f( 0.75, -0.0, 0.0);
glTexCoord2f(1.0, 0.0); glVertex3f( 0.75, -0.5, 0.0);
glEnd();
/* Flush */
GdkGLDrawable *gldrawable = gdk_gl_drawable_get_current();
if (gdk_gl_drawable_is_double_buffered(gldrawable))
gdk_gl_drawable_swap_buffers(gldrawable);
else
glFlush();
return FALSE;
}
void VR_ShowCrosshair ()
{
vec3_t forward, up, right;
vec3_t start, end, impact;
float size;
if( (sv_player && (int)(sv_player->v.weapon) == IT_AXE) )
return;
// setup gl
glDisable (GL_DEPTH_TEST);
glPolygonMode (GL_FRONT_AND_BACK, GL_LINE);
GL_PolygonOffset (OFFSET_SHOWTRIS);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable (GL_TEXTURE_2D);
glDisable (GL_CULL_FACE);
// calc the line and draw
VectorCopy (cl.viewent.origin, start);
start[2] -= cl.viewheight - 10;
AngleVectors (cl.aimangles, forward, right, up);
size = CLAMP (1.0, vr_crosshair_size.value, 5.0);
switch((int) vr_crosshair.value)
{
default:
case VR_CROSSHAIR_POINT:
if (vr_crosshair_depth.value <= 0) {
// trace to first wall
VectorMA (start, 4096, forward, end);
TraceLine (start, end, impact);
} else {
// fix crosshair to specific depth
VectorMA (start, vr_crosshair_depth.value * meters_to_units, forward, impact);
}
glEnable(GL_POINT_SMOOTH);
glColor4f (1, 0, 0, 0.5);
glPointSize( size * glwidth / 1280.0f );
glBegin(GL_POINTS);
glVertex3f (impact[0], impact[1], impact[2]);
glEnd();
glDisable(GL_POINT_SMOOTH);
break;
case VR_CROSSHAIR_LINE:
// trace to first entity
VectorMA (start, 4096, forward, end);
TraceLineToEntity (start, end, impact, sv_player);
glColor4f (1, 0, 0, 0.4);
glLineWidth( size * glwidth / (1280.0f) );
glBegin (GL_LINES);
glVertex3f (start[0], start[1], start[2]);
glVertex3f (impact[0], impact[1], impact[2]);
glEnd ();
break;
}
// cleanup gl
glColor3f (1,1,1);
glEnable (GL_TEXTURE_2D);
glEnable (GL_CULL_FACE);
glDisable(GL_BLEND);
glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
GL_PolygonOffset (OFFSET_NONE);
glEnable (GL_DEPTH_TEST);
}
void draw(const Stroke& stroke, CL_GraphicContext* gc)
{
CL_OpenGLState state(CL_Display::get_current_window()->get_gc());
state.set_active();
state.setup_2d();
CL_Color color = DrawerProperties::current()->get_color();
const Stroke::Dabs& dabs = stroke.get_interpolated_dabs(DrawerProperties::current()->get_spacing(),
DrawerProperties::current()->get_spacing());
if (dabs.size() >= 2)
{
std::vector<CL_Pointf> normals;
if (stroke.get_dab_count() == 2)
{
normals.push_back(CL_Pointf(1.0f, 1.0f));
normals.push_back(CL_Pointf(1.0f, 1.0f));
}
else if (stroke.get_dab_count() >= 3)
{
for(Stroke::Dabs::size_type i = 0; i < dabs.size()-1; ++i)
{
CL_Pointf normal((dabs[i].pos.y - dabs[i+1].pos.y),
-(dabs[i].pos.x - dabs[i+1].pos.x));
float length = sqrt(normal.x * normal.x + normal.y * normal.y);
normal.x /= length;
normal.y /= length;
normals.push_back(normal);
}
normals.push_back(CL_Pointf(1.0f, 1.0f));
}
float len = DrawerProperties::current()->get_size() * 8.0f;
float len2 = DrawerProperties::current()->get_size() * 16.0f;
glEnable(GL_BLEND);
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glBegin(GL_QUAD_STRIP);
for(unsigned int j = 0; j < dabs.size()-2; ++j)
{
glColor4ub(color.get_red(), color.get_green(), color.get_blue(), color.get_alpha());
glVertex2f(dabs[j].pos.x + normals[j].x * len,
dabs[j].pos.y + normals[j].y * len);
glColor4ub(color.get_red(), color.get_green(), color.get_blue(), 0);
glVertex2f(dabs[j].pos.x + normals[j].x * len2,
dabs[j].pos.y + normals[j].y * len2);
}
glEnd();
glBegin(GL_QUAD_STRIP);
for(unsigned int j = 0; j < dabs.size()-2; ++j)
{
glColor4ub(color.get_red(), color.get_green(), color.get_blue(), 0);
glVertex2f(dabs[j].pos.x - normals[j].x * len2,
dabs[j].pos.y - normals[j].y * len2);
glColor4ub(color.get_red(), color.get_green(), color.get_blue(), color.get_alpha());
glVertex2f(dabs[j].pos.x - normals[j].x * len,
dabs[j].pos.y - normals[j].y * len);
}
glEnd();
glBegin(GL_QUAD_STRIP);
glColor4ub(color.get_red(), color.get_green(), color.get_blue(), color.get_alpha());
for(unsigned int j = 0; j < dabs.size()-2; ++j)
{
glVertex2f(dabs[j].pos.x + normals[j].x * len,
dabs[j].pos.y + normals[j].y * len);
glVertex2f(dabs[j].pos.x - normals[j].x * len,
dabs[j].pos.y - normals[j].y * len);
}
glEnd();
}
}
void SurfaceItem::render(const Map &map, const Camera &camera)
{
int zone = map.zone(vertices().at(0));
GLuint tex = textureId();
if (zone < 0)
return;
m_program->bind();
m_program->setUniformValue(m_matrixUniform, camera.viewProjectionMatrix());
QSize size = surface()->size();
m_program->setUniformValue(m_pixelSizeUniform, 5. / size.width(), 5. / size.height());
m_program->setUniformValue(m_eyeUniform, camera.viewPos());
m_program->setUniformValue(m_focusColorUniform, GLfloat(m_opacity));
m_program->setUniformValueArray(m_lightsUniform, map.lights(zone).constData(), map.lights(zone).size());
m_program->setUniformValue(m_numLightsUniform, map.lights(zone).size());
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, tex);
QVector<QVector3D> v = vertices();
QVector3D va = v[0];
QVector3D vb = v[1];
QVector3D vc = v[2];
QVector3D vd = v[3];
QVector<QVector3D> vertexBuffer;
vertexBuffer << va << vb << vd << vd << vb << vc;
qreal y1 = 0;
qreal y2 = 1;
if (surface()->origin() == QWaylandSurface::OriginTopLeft)
qSwap(y1, y2);
QVector<QVector2D> texCoordBuffer;
texCoordBuffer << QVector2D(0, y2) << QVector2D(1, y2)
<< QVector2D(0, y1) << QVector2D(0, y1)
<< QVector2D(1, y2) << QVector2D(1, y1);
m_program->setUniformValue(m_normalUniform, -QVector3D::crossProduct(vb - va, vc - va).normalized());
m_program->enableAttributeArray(m_vertexAttr);
m_program->setAttributeArray(m_vertexAttr, vertexBuffer.constData());
m_program->enableAttributeArray(m_texCoordAttr);
m_program->setAttributeArray(m_texCoordAttr, texCoordBuffer.constData());
glEnable(GL_BLEND);
glDisable(GL_CULL_FACE);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glDrawArrays(GL_TRIANGLES, 0, 6);
glDisable(GL_BLEND);
m_program->disableAttributeArray(m_texCoordAttr);
m_program->disableAttributeArray(m_vertexAttr);
#if 0
QOpenGLPaintDevice device(camera.viewSize());
QPainter p(&device);
va = camera.viewProjectionMatrix().map(va);
vb = camera.viewProjectionMatrix().map(vb);
vc = camera.viewProjectionMatrix().map(vc);
vd = camera.viewProjectionMatrix().map(vd);
QVector3D c(camera.viewSize().width() * 0.5, camera.viewSize().height() * 0.5, 0);
va = c + c * va * QVector3D(1, -1, 0);
vb = c + c * vb * QVector3D(1, -1, 0);
vc = c + c * vc * QVector3D(1, -1, 0);
vd = c + c * vd * QVector3D(1, -1, 0);
QPointF pa(va.x(), va.y());
QPointF pb(vb.x(), vb.y());
QPointF pc(vc.x(), vc.y());
QPointF pd(vd.x(), vd.y());
p.drawLine(pa, pb);
p.drawLine(pb, pc);
p.drawLine(pc, pd);
p.drawLine(pd, pa);
extern QVector3D debug;
QVector3D d = camera.viewProjectionMatrix().map(debug);
d = c + c * d * QVector3D(1, -1, 0);
static QVector3D old;
if (debug != old)
old = debug;
p.setPen(Qt::NoPen);
p.setBrush(Qt::red);
p.drawEllipse(QRectF(d.x() - 2, d.y() - 2, 4, 4));
p.end();
#endif
}
void Blur_apply(){
if(multiSamples!=1 && blur==Blur_glsl_depth){
consoleLog("Blur_apply: Blur_glsl_depth can't be used with multisample, disabling\n");
blur=Blur_glsl_simple;
}
if(blur==Blur_none)
return;
float lastMatrix[16];
glGetFloatv(GL_MODELVIEW_MATRIX, lastMatrix);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glScalef(2.f/screen->w, -2.f/screen->h, 1.f);
glTranslatef(-screen->w*.5f, -screen->h*.5f, 0.f);
glDisable(GL_DEPTH_TEST);
glDisable(GL_FOG);
glDisable(GL_LIGHTING);
glDepthMask(GL_FALSE);
if(blur==Blur_basic){
glColor4f(1.f, 1.f, 1.f, powf(.3f, blurdt*60.f));
glBindTexture(GL_TEXTURE_2D, tex_screen);
glBegin(GL_QUADS);
glTexCoord2f(0.f, (float)screen->h/sh);
glVertex2i(0, 0);
glTexCoord2f(0.f, 0.f);
glVertex2i(0, screen->h);
glTexCoord2f((float)screen->w/sw, 0.f);
glVertex2i(screen->w, screen->h);
glTexCoord2f((float)screen->w/sw, (float)screen->h/sh);
glVertex2i(screen->w, 0);
glEnd();
totalPolys+=2;
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
}
#if GL_ARB_shader_objects
else if(blur==Blur_glsl_simple){
glUseProgramObjectARB(prg_blurSimple);
glUniform1iARB(glGetUniformLocationARB(prg_blurSimple, "screen"),
0);
glUniform2fARB(glGetUniformLocationARB(prg_blurSimple, "texSize"),
(float)screen->w/sw, (float)screen->h/sh);
float imat[16];
float mat2[16];
memcpy(imat, mx_old, sizeof(imat));
inverseMatrix4(imat);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "curMatrix"),
1, GL_FALSE, lastMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "oldMatrix"),
1, GL_FALSE, mx_old);
inverseMatrix4(lastMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "oldMatrixInverse"),
1, GL_FALSE, imat);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurSimple, "curMatrixInverse"),
1, GL_FALSE, lastMatrix);
glColor4f(1,1,1,1);
glBindTexture(GL_TEXTURE_2D, tex_screen);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
glBegin(GL_QUADS);
glTexCoord2f(-1.f, 1.f);
glVertex2i(0, 0);
glTexCoord2f(-1.f, -1.f);
glVertex2i(0, screen->h);
glTexCoord2f(1.f, -1.f);
glVertex2i(screen->w, screen->h);
glTexCoord2f(1.f, 1.f);
glVertex2i(screen->w, 0);
glEnd();
totalPolys+=2;
glUseProgramObjectARB(0);
}
#if GL_ARB_depth_texture
else if(blur==Blur_glsl_depth){
glActiveTexture(GL_TEXTURE1_ARB);
glBindTexture(GL_TEXTURE_2D, tex_depth);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
glActiveTexture(GL_TEXTURE0_ARB);
glUseProgramObjectARB(prg_blurDepth);
glUniform1iARB(glGetUniformLocationARB(prg_blurDepth, "screen"),
0);
glUniform1iARB(glGetUniformLocationARB(prg_blurDepth, "depthTex"),
1);
glUniform2fARB(glGetUniformLocationARB(prg_blurDepth, "texSize"),
(float)screen->w/sw, (float)screen->h/sh);
float imat[16];
float mat2[16];
memcpy(imat, mx_old, sizeof(imat));
inverseMatrix4(imat);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "curMatrix"),
1, GL_FALSE, lastMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "oldMatrix"),
1, GL_FALSE, mx_old);
inverseMatrix4(lastMatrix);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "oldMatrixInverse"),
1, GL_FALSE, imat);
glUniformMatrix4fvARB(glGetUniformLocationARB(prg_blurDepth, "curMatrixInverse"),
1, GL_FALSE, lastMatrix);
glColor4f(1,1,1,1);
glBindTexture(GL_TEXTURE_2D, tex_screen);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, screen->w, screen->h);
glBegin(GL_QUADS);
glTexCoord2f(-1.f, 1.f);
glVertex2i(0, 0);
glTexCoord2f(-1.f, -1.f);
glVertex2i(0, screen->h);
glTexCoord2f(1.f, -1.f);
glVertex2i(screen->w, screen->h);
glTexCoord2f(1.f, 1.f);
glVertex2i(screen->w, 0);
glEnd();
totalPolys+=2;
glUseProgramObjectARB(0);
}
#endif
#endif
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_LIGHTING);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glEnable(GL_DEPTH_TEST);
glEnable(GL_FOG);
glDepthMask(GL_TRUE);
}
void vsx_widget_desktop::draw() {
if (!init_run) return;
// this is designed to be root, so set up things
// Deal with movement around the desktop
#define SGN(N) (N >= 0 ? 1 : -1)
#define MAX(N, M) ((N) >= (M) ? (N) : (M))
#define MIN(N, M) ((N) <= (M) ? (N) : (M))
#define CLAMP(N, L, U) (MAX(MIN((N), (U)), (L)))
//if (logo_time > animlen) {
if (!interpolating) {
double acc = 4, dec = 3, spd = global_key_speed;
// interpolation falloff control
float tt = dtime*interpolation_speed*global_interpolation_speed;
if (tt > 1) { tt = 1; }
if(zpd != 0.0) {
double sgn = SGN(zpd);
zps += dtime * acc * sgn * global_interpolation_speed;
zps = CLAMP(zps, -1.2f, 1.2f);
}
if(zpd == 0.0) {
double sgn = SGN(zps);
zps -= dtime * dec * sgn * global_interpolation_speed;
zps = MAX(zps * sgn, 0) * sgn;
}
zp += zps * fabs(zp - 1.1)* spd * dtime + zpp*(zp - 1.0f);
zpp = zpp*(1-tt);
if (zp > 100) {zp = 100; zps = 0;}
if (zp < 1.2) {zp = 1.2; zps = 0;}
if(xpd != 0.0) {
double sgn = SGN(xpd);
xps += dtime * acc * sgn * global_interpolation_speed;
xps = CLAMP(xps, -1, 1);
}
if(xpd == 0.0) {
double sgn = SGN(xps);
xps -= dtime * dec * sgn * global_interpolation_speed;
xps = MAX(xps * sgn, 0) * sgn;
}
xp += xps * fabs(zp - 1.1)* spd * dtime*0.6 + xpp*(zp-1.0f);
xpp = xpp*(1-tt);
if (xp > 10) {xp = 10; xps = 0;}
if (xp < -10) {xp = -10; xps = 0;}
if(ypd != 0.0) {
double sgn = SGN(ypd);
yps += dtime * acc * sgn * global_interpolation_speed;
yps = CLAMP(yps, -1, 1);
}
if(ypd == 0.0) {
double sgn = SGN(yps);
yps -= dtime * dec * sgn * global_interpolation_speed;
yps = MAX(yps * sgn, 0) * sgn;
}
yp += yps * fabs(zp - 1.1)* spd * dtime*0.6 + ypp*(zp-1.0f);
ypp = ypp*(1-tt);
if (yp > 10) {yp = 10; yps = 0;}
if (yp < -10) {yp = -10; yps = 0;}
// printf("xp: %f xps: %f xpd %f dt %f::",xp,xps,xpd,tt);
}
else {
float tt = dtime*10.0f*global_interpolation_speed;
if (tt > 1) { tt = 1; interpolating = false;}
xp = xp*(1-tt)+camera_target.x*tt;
yp = yp*(1-tt)+camera_target.y*tt;
zp = zp*(1-tt)+camera_target.z*tt;
if (
(round(xp*2000) == round(camera_target.x*2000)) &&
(round(yp*2000) == round(camera_target.y*2000)) &&
(round(zp*2000) == round(camera_target.z*2000))
) interpolating = false;
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45,screen_x/screen_y,0.001,120.0);
gluLookAt(xp,yp,zp-1.1f,xp,yp,-1.1f,0.0,1.0,0.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// PERFORMANCE_MODE_CHANGE
// if (performance_mode)
// glBlendFunc(GL_SRC_ALPHA, GL_ONE);
//else
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//
//return;
glEnable(GL_BLEND);
//glClear(GL_COLOR_BUFFER_BIT);
if (!performance_mode)
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
//glEnable(GL_LINE_SMOOTH);
if (!performance_mode)
{
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glColor4f(1,1,1,1);
#ifndef VSXU_PLAYER
if (!mtex.bind())
#endif
glColor4f(skin_color[13].r,skin_color[13].g,skin_color[13].b,skin_color[13].a);
//else
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex3f(pos.x-size.x/2,pos.y-size.y/2,-10.0f);
glTexCoord2f(0, 1);
glVertex3f(pos.x-size.x/2,pos.y+size.y/2,-10.0f);
glTexCoord2f(1, 1);
glVertex3f(pos.x+size.x/2,pos.y+size.y/2,-10.0f);
glTexCoord2f(1, 0);
glVertex3f(pos.x+size.x/2,pos.y-size.y/2,-10.0f);
glEnd();
#ifndef VSXU_PLAYER
mtex._bind();
#endif
}
draw_children();
}
void IrrDriver::renderGlow(video::SOverrideMaterial &overridemat,
std::vector<GlowData>& glows,
const core::aabbox3df& cambox,
int cam)
{
m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID);
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_TMP1), false, false);
glClearColor(0, 0, 0, 0);
glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
const u32 glowcount = glows.size();
ColorizeProvider * const cb = (ColorizeProvider *) m_shaders->m_callbacks[ES_COLORIZE];
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 1, ~0);
glEnable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_BLEND);
for (u32 i = 0; i < glowcount; i++)
{
const GlowData &dat = glows[i];
scene::ISceneNode * const cur = dat.node;
// Quick box-based culling
const core::aabbox3df nodebox = cur->getTransformedBoundingBox();
if (!nodebox.intersectsWithBox(cambox))
continue;
cb->setColor(dat.r, dat.g, dat.b);
cur->render();
}
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glDisable(GL_STENCIL_TEST);
// Cool, now we have the colors set up. Progressively minify.
video::SMaterial minimat;
minimat.Lighting = false;
minimat.ZWriteEnable = false;
minimat.ZBuffer = video::ECFN_ALWAYS;
minimat.setFlag(video::EMF_TRILINEAR_FILTER, true);
minimat.TextureLayer[0].TextureWrapU =
minimat.TextureLayer[0].TextureWrapV = video::ETC_CLAMP_TO_EDGE;
// To half
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_HALF1), false, false);
m_post_processing->renderPassThrough(m_rtts->getRTT(RTT_TMP1));
// To quarter
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_QUARTER1), false, false);
m_post_processing->renderPassThrough(m_rtts->getRTT(RTT_HALF1));
// Blur it
m_post_processing->renderGaussian6Blur(m_rtts->getRTT(RTT_QUARTER1), m_rtts->getRTT(RTT_QUARTER2), 4.f / UserConfigParams::m_width, 4.f / UserConfigParams::m_height);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glStencilFunc(GL_EQUAL, 0, ~0);
glEnable(GL_STENCIL_TEST);
m_video_driver->setRenderTarget(m_rtts->getRTT(RTT_COLOR), false, false);
m_post_processing->renderGlow(m_rtts->getRTT(RTT_QUARTER1));
glDisable(GL_STENCIL_TEST);
}
void VideoViewer(const std::string& input_uri, const std::string& output_uri)
{
pangolin::Var<int> record_timelapse_frame_skip("viewer.record_timelapse_frame_skip", 1 );
pangolin::Var<int> end_frame("viewer.end_frame", std::numeric_limits<int>::max() );
pangolin::Var<bool> video_wait("video.wait", true);
pangolin::Var<bool> video_newest("video.newest", false);
// Open Video by URI
pangolin::VideoRecordRepeat video(input_uri, output_uri);
const size_t num_streams = video.Streams().size();
if(num_streams == 0) {
pango_print_error("No video streams from device.\n");
return;
}
// Output details of video stream
for(size_t s = 0; s < num_streams; ++s) {
const pangolin::StreamInfo& si = video.Streams()[s];
std::cout << "Stream " << s << ": " << si.Width() << " x " << si.Height()
<< " " << si.PixFormat().format << " (pitch: " << si.Pitch() << " bytes)" << std::endl;
}
// Check if video supports VideoPlaybackInterface
pangolin::VideoPlaybackInterface* video_playback = pangolin::FindFirstMatchingVideoInterface<pangolin::VideoPlaybackInterface>(video);
const int total_frames = video_playback ? video_playback->GetTotalFrames() : std::numeric_limits<int>::max();
const int slider_size = (total_frames < std::numeric_limits<int>::max() ? 20 : 0);
if( video_playback ) {
if(total_frames < std::numeric_limits<int>::max() ) {
std::cout << "Video length: " << total_frames << " frames" << std::endl;
}
end_frame = 0;
}
std::vector<unsigned char> buffer;
buffer.resize(video.SizeBytes()+1);
// Create OpenGL window - guess sensible dimensions
pangolin::CreateWindowAndBind( "VideoViewer",
(int)(video.Width() * num_streams),
(int)(video.Height() + slider_size)
);
// Assume packed OpenGL data unless otherwise specified
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_PACK_ALIGNMENT, 1);
glEnable (GL_BLEND);
glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Setup resizable views for video streams
std::vector<pangolin::GlPixFormat> glfmt;
std::vector<std::pair<float,float> > gloffsetscale;
std::vector<size_t> strides;
std::vector<pangolin::ImageViewHandler> handlers;
handlers.reserve(num_streams);
size_t scratch_buffer_bytes = 0;
pangolin::View& container = pangolin::Display("streams");
container.SetLayout(pangolin::LayoutEqual)
.SetBounds(pangolin::Attach::Pix(slider_size), 1.0, 0.0, 1.0);
for(unsigned int d=0; d < num_streams; ++d) {
const pangolin::StreamInfo& si = video.Streams()[d];
pangolin::View& view = pangolin::CreateDisplay().SetAspect(si.Aspect());
container.AddDisplay(view);
glfmt.push_back(pangolin::GlPixFormat(si.PixFormat()));
gloffsetscale.push_back(std::pair<float,float>(0.0f, 1.0f) );
if( si.PixFormat().bpp % 8 ) {
pango_print_warn("Stream %i: Unable to display formats that are not a multiple of 8 bits.", d);
}
if( (8*si.Pitch()) % si.PixFormat().bpp ) {
pango_print_warn("Stream %i: Unable to display formats whose pitch is not a whole number of pixels.", d);
}
if(glfmt.back().gltype == GL_DOUBLE) {
scratch_buffer_bytes = std::max(scratch_buffer_bytes, sizeof(float)*si.Width() * si.Height());
}
strides.push_back( (8*si.Pitch()) / si.PixFormat().bpp );
handlers.push_back( pangolin::ImageViewHandler(si.Width(), si.Height()) );
view.SetHandler(&handlers.back());
}
// current frame in memory buffer and displaying.
pangolin::Var<int> frame("ui.frame", -1, 0, total_frames-1 );
pangolin::Slider frame_slider("frame", frame.Ref() );
if(video_playback && total_frames < std::numeric_limits<int>::max())
{
frame_slider.SetBounds(0.0, pangolin::Attach::Pix(slider_size), 0.0, 1.0);
pangolin::DisplayBase().AddDisplay(frame_slider);
}
std::vector<unsigned char> scratch_buffer;
scratch_buffer.resize(scratch_buffer_bytes);
std::vector<pangolin::Image<unsigned char> > images;
#ifdef CALLEE_HAS_CPP11
const int FRAME_SKIP = 30;
const char show_hide_keys[] = {'1','2','3','4','5','6','7','8','9'};
const char screenshot_keys[] = {'!','"','#','$','%','^','&','*','('};
// Show/hide streams
for(size_t v=0; v < container.NumChildren() && v < 9; v++) {
pangolin::RegisterKeyPressCallback(show_hide_keys[v], [v,&container](){
container[v].ToggleShow();
} );
pangolin::RegisterKeyPressCallback(screenshot_keys[v], [v,&images,&video](){
if(v < images.size() && images[v].ptr) {
try{
pangolin::SaveImage(
images[v], video.Streams()[v].PixFormat(),
pangolin::MakeUniqueFilename("capture.png")
);
}catch(std::exception e){
pango_print_error("Unable to save frame: %s\n", e.what());
}
}
} );
}
pangolin::RegisterKeyPressCallback('r', [&](){
if(!video.IsRecording()) {
video.SetTimelapse( static_cast<size_t>(record_timelapse_frame_skip) );
video.Record();
pango_print_info("Started Recording.\n");
}else{
video.Stop();
pango_print_info("Finished recording.\n");
}
fflush(stdout);
});
pangolin::RegisterKeyPressCallback('p', [&](){
video.Play();
end_frame = std::numeric_limits<int>::max();
pango_print_info("Playing from file log.\n");
fflush(stdout);
});
pangolin::RegisterKeyPressCallback('s', [&](){
video.Source();
end_frame = std::numeric_limits<int>::max();
pango_print_info("Playing from source input.\n");
fflush(stdout);
});
pangolin::RegisterKeyPressCallback(' ', [&](){
end_frame = (frame < end_frame) ? frame : std::numeric_limits<int>::max();
});
pangolin::RegisterKeyPressCallback('w', [&](){
video_wait = !video_wait;
if(video_wait) {
pango_print_info("Gui wait's for video frame.\n");
}else{
pango_print_info("Gui doesn't wait for video frame.\n");
}
});
pangolin::RegisterKeyPressCallback('d', [&](){
video_newest = !video_newest;
if(video_newest) {
pango_print_info("Discarding old frames.\n");
}else{
pango_print_info("Not discarding old frames.\n");
}
});
pangolin::RegisterKeyPressCallback('<', [&](){
if(video_playback) {
frame = video_playback->Seek(frame - FRAME_SKIP) -1;
end_frame = frame + 1;
}else{
pango_print_warn("Unable to skip backward.");
}
});
pangolin::RegisterKeyPressCallback('>', [&](){
if(video_playback) {
frame = video_playback->Seek(frame + FRAME_SKIP) -1;
end_frame = frame + 1;
}else{
end_frame = frame + FRAME_SKIP;
}
});
pangolin::RegisterKeyPressCallback(',', [&](){
if(video_playback) {
frame = video_playback->Seek(frame - 1) -1;
end_frame = frame+1;
}else{
pango_print_warn("Unable to skip backward.");
}
});
pangolin::RegisterKeyPressCallback('.', [&](){
// Pause at next frame
end_frame = frame+1;
});
pangolin::RegisterKeyPressCallback('0', [&](){
video.RecordOneFrame();
});
pangolin::RegisterKeyPressCallback('a', [&](){
// Adapt scale
for(unsigned int i=0; i<images.size(); ++i) {
if(container[i].HasFocus()) {
pangolin::Image<unsigned char>& img = images[i];
pangolin::ImageViewHandler& ivh = handlers[i];
const bool have_selection = std::isfinite(ivh.GetSelection().Area()) && std::abs(ivh.GetSelection().Area()) >= 4;
pangolin::XYRangef froi = have_selection ? ivh.GetSelection() : ivh.GetViewToRender();
gloffsetscale[i] = pangolin::GetOffsetScale(img, froi.Cast<int>(), glfmt[i]);
}
}
});
pangolin::RegisterKeyPressCallback('g', [&](){
std::pair<float,float> os_default(0.0f, 1.0f);
// Get the scale and offset from the container that has focus.
for(unsigned int i=0; i<images.size(); ++i) {
if(container[i].HasFocus()) {
pangolin::Image<unsigned char>& img = images[i];
pangolin::ImageViewHandler& ivh = handlers[i];
const bool have_selection = std::isfinite(ivh.GetSelection().Area()) && std::abs(ivh.GetSelection().Area()) >= 4;
pangolin::XYRangef froi = have_selection ? ivh.GetSelection() : ivh.GetViewToRender();
os_default = pangolin::GetOffsetScale(img, froi.Cast<int>(), glfmt[i]);
break;
}
}
// Adapt scale for all images equally
// TODO : we're assuming the type of all the containers images' are the same.
for(unsigned int i=0; i<images.size(); ++i) {
gloffsetscale[i] = os_default;
}
});
#endif // CALLEE_HAS_CPP11
#ifdef DEBUGVIDEOVIEWER
unsigned int delayms = 0;
pangolin::RegisterKeyPressCallback('z', [&](){
// Adapt delay
delayms += 1;
std::cout << " Fake delay " << delayms << "ms" << std::endl;
});
pangolin::RegisterKeyPressCallback('x', [&](){
// Adapt delay
delayms = (delayms > 1) ? delayms-1 : 0;
});
pangolin::basetime start,now;
#endif // DEBUGVIDEOVIEWER
// Stream and display video
while(!pangolin::ShouldQuit())
{
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
glColor3f(1.0f, 1.0f, 1.0f);
if(frame.GuiChanged()) {
if(video_playback) {
frame = video_playback->Seek(frame) -1;
}
end_frame = frame + 1;
}
#ifdef DEBUGVIDEOVIEWER
boostd::this_thread::sleep_for(boostd::chrono::milliseconds(delayms));
std::cout << "-------------------------------------------------------" << std::endl;
now = pangolin::TimeNow();
std::cout << " FPS: " << 1.0/pangolin::TimeDiff_s(start, now) << " artificial delay: " << delayms <<"ms"<< std::endl;
std::cout << "-------------------------------------------------------" << std::endl;
start = now;
#endif
if ( frame < end_frame ) {
if( video.Grab(&buffer[0], images, video_wait, video_newest) ) {
frame = frame +1;
}
}
#ifdef DEBUGVIDEOVIEWER
const pangolin::basetime end = pangolin::TimeNow();
std::cout << "Total grab time: " << 1000*pangolin::TimeDiff_s(start, end) << "ms" << std::endl;
#endif
glLineWidth(1.5f);
glDisable(GL_DEPTH_TEST);
for(unsigned int i=0; i<images.size(); ++i)
{
if(container[i].IsShown()) {
container[i].Activate();
pangolin::Image<unsigned char>& image = images[i];
// Get texture of correct dimension / format
const pangolin::GlPixFormat& fmt = glfmt[i];
pangolin::GlTexture& tex = pangolin::TextureCache::I().GlTex((GLsizei)image.w, (GLsizei)image.h, fmt.scalable_internal_format, fmt.glformat, GL_FLOAT);
// Upload image data to texture
tex.Bind();
if(fmt.gltype == GL_DOUBLE) {
// Convert to float first, using scrath_buffer for storage
pangolin::Image<float> fimage(image.w, image.h, image.w*sizeof(float), (float*)scratch_buffer.data());
ConvertPixels<float,double>( fimage, image.Reinterpret<double>() );
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
tex.Upload(fimage.ptr,0,0, (GLsizei)fimage.w, (GLsizei)fimage.h, fmt.glformat, GL_FLOAT);
}else{
glPixelStorei(GL_UNPACK_ROW_LENGTH, (GLint)strides[i]);
tex.Upload(image.ptr,0,0, (GLsizei)image.w, (GLsizei)image.h, fmt.glformat, fmt.gltype);
}
// Render
handlers[i].UpdateView();
handlers[i].glSetViewOrtho();
const std::pair<float,float> os = gloffsetscale[i];
pangolin::GlSlUtilities::OffsetAndScale(os.first, os.second);
handlers[i].glRenderTexture(tex);
pangolin::GlSlUtilities::UseNone();
handlers[i].glRenderOverlay();
}
}
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
// leave in pixel orthographic for slider to render.
pangolin::DisplayBase().ActivatePixelOrthographic();
if(video.IsRecording()) {
pangolin::glRecordGraphic(pangolin::DisplayBase().v.w-14.0f, pangolin::DisplayBase().v.h-14.0f, 7.0f);
}
pangolin::FinishFrame();
}
}
void CMiniMap::DrawForReal(bool use_geo)
{
SCOPED_TIMER("MiniMap::DrawForReal");
//glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPushAttrib(GL_DEPTH_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDepthMask(GL_FALSE);
glDisable(GL_TEXTURE_2D);
glMatrixMode(GL_MODELVIEW);
if (minimized) {
if (!slaveDrawMode) {
DrawMinimizedButton();
}
glPopAttrib();
glEnable(GL_TEXTURE_2D);
return;
}
// draw the frameborder
if (!slaveDrawMode && !globalRendering->dualScreenMode && !maximized) {
glEnable(GL_BLEND);
DrawFrame();
glDisable(GL_BLEND);
}
bool resetTextureMatrix = false;
if (use_geo) {
glPushMatrix();
// switch to normalized minimap coords
if (globalRendering->dualScreenMode) {
glViewport(xpos, ypos, width, height);
glScalef(width * globalRendering->pixelX, height * globalRendering->pixelY, 1.0f);
} else {
glTranslatef(xpos * globalRendering->pixelX, ypos * globalRendering->pixelY, 0.0f);
glScalef(width * globalRendering->pixelX, height * globalRendering->pixelY, 1.0f);
}
/* FIXME: fix mouse handling too and make it fully customizable, so Lua can rotate the minimap to any angle
CCameraController* camController = &camHandler->GetCurrentController();
COverheadController* taCam = dynamic_cast<COverheadController*>(camController);
SmoothController* smCam = dynamic_cast<SmoothController*>(camController);
if ((taCam && taCam->flipped) || (smCam && smCam->flipped)) {
glTranslatef(1.0f, 1.0f, 0.0f);
glScalef(-1.0f, -1.0f, 1.0f);
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glTranslatef(1.0f, 1.0f, 0.0f);
glScalef(-1.0f, -1.0f, 1.0f);
glMatrixMode(GL_MODELVIEW);
resetTextureMatrix = true;
}*/
}
setSurfaceCircleFunc(DrawSurfaceCircle);
setSurfaceSquareFunc(DrawSurfaceSquare);
cursorIcons.Enable(false);
glColor4f(0.6f, 0.6f, 0.6f, 1.0f);
// don't mirror the map texture with flipped cameras
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
// draw the map
glDisable(GL_BLEND);
readmap->DrawMinimap();
glEnable(GL_BLEND);
glMatrixMode(GL_TEXTURE);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
// clip everything outside of the minimap box
{
const double plane0[4] = {0,-1,0,1};
const double plane1[4] = {0,1,0,0};
const double plane2[4] = {-1,0,0,1};
const double plane3[4] = {1,0,0,0};
glClipPlane(GL_CLIP_PLANE0, plane0); // clip bottom
glClipPlane(GL_CLIP_PLANE1, plane1); // clip top
glClipPlane(GL_CLIP_PLANE2, plane2); // clip right
glClipPlane(GL_CLIP_PLANE3, plane3); // clip left
glEnable(GL_CLIP_PLANE0);
glEnable(GL_CLIP_PLANE1);
glEnable(GL_CLIP_PLANE2);
glEnable(GL_CLIP_PLANE3);
}
// switch to top-down map/world coords (z is twisted with y compared to the real map/world coords)
glPushMatrix();
glTranslatef(0.0f, +1.0f, 0.0f);
glScalef(+1.0f / (gs->mapx * SQUARE_SIZE), -1.0f / (gs->mapy * SQUARE_SIZE), 1.0f);
glEnable(GL_TEXTURE_2D);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.0f);
{
GML_RECMUTEX_LOCK(unit); // DrawForReal
const std::set<CUnit*>& units = unitDrawer->GetUnsortedUnits();
for (std::set<CUnit*>::const_iterator it = units.begin(); it != units.end(); ++it) {
DrawUnit(*it);
}
// highlight the selected unit
CUnit* unit = GetSelectUnit(GetMapPosition(mouse->lastx, mouse->lasty));
if (unit != NULL) {
DrawUnitHighlight(unit);
}
}
glDisable(GL_ALPHA_TEST);
glDisable(GL_TEXTURE_2D);
glPushMatrix();
glRotatef(-90.0f, +1.0f, 0.0f, 0.0f); // real 'world' coordinates
glScalef(1.0f, 0.0f, 1.0f); // skip the y-coord (Lua's DrawScreen is perspective and so any z-coord in it influence the x&y, too)
// draw the projectiles
if (drawProjectiles) {
glPointSize(1.0f);
WorkaroundATIPointSizeBug();
projectileDrawer->DrawProjectilesMiniMap();
}
// draw the queued commands
//
// NOTE: this needlessly adds to the CursorIcons list, but at least
// they are not drawn (because the input receivers are drawn
// after the command queues)
LuaUnsyncedCtrl::DrawUnitCommandQueues();
if ((drawCommands > 0) && guihandler->GetQueueKeystate()) {
selectedUnits.DrawCommands();
}
lineDrawer.DrawAll();
// draw the selection shape, and some ranges
if (drawCommands > 0) {
guihandler->DrawMapStuff(!!drawCommands);
}
{
GML_RECMUTEX_LOCK(sel); // DrawForReal
// draw unit ranges
const float radarSquare = radarhandler->radarDiv;
CUnitSet& selUnits = selectedUnits.selectedUnits;
for(CUnitSet::iterator si = selUnits.begin(); si != selUnits.end(); ++si) {
CUnit* unit = *si;
if (unit->radarRadius && !unit->beingBuilt && unit->activated) {
glColor3fv(cmdColors.rangeRadar);
DrawCircle(unit->pos, (unit->radarRadius * radarSquare));
}
if (unit->sonarRadius && !unit->beingBuilt && unit->activated) {
glColor3fv(cmdColors.rangeSonar);
DrawCircle(unit->pos, (unit->sonarRadius * radarSquare));
}
if (unit->jammerRadius && !unit->beingBuilt && unit->activated) {
glColor3fv(cmdColors.rangeJammer);
DrawCircle(unit->pos, (unit->jammerRadius * radarSquare));
}
// change if someone someday create a non stockpiled interceptor
const CWeapon* w = unit->stockpileWeapon;
if((w != NULL) && w->weaponDef->interceptor) {
if (w->numStockpiled) {
glColor3fv(cmdColors.rangeInterceptorOn);
} else {
glColor3fv(cmdColors.rangeInterceptorOff);
}
DrawCircle(unit->pos, w->weaponDef->coverageRange);
}
}
}
glPopMatrix(); // revert to the 2d xform
if (!minimap->maximized) {
// draw the camera frustum lines
cam2->GetFrustumSides(0.0f, 0.0f, 1.0f, true);
cam2->ClipFrustumLines(true, -10000.0f, 400096.0f);
const std::vector<CCamera::FrustumLine>& negSides = cam2->negFrustumSides;
// const std::vector<CCamera::FrustumLine>& posSides = cam2->posFrustumSides;
std::vector<CCamera::FrustumLine>::const_iterator fli;
CVertexArray* va = GetVertexArray();
va->Initialize();
va->EnlargeArrays(negSides.size() * 2, 0, VA_SIZE_2D0);
for (fli = negSides.begin(); fli != negSides.end(); ++fli) {
if (fli->minz < fli->maxz) {
va->AddVertex2dQ0(fli->base + (fli->dir * fli->minz), fli->minz);
va->AddVertex2dQ0(fli->base + (fli->dir * fli->maxz), fli->maxz);
}
}
glLineWidth(2.5f);
glColor4f(0, 0, 0, 0.5f);
va->DrawArray2d0(GL_LINES);
glLineWidth(1.5f);
glColor4f(1, 1, 1, 0.75f);
va->DrawArray2d0(GL_LINES);
glLineWidth(1.0f);
}
// selection box
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
CMouseHandler::ButtonPressEvt& bp = mouse->buttons[SDL_BUTTON_LEFT];
if (selecting && fullProxy && (bp.movement > 4)) {
const float3 oldPos = GetMapPosition(bp.x, bp.y);
const float3 newPos = GetMapPosition(mouse->lastx, mouse->lasty);
glColor4fv(cmdColors.mouseBox);
glBlendFunc((GLenum)cmdColors.MouseBoxBlendSrc(),
(GLenum)cmdColors.MouseBoxBlendDst());
glLineWidth(cmdColors.MouseBoxLineWidth());
float verts[] = {
oldPos.x, oldPos.z,
newPos.x, oldPos.z,
newPos.x, newPos.z,
oldPos.x, newPos.z,
};
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(2, GL_FLOAT, 0, verts);
glDrawArrays(GL_LINE_LOOP, 0, 4);
glDisableClientState(GL_VERTEX_ARRAY);
glLineWidth(1.0f);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
DrawNotes();
// reset 1
if (resetTextureMatrix) {
glMatrixMode(GL_TEXTURE_MATRIX);
glPopMatrix();
}
glMatrixMode(GL_MODELVIEW);
if (use_geo) {
glPopMatrix();
}
// reset 2
glPopMatrix();
glPopAttrib();
glEnable(GL_TEXTURE_2D);
{
//! prepare ClipPlanes for Lua's DrawInMinimap Modelview matrix
//! quote from glClipPlane spec:
//! "When glClipPlane is called, equation is transformed by the inverse of the modelview matrix and stored in the resulting eye coordinates.
//! Subsequent changes to the modelview matrix have no effect on the stored plane-equation components."
//! -> we have to use the same modelview matrix when calling glClipPlane and later draw calls
//! set the modelview matrix to the same as used in Lua's DrawInMinimap
glPushMatrix();
glLoadIdentity();
glScalef(1.0f / width, 1.0f / height, 1.0f);
const double plane0[4] = {0, -1, 0, double(height)};
const double plane1[4] = {0, 1, 0, 0};
const double plane2[4] = {-1, 0, 0, double(width)};
const double plane3[4] = {1, 0, 0, 0};
glClipPlane(GL_CLIP_PLANE0, plane0); // clip bottom
glClipPlane(GL_CLIP_PLANE1, plane1); // clip top
glClipPlane(GL_CLIP_PLANE2, plane2); // clip right
glClipPlane(GL_CLIP_PLANE3, plane3); // clip left
glPopMatrix();
}
//! allow the LUA scripts to draw into the minimap
eventHandler.DrawInMiniMap();
if (use_geo && globalRendering->dualScreenMode)
glViewport(globalRendering->viewPosX,0,globalRendering->viewSizeX,globalRendering->viewSizeY);
//FIXME: Lua modifies the matrices w/o reseting it! (quite complexe to fix because ClearMatrixStack() makes it impossible to use glPushMatrix)
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,1,0,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// disable ClipPlanes
glDisable(GL_CLIP_PLANE0);
glDisable(GL_CLIP_PLANE1);
glDisable(GL_CLIP_PLANE2);
glDisable(GL_CLIP_PLANE3);
cursorIcons.Enable(true);
setSurfaceCircleFunc(NULL);
setSurfaceSquareFunc(NULL);
}
void RobotWindow::configure()
{
// Especifica que a cor de fundo da janela será preta
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
// informações sobre a luz
GLfloat luzAmbiente[4]={0.4, 0.4, 0.4, 1.0};
GLfloat luzDifusa[4]={0.8, 0.8, 0.8, 1.0}; // "cor"
GLfloat luzEspecular[4]={1.0, 1.0, 1.0, 1.0}; // "brilho"
GLfloat posicaoLuz[4]={4.0, 100, 4.0, 0};
// Define os parâmetros da luz de número 0
glLightfv(GL_LIGHT0, GL_AMBIENT, luzAmbiente);
glLightfv(GL_LIGHT0, GL_DIFFUSE, luzDifusa);
glLightfv(GL_LIGHT0, GL_SPECULAR, luzEspecular);
glLightfv(GL_LIGHT0, GL_POSITION, posicaoLuz);
// Capacidade de brilho do material
GLfloat especularidade[4]={0.5,0.5,0.5,0.5};
GLint especMaterial = 60;
// Define a refletância do material
glMaterialfv(GL_FRONT, GL_SPECULAR, especularidade);
// Define a concentração do brilho
glMateriali(GL_FRONT, GL_SHININESS, especMaterial);
//
GLfloat materialColor[] = { 1.0, 1.0, 1.0, 1.0 };
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, materialColor);
// Ativa o uso da luz ambiente
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, luzAmbiente);
// Habilita a definição da cor do material a partir da cor corrente
// Usar as cores correntes para colorir os materiais perceptíveis no escuro
glEnable(GL_COLOR_MATERIAL);
//Habilita o uso de iluminação
glEnable(GL_LIGHTING); // Declara iluminação
// Habilita a luz de número 0
glEnable(GL_LIGHT0); // Usa iluminação na luz/lâmpada 0
// Habilita o depth-buffering
// Faz a luz preencher o buffer de pronfundidade e não só o fundo
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
//glDepthRange(0.0f,1.0f);
// Habilita o modelo de colorização de Gouraud
glShadeModel(GL_SMOOTH);
//glShadeModel(GL_FLAT);
glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
glEnable(GL_NORMALIZE);
glEnable(GL_DITHER);
//glEnable(GL_POINT_SMOOTH);
//glHint(GL_POINT_SMOOTH_HINT, GL_NICEST);
glEnable(GL_LINE_SMOOTH);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glLineWidth(0.5);
//glEnable(GL_POLYGON_SMOOTH);
//glHint(GL_POLYGON_SMOOTH_HINT, GL_NICEST);
//glDepthFunc( GL_LEQUAL );
//glClearAccum( 0.0, 0.0, 0.0, 0.0 );
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glEnable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
//glBlendFunc(GL_SRC_ALPHA, GL_DST_COLOR);
//glBlendFunc(GL_ONE, GL_ONE);
//glBlendFunc(GL_SRC_ALPHA_SATURATE, GL_ONE);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glBlendFunc(GL_ONE_MINUS_DST_ALPHA,GL_DST_ALPHA);
//glDepthFunc(GL_EQUAL);
//glDepthFunc(GL_GEQUAL);
glEnable(GL_CULL_FACE);
//glCullFace(GL_BACK);
}
void
glmShaderMaterial(GLMmaterial *mat)
{
static const float ambientLight[4] = { 0.1, 0.1, 0.1, 0.0 };
static const float diffuseLight[4] = { 0.75, 0.75, 0.75, 1.0 };
static const float specularLight[4] = { 1.0, 1.0, 1.0, 0.0 };
if (!mat->prog) {
/* make shader now */
char newShader[10000];
GLuint vs, fs;
const char *diffuseTex = mat->texture_kd ? "true" : "false";
const char *specularTex = mat->texture_ks ? "true" : "false";
GLint uAmbientLight, uDiffuseLight, uSpecularLight;
/* replace %d with 0 or 1 */
sprintf(newShader, TexFragmentShader, diffuseTex, specularTex);
if (0)
printf("===== new shader =====\n%s\n============\n", newShader);
vs = CompileShaderText(GL_VERTEX_SHADER, VertexShader);
fs = CompileShaderText(GL_FRAGMENT_SHADER, newShader);
mat->prog = LinkShaders(vs, fs);
assert(mat->prog);
glUseProgram(mat->prog);
mat->uAmbient = glGetUniformLocation(mat->prog, "ambient");
mat->uDiffuse = glGetUniformLocation(mat->prog, "diffuse");
mat->uSpecular = glGetUniformLocation(mat->prog, "specular");
mat->uShininess = glGetUniformLocation(mat->prog, "shininess");
mat->uDiffTex = glGetUniformLocation(mat->prog, "diffTex");
mat->uSpecTex = glGetUniformLocation(mat->prog, "specTex");
uAmbientLight = glGetUniformLocation(mat->prog, "ambientLight");
uDiffuseLight = glGetUniformLocation(mat->prog, "diffuseLight");
uSpecularLight = glGetUniformLocation(mat->prog, "specularLight");
glUniform4fv(mat->uAmbient, 1, mat->ambient);
glUniform4fv(mat->uDiffuse, 1, mat->diffuse);
glUniform4fv(mat->uSpecular, 1, mat->specular);
glUniform1f(mat->uShininess, mat->shininess);
glUniform1i(mat->uDiffTex, 0);
glUniform1i(mat->uSpecTex, 1);
glUniform4fv(uAmbientLight, 1, ambientLight);
glUniform4fv(uDiffuseLight, 1, diffuseLight);
glUniform4fv(uSpecularLight, 1, specularLight);
}
glActiveTexture(GL_TEXTURE1);
if (mat->texture_ks)
glBindTexture(GL_TEXTURE_CUBE_MAP, mat->texture_ks);
else
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
glActiveTexture(GL_TEXTURE0);
if (mat->texture_kd)
glBindTexture(GL_TEXTURE_2D, mat->texture_kd);
else
glBindTexture(GL_TEXTURE_2D, 0);
if (mat->diffuse[3] < 1.0) {
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
else {
glDisable(GL_BLEND);
}
glUseProgram(mat->prog);
}
void GraphicsWindow::Paint(void) {
int i;
havePainted = true;
int w, h;
GetGraphicsWindowSize(&w, &h);
width = w; height = h;
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glScaled(scale*2.0/w, scale*2.0/h, scale*1.0/30000);
double mat[16];
// Last thing before display is to apply the perspective
double clp = SS.CameraTangent()*scale;
MakeMatrix(mat, 1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, clp, 1);
glMultMatrixd(mat);
// Before that, we apply the rotation
Vector n = projUp.Cross(projRight);
MakeMatrix(mat, projRight.x, projRight.y, projRight.z, 0,
projUp.x, projUp.y, projUp.z, 0,
n.x, n.y, n.z, 0,
0, 0, 0, 1);
glMultMatrixd(mat);
// And before that, the translation
MakeMatrix(mat, 1, 0, 0, offset.x,
0, 1, 0, offset.y,
0, 0, 1, offset.z,
0, 0, 0, 1);
glMultMatrixd(mat);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glShadeModel(GL_SMOOTH);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glEnable(GL_LINE_SMOOTH);
// don't enable GL_POLYGON_SMOOTH; that looks ugly on some graphics cards,
// drawn with leaks in the mesh
glEnable(GL_POLYGON_OFFSET_LINE);
glEnable(GL_POLYGON_OFFSET_FILL);
glEnable(GL_DEPTH_TEST);
glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
glEnable(GL_NORMALIZE);
// At the same depth, we want later lines drawn over earlier.
glDepthFunc(GL_LEQUAL);
if(SS.AllGroupsOkay()) {
glClearColor(REDf(SS.backgroundColor),
GREENf(SS.backgroundColor),
BLUEf(SS.backgroundColor), 1.0f);
} else {
// Draw a different background whenever we're having solve problems.
DWORD rgb = Style::Color(Style::DRAW_ERROR);
glClearColor(0.4f*REDf(rgb), 0.4f*GREENf(rgb), 0.4f*BLUEf(rgb), 1.0f);
// And show the text window, which has info to debug it
ForceTextWindowShown();
}
glClear(GL_COLOR_BUFFER_BIT);
glClearDepth(1.0);
glClear(GL_DEPTH_BUFFER_BIT);
if(SS.bgImage.fromFile) {
// If a background image is loaded, then we draw it now as a texture.
// This handles the resizing for us nicely.
glBindTexture(GL_TEXTURE_2D, TEXTURE_BACKGROUND_IMG);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB,
SS.bgImage.rw, SS.bgImage.rh,
0,
GL_RGB, GL_UNSIGNED_BYTE,
SS.bgImage.fromFile);
double tw = ((double)SS.bgImage.w) / SS.bgImage.rw,
th = ((double)SS.bgImage.h) / SS.bgImage.rh;
double mmw = SS.bgImage.w / SS.bgImage.scale,
mmh = SS.bgImage.h / SS.bgImage.scale;
Vector origin = SS.bgImage.origin;
origin = origin.DotInToCsys(projRight, projUp, n);
// Place the depth of our origin at the point that corresponds to
// w = 1, so that it's unaffected by perspective.
origin.z = (offset.ScaledBy(-1)).Dot(n);
origin = origin.ScaleOutOfCsys(projRight, projUp, n);
// Place the background at the very back of the Z order, though, by
// mucking with the depth range.
glDepthRange(1, 1);
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glxVertex3v(origin);
glTexCoord2d(0, th);
glxVertex3v(origin.Plus(projUp.ScaledBy(mmh)));
glTexCoord2d(tw, th);
glxVertex3v(origin.Plus(projRight.ScaledBy(mmw).Plus(
projUp. ScaledBy(mmh))));
glTexCoord2d(tw, 0);
glxVertex3v(origin.Plus(projRight.ScaledBy(mmw)));
glEnd();
glDisable(GL_TEXTURE_2D);
}
glxDepthRangeOffset(0);
// Nasty case when we're reloading the imported files; could be that
// we get an error, so a dialog pops up, and a message loop starts, and
// we have to get called to paint ourselves. If the sketch is screwed
// up, then we could trigger an oops trying to draw.
if(!SS.allConsistent) return;
// Let's use two lights, at the user-specified locations
GLfloat f;
glEnable(GL_LIGHT0);
f = (GLfloat)SS.lightIntensity[0];
GLfloat li0[] = { f, f, f, 1.0f };
glLightfv(GL_LIGHT0, GL_DIFFUSE, li0);
glLightfv(GL_LIGHT0, GL_SPECULAR, li0);
glEnable(GL_LIGHT1);
f = (GLfloat)SS.lightIntensity[1];
GLfloat li1[] = { f, f, f, 1.0f };
glLightfv(GL_LIGHT1, GL_DIFFUSE, li1);
glLightfv(GL_LIGHT1, GL_SPECULAR, li1);
Vector ld;
ld = VectorFromProjs(SS.lightDir[0]);
GLfloat ld0[4] = { (GLfloat)ld.x, (GLfloat)ld.y, (GLfloat)ld.z, 0 };
glLightfv(GL_LIGHT0, GL_POSITION, ld0);
ld = VectorFromProjs(SS.lightDir[1]);
GLfloat ld1[4] = { (GLfloat)ld.x, (GLfloat)ld.y, (GLfloat)ld.z, 0 };
glLightfv(GL_LIGHT1, GL_POSITION, ld1);
if(SS.drawBackFaces) {
// For debugging, draw the backs of the triangles in red, so that we
// notice when a shell is open
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1);
} else {
glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 0);
}
GLfloat ambient[4] = { (float)SS.ambientIntensity,
(float)SS.ambientIntensity,
(float)SS.ambientIntensity, 1 };
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambient);
glxUnlockColor();
if(showSnapGrid && LockedInWorkplane()) {
hEntity he = ActiveWorkplane();
EntityBase *wrkpl = SK.GetEntity(he),
*norm = wrkpl->Normal();
Vector wu, wv, wn, wp;
wp = SK.GetEntity(wrkpl->point[0])->PointGetNum();
wu = norm->NormalU();
wv = norm->NormalV();
wn = norm->NormalN();
double g = SS.gridSpacing;
double umin = VERY_POSITIVE, umax = VERY_NEGATIVE,
vmin = VERY_POSITIVE, vmax = VERY_NEGATIVE;
int a;
for(a = 0; a < 4; a++) {
// Ideally, we would just do +/- half the width and height; but
// allow some extra slop for rounding.
Vector horiz = projRight.ScaledBy((0.6*width)/scale + 2*g),
vert = projUp. ScaledBy((0.6*height)/scale + 2*g);
if(a == 2 || a == 3) horiz = horiz.ScaledBy(-1);
if(a == 1 || a == 3) vert = vert. ScaledBy(-1);
Vector tp = horiz.Plus(vert).Minus(offset);
// Project the point into our grid plane, normal to the screen
// (not to the grid plane). If the plane is on edge then this is
// impossible so don't try to draw the grid.
bool parallel;
Vector tpp = Vector::AtIntersectionOfPlaneAndLine(
wn, wn.Dot(wp),
tp, tp.Plus(n),
¶llel);
if(parallel) goto nogrid;
tpp = tpp.Minus(wp);
double uu = tpp.Dot(wu),
vv = tpp.Dot(wv);
umin = min(uu, umin);
umax = max(uu, umax);
vmin = min(vv, vmin);
vmax = max(vv, vmax);
}
int i, j, i0, i1, j0, j1;
i0 = (int)(umin / g);
i1 = (int)(umax / g);
j0 = (int)(vmin / g);
j1 = (int)(vmax / g);
if(i0 > i1 || i1 - i0 > 400) goto nogrid;
if(j0 > j1 || j1 - j0 > 400) goto nogrid;
glLineWidth(1);
glxColorRGBa(Style::Color(Style::DATUM), 0.3);
glBegin(GL_LINES);
for(i = i0 + 1; i < i1; i++) {
glxVertex3v(wp.Plus(wu.ScaledBy(i*g)).Plus(wv.ScaledBy(j0*g)));
glxVertex3v(wp.Plus(wu.ScaledBy(i*g)).Plus(wv.ScaledBy(j1*g)));
}
for(j = j0 + 1; j < j1; j++) {
glxVertex3v(wp.Plus(wu.ScaledBy(i0*g)).Plus(wv.ScaledBy(j*g)));
glxVertex3v(wp.Plus(wu.ScaledBy(i1*g)).Plus(wv.ScaledBy(j*g)));
}
glEnd();
// Clear the depth buffer, so that the grid is at the very back of
// the Z order.
glClear(GL_DEPTH_BUFFER_BIT);
nogrid:;
}
// Draw the active group; this does stuff like the mesh and edges.
(SK.GetGroup(activeGroup))->Draw();
// Now draw the entities
if(showHdnLines) glDisable(GL_DEPTH_TEST);
Entity::DrawAll();
// Draw filled paths in all groups, when those filled paths were requested
// specially by assigning a style with a fill color, or when the filled
// paths are just being filled by default. This should go last, to make
// the transparency work.
Group *g;
for(g = SK.group.First(); g; g = SK.group.NextAfter(g)) {
if(!(g->IsVisible())) continue;
g->DrawFilledPaths();
}
glDisable(GL_DEPTH_TEST);
// Draw the constraints
for(i = 0; i < SK.constraint.n; i++) {
SK.constraint.elem[i].Draw();
}
// Draw the traced path, if one exists
glLineWidth(Style::Width(Style::ANALYZE));
glxColorRGB(Style::Color(Style::ANALYZE));
SContour *sc = &(SS.traced.path);
glBegin(GL_LINE_STRIP);
for(i = 0; i < sc->l.n; i++) {
glxVertex3v(sc->l.elem[i].p);
}
glEnd();
// And the naked edges, if the user did Analyze -> Show Naked Edges.
glLineWidth(Style::Width(Style::DRAW_ERROR));
glxColorRGB(Style::Color(Style::DRAW_ERROR));
glxDrawEdges(&(SS.nakedEdges), true);
// Then redraw whatever the mouse is hovering over, highlighted.
glDisable(GL_DEPTH_TEST);
glxLockColorTo(Style::Color(Style::HOVERED));
hover.Draw();
// And finally draw the selection, same mechanism.
glxLockColorTo(Style::Color(Style::SELECTED));
for(Selection *s = selection.First(); s; s = selection.NextAfter(s)) {
s->Draw();
}
glxUnlockColor();
// If a marquee selection is in progress, then draw the selection
// rectangle, as an outline and a transparent fill.
if(pending.operation == DRAGGING_MARQUEE) {
Point2d begin = ProjectPoint(orig.marqueePoint);
double xmin = min(orig.mouse.x, begin.x),
xmax = max(orig.mouse.x, begin.x),
ymin = min(orig.mouse.y, begin.y),
ymax = max(orig.mouse.y, begin.y);
Vector tl = UnProjectPoint(Point2d::From(xmin, ymin)),
tr = UnProjectPoint(Point2d::From(xmax, ymin)),
br = UnProjectPoint(Point2d::From(xmax, ymax)),
bl = UnProjectPoint(Point2d::From(xmin, ymax));
glLineWidth((GLfloat)1.3);
glxColorRGB(Style::Color(Style::HOVERED));
glBegin(GL_LINE_LOOP);
glxVertex3v(tl);
glxVertex3v(tr);
glxVertex3v(br);
glxVertex3v(bl);
glEnd();
glxColorRGBa(Style::Color(Style::HOVERED), 0.10);
glBegin(GL_QUADS);
glxVertex3v(tl);
glxVertex3v(tr);
glxVertex3v(br);
glxVertex3v(bl);
glEnd();
}
// An extra line, used to indicate the origin when rotating within the
// plane of the monitor.
if(SS.extraLine.draw) {
glLineWidth(1);
glxLockColorTo(Style::Color(Style::DATUM));
glBegin(GL_LINES);
glxVertex3v(SS.extraLine.ptA);
glxVertex3v(SS.extraLine.ptB);
glEnd();
}
// A note to indicate the origin in the just-exported file.
if(SS.justExportedInfo.draw) {
glxColorRGB(Style::Color(Style::DATUM));
Vector p = SS.justExportedInfo.pt,
u = SS.justExportedInfo.u,
v = SS.justExportedInfo.v;
glLineWidth(1.5);
glBegin(GL_LINES);
glxVertex3v(p.Plus(u.WithMagnitude(-15/scale)));
glxVertex3v(p.Plus(u.WithMagnitude(30/scale)));
glxVertex3v(p.Plus(v.WithMagnitude(-15/scale)));
glxVertex3v(p.Plus(v.WithMagnitude(30/scale)));
glEnd();
glxWriteText("(x, y) = (0, 0) for file just exported",
DEFAULT_TEXT_HEIGHT,
p.Plus(u.ScaledBy(10/scale)).Plus(v.ScaledBy(10/scale)),
u, v, NULL, NULL);
glxWriteText("press Esc to clear this message",
DEFAULT_TEXT_HEIGHT,
p.Plus(u.ScaledBy(40/scale)).Plus(
v.ScaledBy(-(DEFAULT_TEXT_HEIGHT)/scale)),
u, v, NULL, NULL);
}
// And finally the toolbar.
if(SS.showToolbar) {
ToolbarDraw();
}
}
