//--------------------------------------------------------------------------------------------------
/// Draw the legend using immediate mode OpenGL
//--------------------------------------------------------------------------------------------------
void OverlayScalarMapperLegend::renderLegendImmediateMode(OpenGLContext* oglContext, OverlayColorLegendLayoutInfo* layout)
{
#ifdef CVF_OPENGL_ES
CVF_UNUSED(layout);
CVF_FAIL_MSG("Not supported on OpenGL ES");
#else
CVF_TIGHT_ASSERT(layout);
CVF_TIGHT_ASSERT(layout->size.x() > 0);
CVF_TIGHT_ASSERT(layout->size.y() > 0);
RenderStateDepth depth(false);
depth.applyOpenGL(oglContext);
RenderStateLighting_FF lighting(false);
lighting.applyOpenGL(oglContext);
// All vertices. Initialized here to set Z to zero once and for all.
static float vertexArray[] =
{
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
0.0f, 0.0f, 0.0f,
};
// Per vector convenience pointers
float* v0 = &vertexArray[0];
float* v1 = &vertexArray[3];
float* v2 = &vertexArray[6];
float* v3 = &vertexArray[9];
float* v4 = &vertexArray[12];
// Constant coordinates
v0[0] = v3[0] = layout->x0;
v1[0] = v4[0] = layout->x1;
// Render color bar as one colored quad per pixel
int legendHeightPixelCount = static_cast<int>(layout->tickPixelPos->get(m_tickValues.size() - 1) - layout->tickPixelPos->get(0) + 0.01);
if (m_scalarMapper.notNull())
{
int iPx;
for (iPx = 0; iPx < legendHeightPixelCount; iPx++)
{
const Color3ub& clr = m_scalarMapper->mapToColor(m_scalarMapper->domainValue((iPx+0.5)/legendHeightPixelCount));
float y0 = static_cast<float>(layout->legendRect.min().y() + iPx);
float y1 = static_cast<float>(layout->legendRect.min().y() + iPx + 1);
// Dynamic coordinates for rectangle
v0[1] = v1[1] = y0;
v3[1] = v4[1] = y1;
// Draw filled rectangle elements
glColor3ubv(clr.ptr());
glBegin(GL_TRIANGLE_FAN);
glVertex3fv(v0);
glVertex3fv(v1);
glVertex3fv(v4);
glVertex3fv(v3);
glEnd();
}
}
// Render frame
// Dynamic coordinates for tickmarks-lines
bool isRenderingFrame = true;
if (isRenderingFrame)
{
v0[0] = v2[0] = layout->legendRect.min().x()-0.5f;
v1[0] = v3[0] = layout->legendRect.max().x()-0.5f;
v0[1] = v1[1] = layout->legendRect.min().y()-0.5f;
v2[1] = v3[1] = layout->legendRect.max().y()-0.5f;
glColor3fv(m_color.ptr());
glBegin(GL_LINES);
glVertex3fv(v0);
glVertex3fv(v1);
glVertex3fv(v1);
glVertex3fv(v3);
glVertex3fv(v3);
glVertex3fv(v2);
glVertex3fv(v2);
glVertex3fv(v0);
glEnd();
}
// Render tickmarks
bool isRenderingTicks = true;
if (isRenderingTicks)
{
// Constant coordinates
v0[0] = layout->x0;
v1[0] = layout->x1 - 0.5f*(layout->tickX - layout->x1) - 0.5f;
v2[0] = layout->x1;
v3[0] = layout->tickX - 0.5f*(layout->tickX - layout->x1) - 0.5f;
v4[0] = layout->tickX;
size_t ic;
for (ic = 0; ic < m_tickValues.size(); ic++)
{
float y0 = static_cast<float>(layout->legendRect.min().y() + layout->tickPixelPos->get(ic) - 0.5f);
// Dynamic coordinates for tickmarks-lines
v0[1] = v1[1] = v2[1] = v3[1] = v4[1] = y0;
glColor3fv(m_color.ptr());
glBegin(GL_LINES);
if ( m_visibleTickLabels[ic])
{
glVertex3fv(v0);
glVertex3fv(v4);
}
else
{
glVertex3fv(v2);
glVertex3fv(v3);
}
glEnd();
}
}
// Reset render states
RenderStateLighting_FF resetLighting;
resetLighting.applyOpenGL(oglContext);
RenderStateDepth resetDepth;
resetDepth.applyOpenGL(oglContext);
CVF_CHECK_OGL(oglContext);
#endif // CVF_OPENGL_ES
}
void DeferredLighting::SpotLightPass()
{
// Active differents buffers
m_FBO_graphics->GetTexture("Diffuse")->activateMultiTex(CUSTOM_TEXTURE + 0);
m_FBO_graphics->GetTexture("Specular")->activateMultiTex(
CUSTOM_TEXTURE + 1);
m_FBO_graphics->GetTexture("Normal")->activateMultiTex(CUSTOM_TEXTURE + 2);
m_FBO_graphics->GetTexture("Depth")->activateMultiTex(CUSTOM_TEXTURE + 3);
// Update Info
m_spot_light_shader->Begin();
ShaderHelperUniformPositionFromView(m_spot_light_shader);
m_spot_light_shader->End();
for (int i = 0; i < m_spots_lights.size(); i++)
{
// Generate the Shadow Map
// * Transformations
Math::CMatrix4 oldProjectionMatrix =
CMatrixManager::Instance().GetMatrix(PROJECTION_MATRIX);
Math::CMatrix4 oldViewMatrix = CMatrixManager::Instance().GetMatrix(
VIEW_MATRIX);
Math::CMatrix4 LightViewMatrix;
LightViewMatrix.LookAt(m_spots_lights[i].Position,
m_spots_lights[i].Direction);
Math::CMatrix4 LightProjectionMatrix;
CMatrixManager::Instance().SetProjectionMatrix(
Math::CMatrix4::CreatePerspectiveFOV(
m_spots_lights[i].LightCutOff, 512.0 / 512.0, 1.0,
m_spots_lights[i].LightRaduis));
CMatrixManager::Instance().SetViewMatrix(LightViewMatrix);
// * Draw the scene
// glEnable(GL_CULL_FACE);
// glCullFace(GL_BACK);
m_simple_shader->Begin();
CSceneManager::Instance().RenderAll(); // Draw the scene
m_simple_shader->End();
// glDisable(GL_CULL_FACE);
// * Revert transformations
CMatrixManager::Instance().SetProjectionMatrix(oldProjectionMatrix);
CMatrixManager::Instance().SetViewMatrix(oldViewMatrix);
// * Give Depth Texture
m_simple_shader->GetFBO()->GetTexture("Depth")->activateMultiTex(
CUSTOM_TEXTURE + 4);
// glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Go to spot pass
m_spot_light_shader->Begin();
// * Light propreties
m_spot_light_shader->SetUniform1f("LightRaduis",
m_spots_lights[i].LightRaduis);
m_spot_light_shader->SetUniform1f("LightCutOff",
cos(m_spots_lights[i].LightCutOff * (M_PI / 180.0)));
m_spot_light_shader->SetUniform1f("LightIntensity",
m_spots_lights[i].LightIntensity);
m_spot_light_shader->SetUniformVector("LightPosition",
m_spots_lights[i].Position);
m_spot_light_shader->SetUniformVector("LightSpotDirection",
m_spots_lights[i].Direction);
m_spot_light_shader->SetUniformColor("LightColor",
m_spots_lights[i].LightColor);
// * Shadow Map propreties
m_spot_light_shader->SetUniformMatrix4fv("LightViewMatrix",
LightViewMatrix);
m_spot_light_shader->SetUniformMatrix4fv("LightProjectionMatrix",
LightProjectionMatrix);
// Draw ...
glBegin(GL_QUADS);
glTexCoord2f(0.0, 0.0);
glVertex2f(-1.0, -1.0);
glTexCoord2f(0.0, 1.0);
glVertex2f(-1.0, 1.0);
glTexCoord2f(1.0, 1.0);
glVertex2f(1.0, 1.0);
glTexCoord2f(1.0, 0.0);
glVertex2f(1.0, -1.0);
glEnd();
m_spot_light_shader->End();
}
// Desactive differents buffers
m_FBO_graphics->GetTexture("Diffuse")->desactivateMultiTex(
CUSTOM_TEXTURE + 0);
m_FBO_graphics->GetTexture("Specular")->desactivateMultiTex(
CUSTOM_TEXTURE + 1);
m_FBO_graphics->GetTexture("Normal")->desactivateMultiTex(
CUSTOM_TEXTURE + 2);
m_FBO_graphics->GetTexture("Depth")->desactivateMultiTex(
CUSTOM_TEXTURE + 3);
m_simple_shader->GetFBO()->GetTexture("Depth")->desactivateMultiTex(
CUSTOM_TEXTURE + 4);
}
static void
make_helix (logo_configuration *dc, int facetted, int wire)
{
int wall_facets = dc->wall_facets / (facetted ? 15 : 1);
GLfloat th;
GLfloat max_th = M_PI * 2 * dc->turns;
GLfloat th_inc = M_PI * 2 / wall_facets;
GLfloat x1=0, y1=0, x2=0, y2=0;
GLfloat x1b=0, y1b=0, x2b=0, y2b=0;
GLfloat z1=0, z2=0;
GLfloat h1=0, h2=0;
GLfloat h1off=0, h2off=0;
GLfloat z_inc = dc->turn_spacing / wall_facets;
th = 0;
x1 = 1;
y1 = 0;
x1b = 1 - dc->wall_thickness;
y1b = 0;
z1 = -(dc->turn_spacing * dc->turns / 2);
h1 = (dc->wall_taper > 0 ? 0 : dc->wall_height / 2);
h1off = (dc->wall_taper > 0 ? -dc->wall_height / 2 : 0);
if (!dc->clockwise)
z1 = -z1, z_inc = -z_inc, h1off = -h1off;
/* Leading end-cap
*/
if (!wire && h1 > 0)
{
GLfloat nx, ny;
glFrontFace(GL_CCW);
glBegin(GL_QUADS);
nx = cos (th + M_PI/2);
ny = sin (th + M_PI/2);
glNormal3f(nx, ny, 0);
glVertex3f( x1, y1, z1 - h1 + h1off);
glVertex3f( x1, y1, z1 + h1 + h1off);
glVertex3f(x1b, y1b, z1 + h1 + h1off);
glVertex3f(x1b, y1b, z1 - h1 + h1off);
glEnd();
}
while (th + th_inc <= max_th)
{
th += th_inc;
x2 = cos (th);
y2 = sin (th);
z2 = z1 + z_inc;
x2b = x2 * (1 - dc->wall_thickness);
y2b = y2 * (1 - dc->wall_thickness);
h2 = h1;
h2off = h1off;
if (dc->wall_taper > 0)
{
h2off = 0;
if (th < dc->wall_taper)
{
h2 = dc->wall_height/2 * cos (M_PI / 2
* (1 - (th / dc->wall_taper)));
if (dc->clockwise)
h2off = h2 - dc->wall_height/2;
else
h2off = dc->wall_height/2 - h2;
}
else if (th >= max_th - dc->wall_taper)
{
if (th + th_inc > max_th) /* edge case: always come to a point */
h2 = 0;
else
h2 = dc->wall_height/2 * cos (M_PI / 2
* (1 - ((max_th - th)
/ dc->wall_taper)));
if (dc->clockwise)
h2off = dc->wall_height/2 - h2;
else
h2off = h2 - dc->wall_height/2;
}
}
/* outer face
*/
glFrontFace(GL_CW);
glBegin(wire ? GL_LINES : GL_QUADS);
glNormal3f(x1, y1, 0);
glVertex3f(x1, y1, z1 - h1 + h1off);
glVertex3f(x1, y1, z1 + h1 + h1off);
glNormal3f(x2, y2, 0);
glVertex3f(x2, y2, z2 + h2 + h2off);
glVertex3f(x2, y2, z2 - h2 + h2off);
glEnd();
/* inner face
*/
glFrontFace(GL_CCW);
glBegin(wire ? GL_LINES : GL_QUADS);
glNormal3f(-x1b, -y1b, 0);
glVertex3f( x1b, y1b, z1 - h1 + h1off);
glVertex3f( x1b, y1b, z1 + h1 + h1off);
glNormal3f(-x2b, -y2b, 0);
glVertex3f( x2b, y2b, z2 + h2 + h2off);
glVertex3f( x2b, y2b, z2 - h2 + h2off);
glEnd();
/* top face
*/
glFrontFace(GL_CCW);
/* glNormal3f(0, 0, 1);*/
do_normal (x2, y2, z2 + h2 + h2off,
x2b, y2b, z2 + h2 + h2off,
x1b, y1b, z1 + h1 + h1off);
glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
glVertex3f( x2, y2, z2 + h2 + h2off);
glVertex3f( x2b, y2b, z2 + h2 + h2off);
glVertex3f( x1b, y1b, z1 + h1 + h1off);
glVertex3f( x1, y1, z1 + h1 + h1off);
glEnd();
/* bottom face
*/
glFrontFace(GL_CCW);
do_normal ( x1, y1, z1 - h1 + h1off,
x1b, y1b, z1 - h1 + h1off,
x2b, y2b, z2 - h2 + h2off);
glBegin(wire ? GL_LINE_LOOP : GL_QUADS);
glNormal3f(0, 0, -1);
glVertex3f( x1, y1, z1 - h1 + h1off);
glVertex3f( x1b, y1b, z1 - h1 + h1off);
glVertex3f( x2b, y2b, z2 - h2 + h2off);
glVertex3f( x2, y2, z2 - h2 + h2off);
glEnd();
x1 = x2;
y1 = y2;
x1b = x2b;
y1b = y2b;
z1 += z_inc;
h1 = h2;
h1off = h2off;
}
/* Trailing end-cap
*/
if (!wire && h2 > 0)
{
GLfloat nx, ny;
glFrontFace(GL_CW);
glBegin(GL_QUADS);
nx = cos (th + M_PI/2);
ny = sin (th + M_PI/2);
glNormal3f(nx, ny, 0);
glVertex3f(x2, y2, z1 - h2 + h2off);
glVertex3f(x2, y2, z1 + h2 + h2off);
glVertex3f(x2b, y2b, z1 + h2 + h2off);
glVertex3f(x2b, y2b, z1 - h2 + h2off);
glEnd();
}
}
static void pie_Draw3DShape2(iIMDShape *shape, int frame, PIELIGHT colour, PIELIGHT teamcolour, int pieFlag, int pieFlagData)
{
iIMDPoly *pPolys;
bool light = true;
bool shaders = pie_GetShaderAvailability();
pie_SetAlphaTest((pieFlag & pie_PREMULTIPLIED) == 0);
/* Set fog status */
if (!(pieFlag & pie_FORCE_FOG) &&
(pieFlag & pie_ADDITIVE || pieFlag & pie_TRANSLUCENT || pieFlag & pie_BUTTON || pieFlag & pie_PREMULTIPLIED))
{
pie_SetFogStatus(false);
}
else
{
pie_SetFogStatus(true);
}
/* Set tranlucency */
if (pieFlag & pie_ADDITIVE)
{
pie_SetRendMode(REND_ADDITIVE);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_TRANSLUCENT)
{
pie_SetRendMode(REND_ALPHA);
colour.byte.a = (UBYTE)pieFlagData;
light = false;
}
else if (pieFlag & pie_PREMULTIPLIED)
{
pie_SetRendMode(REND_PREMULTIPLIED);
light = false;
}
else
{
if (pieFlag & pie_BUTTON)
{
pie_SetDepthBufferStatus(DEPTH_CMP_LEQ_WRT_ON);
light = false;
if (shaders)
{
pie_ActivateShader(SHADER_BUTTON, shape, teamcolour, colour);
}
else
{
pie_ActivateFallback(SHADER_BUTTON, shape, teamcolour, colour);
}
}
pie_SetRendMode(REND_OPAQUE);
}
if (pieFlag & pie_ECM)
{
pie_SetRendMode(REND_ALPHA);
light = true;
pie_SetShaderEcmEffect(true);
}
if (light)
{
glMaterialfv(GL_FRONT, GL_AMBIENT, shape->material[LIGHT_AMBIENT]);
glMaterialfv(GL_FRONT, GL_DIFFUSE, shape->material[LIGHT_DIFFUSE]);
glMaterialfv(GL_FRONT, GL_SPECULAR, shape->material[LIGHT_SPECULAR]);
glMaterialf(GL_FRONT, GL_SHININESS, shape->shininess);
glMaterialfv(GL_FRONT, GL_EMISSION, shape->material[LIGHT_EMISSIVE]);
if (shaders)
{
pie_ActivateShader(SHADER_COMPONENT, shape, teamcolour, colour);
}
else
{
pie_ActivateFallback(SHADER_COMPONENT, shape, teamcolour, colour);
}
}
if (pieFlag & pie_HEIGHT_SCALED) // construct
{
glScalef(1.0f, (float)pieFlagData / (float)pie_RAISE_SCALE, 1.0f);
}
if (pieFlag & pie_RAISE) // collapse
{
glTranslatef(1.0f, (-shape->max.y * (pie_RAISE_SCALE - pieFlagData)) * (1.0f / pie_RAISE_SCALE), 1.0f);
}
glColor4ubv(colour.vector); // Only need to set once for entire model
pie_SetTexturePage(shape->texpage);
frame %= MAX(1, shape->numFrames);
glBegin(GL_TRIANGLES);
for (pPolys = shape->polys; pPolys < shape->polys + shape->npolys; pPolys++)
{
Vector3f vertexCoords[3];
unsigned int n, frameidx = frame;
int *index;
if (!(pPolys->flags & iV_IMD_TEXANIM))
{
frameidx = 0;
}
for (n = 0, index = pPolys->pindex;
n < pPolys->npnts;
n++, index++)
{
vertexCoords[n].x = shape->points[*index].x;
vertexCoords[n].y = shape->points[*index].y;
vertexCoords[n].z = shape->points[*index].z;
}
polyCount++;
glNormal3fv((GLfloat*)&pPolys->normal);
for (n = 0; n < pPolys->npnts; n++)
{
GLfloat* texCoord = (GLfloat*)&pPolys->texCoord[frameidx * pPolys->npnts + n];
glTexCoord2fv(texCoord);
if (!shaders)
{
glMultiTexCoord2fv(GL_TEXTURE1, texCoord);
}
glVertex3fv((GLfloat*)&vertexCoords[n]);
}
}
glEnd();
if (light || (pieFlag & pie_BUTTON))
{
if (shaders)
{
pie_DeactivateShader();
}
else
{
pie_DeactivateFallback();
}
}
pie_SetShaderEcmEffect(false);
if (pieFlag & pie_BUTTON)
{
pie_SetDepthBufferStatus(DEPTH_CMP_ALWAYS_WRT_ON);
}
}
static void pie_DrawShadows(void)
{
const float width = pie_GetVideoBufferWidth();
const float height = pie_GetVideoBufferHeight();
GLenum op_depth_pass_front = GL_INCR, op_depth_pass_back = GL_DECR;
pie_SetTexturePage(TEXPAGE_NONE);
glPushMatrix();
pie_SetAlphaTest(false);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glDepthFunc(GL_LESS);
glDepthMask(GL_FALSE);
glEnable(GL_STENCIL_TEST);
// Check if we have the required extensions
if (GLEW_EXT_stencil_wrap)
{
op_depth_pass_front = GL_INCR_WRAP_EXT;
op_depth_pass_back = GL_DECR_WRAP_EXT;
}
// generic 1-pass version
if (GLEW_EXT_stencil_two_side)
{
glEnable(GL_STENCIL_TEST_TWO_SIDE_EXT);
glDisable(GL_CULL_FACE);
glStencilMask(~0);
glActiveStencilFaceEXT(GL_BACK);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);
glStencilFunc(GL_ALWAYS, 0, ~0);
glActiveStencilFaceEXT(GL_FRONT);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);
glStencilFunc(GL_ALWAYS, 0, ~0);
pie_ShadowDrawLoop();
glDisable(GL_STENCIL_TEST_TWO_SIDE_EXT);
}
// check for ATI-specific 1-pass version
else if (GLEW_ATI_separate_stencil)
{
glDisable(GL_CULL_FACE);
glStencilMask(~0);
glStencilOpSeparateATI(GL_BACK, GL_KEEP, GL_KEEP, op_depth_pass_back);
glStencilOpSeparateATI(GL_FRONT, GL_KEEP, GL_KEEP, op_depth_pass_front);
glStencilFunc(GL_ALWAYS, 0, ~0);
pie_ShadowDrawLoop();
}
// fall back to default 2-pass version
else
{
glStencilMask(~0);
glStencilFunc(GL_ALWAYS, 0, ~0);
glEnable(GL_CULL_FACE);
// Setup stencil for front-facing polygons
glCullFace(GL_BACK);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_front);
pie_ShadowDrawLoop();
// Setup stencil for back-facing polygons
glCullFace(GL_FRONT);
glStencilOp(GL_KEEP, GL_KEEP, op_depth_pass_back);
pie_ShadowDrawLoop();
}
pie_SetRendMode(REND_ALPHA);
glEnable(GL_CULL_FACE);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glStencilMask(~0);
glStencilFunc(GL_LESS, 0, ~0);
glColor4f(0, 0, 0, 0.5);
pie_PerspectiveEnd();
glLoadIdentity();
glDisable(GL_DEPTH_TEST);
glBegin(GL_TRIANGLE_STRIP);
glVertex2f(0, 0);
glVertex2f(width, 0);
glVertex2f(0, height);
glVertex2f(width, height);
glEnd();
pie_PerspectiveBegin();
pie_SetRendMode(REND_OPAQUE);
glDisable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glPopMatrix();
scshapes.clear();
}
static void erzeuge_objekt_liste (void){
int i;
float phi, r = 2.0, x, z;
glNewList(objekt_liste, GL_COMPILE);
glBegin (GL_POLYGON);
glColor3f(1.0f,0.0f,0.0f);
for (i = 0; i < n_vertices; i ++) {
phi = 2 * 3.14159265359 * i / (float) n_vertices;
x = r * cos (phi);
z = r * sin (phi);
glVertex3f(x, -3.0f, z);
}
glEnd ();
glBegin (GL_POLYGON);
glColor3f(1.0f,0.0f,0.0f);
for (i = 0; i < n_vertices; i ++) {
phi = 2 * 3.14159265359 * i / (float) n_vertices;
x = r * cos (phi);
z = r * sin (phi);
glVertex3f(x, 3.0f, z);
}
glEnd ();
glBegin(GL_TRIANGLE_FAN);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f(0.0f, 0.0f, 0.0f);
for (i = 0; i < n_vertices + 1; i ++) {
phi = 2 * 3.14159265359 * i / (float) n_vertices;
x = r * cos (phi);
z = r * sin (phi);
if (i%2 == 0){
glColor3f(0.0f,1.0f,0.0f);
}
else{
glColor3f(0.0f,0.0f,1.0f);
}
glVertex3f(x, -3.0f, z);
}
glEnd ();
glBegin(GL_TRIANGLE_FAN);
glColor3f(1.0f,0.0f,0.0f);
glVertex3f(0.0f, 0.0f, 0.0f);
for (i = 0; i < n_vertices + 1; i ++) {
phi = 2 * 3.14159265359 * i / (float) n_vertices;
x = r * cos (phi);
z = r * sin (phi);
if (i%2 == 0){
glColor3f(0.0f,1.0f,0.0f);
}
else{
glColor3f(0.0f,0.0f,1.0f);
}
glVertex3f(x, 3.0f, z);
}
glEnd ();
glEndList();
}
void
gl_window_draw_grid(GtkGLArea *glarea)
{
gl_window_info *info = gtk_object_get_data(GTK_OBJECT(glarea), "info");
GLfloat top, left, right, bottom, x, y;
static GLfloat line_spacing = 5;
gint line_count, i;
// don't draw grid for texture ball
if(info->orientation == ORIENTATION_TEXTURE)
return;
line_count = (int) rintf(info->x_median / line_spacing) + 1;
if(line_count > 10){
line_spacing *= 2.0;
line_count = (int) rintf(info->x_median / line_spacing) + 1;
}else if(line_count < 6){
line_spacing /= 2.0;
line_count = (int) rintf(info->x_median / line_spacing) + 1;
}
/* set top, bottom, left and right ordinates */
if(info->orientation == ORIENTATION_3D){
/* in 3d mode, draw a grid on the Y = 0 plane */
top = 0.90 * info->y_median;
if(top < 10) top = 10;
top -= fmod(top, line_spacing);
bottom = -top;
right = top;
left = bottom;
line_count = rintf(right / line_spacing) + 1;
}else{
top = info->y_median * -1;
bottom = info->y_median;
left = info->x_median * -1;
right = info->x_median;
}
if (gtk_gl_area_make_current(GTK_GL_AREA(glarea))){
glMatrixMode(GL_MODELVIEW);
switch(info->orientation)
{
case ORIENTATION_FRONT: break;
case ORIENTATION_3D: glRotatef(-90, 1,0,0); break;
case ORIENTATION_TOP: glRotatef(-90, 1,0,0); break;
case ORIENTATION_BOTTOM: glRotatef( 90, 1,0,0); break;
case ORIENTATION_LEFT: glRotatef(90, 0,1,0); break;
case ORIENTATION_RIGHT: glRotatef(-90, 0,1,0); break;
case ORIENTATION_BACK: glRotatef(180, 0,1,0); break;
default: break;
}
glColor3f(0.3, 0.3, 0.3);
glBegin(GL_LINES);
/* draw x=0 z=0 line */
glVertex3f( 0, top, 0 );
glVertex3f( 0, bottom, 0 );
/* draw y=0 z=0 line */
glVertex3f( left, 0, 0 );
glVertex3f( right, 0, 0 );
for(i = 0; i < line_count; i++){
y = line_spacing * i;
x = y;
glVertex3f( -x, top, 0 );
glVertex3f( -x, bottom, 0 );
glVertex3f( x, bottom, 0 );
glVertex3f( x, top, 0 );
glVertex3f( left, y, 0 );
glVertex3f( right, y, 0 );
glVertex3f( right, -y, 0 );
glVertex3f( left, -y, 0 );
}
glEnd();
switch(info->orientation)
{
case ORIENTATION_FRONT: break;
case ORIENTATION_3D: glRotatef(90, 1,0,0); break;
case ORIENTATION_TOP: glRotatef(90, 1,0,0); break;
case ORIENTATION_BOTTOM: glRotatef(-90, 1,0,0); break;
case ORIENTATION_LEFT: glRotatef(-90, 0,1,0); break;
case ORIENTATION_RIGHT: glRotatef(90, 0,1,0); break;
case ORIENTATION_BACK: glRotatef(180, 0,1,0); break;
default: break;
}
}
return;
}
void ColorBar::draw(GLContextData& contextData) const
{
/* Retrieve the context data item: */
DataItem* dataItem=contextData.retrieveDataItem<DataItem>(this);
/* Draw parent class decorations: */
Widget::draw(contextData);
/* Draw the widget margin: */
glColor(backgroundColor);
glBegin(GL_TRIANGLE_FAN);
glNormal3f(0.0f,0.0f,1.0f);
glVertex(getInterior().getCorner(0));
glVertex(getInterior().getCorner(1));
for(int i=numTickMarks-1;i>=0;--i)
{
glVertex(tickMarks[i].labelBox.getCorner(1));
glVertex(tickMarks[i].labelBox.getCorner(0));
}
glVertex(tickMarks[0].labelBox.getCorner(2));
glVertex(tickMarkLabelBox.getCorner(2));
glVertex(colorBarBox.getCorner(0));
glVertex(colorBarBox.getCorner(2));
glVertex(getInterior().getCorner(2));
glEnd();
glBegin(GL_TRIANGLE_FAN);
glVertex(getInterior().getCorner(3));
glVertex(getInterior().getCorner(2));
glVertex(colorBarBox.getCorner(2));
glVertex(colorBarBox.getCorner(3));
glVertex(colorBarBox.getCorner(1));
glVertex(tickMarkLabelBox.getCorner(3));
glVertex(tickMarks[numTickMarks-1].labelBox.getCorner(3));
glVertex(tickMarks[numTickMarks-1].labelBox.getCorner(1));
glVertex(getInterior().getCorner(1));
glEnd();
/* Draw the spaces between the tick mark labels: */
glBegin(GL_QUADS);
for(int i=1;i<numTickMarks;++i)
{
glVertex(tickMarks[i-1].labelBox.getCorner(3));
glVertex(tickMarks[i-1].labelBox.getCorner(1));
glVertex(tickMarks[i].labelBox.getCorner(0));
glVertex(tickMarks[i].labelBox.getCorner(2));
}
glEnd();
/* Draw the border between tick marks and tick mark labels: */
glBegin(GL_QUAD_STRIP);
GLfloat tickBot=tickMarkLabelBox.origin[1]+tickMarkLabelBox.size[1];
glVertex(tickMarkLabelBox.getCorner(2));
glVertex(tickMarks[0].labelBox.getCorner(2));
glVertex3f(tickMarkLabelBox.origin[0]+tickMarkWidth,tickBot,tickMarkLabelBox.origin[2]);
glVertex(tickMarks[0].labelBox.getCorner(3));
for(int i=1;i<numTickMarks-1;++i)
{
GLfloat x=colorBarBox.origin[0]+colorBarBox.size[0]*GLfloat(i)/GLfloat(numTickMarks-1);
glVertex3f(x-tickMarkWidth*0.5f,tickBot,tickMarkLabelBox.origin[2]);
glVertex(tickMarks[i].labelBox.getCorner(2));
glVertex3f(x+tickMarkWidth*0.5f,tickBot,tickMarkLabelBox.origin[2]);
glVertex(tickMarks[i].labelBox.getCorner(3));
}
glVertex3f(tickMarkLabelBox.origin[0]+tickMarkLabelBox.size[0]-tickMarkWidth,tickBot,tickMarkLabelBox.origin[2]);
glVertex(tickMarks[numTickMarks-1].labelBox.getCorner(2));
glVertex(tickMarkLabelBox.getCorner(3));
glVertex(tickMarks[numTickMarks-1].labelBox.getCorner(3));
glEnd();
/* Draw the spaces between tick marks: */
glBegin(GL_QUADS);
GLfloat tickTop=colorBarBox.origin[1];
glVertex(colorBarBox.getCorner(0));
glVertex3f(tickMarkLabelBox.origin[0]+tickMarkWidth,tickBot,tickMarkLabelBox.origin[2]);
for(int i=1;i<numTickMarks-1;++i)
{
GLfloat x=colorBarBox.origin[0]+colorBarBox.size[0]*GLfloat(i)/GLfloat(numTickMarks-1);
glVertex3f(x-tickMarkWidth*0.5f,tickBot,tickMarkLabelBox.origin[2]);
glVertex3f(x,tickTop,colorBarBox.origin[2]);
glVertex3f(x,tickTop,colorBarBox.origin[2]);
glVertex3f(x+tickMarkWidth*0.5f,tickBot,tickMarkLabelBox.origin[2]);
}
glVertex3f(tickMarkLabelBox.origin[0]+tickMarkLabelBox.size[0]-tickMarkWidth,tickBot,tickMarkLabelBox.origin[2]);
glVertex(colorBarBox.getCorner(1));
glEnd();
/* Draw the tick marks: */
glBegin(GL_TRIANGLES);
glColor(foregroundColor);
glVertex(tickMarkLabelBox.getCorner(2));
glVertex3f(tickMarkLabelBox.origin[0]+tickMarkWidth,tickBot,tickMarkLabelBox.origin[2]);
glVertex(colorBarBox.getCorner(0));
for(int i=1;i<numTickMarks-1;++i)
{
GLfloat x=colorBarBox.origin[0]+colorBarBox.size[0]*GLfloat(i)/GLfloat(numTickMarks-1);
glVertex3f(x-tickMarkWidth*0.5f,tickBot,tickMarkLabelBox.origin[2]);
glVertex3f(x+tickMarkWidth*0.5f,tickBot,tickMarkLabelBox.origin[2]);
glVertex3f(x,tickTop,colorBarBox.origin[2]);
}
glVertex3f(tickMarkLabelBox.origin[0]+tickMarkLabelBox.size[0]-tickMarkWidth,tickBot,tickMarkLabelBox.origin[2]);
glVertex(tickMarkLabelBox.getCorner(3));
glVertex(colorBarBox.getCorner(1));
glEnd();
/* Set up OpenGL state for color bar rendering: */
GLboolean lightingEnabled=glIsEnabled(GL_LIGHTING);
if(lightingEnabled)
glDisable(GL_LIGHTING);
GLboolean texture1DEnabled=glIsEnabled(GL_TEXTURE_1D);
if(!texture1DEnabled)
glEnable(GL_TEXTURE_1D);
GLboolean texture2DEnabled=glIsEnabled(GL_TEXTURE_2D);
if(texture2DEnabled)
glDisable(GL_TEXTURE_2D);
GLboolean texture3DEnabled=glIsEnabled(GL_TEXTURE_3D);
if(texture3DEnabled)
glDisable(GL_TEXTURE_3D);
/* Upload the color map as a 1D texture: */
glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_BASE_LEVEL,0);
glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAX_LEVEL,0);
glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexImage1D(GL_TEXTURE_1D,0,GL_RGBA8,256,0,GL_RGBA,GL_FLOAT,colorMap->getColors());
glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_REPLACE);
GLint matrixMode;
glGetIntegerv(GL_MATRIX_MODE,&matrixMode);
if(matrixMode!=GL_TEXTURE)
glMatrixMode(GL_TEXTURE);
glPushMatrix();
glLoadIdentity();
glScaled(1.0/(valueMax-valueMin),1.0,1.0);
glTranslated(-valueMin,0.0,0.0);
/* Draw the color bar: */
glBegin(GL_TRIANGLE_FAN);
glColor4f(1.0f,1.0f,1.0f,1.0f);
glTexCoord1d(valueMin);
glVertex(colorBarBox.getCorner(2));
glVertex(colorBarBox.getCorner(0));
for(int i=1;i<numTickMarks-1;++i)
{
GLfloat x=colorBarBox.origin[0]+colorBarBox.size[0]*GLfloat(i)/GLfloat(numTickMarks-1);
glTexCoord1d(valueMin+(valueMax-valueMin)*double(i)/double(numTickMarks-1));
glVertex3f(x,tickTop,colorBarBox.origin[2]);
}
glTexCoord1d(valueMax);
glVertex(colorBarBox.getCorner(1));
glVertex(colorBarBox.getCorner(3));
glEnd();
/* Reset OpenGL state: */
glPopMatrix();
if(matrixMode!=GL_TEXTURE)
glMatrixMode(matrixMode);
if(texture3DEnabled)
glEnable(GL_TEXTURE_3D);
if(texture2DEnabled)
glEnable(GL_TEXTURE_2D);
if(!texture1DEnabled)
glDisable(GL_TEXTURE_1D);
if(lightingEnabled)
glEnable(GL_LIGHTING);
/* Draw the tick mark labels: */
glPushAttrib(GL_TEXTURE_BIT);
GLint lightModelColorControl;
glGetIntegerv(GL_LIGHT_MODEL_COLOR_CONTROL,&lightModelColorControl);
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,GL_SEPARATE_SPECULAR_COLOR);
glEnable(GL_TEXTURE_2D);
for(int i=0;i<numTickMarks;++i)
{
glBindTexture(GL_TEXTURE_2D,dataItem->textureObjectIds[i]);
if(dataItem->tickMarksVersion!=tickMarksVersion) // Have the tick marks changed?
{
/* Upload the tick mark label string texture again: */
font->uploadStringTexture(tickMarks[i].label,backgroundColor,foregroundColor);
}
glTexEnvMode(GLTexEnvEnums::TEXTURE_ENV,GLTexEnvEnums::MODULATE);
glColor4f(1.0f,1.0f,1.0f,backgroundColor[3]);
glBegin(GL_QUADS);
glNormal3f(0.0f,0.0f,1.0f);
glTexCoord(tickMarks[i].labelTexCoords.getCorner(0));
glVertex(tickMarks[i].labelBox.getCorner(0));
glTexCoord(tickMarks[i].labelTexCoords.getCorner(1));
glVertex(tickMarks[i].labelBox.getCorner(1));
glTexCoord(tickMarks[i].labelTexCoords.getCorner(3));
glVertex(tickMarks[i].labelBox.getCorner(3));
glTexCoord(tickMarks[i].labelTexCoords.getCorner(2));
glVertex(tickMarks[i].labelBox.getCorner(2));
glEnd();
}
dataItem->tickMarksVersion=tickMarksVersion;
glBindTexture(GL_TEXTURE_2D,0);
glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL,lightModelColorControl);
glPopAttrib();
}
/* Parse arguments, and set up interface between OpenGL and window system */
int
main(int argc, char *argv[])
{
GLUquadricObj *sphere, *cone, *base;
GLfloat v0[3], v1[3], v2[3];
unsigned *floortex;
int texcomps, texwid, texht;
glutInit(&argc, argv);
glutInitWindowSize(512, 512);
if(argc > 1)
{
char *args = argv[1];
int done = GL_FALSE;
while(!done)
{
switch(*args)
{
case 's': /* single buffer */
printf("Single Buffered\n");
dblbuf = GL_FALSE;
break;
case '-': /* do nothing */
break;
case 0:
done = GL_TRUE;
break;
}
args++;
}
}
if(dblbuf)
glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL|GLUT_DOUBLE);
else
glutInitDisplayMode(GLUT_RGBA|GLUT_DEPTH|GLUT_STENCIL);
(void)glutCreateWindow("projection shadows");
glutDisplayFunc(redraw);
glutKeyboardFunc(key);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutCreateMenu(menu);
glutAddMenuEntry("No Shadows", NONE);
glutAddMenuEntry("Black Shadows", SHADOW_BLACK);
glutAddMenuEntry("Shadows on Texture", SHADOW);
glutAttachMenu(GLUT_RIGHT_BUTTON);
/* draw a perspective scene */
glMatrixMode(GL_PROJECTION);
glFrustum(-100., 100., -100., 100., 320., 640.);
glMatrixMode(GL_MODELVIEW);
/* turn on features */
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
/* make shadow matricies */
/* 3 points on floor */
v0[X] = -100.f; v0[Y] = -100.f; v0[Z] = -320.f;
v1[X] = 100.f; v1[Y] = -100.f; v1[Z] = -320.f;
v2[X] = 100.f; v2[Y] = -100.f; v2[Z] = -520.f;
findplane(floorplane, v0, v1, v2);
shadowmatrix(floorshadow, floorplane, lightpos);
/* 3 points on left wall */
v0[X] = -100.f; v0[Y] = -100.f; v0[Z] = -320.f;
v1[X] = -100.f; v1[Y] = -100.f; v1[Z] = -520.f;
v2[X] = -100.f; v2[Y] = 100.f; v2[Z] = -520.f;
findplane(lwallplane, v0, v1, v2);
shadowmatrix(leftwallshadow, lwallplane, lightpos);
/* place light 0 in the right place */
glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
/* remove back faces to speed things up */
glCullFace(GL_BACK);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
/* make display lists for sphere and cone; for efficiency */
glNewList(WALLS, GL_COMPILE);
glColor3f(1.f, 1.f, 1.f);
glBegin(GL_QUADS);
/* right wall */
glNormal3f(-1.f, 0.f, 0.f);
glVertex3f( 100.f, -100.f, -320.f);
glVertex3f( 100.f, 100.f, -320.f);
glVertex3f( 100.f, 100.f, -520.f);
glVertex3f( 100.f, -100.f, -520.f);
/* ceiling */
glNormal3f(0.f, -1.f, 0.f);
glVertex3f(-100.f, 100.f, -320.f);
glVertex3f(-100.f, 100.f, -520.f);
glVertex3f( 100.f, 100.f, -520.f);
glVertex3f( 100.f, 100.f, -320.f);
/* back wall */
glNormal3f(0.f, 0.f, 1.f);
glVertex3f(-100.f, -100.f, -520.f);
glVertex3f( 100.f, -100.f, -520.f);
glVertex3f( 100.f, 100.f, -520.f);
glVertex3f(-100.f, 100.f, -520.f);
glEnd();
glEndList();
glNewList(SPHERE, GL_COMPILE);
sphere = gluNewQuadric();
glPushMatrix();
glTranslatef(60.f, -50.f, -360.f);
gluSphere(sphere, 20.f, 20, 20);
gluDeleteQuadric(sphere);
glPopMatrix();
glEndList();
glNewList(LIGHT, GL_COMPILE);
sphere = gluNewQuadric();
gluSphere(sphere, 5.f, 20, 20);
gluDeleteQuadric(sphere);
glEndList();
glNewList(CONE, GL_COMPILE);
cone = gluNewQuadric();
base = gluNewQuadric();
glPushMatrix();
glTranslatef(-40.f, -40.f, -400.f);
glRotatef(-90.f, 1.f, 0.f, 0.f);
gluDisk(base, 0., 20., 20, 1);
gluCylinder(cone, 20., 0., 60., 20, 20);
gluDeleteQuadric(cone);
gluDeleteQuadric(base);
glPopMatrix();
glEndList();
glNewList(SHADOWERS, GL_COMPILE);
glCallList(CONE);
glCallList(SPHERE);
glEndList();
glNewList(FLOOR, GL_COMPILE);
/* make the floor textured */
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glNormal3f(0.f, 1.f, 0.f);
glTexCoord2i(0, 0);
glVertex3f(-100.f, -100.f, -320.f);
glTexCoord2i(1, 0);
glVertex3f( 100.f, -100.f, -320.f);
glTexCoord2i(1, 1);
glVertex3f( 100.f, -100.f, -520.f);
glTexCoord2i(0, 1);
glVertex3f(-100.f, -100.f, -520.f);
glEnd();
glDisable(GL_TEXTURE_2D);
glEndList();
glNewList(LEFTWALL, GL_COMPILE);
glBegin(GL_QUADS);
/* left wall */
glNormal3f(1.f, 0.f, 0.f);
glVertex3f(-100.f, -100.f, -320.f);
glVertex3f(-100.f, -100.f, -520.f);
glVertex3f(-100.f, 100.f, -520.f);
glVertex3f(-100.f, 100.f, -320.f);
glEnd();
glEndList();
floortex = read_texture("../../data/wood0.rgb",
&texwid, &texht, &texcomps);
gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, texwid, texht, GL_RGBA,
GL_UNSIGNED_BYTE, floortex);
free(floortex);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glutMainLoop();
return 0;
}
void Help::draw(const glm::vec3 &camera_pos, const glm::vec3 &look_at, const glm::vec3 &up, const glm::vec2 &view_angle) const {
if (!is_enabled) return;
glPushAttrib(GL_LIGHTING_BIT | GL_ENABLE_BIT); // {
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glPushMatrix();
glLoadIdentity();
gluLookAt(0.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);
glColor3f(1.0f, 1.0f, 1.0f);
static const GLfloat alen = 0.2f; // arrow length
glBegin(GL_LINES); glVertex3f( alen, 0.0f, 0.0f); glVertex3f(-alen, 0.0f, 0.0f); glEnd();
glBegin(GL_LINES); glVertex3f( 0.0f, alen, 0.0f); glVertex3f( 0.0f,-alen, 0.0f); glEnd();
glBegin(GL_LINES); glVertex3f( 0.0f, 0.0f, alen); glVertex3f( 0.0f, 0.0f,-alen); glEnd();
// TODO: do something with this. I'm tired of thinking about it right now.
glPopMatrix();
glPopAttrib(); // }
}
void Frustum::DrawFrustum(const mat4x4& view,const mat4x4& proj){
mat4x4 temp = m_projMatrix * m_modView;
mat4x4 inv = proj * view * glm::inverse(temp);
vec4 fr[8]=
{
// near
vec4(-1, -1, -1, 1), vec4( 1, -1, -1, 1), vec4( 1, 1, -1, 1), vec4(-1, 1, -1, 1),
// far
vec4(-1, -1, 1, 1), vec4( 1, -1, 1, 1), vec4( 1, 1, 1, 1), vec4(-1, 1, 1, 1)
};
// Transform all vertices:
// multiply vertex array (fr) by matrix. result is transformed vertex array (tfr)
for(int i = 0; i < 8; i++)
fr[i] = inv * fr[i];
for (int i=0; i<8; i++)
{
fr[i].x /= fr[i].w;
fr[i].y /= fr[i].w;
fr[i].z /= fr[i].w;
fr[i].w = 1.0f;
}
glColor3f(1.0f,0.0f,0.0f);
glBegin(GL_LINES);
glVertex4fv(&(fr[0][0]));
glVertex4fv(&(fr[1][0]));
glVertex4fv(&(fr[1][0]));
glVertex4fv(&(fr[2][0]));
glVertex4fv(&(fr[2][0]));
glVertex4fv(&(fr[3][0]));
glVertex4fv(&(fr[3][0]));
glVertex4fv(&(fr[0][0]));
glVertex4fv(&(fr[4][0]));
glVertex4fv(&(fr[5][0]));
glVertex4fv(&(fr[5][0]));
glVertex4fv(&(fr[6][0]));
glVertex4fv(&(fr[6][0]));
glVertex4fv(&(fr[7][0]));
glVertex4fv(&(fr[7][0]));
glVertex4fv(&(fr[4][0]));
glVertex4fv(&(fr[0][0]));
glVertex4fv(&(fr[4][0]));
glVertex4fv(&(fr[1][0]));
glVertex4fv(&(fr[5][0]));
glVertex4fv(&(fr[2][0]));
glVertex4fv(&(fr[6][0]));
glVertex4fv(&(fr[3][0]));
glVertex4fv(&(fr[7][0]));
glEnd();
}
//=========================================================
// Draw cube with normals turned on
// Note: have to use triangles, (dope!)
// - also no particular order when drawing triangles
//=========================================================
static void drawcube(void)
{
float v[3][3] = { 0 };
float size = 1.0f;
// change the size here
// Note: starts from ground
glBegin(GL_TRIANGLES);
// left bottom front
v[0][0] = -size;
v[0][1] = 0.0f;
v[0][2] = size;
v[1][0] = size;
v[1][1] = 0.0f;
v[1][2] = size;
v[2][0] = size;
v[2][1] = size;
v[2][2] = size;
glColor3f(1.0f,0.0f,0.0f);
// Calc normal and draw
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left bottom front
// Finish the front
v[0][0] = size;
v[0][1] = size;
v[0][2] = size;
v[1][0] = -size;
v[1][1] = size;
v[1][2] = size;
v[2][0] = -size;
v[2][1] = 0.0f;
v[2][2] = size;
// Calc normal and draw
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left bottom front
// Draw the back triangle
//-----------------------------
v[0][0] = -size;
v[0][1] = 0.0f;
v[0][2] = -size;
v[1][0] = size;
v[1][1] = 0.0f;
v[1][2] = -size;
v[2][0] = size;
v[2][1] = size;
v[2][2] = -size;
glColor3f(1.0f,1.0f,0.0f);
// Calc normal and draw
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left bottom bac
// Finish the back
v[0][0] = size;
v[0][1] = size;
v[0][2] = -size;
v[1][0] = -size;
v[1][1] = size;
v[1][2] = -size;
v[2][0] = -size;
v[2][1] = 0.0f;
v[2][2] = -size;
// Calc normal and draw
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left bottom front
// Draw the right side
// Triangle
v[0][0] = size;
v[0][1] = 0.0f;
v[0][2] = size;
v[1][0] = size;
v[1][1] = 0.0f;
v[1][2] = -size;
v[2][0] = size;
v[2][1] = size;
v[2][2] = size;
glColor3f(0.0f,0.5f,1.0f);
// Calc normal and draw
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left bottom bac
// FINISh the right side of the box
v[0][0] = size;
v[0][1] = 0.0f;
v[0][2] = -size;
v[1][0] = size;
v[1][1] = size;
v[1][2] = -size;
v[2][0] = size;
v[2][1] = size;
v[2][2] = size;
// Calc normal and draw
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left bottom bac
// FINISh the left side of the box
v[0][0] = -size;
v[0][1] = 0.0f;
v[0][2] = -size;
v[1][0] = -size;
v[1][1] = size;
v[1][2] = -size;
v[2][0] = -size;
v[2][1] = size;
v[2][2] = size;
glColor3f(1.0f,0.5f,1.0f);
// Calc normal and draw
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left bottom bac
// Draw the left side
// Triangle
v[0][0] = -size;
v[0][1] = 0.0f;
v[0][2] = size;
v[1][0] = -size;
v[1][1] = 0.0f;
v[1][2] = -size;
v[2][0] = -size;
v[2][1] = size;
v[2][2] = size;
// Calc normal and draw
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left side
// Draw the top and bottom
v[0][0] = size;
v[0][1] = size;
v[0][2] = size;
v[1][0] = size;
v[1][1] = size;
v[1][2] = -size;
v[2][0] = -size;
v[2][1] = size;
v[2][2] = -size;
glColor3f(0.6f,0.6f,0.6f);
// Calc normal and dra
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left side
// Draw one of the bottom triangles
v[0][0] = size;
v[0][1] = 0.0f;
v[0][2] = size;
v[1][0] = size;
v[1][1] = 0.0f;
v[1][2] = -size;
v[2][0] = -size;
v[2][1] = 0.0f;
v[2][2] = -size;
// Calc normal and draw
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left side
// Lets finish the bottom with the second triangle
v[0][0] = -size;
v[0][1] = 0.0f;
v[0][2] = size;
v[1][0] = size;
v[1][1] = 0.0f;
v[1][2] = size;
v[2][0] = -size;
v[2][1] = 0.0f;
v[2][2] = -size;
glColor3f(0.03f,0.3f,0.3f);
// Calc normal and dra
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left side
// Go back and finish the top
v[0][0] = -size;
v[0][1] = size;
v[0][2] = size;
v[1][0] = size;
v[1][1] = size;
v[1][2] = size;
v[2][0] = -size;
v[2][1] = size;
v[2][2] = -size;
// Calc normal and dra
glVertex3fv(v[0]);
glVertex3fv(v[1]);
glVertex3fv(v[2]); // triangle left side
glEnd();
} // end of the function
void Star::DrawObject()
{
glBindTexture(GL_TEXTURE_2D, Textures::GetInstance()->GetTextures()[13]);
for(double i = -0.05; i <= 0.05; i += 0.1)
{
glBegin(GL_TRIANGLE_FAN);
glTexCoord2f(0.5, 0.557);glVertex3f(0, 0.557, i);
glTexCoord2f(0.5, 0.876);glVertex3f(0, 0.876, 0);
glTexCoord2f(0.632, 0.643);glVertex3f(0.132, 0.643, i);
glTexCoord2f(0.5, 0.557);glVertex3f(0, 0.557, i);
glTexCoord2f(0.632, 0.643);glVertex3f(0.132, 0.643, i);
glTexCoord2f(0.893, 0.589);glVertex3f(0.393, 0.589, 0);
glTexCoord2f(0.5, 0.557);glVertex3f(0, 0.557, i);
glTexCoord2f(0.893, 0.589);glVertex3f(0.393, 0.589, 0);
glTexCoord2f(0.712, 0.39);glVertex3f(0.212, 0.39, i);
glTexCoord2f(0.5, 0.557);glVertex3f(0, 0.557, i);
glTexCoord2f(0.712, 0.39);glVertex3f(0.212, 0.39, i);
glTexCoord2f(0.742, 0.13);glVertex3f(0.242, 0.13, 0);
glTexCoord2f(0.742, 0.13);glVertex3f(0, 0.557, i);
glTexCoord2f(0.742, 0.13);glVertex3f(0.242, 0.13, 0);
glTexCoord2f(0.5, 0.238);glVertex3f(0, 0.238, i);
glTexCoord2f(0.5, 0.557);glVertex3f(0, 0.557, i);
glTexCoord2f(0.5, 0.238);glVertex3f(0, 0.238, i);
glTexCoord2f(0.256, 0.127);glVertex3f(-0.244, 0.127, 0);
glTexCoord2f(0.5, 0.557);glVertex3f(0, 0.557, i);
glTexCoord2f(0.256, 0.127);glVertex3f(-0.244, 0.127, 0);
glTexCoord2f(0.286, 0.395);glVertex3f(-0.214, 0.395, i);
glTexCoord2f(0.5, 0.557);glVertex3f(0, 0.557, i);
glTexCoord2f(0.286, 0.395);glVertex3f(-0.214, 0.395, i);
glTexCoord2f(0.105, 0.588);glVertex3f(-0.395, 0.588, 0);
glTexCoord2f(0.5, 0.557);glVertex3f(0, 0.557, i);
glTexCoord2f(0.105, 0.588);glVertex3f(-0.395, 0.588, 0);
glTexCoord2f(0.368, 0.648);glVertex3f(-0.132, 0.648, i);
glTexCoord2f(0.5, 0.557);glVertex3f(0, 0.557, i);
glTexCoord2f(0.368, 0.648);glVertex3f(-0.132, 0.648, i);
glTexCoord2f(0.5, 0.876);glVertex3f(0, 0.876, 0);
glEnd();
}
glBegin(GL_TRIANGLES);
glTexCoord2f(0.5, 0.6);glVertex3f(0, 0.876, 0);
glTexCoord2f(0.5, 0.6);glVertex3f(0.132, 0.643, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0.132, 0.643, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0.132, 0.643, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0.132, 0.643, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0.393, 0.589, 0);
glTexCoord2f(0.5, 0.6);glVertex3f(0.393, 0.589, 0);
glTexCoord2f(0.5, 0.6);glVertex3f(0.212, 0.39, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0.212, 0.39, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0.212, 0.39, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0.212, 0.39, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0.242, 0.13, 0);
glTexCoord2f(0.5, 0.6);glVertex3f(0.242, 0.13, 0);
glTexCoord2f(0.5, 0.6);glVertex3f(0, 0.238, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0, 0.238, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0, 0.238, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0, 0.238, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.244, 0.127, 0);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.244, 0.127, 0);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.214, 0.395, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.214, 0.395, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.214, 0.395, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.214, 0.395, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.395, 0.588, 0);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.395, 0.588, 0);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.132, 0.648, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.132, 0.648, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.132, 0.648, 0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(-0.132, 0.648, -0.05);
glTexCoord2f(0.5, 0.6);glVertex3f(0, 0.876, 0);
glEnd();
}
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 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();
}
}
static void
updateSnowTextures (CompScreen *s)
{
const BananaValue *
option_snow_size = bananaGetOption (bananaIndex,
"snow_size",
-1);
const BananaValue *
option_num_snowflakes = bananaGetOption (bananaIndex,
"num_snowflakes",
-1);
const BananaValue *
option_snow_textures = bananaGetOption (bananaIndex,
"snow_textures",
-1);
int i, count = 0;
float snowSize = option_snow_size->f;
int numFlakes = option_num_snowflakes->i;
SnowFlake *snowFlake;
SNOW_SCREEN (s);
snowFlake = ss->allSnowFlakes;
for (i = 0; i < ss->snowTexturesLoaded; i++)
{
finiTexture (s, &ss->snowTex[i].tex);
glDeleteLists (ss->snowTex[i].dList, 1);
}
if (ss->snowTex)
free (ss->snowTex);
ss->snowTexturesLoaded = 0;
ss->snowTex = calloc (1,
sizeof (SnowTexture) * option_snow_textures->list.nItem);
for (i = 0; i < option_snow_textures->list.nItem; i++)
{
CompMatrix *mat;
SnowTexture *sTex;
ss->snowTex[count].loaded =
readImageToTexture (s, &ss->snowTex[count].tex,
option_snow_textures->list.item[i].s,
&ss->snowTex[count].width,
&ss->snowTex[count].height);
if (!ss->snowTex[count].loaded)
{
compLogMessage ("snow", CompLogLevelWarn,
"Texture not found : %s",
option_snow_textures->list.item[i].s);
continue;
}
compLogMessage ("snow", CompLogLevelInfo,
"Loaded Texture %s",
option_snow_textures->list.item[i].s);
mat = &ss->snowTex[count].tex.matrix;
sTex = &ss->snowTex[count];
sTex->dList = glGenLists (1);
glNewList (sTex->dList, GL_COMPILE);
glBegin (GL_QUADS);
glTexCoord2f (COMP_TEX_COORD_X (mat, 0), COMP_TEX_COORD_Y (mat, 0));
glVertex2f (0, 0);
glTexCoord2f (COMP_TEX_COORD_X (mat, 0),
COMP_TEX_COORD_Y (mat, sTex->height));
glVertex2f (0, snowSize * sTex->height / sTex->width);
glTexCoord2f (COMP_TEX_COORD_X (mat, sTex->width),
COMP_TEX_COORD_Y (mat, sTex->height));
glVertex2f (snowSize, snowSize * sTex->height / sTex->width);
glTexCoord2f (COMP_TEX_COORD_X (mat, sTex->width),
COMP_TEX_COORD_Y (mat, 0));
glVertex2f (snowSize, 0);
glEnd ();
glEndList ();
count++;
}
ss->snowTexturesLoaded = count;
if (count < option_snow_textures->list.nItem)
ss->snowTex = realloc (ss->snowTex, sizeof (SnowTexture) * count);
for (i = 0; i < numFlakes; i++)
setSnowflakeTexture (ss, snowFlake++);
}
void obj_display() {
// 只有一个物体
mesh *object = globalscene->mList[0].obejct;
//bind texture 0
// glUnifor1i( 0) for colorTexture
glActiveTexture( GL_TEXTURE0 );
glBindTexture(GL_TEXTURE_2D, globalscene->mList[0].ambTextureId);
GLint location0 = glGetUniformLocation(MyShader, "colorTexture");
if(location0 == -1)
printf("Cant find texture name: colorTexture\n");
else
glUniform1i(location0, 0);
//bind texture 1
// glUnifor1i( 1) for diffuse Texture
glActiveTexture( GL_TEXTURE1 );
glBindTexture(GL_TEXTURE_2D, globalscene->mList[0].difTextureId);
GLint location1 = glGetUniformLocation(MyShader, "diffuseTex");
if(location1 == -1)
printf("Cant find texture name: diffuseTex\n");
else
glUniform1i(location1, 1);
//bind texture 2
// glUnifor1i( 2) for specular Texture
glActiveTexture( GL_TEXTURE2 );
glBindTexture(GL_TEXTURE_2D, globalscene->mList[0].spcTextureId);
GLint location2 = glGetUniformLocation(MyShader, "specularTex");
if(location2 == -1)
printf("Cant find texture name: specularTex\n");
else
glUniform1i(location2, 2);
// 确定顶点属性的 location，算完切向量后，再设置属性值
tangent_loc = glGetAttribLocation(MyShader, "tangent");
bitangent_loc = glGetAttribLocation(MyShader, "bitangent");
int lastMaterial = -1;
for(size_t i=0;i < object->fTotal;++i)
{
// set material property if this face used different material
if(lastMaterial != object->faceList[i].m)
{
lastMaterial = (int)object->faceList[i].m;
glMaterialfv(GL_FRONT, GL_AMBIENT , object->mList[lastMaterial].Ka);
glMaterialfv(GL_FRONT, GL_DIFFUSE , object->mList[lastMaterial].Kd);
glMaterialfv(GL_FRONT, GL_SPECULAR , object->mList[lastMaterial].Ks);
glMaterialfv(GL_FRONT, GL_SHININESS, &object->mList[lastMaterial].Ns);
//you can obtain the texture name by object->mList[lastMaterial].map_Kd
//load them once in the main function before mainloop
//bind them in display function here
}
// 取得三个顶点 p0 p1 p2 坐标
float *vertex0 = object->vList[object->faceList[i][0].v].ptr;
float *vertex1 = object->vList[object->faceList[i][1].v].ptr;
float *vertex2 = object->vList[object->faceList[i][2].v].ptr;
glm::vec3 p0(vertex0[0], vertex0[1], vertex0[2]);
glm::vec3 p1(vertex1[0], vertex1[1], vertex1[2]);
glm::vec3 p2(vertex2[0], vertex2[1], vertex2[2]);
// 取得贴图三点 对应贴图坐标
float *texture0 = object->tList[object->faceList[i][0].t].ptr;
float *texture1 = object->tList[object->faceList[i][1].t].ptr;
float *texture2 = object->tList[object->faceList[i][2].t].ptr;
glm::vec2 UV0(texture0[0], texture0[1]);
glm::vec2 UV1(texture1[0], texture1[1]);
glm::vec2 UV2(texture2[0], texture2[1]);
// 得到两边
glm::vec3 Edge1 = p1 - p0;
glm::vec3 Edge2 = p2 - p0;
glm::vec2 Edge1uv = UV1 - UV0;
glm::vec2 Edge2uv = UV2 - UV0;
// 计算切向量，副切向量
glm::vec3 tangent, bitangent;
float cp = Edge1uv.x * Edge2uv.y - Edge2uv.x * Edge1uv.y;
if(cp != 0.0f) {
float mul = 1.0f /cp;
tangent = (Edge1 * Edge2uv.y + Edge2 * -Edge1uv.y) * mul;
bitangent = (Edge1 * -Edge2uv.x + Edge2 * Edge1uv.x) * mul;
}
// specify the value of a generic vertex attribute 设置顶点属性
glVertexAttrib3f(tangent_loc, tangent.x, tangent.y, tangent.z);
glVertexAttrib3f(bitangent_loc, bitangent.x, bitangent.y, bitangent.z);
glBegin(GL_TRIANGLES);
for (size_t j=0;j<3;++j)
{
//textex corrd.
glMultiTexCoord2fv(GL_TEXTURE0, object->tList[object->faceList[i][j].t].ptr);
glMultiTexCoord2fv(GL_TEXTURE1, object->tList[object->faceList[i][j].t].ptr);
glMultiTexCoord2fv(GL_TEXTURE2, object->tList[object->faceList[i][j].t].ptr);
glNormal3fv(object->nList[object->faceList[i][j].n].ptr);
glVertex3fv(object->vList[object->faceList[i][j].v].ptr);
}
glEnd();
}
}
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 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 CellGrid::draw()
{
float xstart = mMin[X];
float ystart = mMin[Y];
float zstart = mMin[Z];
float xend = mMax[X];
float yend = mMax[Y];
float zend = mMax[Z];
/*float delta_x = (xend - xstart) / mDimension[X];
float delta_y = (yend - ystart) / mDimension[Y];
float delta_z = (zend - zstart) / mDimension[Z];*/
glPushAttrib(GL_LIGHTING_BIT | GL_LINE_BIT | GL_COLOR_BUFFER_BIT);
glDisable(GL_LIGHTING);
glLineWidth(2.0);
glColor3f(0.25f, 0.25f, 0.25f);
glBegin(GL_LINE_LOOP);
glVertex3f(xstart, ystart, zstart);
glVertex3f(xstart, yend, zstart);
glVertex3f(xstart, yend, zend);
glVertex3f(xstart, ystart, zend);
glEnd();
glBegin(GL_LINE_LOOP);
glVertex3f(xend, ystart, zstart);
glVertex3f(xend, yend, zstart);
glVertex3f(xend, yend, zend);
glVertex3f(xend, ystart, zend);
glEnd();
glBegin(GL_LINES);
glVertex3f(xstart, ystart, zstart);
glVertex3f(xend, ystart, zstart);
glVertex3f(xstart, yend, zstart);
glVertex3f(xend, yend, zstart);
glVertex3f(xstart, yend, zend);
glVertex3f(xend, yend, zend);
glVertex3f(xstart, ystart, zend);
glVertex3f(xend, ystart, zend);
glEnd();
//along x
/*for(float i = xstart; i <= xend + 0.5 * delta_x; i += delta_x)//in case of numerical error
{
glBegin(GL_LINE_LOOP);
glVertex3f(i, ystart, zstart);
glVertex3f(i, yend, zstart);
glVertex3f(i, yend, zend);
glVertex3f(i, ystart, zend);
glEnd();
}
//along y
for(float j = ystart; j <= yend + 0.5 * delta_y; j += delta_y)//in case of numerical error
{
glBegin(GL_LINE_LOOP);
glVertex3f(xstart, j, zstart);
glVertex3f(xend, j, zstart);
glVertex3f(xend, j, zend);
glVertex3f(xstart, j, zend);
glEnd();
}
//along z
for(float k = zstart; k <= zend + 0.5 * delta_z; k += delta_z)//in case of numerical error
{
glBegin(GL_LINE_LOOP);
glVertex3f(xstart, ystart, k);
glVertex3f(xend, ystart, k);
glVertex3f(xend, yend, k);
glVertex3f(xstart, yend, k);
glEnd();
}*/
glPopAttrib();
}
int main( int argc, char **argv )
{
SDL_Window* window = NULL;
if ( SDL_Init( SDL_INIT_VIDEO ) < 0 ){
printf( "Unable to initialize SDL: %s\n",
SDL_GetError() );
return 1;
}
atexit( SDL_Quit );
window = SDL_CreateWindow( "OpenGL with SDL2",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
SCREEN_WIDTH, SCREEN_HEIGHT,
SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL );
if ( !window ){
printf( "Unable to create window, %s\n",
SDL_GetError() );
return 1;
}
SDL_GLContext glcontext = SDL_GL_CreateContext( window );
if ( !glcontext ){
printf( "Unable to create context, %s\n",
SDL_GetError() );
return 1;
}
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 );
SDL_GL_SetAttribute( SDL_GL_RED_SIZE, 5 );
SDL_GL_SetAttribute( SDL_GL_GREEN_SIZE, 6 );
SDL_GL_SetAttribute( SDL_GL_BLUE_SIZE, 5 );
glViewport( 80, 0, 480, 480 );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glFrustum( -1.0, 1.0, -1.0, 1.0, 1.0, 100.0 );
glClearColor( 0, 0, 0, 0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glClear( GL_COLOR_BUFFER_BIT );
glBegin( GL_TRIANGLES );
glColor3f( 1.0, 0.0, 0.0 );
glVertex3f( 0.0, 1.0, -2.0 );
glColor3f( 0.0, 1.0, 0.0 );
glVertex3f( 1.0, -1.0, -2.0 );
glColor3f( 0.0, 0.0, 1.0 );
glVertex3f( -1.0, -1.0, -2.0 );
glEnd();
glFlush();
SDL_GL_SwapWindow( window );
SDL_Delay( 5000 );
SDL_GL_DeleteContext( glcontext );
return 0;
}
void MouseDialogNavigationTool::display(GLContextData& contextData) const
{
if(showScreenCenter)
{
/* Save and set up OpenGL state: */
glPushAttrib(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT|GL_ENABLE_BIT|GL_LINE_BIT|GL_TEXTURE_BIT);
glDisable(GL_LIGHTING);
/* Get a pointer to the screen the mouse is on: */
const VRScreen* screen;
if(mouseAdapter!=0&&mouseAdapter->getWindow()!=0)
screen=mouseAdapter->getWindow()->getVRScreen();
else
screen=getMainScreen();
ONTransform screenT=screen->getScreenTransformation();
/* Go to screen coordinates: */
glPushMatrix();
glMultMatrix(screenT);
/* Determine the screen containing the input device and find its center: */
Scalar centerPos[2];
if(mouseAdapter!=0)
mouseAdapter->getWindow()->getWindowCenterPos(centerPos);
else
{
centerPos[0]=getMainScreen()->getWidth()*Scalar(0.5);
centerPos[1]=getMainScreen()->getHeight()*Scalar(0.5);
}
/* Calculate the endpoints of the screen's crosshair lines in screen coordinates: */
Point l=Point(Scalar(0),centerPos[1],Scalar(0));
Point r=Point(screen->getWidth(),centerPos[1],Scalar(0));
Point b=Point(centerPos[0],Scalar(0),Scalar(0));
Point t=Point(centerPos[0],screen->getHeight(),Scalar(0));
/* Determine the crosshair colors: */
Color bgColor=getBackgroundColor();
Color fgColor;
for(int i=0;i<3;++i)
fgColor[i]=1.0f-bgColor[i];
fgColor[3]=bgColor[3];
/* Draw the screen crosshairs: */
glDepthFunc(GL_LEQUAL);
glLineWidth(3.0f);
glColor(bgColor);
glBegin(GL_LINES);
glVertex(l);
glVertex(r);
glVertex(b);
glVertex(t);
glEnd();
glLineWidth(1.0f);
glColor(fgColor);
glBegin(GL_LINES);
glVertex(l);
glVertex(r);
glVertex(b);
glVertex(t);
glEnd();
/* Go back to physical coordinates: */
glPopMatrix();
/* Restore OpenGL state: */
glPopAttrib();
}
}
/// Draw the shadow for a shape
static void pie_DrawShadow(iIMDShape *shape, int flag, int flag_data, Vector3f* light)
{
unsigned int i, j, n;
Vector3f *pVertices;
iIMDPoly *pPolys;
static std::vector<EDGE> edgelist; // Static, to save allocations.
static std::vector<EDGE> edgelistFlipped; // Static, to save allocations.
static std::vector<EDGE> edgelistFiltered; // Static, to save allocations.
EDGE *drawlist = NULL;
unsigned edge_count;
pVertices = shape->points;
if( flag & pie_STATIC_SHADOW && shape->shadowEdgeList )
{
drawlist = shape->shadowEdgeList;
edge_count = shape->nShadowEdges;
}
else
{
edgelist.clear();
for (i = 0, pPolys = shape->polys; i < shape->npolys; ++i, ++pPolys)
{
Vector3f p[3];
for(j = 0; j < 3; j++)
{
int current = pPolys->pindex[j];
p[j] = Vector3f(pVertices[current].x, scale_y(pVertices[current].y, flag, flag_data), pVertices[current].z);
}
Vector3f normal = crossProduct(p[2] - p[0], p[1] - p[0]);
if (normal * *light > 0)
{
for (n = 1; n < pPolys->npnts; n++)
{
// link to the previous vertex
addToEdgeList(pPolys->pindex[n-1], pPolys->pindex[n], edgelist);
}
// back to the first
addToEdgeList(pPolys->pindex[pPolys->npnts-1], pPolys->pindex[0], edgelist);
}
}
// Remove duplicate pairs from the edge list. For example, in the list ((1 2), (2 6), (6 2), (3, 4)), remove (2 6) and (6 2).
edgelistFlipped = edgelist;
std::for_each(edgelistFlipped.begin(), edgelistFlipped.end(), flipEdge);
std::sort(edgelist.begin(), edgelist.end(), edgeLessThan);
std::sort(edgelistFlipped.begin(), edgelistFlipped.end(), edgeLessThan);
edgelistFiltered.resize(edgelist.size());
edgelistFiltered.erase(std::set_difference(edgelist.begin(), edgelist.end(), edgelistFlipped.begin(), edgelistFlipped.end(), edgelistFiltered.begin(), edgeLessThan), edgelistFiltered.end());
drawlist = &edgelistFiltered[0];
edge_count = edgelistFiltered.size();
//debug(LOG_WARNING, "we have %i edges", edge_count);
if(flag & pie_STATIC_SHADOW)
{
// then store it in the imd
shape->nShadowEdges = edge_count;
shape->shadowEdgeList = (EDGE *)realloc(shape->shadowEdgeList, sizeof(EDGE) * shape->nShadowEdges);
std::copy(drawlist, drawlist + edge_count, shape->shadowEdgeList);
}
}
// draw the shadow volume
glBegin(GL_QUADS);
glNormal3f(0.0, 1.0, 0.0);
for(i=0;i<edge_count;i++)
{
int a = drawlist[i].from, b = drawlist[i].to;
glVertex3f(pVertices[b].x, scale_y(pVertices[b].y, flag, flag_data), pVertices[b].z);
glVertex3f(pVertices[b].x+light->x, scale_y(pVertices[b].y, flag, flag_data)+light->y, pVertices[b].z+light->z);
glVertex3f(pVertices[a].x+light->x, scale_y(pVertices[a].y, flag, flag_data)+light->y, pVertices[a].z+light->z);
glVertex3f(pVertices[a].x, scale_y(pVertices[a].y, flag, flag_data), pVertices[a].z);
}
glEnd();
#ifdef SHOW_SHADOW_EDGES
glDisable(GL_DEPTH_TEST);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glColor4ub(0xFF, 0, 0, 0xFF);
glBegin(GL_LINES);
for(i = 0; i < edge_count; i++)
{
int a = drawlist[i].from, b = drawlist[i].to;
if(a < 0)
{
continue;
}
glVertex3f(pVertices[b].x, scale_y(pVertices[b].y, flag, flag_data), pVertices[b].z);
glVertex3f(pVertices[a].x, scale_y(pVertices[a].y, flag, flag_data), pVertices[a].z);
}
glEnd();
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
glEnable(GL_DEPTH_TEST);
#endif
}
//The main function of the sweep algorithm.
void findIntersection(float pt[][2])
{
int i,j;
//"ordHead" doesn't save any data
//ordHead->next is the first point in ordered list
POrder *ordHead;
POrder *ordTemp;
ordHead = (POrder *)malloc(LEN_P);
ordHead->next=NULL;
//Initialize the original points and ordered list.
initPt(ordHead,pt);
//Draw the original points and lines.
glPointSize(3.0);
glBegin(GL_POINTS);
glColor3f(0.0,0.0,0.0);
for(i=0;i<NUM_PT;i+=2){
glVertex2f(pt[i][0],pt[i][1]);
glVertex2f(pt[i+1][0],pt[i+1][1]);
}
glEnd();
glColor3f(0.5,0.5,0.5);
glBegin(GL_LINES);
for(i=0;i<NUM_PT;i++)
glVertex2f(pt[i][0],pt[i][1]);
glEnd();
//Scan the ordered list and check intersection,
//"top" is always the root node of the scan tree
tree *top;
top=(struct tree *)malloc(LEN_S);
top->id=ordHead->next;
top->left=NULL;
top->right=NULL;
top->father=NULL;
_inteCount=0;
_maxPtOrd=NUM_PT;
tree *left_s;
tree *right_s;
tree *left_l;
tree *right_l;
tree *scan_temp;
ordTemp = ordHead->next->next;
i=1;
float x_scan;
float y_scan;
while(i<_maxPtOrd)
{
if(ordTemp==NULL)
break;
tree *scan;
scan=(struct tree *)malloc(LEN_S);
scan->id=ordTemp;
x_scan=scan->id->x;
y_scan=scan->id->y;
if(scan->id->type==ORD_UPPER)
{
//For an upper point:
//Add it into scan tree.
if(top==NULL)
{
top=scan;
scan->id=ordTemp;
scan->father=NULL;
scan->left=NULL;
scan->right=NULL;
}else
addIntoScan(top,scan,scan->id->y);
//Get left and right neighbors in the scan tree.
left_s=get_left(scan);
while(left_s!=NULL && left_s->id->type!=ORD_UPPER)
left_s=get_left(left_s);
right_s=get_right(scan);
while(right_s!=NULL && right_s->id->type!=ORD_UPPER)
right_s=get_right(right_s);
//Check intersection points.
if(left_s!=NULL)
checkInte(ordHead->next,left_s->id,scan->id,top,x_scan,y_scan);
if(right_s!=NULL)
checkInte(ordHead->next,scan->id,right_s->id,top,x_scan,y_scan);
}else if(scan->id->type==ORD_LOWER){
//For a lower point:
//Find its upper point in scan tree.
scan_temp=searchInScan(top,scan->id->l,NO_LINE,SCAN_L);
//Get left and right neighbors of the upper point in scan tree.
left_s=get_left(scan_temp);
while(left_s!=NULL && (left_s->id->type!=ORD_UPPER || left_s==scan))
left_s=get_left(left_s);
right_s=get_right(scan_temp);
while(right_s!=NULL && (right_s->id->type!=ORD_UPPER || right_s==scan))
right_s=get_right(right_s);
//Check intersection between left and right neighbors of the deleted line.
if(left_s!=NULL && right_s!=NULL)
checkInte(ordHead->next,left_s->id,right_s->id,top,x_scan,y_scan);
//Delete the upper point.
top=dltFromScan(top,scan_temp);
//Find inte-points of the line, and mark them.
//If both of two inte-lines have been deleted,
//their inte-points have to be deleted in the scan tree.
for(j=0;j<_inteCount;j++)
{
if(found[j][0]==scan->id->l || found[j][1]==scan->id->l)
{
if(found[j][2]==FND_2)
found[j][2]=FND_1;
else if(found[j][2]==FND_1){
scan_temp=searchInScan(top,found[j][0],found[j][1],SCAN_L_L2);
if(scan_temp!=NULL)
top=dltFromScan(top,scan_temp);
found[j][2]=FND_D;
}
}
}
}else if(scan->id->type==ORD_INTE){
//For an intersection point:
//Find its node in the scan tree
//Because the current "scan" node is not in the scan tree,
//only its "id" pointer is evaluated.
scan=searchInScan(top,scan->id->l,scan->id->l2,SCAN_L_L2);
//Check for inte-points between its left line and its right neighbor,
//and between its right line and its left neighbor.
left_l=searchInScan(top,scan->id->l,NO_LINE,SCAN_L);
right_l=searchInScan(top,NO_LINE,scan->id->l2,SCAN_L2);
left_s=get_left(left_l);
while(left_s!=NULL && (left_s->id->type!=ORD_UPPER || left_s==left_l || left_s==right_l))
left_s=get_left(left_s);
right_s=get_right(right_l);
while(right_s!=NULL && (right_s->id->type!=ORD_UPPER || right_s==left_l || right_s==right_l))
right_s=get_right(right_s);
switchScan(left_l,right_l);
if(left_s!=NULL)
checkInte(ordHead->next,left_s->id,left_l->id,top,x_scan,y_scan);
if(right_s!=NULL)
checkInte(ordHead->next,right_l->id,right_s->id,top,x_scan,y_scan);
//Delete the inte-point node in the scan tree.
top=dltFromScan(top,scan);
}
//Get next point in the ordered list
ordTemp=ordTemp->next;
i++;
}
//Draw all the intersection points.
glPointSize(4.0);
glBegin(GL_POINTS);
glColor3f(0.0,0.0,1.0);
for(i=0;i<_inteCount;i++)
glVertex2f(inte[i][0],inte[i][1]);
glEnd();
}
void draw_tile_map()
{
int x_start,x_end,y_start,y_end;
int x,y;
float x_scaled,y_scaled;
//get only the tiles around the camera
//we have the axes inverted, btw the go from 0 to -255
if(camera_x<0)x=(int)(camera_x*-1)/3;
else x=(int)camera_x/3;
if(camera_y<0)y=(int)(camera_y*-1)/3;
else y=(int)camera_y/3;
x_start=x-(int)zoom_level;
y_start=y-(int)zoom_level;
x_end=x+(int)zoom_level;
y_end=y+(int)zoom_level;
if(x_start<0)x_start=0;
if(x_end>=tile_map_size_x)x_end=tile_map_size_x-1;
if(y_start<0)y_start=0;
if(y_end>=tile_map_size_y)y_end=tile_map_size_y-1;
if(!have_multitexture || poor_man)
{
for(y=y_start;y<=y_end;y++)
{
y_scaled=y*3.0f;
for(x=x_start;x<=x_end;x++)
{
x_scaled=x*3.0f;
if(is_water_tile(tile_map[y*tile_map_size_x+x]))continue;//lake, skip
if(tile_map[y*tile_map_size_x+x]==255){
/*glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glBegin(GL_QUADS);
glColor3f(0.2,0.2,0.2);
glVertex3f(x_scaled,y_scaled+3, -3.0f);
glVertex3f(x_scaled,y_scaled, -3.0f);
glVertex3f(x_scaled+3, y_scaled,-3.0f);
glVertex3f(x_scaled+3, y_scaled+3,-3.0f);
glColor3f(1.0,1.0,1.0);
glEnd();
glEnable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);*/
continue;
}//null, skip
bind_texture(tile_list[tile_map[y*tile_map_size_x+x]]);
glBegin(GL_QUADS);
glTexCoord2f(0, 0.0f);
glVertex3f(x_scaled,y_scaled+3, 0.0f);
glTexCoord2f(0, 1.0f);
glVertex3f(x_scaled,y_scaled, 0.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex3f(x_scaled+3, y_scaled,0.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex3f(x_scaled+3, y_scaled+3,0.0f);
glEnd();
}
}
}
else//we draw the ground details
{
//bind the detail texture
glActiveTextureARB(GL_TEXTURE1_ARB);
glEnable(GL_TEXTURE_2D);
bind_texture_unbuffered(ground_detail_text);
glActiveTextureARB(GL_TEXTURE0_ARB);
glEnable(GL_TEXTURE_2D);
for(y=y_start;y<=y_end;y++)
{
y_scaled=y*3.0f;
for(x=x_start;x<=x_end;x++)
{
x_scaled=x*3.0f;
if(is_water_tile(tile_map[y*tile_map_size_x+x]))continue;//lake, skip
if(tile_map[y*tile_map_size_x+x]==255){
/*glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glBegin(GL_QUADS);
glColor3f(0.2,0.2,0.2);
glVertex3f(x_scaled,y_scaled+3, -3.0f);
glVertex3f(x_scaled,y_scaled, -3.0f);
glVertex3f(x_scaled+3, y_scaled,-3.0f);
glVertex3f(x_scaled+3, y_scaled+3,-3.0f);
glColor3f(1.0,1.0,1.0);
glEnd();
glEnable(GL_LIGHTING);
glEnable(GL_TEXTURE_2D);*/
continue;
}//null, skip
bind_texture(tile_list[tile_map[y*tile_map_size_x+x]]);
//draw our normal tile
glBegin(GL_QUADS);
glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0, 0.0f);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,x_scaled/texture_scale+clouds_movement_u, (y_scaled+3.0)/texture_scale+clouds_movement_v);
glVertex3f(x_scaled,y_scaled+3, 0.0f);
glMultiTexCoord2fARB(GL_TEXTURE0_ARB,0, 1.0f);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,x_scaled/texture_scale+clouds_movement_u, y_scaled/texture_scale+clouds_movement_v);
glVertex3f(x_scaled,y_scaled, 0.0f);
glMultiTexCoord2fARB(GL_TEXTURE0_ARB,1.0f, 1.0f);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,(x_scaled+3.0f)/texture_scale+clouds_movement_u, y_scaled/texture_scale+clouds_movement_v);
glVertex3f(x_scaled+3, y_scaled,0.0f);
glMultiTexCoord2fARB(GL_TEXTURE0_ARB,1.0f, 0.0f);
glMultiTexCoord2fARB(GL_TEXTURE1_ARB,(x_scaled+3.0)/texture_scale+clouds_movement_u, (y_scaled+3.0)/texture_scale+clouds_movement_v);
glVertex3f(x_scaled+3, y_scaled+3,0.0f);
glEnd();
}
}
//disable the second texture unit
glActiveTextureARB(GL_TEXTURE1_ARB);
glDisable(GL_TEXTURE_2D);
glActiveTextureARB(GL_TEXTURE0_ARB);
}
}
void OGLRender::DrawSpriteR_Render() // With Rotation
{
glViewportWrapper(0, windowSetting.statusBarHeightToUse, windowSetting.uDisplayWidth, windowSetting.uDisplayHeight);
GLboolean cullface = glIsEnabled(GL_CULL_FACE);
glDisable(GL_CULL_FACE);
#ifndef USE_GLES
glBegin(GL_TRIANGLES);
glColor4fv(gRDP.fvPrimitiveColor);
OGLRender::TexCoord(g_texRectTVtx[0]);
glVertex3f(g_texRectTVtx[0].x, g_texRectTVtx[0].y, -g_texRectTVtx[0].z);
OGLRender::TexCoord(g_texRectTVtx[1]);
glVertex3f(g_texRectTVtx[1].x, g_texRectTVtx[1].y, -g_texRectTVtx[1].z);
OGLRender::TexCoord(g_texRectTVtx[2]);
glVertex3f(g_texRectTVtx[2].x, g_texRectTVtx[2].y, -g_texRectTVtx[2].z);
OGLRender::TexCoord(g_texRectTVtx[0]);
glVertex3f(g_texRectTVtx[0].x, g_texRectTVtx[0].y, -g_texRectTVtx[0].z);
OGLRender::TexCoord(g_texRectTVtx[2]);
glVertex3f(g_texRectTVtx[2].x, g_texRectTVtx[2].y, -g_texRectTVtx[2].z);
OGLRender::TexCoord(g_texRectTVtx[3]);
glVertex3f(g_texRectTVtx[3].x, g_texRectTVtx[3].y, -g_texRectTVtx[3].z);
glEnd();
#else
GLfloat colour[] = {
gRDP.fvPrimitiveColor[0], gRDP.fvPrimitiveColor[1], gRDP.fvPrimitiveColor[2], gRDP.fvPrimitiveColor[3],
gRDP.fvPrimitiveColor[0], gRDP.fvPrimitiveColor[1], gRDP.fvPrimitiveColor[2], gRDP.fvPrimitiveColor[3],
gRDP.fvPrimitiveColor[0], gRDP.fvPrimitiveColor[1], gRDP.fvPrimitiveColor[2], gRDP.fvPrimitiveColor[3],
gRDP.fvPrimitiveColor[0], gRDP.fvPrimitiveColor[1], gRDP.fvPrimitiveColor[2], gRDP.fvPrimitiveColor[3],
gRDP.fvPrimitiveColor[0], gRDP.fvPrimitiveColor[1], gRDP.fvPrimitiveColor[2], gRDP.fvPrimitiveColor[3],
gRDP.fvPrimitiveColor[0], gRDP.fvPrimitiveColor[1], gRDP.fvPrimitiveColor[2], gRDP.fvPrimitiveColor[3],
};
GLfloat tex[] = {
g_texRectTVtx[0].tcord[0].u,g_texRectTVtx[0].tcord[0].v,
g_texRectTVtx[1].tcord[0].u,g_texRectTVtx[1].tcord[0].v,
g_texRectTVtx[2].tcord[0].u,g_texRectTVtx[2].tcord[0].v,
g_texRectTVtx[0].tcord[0].u,g_texRectTVtx[0].tcord[0].v,
g_texRectTVtx[2].tcord[0].u,g_texRectTVtx[2].tcord[0].v,
g_texRectTVtx[3].tcord[0].u,g_texRectTVtx[3].tcord[0].v,
};
GLfloat tex2[] = {
g_texRectTVtx[0].tcord[1].u,g_texRectTVtx[0].tcord[1].v,
g_texRectTVtx[1].tcord[1].u,g_texRectTVtx[1].tcord[1].v,
g_texRectTVtx[2].tcord[1].u,g_texRectTVtx[2].tcord[1].v,
g_texRectTVtx[0].tcord[1].u,g_texRectTVtx[0].tcord[1].v,
g_texRectTVtx[2].tcord[1].u,g_texRectTVtx[2].tcord[1].v,
g_texRectTVtx[3].tcord[1].u,g_texRectTVtx[3].tcord[1].v,
};
float w = windowSetting.uDisplayWidth / 2.0f, h = windowSetting.uDisplayHeight / 2.0f, inv = 1.0f;
GLfloat vertices[] = {
-inv + g_texRectTVtx[0].x/ w, inv - g_texRectTVtx[0].y/ h, -g_texRectTVtx[0].z,1,
-inv + g_texRectTVtx[1].x/ w, inv - g_texRectTVtx[1].y/ h, -g_texRectTVtx[1].z,1,
-inv + g_texRectTVtx[2].x/ w, inv - g_texRectTVtx[2].y/ h, -g_texRectTVtx[2].z,1,
-inv + g_texRectTVtx[0].x/ w, inv - g_texRectTVtx[0].y/ h, -g_texRectTVtx[0].z,1,
-inv + g_texRectTVtx[2].x/ w, inv - g_texRectTVtx[2].y/ h, -g_texRectTVtx[2].z,1,
-inv + g_texRectTVtx[3].x/ w, inv - g_texRectTVtx[3].y/ h, -g_texRectTVtx[3].z,1
};
glVertexAttribPointer(VS_COLOR, 4, GL_FLOAT,GL_FALSE, 0, &colour );
glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,0,&vertices);
glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, 0, &tex);
glVertexAttribPointer(VS_TEXCOORD1,2,GL_FLOAT,GL_FALSE, 0, &tex2);
//OPENGL_CHECK_ERRORS;
glDrawArrays(GL_TRIANGLES,0,6);
//OPENGL_CHECK_ERRORS;
//Restore old pointers
glVertexAttribPointer(VS_COLOR, 4, GL_UNSIGNED_BYTE,GL_TRUE, sizeof(uint8)*4, &(g_oglVtxColors[0][0]) );
glVertexAttribPointer(VS_POSITION,4,GL_FLOAT,GL_FALSE,sizeof(float)*5,&(g_vtxProjected5[0][0]));
glVertexAttribPointer(VS_TEXCOORD0,2,GL_FLOAT,GL_FALSE, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[0].u));
glVertexAttribPointer(VS_TEXCOORD1,2,GL_FLOAT,GL_FALSE, sizeof( TLITVERTEX ), &(g_vtxBuffer[0].tcord[1].u));
#endif
if( cullface ) glEnable(GL_CULL_FACE);
}
void CPathEstimator::Draw(void)
{
MoveData* md=moveinfo->GetMoveDataFromName("TANKSH2");
if(!selectedUnits.selectedUnits.empty() && (*selectedUnits.selectedUnits.begin())->unitDef->movedata)
md=(*selectedUnits.selectedUnits.begin())->unitDef->movedata;
glDisable(GL_TEXTURE_2D);
glColor3f(1,1,0);
float blue=BLOCK_SIZE==32?1:0;
/* glBegin(GL_LINES);
for(int z = 0; z < nbrOfBlocksZ; z++) {
for(int x = 0; x < nbrOfBlocksX; x++) {
int blocknr = z * nbrOfBlocksX + x;
float3 p1;
p1.x=(blockState[blocknr].sqrCenter[md->pathType].x)*8;
p1.z=(blockState[blocknr].sqrCenter[md->pathType].y)*8;
p1.y=ground->GetHeight(p1.x,p1.z)+10;
glColor3f(1,1,blue);
glVertexf3(p1);
glVertexf3(p1-UpVector*10);
for(int dir = 0; dir < PATH_DIRECTION_VERTICES; dir++){
int obx = x + directionVector[dir].x;
int obz = z + directionVector[dir].y;
if(obx >= 0 && obz >= 0 && obx < nbrOfBlocksX && obz < nbrOfBlocksZ) {
float3 p2;
int obblocknr = obz * nbrOfBlocksX + obx;
p2.x=(blockState[obblocknr].sqrCenter[md->pathType].x)*8;
p2.z=(blockState[obblocknr].sqrCenter[md->pathType].y)*8;
p2.y=ground->GetHeight(p2.x,p2.z)+10;
int vertexNbr = md->pathType * nbrOfBlocks * PATH_DIRECTION_VERTICES + blocknr * PATH_DIRECTION_VERTICES + directionVertex[dir];
float cost=vertex[vertexNbr];
glColor3f(1/(sqrt(cost/BLOCK_SIZE)),1/(cost/BLOCK_SIZE),blue);
glVertexf3(p1);
glVertexf3(p2);
}
}
}
}
glEnd();/**/
/* glEnable(GL_TEXTURE_2D);
for(int z = 0; z < nbrOfBlocksZ; z++) {
for(int x = 0; x < nbrOfBlocksX; x++) {
int blocknr = z * nbrOfBlocksX + x;
float3 p1;
p1.x=(blockState[blocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
p1.z=(blockState[blocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
p1.y=ground->GetHeight(p1.x,p1.z)+10;
glColor3f(1,1,blue);
for(int dir = 0; dir < PATH_DIRECTION_VERTICES; dir++){
int obx = x + directionVector[dir].x;
int obz = z + directionVector[dir].y;
if(obx >= 0 && obz >= 0 && obx < nbrOfBlocksX && obz < nbrOfBlocksZ) {
float3 p2;
int obblocknr = obz * nbrOfBlocksX + obx;
p2.x=(blockState[obblocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
p2.z=(blockState[obblocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
p2.y=ground->GetHeight(p2.x,p2.z)+10;
int vertexNbr = md->pathType * nbrOfBlocks * PATH_DIRECTION_VERTICES + blocknr * PATH_DIRECTION_VERTICES + directionVertex[dir];
float cost=vertex[vertexNbr];
glColor3f(1,1/(cost/BLOCK_SIZE),blue);
p2=(p1+p2)/2;
if(camera->pos.distance(p2)<500){
glPushMatrix();
glTranslatef3(p2);
glScalef(5,5,5);
font->glWorldPrint("%.0f",cost);
glPopMatrix();
}
}
}
}
}
*/
if(BLOCK_SIZE==8)
glColor3f(0.2,0.7,0.2);
else
glColor3f(0.2,0.2,0.7);
glDisable(GL_TEXTURE_2D);
glBegin(GL_LINES);
for(OpenBlock* ob=openBlockBuffer;ob!=openBlockBufferPointer;++ob){
int blocknr = ob->blocknr;
float3 p1;
p1.x=(blockState[blocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
p1.z=(blockState[blocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
p1.y=ground->GetHeight(p1.x,p1.z)+15;
float3 p2;
int obx=blockState[ob->blocknr].parentBlock.x;
int obz=blockState[ob->blocknr].parentBlock.y;
int obblocknr = obz * nbrOfBlocksX + obx;
if(obblocknr>=0){
p2.x=(blockState[obblocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
p2.z=(blockState[obblocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
p2.y=ground->GetHeight(p2.x,p2.z)+15;
glVertexf3(p1);
glVertexf3(p2);
}
}
glEnd();
/* glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glColor4f(1,0,blue,0.7);
glAlphaFunc(GL_GREATER,0.05);
int a=0;
for(OpenBlock* ob=openBlockBuffer;ob!=openBlockBufferPointer;++ob){
int blocknr = ob->blocknr;
float3 p1;
p1.x=(ob->block.x * BLOCK_SIZE + blockState[blocknr].sqrCenter[md->pathType].x)*SQUARE_SIZE;
p1.z=(ob->block.y * BLOCK_SIZE + blockState[blocknr].sqrCenter[md->pathType].y)*SQUARE_SIZE;
p1.y=ground->GetHeight(p1.x,p1.z)+15;
if(camera->pos.distance(p1)<500){
glPushMatrix();
glTranslatef3(p1);
glScalef(5,5,5);
font->glWorldPrint("%.0f %.0f",ob->cost,ob->currentCost);
glPopMatrix();
}
++a;
}
glDisable(GL_BLEND);*/
}
void World::Draw()
{
static GLUquadricObj *quadObj = gluNewQuadric();
float white[4] = {1.0,1.0,1.0,1.0};
float grey[4] = {0.8,0.8,0.8,1.0};
float black[4] = {0.0,0.0,0.0,1.0};
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, grey);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, black);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, black);
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, black);
for (unsigned int i = 0; i < m_shapes.size(); i++)
{
vec3 pos = m_shapes[i]->pos;
if (m_shapes[i]->GetType() == SPHERE)
{
Sphere* c = (Sphere*) m_shapes[i];
glPushMatrix();
glTranslatef(pos[0], pos[1], pos[2]);
glRotated(c->angle, 0, 1, 0);
glutSolidSphere(c->r, 20, 20);
glPopMatrix();
}
else if (m_shapes[i]->GetType() == CUBE)
{
Cube* c = (Cube*) m_shapes[i];
glPushMatrix();
glTranslatef(pos[0], pos[1], pos[2]);
glScalef(c->hx*2, c->hy*2, c->hz*2);
glutSolidCube(1.0);
glPopMatrix();
}
else if (m_shapes[i]->GetType() == CYLINDER)
{
Cylinder* c = (Cylinder*) m_shapes[i];
vec3 forward = c->end - c->start;
double height = forward.Length();
double radius = c->r;
forward.Normalize();
vec3 left = vec3(0,1,0)^forward;
vec3 up;
if (left.Length() < 0.0001)
{
up = forward^vec3(1,0,0);
left = up^forward;
}
else
{
up = forward^left;
}
float m[16];
m[0] = left[0]; m[4] = up[0]; m[8] = forward[0]; m[12] = 0;
m[1] = left[1]; m[5] = up[1]; m[9] = forward[1]; m[13] = 0;
m[2] = left[2]; m[6] = up[2]; m[10] = forward[2]; m[14] = 0;
m[3] = 0.0; m[7] = 0.0; m[11] = 0.0; m[15] = 1.0;
glPushMatrix();
glTranslated(c->start[0], c->start[1], c->start[2]);
glMultMatrixf(m);
gluQuadricDrawStyle(quadObj, GLU_FILL);
gluQuadricNormals(quadObj, GLU_SMOOTH);
gluCylinder(quadObj, radius, radius, height, 12, 12);
//endCaps
glPushMatrix();
gluDisk(quadObj, 0, radius, 12, 12);
glTranslated(0, 0, height);
gluDisk(quadObj, 0, radius, 12, 12);
glPopMatrix();
glPopMatrix();
}
else if (m_shapes[i]->GetType() == GROUND)
{
glBegin(GL_QUADS);
glNormal3d(0,1,0);
glVertex3f(100, 0.0, -100.0);
glVertex3f(100, 0.0, 100.0);
glVertex3f(-100, 0.0, 100);
glVertex3f(-100, 0.0, -100);
glEnd();
}
}
}
static void
make_gasket (logo_configuration *dc, int wire)
{
int i;
int points_size;
int npoints = 0;
int nctrls = 0;
int res = 360/8;
GLfloat d2r = M_PI / 180;
GLfloat thick2 = (dc->gasket_thickness / dc->gasket_size) / 2;
GLfloat *pointsx0, *pointsy0, *pointsx1, *pointsy1, *normals;
GLfloat r0 = 0.780; /* 395 */
GLfloat r1a = 0.855; /* top of wall below upper left hole */
GLfloat r1b = 0.890; /* center of upper left hole */
GLfloat r1c = 0.922; /* bottom of wall above hole */
GLfloat r1 = 0.928; /* 471 */
GLfloat r2 = 0.966; /* 490 */
GLfloat r3 = 0.984; /* 499 */
GLfloat r4 = 1.000; /* 507 */
GLfloat r5 = 1.090; /* 553 */
GLfloat ctrl_r[100], ctrl_th[100];
glPushMatrix();
# define POINT(r,th) \
ctrl_r [nctrls] = r, \
ctrl_th[nctrls] = (th * d2r), \
nctrls++
POINT (0.829, 0); /* top indentation, right half */
POINT (0.831, 0.85);
POINT (0.835, 1.81);
POINT (0.841, 2.65);
POINT (0.851, 3.30);
POINT (0.862, 3.81);
POINT (0.872, 3.95);
POINT (r4, 4.0); /* moving clockwise... */
POINT (r4, 48.2);
POINT (r1, 48.2);
POINT (r1, 54.2);
POINT (r2, 55.8);
POINT (r2, 73.2);
POINT (r1, 74.8);
POINT (r1, 101.2);
POINT (r3, 103.4);
POINT (r3, 132.0);
POINT (r1, 133.4);
POINT (r1, 180.7);
POINT (r2, 183.6);
POINT (r2, 209.8);
POINT (r1, 211.0);
POINT (r1, 221.8);
POINT (r5, 221.8);
POINT (r5, 223.2);
POINT (r4, 223.2);
POINT (r4, 316.8); /* upper left indentation */
POINT (0.990, 326.87);
POINT (0.880, 327.21);
POINT (0.872, 327.45);
POINT (0.869, 327.80);
POINT (0.867, 328.10);
POINT (0.867, 328.85);
POINT (0.869, 329.15);
POINT (0.872, 329.50);
POINT (0.880, 329.74);
POINT (0.990, 330.08);
POINT (r4, 339.0);
if (! wire)
{
POINT (r1a, 339.0); /* cut-out disc */
POINT (r1a, 343.0);
}
POINT (r4, 343.0);
POINT (r4, 356.0);
POINT (0.872, 356.05); /* top indentation, left half */
POINT (0.862, 356.19);
POINT (0.851, 356.70);
POINT (0.841, 357.35);
POINT (0.835, 358.19);
POINT (0.831, 359.15);
POINT (0.829, 360);
# undef POINT
points_size = res + (nctrls * 2);
pointsx0 = (GLfloat *) malloc (points_size * sizeof(GLfloat));
pointsy0 = (GLfloat *) malloc (points_size * sizeof(GLfloat));
pointsx1 = (GLfloat *) malloc (points_size * sizeof(GLfloat));
pointsy1 = (GLfloat *) malloc (points_size * sizeof(GLfloat));
normals = (GLfloat *) malloc (points_size * sizeof(GLfloat) * 2);
npoints = 0;
for (i = 1; i < nctrls; i++)
{
GLfloat from_r = ctrl_r [i-1];
GLfloat from_th = ctrl_th[i-1];
GLfloat to_r = ctrl_r [i];
GLfloat to_th = ctrl_th[i];
GLfloat step = 2*M_PI / res;
int nsteps = 1 + ((to_th - from_th) / step);
int j;
for (j = 0; j < nsteps + (i == nctrls-1); j++)
{
GLfloat r = from_r + (j * (to_r - from_r) / nsteps);
GLfloat th = from_th + (j * (to_th - from_th) / nsteps);
GLfloat cth = cos(th) * dc->gasket_size;
GLfloat sth = sin(th) * dc->gasket_size;
pointsx0[npoints] = r0 * cth; /* inner ring */
pointsy0[npoints] = r0 * sth;
pointsx1[npoints] = r * cth; /* outer ring */
pointsy1[npoints] = r * sth;
npoints++;
if (npoints >= points_size) abort();
}
}
/* normals for the outer ring */
for (i = 1; i < npoints; i++)
{
XYZ a, b, c, n;
a.x = pointsx1[i-1];
a.y = pointsy1[i-1];
a.z = 0;
b.x = pointsx1[i];
b.y = pointsy1[i];
b.z = 0;
c = b;
c.z = 1;
n = calc_normal (a, b, c);
normals[(i-1)*2 ] = n.x;
normals[(i-1)*2+1] = n.y;
}
glRotatef(-90, 0, 1, 0);
glRotatef(180, 0, 0, 1);
if (wire)
{
GLfloat z;
for (z = -thick2; z <= thick2; z += thick2*2)
{
# if 1
/* inside edge */
glBegin (GL_LINE_LOOP);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx0[i], pointsy0[i], z);
glEnd();
/* outside edge */
glBegin (GL_LINE_LOOP);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx1[i], pointsy1[i], z);
glEnd();
# else
for (i = 1; i < npoints; i++)
{
glBegin (GL_LINE_STRIP);
glVertex3f (pointsx0[i-1], pointsy0[i-1], z);
glVertex3f (pointsx0[i ], pointsy0[i ], z);
glVertex3f (pointsx1[i ], pointsy1[i ], z);
glVertex3f (pointsx1[i-1], pointsy1[i-1], z);
glEnd();
}
# endif
}
#if 1
glBegin (GL_LINES);
for (i = 0; i < npoints; i++)
{
/* inside rim */
glVertex3f (pointsx0[i], pointsy0[i], -thick2);
glVertex3f (pointsx0[i], pointsy0[i], thick2);
/* outside rim */
glVertex3f (pointsx1[i], pointsy1[i], -thick2);
glVertex3f (pointsx1[i], pointsy1[i], thick2);
}
glEnd();
#endif
}
else
{
/* top */
glFrontFace(GL_CW);
glNormal3f(0, 0, -1);
glBegin (GL_QUAD_STRIP);
for (i = 0; i < npoints; i++)
{
glVertex3f (pointsx0[i], pointsy0[i], -thick2);
glVertex3f (pointsx1[i], pointsy1[i], -thick2);
}
glEnd();
/* bottom */
glFrontFace(GL_CCW);
glNormal3f(0, 0, 1);
glBegin (GL_QUAD_STRIP);
for (i = 0; i < npoints; i++)
{
glVertex3f (pointsx0[i], pointsy0[i], thick2);
glVertex3f (pointsx1[i], pointsy1[i], thick2);
}
glEnd();
/* inside edge */
glFrontFace(GL_CW);
glBegin (GL_QUAD_STRIP);
for (i = 0; i < npoints; i++)
{
glNormal3f (-pointsx0[i], -pointsy0[i], 0);
glVertex3f ( pointsx0[i], pointsy0[i], thick2);
glVertex3f ( pointsx0[i], pointsy0[i], -thick2);
}
glEnd();
/* outside edge */
glFrontFace(GL_CCW);
glBegin (GL_QUADS);
{
for (i = 0; i < npoints-1; i++)
{
int ia = (i == 0 ? npoints-2 : i-1);
int iz = (i == npoints-2 ? 0 : i+1);
GLfloat x = pointsx1[i];
GLfloat y = pointsy1[i];
GLfloat xz = pointsx1[iz];
GLfloat yz = pointsy1[iz];
GLfloat nxa = normals[ia*2]; /* normal of [i-1 - i] face */
GLfloat nya = normals[ia*2+1];
GLfloat nx = normals[i*2]; /* normal of [i - i+1] face */
GLfloat ny = normals[i*2+1];
GLfloat nxz = normals[iz*2]; /* normal of [i+1 - i+2] face */
GLfloat nyz = normals[iz*2+1];
GLfloat anglea = vector_angle (nx, ny, 0, nxa, nya, 0);
GLfloat anglez = vector_angle (nx, ny, 0, nxz, nyz, 0);
GLfloat pointy = 0.005;
if (anglea > pointy)
{
glNormal3f (nx, ny, 0);
glVertex3f (x, y, thick2);
glVertex3f (x, y, -thick2);
}
else
{
glNormal3f ((nxa + nx) / 2, (nya + ny) / 2, 0);
glVertex3f (x, y, thick2);
glVertex3f (x, y, -thick2);
}
if (anglez > pointy)
{
glNormal3f (nx, ny, 0);
glVertex3f (xz, yz, -thick2);
glVertex3f (xz, yz, thick2);
}
else
{
glNormal3f ((nx + nxz) / 2, (ny + nyz) / 2, 0);
glVertex3f (xz, yz, -thick2);
glVertex3f (xz, yz, thick2);
}
}
}
glEnd();
}
/* Fill in the upper left hole...
*/
{
GLfloat th;
npoints = 0;
th = 339.0 * d2r;
pointsx0[npoints] = r1c * cos(th) * dc->gasket_size;
pointsy0[npoints] = r1c * sin(th) * dc->gasket_size;
npoints++;
pointsx0[npoints] = r4 * cos(th) * dc->gasket_size;
pointsy0[npoints] = r4 * sin(th) * dc->gasket_size;
npoints++;
th = 343.0 * d2r;
pointsx0[npoints] = r1c * cos(th) * dc->gasket_size;
pointsy0[npoints] = r1c * sin(th) * dc->gasket_size;
npoints++;
pointsx0[npoints] = r4 * cos(th) * dc->gasket_size;
pointsy0[npoints] = r4 * sin(th) * dc->gasket_size;
npoints++;
if (! wire)
{
/* front wall */
glNormal3f (0, 0, -1);
glFrontFace(GL_CW);
glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
glVertex3f (pointsx0[0], pointsy0[0], -thick2);
glVertex3f (pointsx0[1], pointsy0[1], -thick2);
glVertex3f (pointsx0[3], pointsy0[3], -thick2);
glVertex3f (pointsx0[2], pointsy0[2], -thick2);
glEnd();
/* back wall */
glNormal3f (0, 0, 1);
glFrontFace(GL_CCW);
glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
glVertex3f (pointsx0[0], pointsy0[0], thick2);
glVertex3f (pointsx0[1], pointsy0[1], thick2);
glVertex3f (pointsx0[3], pointsy0[3], thick2);
glVertex3f (pointsx0[2], pointsy0[2], thick2);
glEnd();
}
/* top wall */
glFrontFace(GL_CW);
glBegin (wire ? GL_LINE_LOOP : GL_QUADS);
glNormal3f (pointsx0[1], pointsy0[1], 0);
glVertex3f (pointsx0[1], pointsy0[1], thick2);
glNormal3f (pointsx0[3], pointsy0[3], 0);
glVertex3f (pointsx0[3], pointsy0[3], thick2);
glVertex3f (pointsx0[3], pointsy0[3], -thick2);
glNormal3f (pointsx0[1], pointsy0[1], 0);
glVertex3f (pointsx0[1], pointsy0[1], -thick2);
glEnd();
/* Now make a donut.
*/
{
int nsteps = 12;
GLfloat r0 = 0.026;
GLfloat r1 = 0.060;
GLfloat th, cth, sth;
glPushMatrix ();
th = ((339.0 + 343.0) / 2) * d2r;
glTranslatef (r1b * cos(th) * dc->gasket_size,
r1b * sin(th) * dc->gasket_size,
0);
npoints = 0;
for (i = 0; i < nsteps; i++)
{
th = 2 * M_PI * i / nsteps;
cth = cos (th) * dc->gasket_size;
sth = sin (th) * dc->gasket_size;
pointsx0[npoints] = r0 * cth;
pointsy0[npoints] = r0 * sth;
pointsx1[npoints] = r1 * cth;
pointsy1[npoints] = r1 * sth;
npoints++;
}
pointsx0[npoints] = pointsx0[0];
pointsy0[npoints] = pointsy0[0];
pointsx1[npoints] = pointsx1[0];
pointsy1[npoints] = pointsy1[0];
npoints++;
if (wire)
{
glBegin (GL_LINE_LOOP);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx0[i], pointsy0[i], -thick2);
glEnd();
glBegin (GL_LINE_LOOP);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx0[i], pointsy0[i], thick2);
glEnd();
# if 0
glBegin (GL_LINE_LOOP);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx1[i], pointsy1[i], -thick2);
glEnd();
glBegin (GL_LINE_LOOP);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx1[i], pointsy1[i], thick2);
glEnd();
# endif
}
else
{
/* top */
glFrontFace(GL_CW);
glNormal3f(0, 0, -1);
glBegin (GL_QUAD_STRIP);
for (i = 0; i < npoints; i++)
{
glVertex3f (pointsx0[i], pointsy0[i], -thick2);
glVertex3f (pointsx1[i], pointsy1[i], -thick2);
}
glEnd();
/* bottom */
glFrontFace(GL_CCW);
glNormal3f(0, 0, 1);
glBegin (GL_QUAD_STRIP);
for (i = 0; i < npoints; i++)
{
glVertex3f (pointsx0[i], pointsy0[i], thick2);
glVertex3f (pointsx1[i], pointsy1[i], thick2);
}
glEnd();
}
/* inside edge */
glFrontFace(GL_CW);
glBegin (wire ? GL_LINES : GL_QUAD_STRIP);
for (i = 0; i < npoints; i++)
{
glNormal3f (-pointsx0[i], -pointsy0[i], 0);
glVertex3f ( pointsx0[i], pointsy0[i], thick2);
glVertex3f ( pointsx0[i], pointsy0[i], -thick2);
}
glEnd();
glPopMatrix();
}
}
/* Attach the bottom-right dingus...
*/
{
GLfloat w = 0.04;
GLfloat h = 0.17;
GLfloat th;
glRotatef (50, 0, 0, 1);
glScalef (dc->gasket_size, dc->gasket_size, 1);
glTranslatef (0, (r0+r1)/2, 0);
/* buried box */
if (! wire)
{
glFrontFace(GL_CCW);
glBegin (wire ? GL_LINE_STRIP : GL_QUADS);
glNormal3f (0, 0, -1);
glVertex3f (-w/2, -h/2, -thick2); glVertex3f (-w/2, h/2, -thick2);
glVertex3f ( w/2, h/2, -thick2); glVertex3f ( w/2, -h/2, -thick2);
glNormal3f (1, 0, 0);
glVertex3f ( w/2, -h/2, -thick2); glVertex3f ( w/2, h/2, -thick2);
glVertex3f ( w/2, h/2, thick2); glVertex3f ( w/2, -h/2, thick2);
glNormal3f (0, 0, 1);
glVertex3f ( w/2, -h/2, thick2); glVertex3f ( w/2, h/2, thick2);
glVertex3f (-w/2, h/2, thick2); glVertex3f (-w/2, -h/2, thick2);
glNormal3f (-1, 0, 0);
glVertex3f (-w/2, -h/2, thick2); glVertex3f (-w/2, h/2, thick2);
glVertex3f (-w/2, h/2, -thick2); glVertex3f (-w/2, -h/2, -thick2);
glEnd();
}
npoints = 0;
for (th = 0; th < M_PI; th += (M_PI / 6))
{
pointsx0[npoints] = w/2 * cos(th);
pointsy0[npoints] = w/2 * sin(th);
npoints++;
}
/* front inside curve */
glNormal3f (0, 0, -1);
glFrontFace(GL_CW);
glBegin (wire ? GL_LINE_STRIP : GL_TRIANGLE_FAN);
if (! wire) glVertex3f (0, h/2, -thick2);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx0[i], h/2 + pointsy0[i], -thick2);
glEnd();
/* front outside curve */
glFrontFace(GL_CCW);
glBegin (wire ? GL_LINE_STRIP : GL_TRIANGLE_FAN);
if (! wire) glVertex3f (0, -h/2, -thick2);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx0[i], -h/2 - pointsy0[i], -thick2);
glEnd();
/* back inside curve */
glNormal3f (0, 0, 1);
glFrontFace(GL_CCW);
glBegin (wire ? GL_LINE_STRIP : GL_TRIANGLE_FAN);
if (! wire) glVertex3f (0, h/2, thick2);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx0[i], h/2 + pointsy0[i], thick2);
glEnd();
/* back outside curve */
glFrontFace(GL_CW);
glBegin (wire ? GL_LINE_STRIP : GL_TRIANGLE_FAN);
if (! wire) glVertex3f (0, -h/2, thick2);
for (i = 0; i < npoints; i++)
glVertex3f (pointsx0[i], -h/2 - pointsy0[i], thick2);
glEnd();
/* inside curve */
glFrontFace(GL_CCW);
glBegin (wire ? GL_LINES : GL_QUAD_STRIP);
for (i = 0; i < npoints; i++)
{
glNormal3f (pointsx0[i], pointsy0[i], 0);
glVertex3f (pointsx0[i], h/2 + pointsy0[i], thick2);
glVertex3f (pointsx0[i], h/2 + pointsy0[i], -thick2);
}
glEnd();
/* outside curve */
glFrontFace(GL_CW);
glBegin (wire ? GL_LINES : GL_QUAD_STRIP);
for (i = 0; i < npoints; i++)
{
glNormal3f (pointsx0[i], -pointsy0[i], 0);
glVertex3f (pointsx0[i], -h/2 - pointsy0[i], thick2);
glVertex3f (pointsx0[i], -h/2 - pointsy0[i], -thick2);
}
glEnd();
}
free (pointsx0);
free (pointsy0);
free (pointsx1);
free (pointsy1);
free (normals);
glPopMatrix();
}
static void
gear(GLfloat inner_radius, GLfloat outer_radius, GLfloat width,
GLint teeth, GLfloat tooth_depth)
{
GLint i;
GLfloat r0, r1, r2;
GLfloat angle, da;
GLfloat u, v, len;
r0 = inner_radius;
r1 = outer_radius - tooth_depth / 2.0;
r2 = outer_radius + tooth_depth / 2.0;
da = 2.0 * M_PI / teeth / 4.0;
glShadeModel(GL_FLAT);
glNormal3f(0.0, 0.0, 1.0);
/* draw front face */
glBegin(GL_QUAD_STRIP);
for (i = 0; i <= teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
if (i < teeth) {
glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
}
}
glEnd();
/* draw front sides of teeth */
glBegin(GL_QUADS);
da = 2.0 * M_PI / teeth / 4.0;
for (i = 0; i < teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
}
glEnd();
glNormal3f(0.0, 0.0, -1.0);
/* draw back face */
glBegin(GL_QUAD_STRIP);
for (i = 0; i <= teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
if (i < teeth) {
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
}
}
glEnd();
/* draw back sides of teeth */
glBegin(GL_QUADS);
da = 2.0 * M_PI / teeth / 4.0;
for (i = 0; i < teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
}
glEnd();
/* draw outward faces of teeth */
glBegin(GL_QUAD_STRIP);
for (i = 0; i < teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
glVertex3f(r1 * cos(angle), r1 * sin(angle), width * 0.5);
glVertex3f(r1 * cos(angle), r1 * sin(angle), -width * 0.5);
u = r2 * cos(angle + da) - r1 * cos(angle);
v = r2 * sin(angle + da) - r1 * sin(angle);
len = sqrt(u * u + v * v);
u /= len;
v /= len;
glNormal3f(v, -u, 0.0);
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), width * 0.5);
glVertex3f(r2 * cos(angle + da), r2 * sin(angle + da), -width * 0.5);
glNormal3f(cos(angle), sin(angle), 0.0);
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), width * 0.5);
glVertex3f(r2 * cos(angle + 2 * da), r2 * sin(angle + 2 * da), -width * 0.5);
u = r1 * cos(angle + 3 * da) - r2 * cos(angle + 2 * da);
v = r1 * sin(angle + 3 * da) - r2 * sin(angle + 2 * da);
glNormal3f(v, -u, 0.0);
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), width * 0.5);
glVertex3f(r1 * cos(angle + 3 * da), r1 * sin(angle + 3 * da), -width * 0.5);
glNormal3f(cos(angle), sin(angle), 0.0);
}
glVertex3f(r1 * cos(0), r1 * sin(0), width * 0.5);
glVertex3f(r1 * cos(0), r1 * sin(0), -width * 0.5);
glEnd();
glShadeModel(GL_SMOOTH);
/* draw inside radius cylinder */
glBegin(GL_QUAD_STRIP);
for (i = 0; i <= teeth; i++) {
angle = i * 2.0 * M_PI / teeth;
glNormal3f(-cos(angle), -sin(angle), 0.0);
glVertex3f(r0 * cos(angle), r0 * sin(angle), -width * 0.5);
glVertex3f(r0 * cos(angle), r0 * sin(angle), width * 0.5);
}
glEnd();
}
