void Route::DrawGL( ViewPort &VP )
{
#ifdef ocpnUSE_GL
if( m_nPoints < 1 || !m_bVisible ) return;
// Hiliting first
// Being special case to draw something for a 1 point route....
ocpnDC dc;
if(m_hiliteWidth) {
wxColour y = GetGlobalColor( _T ( "YELO1" ) );
wxColour hilt( y.Red(), y.Green(), y.Blue(), 128 );
wxPen HiPen( hilt, m_hiliteWidth, wxPENSTYLE_SOLID );
ocpnDC dc;
dc.SetPen( HiPen );
wxRoutePointListNode *node = pRoutePointList->GetFirst();
RoutePoint *prp0 = node->GetData();
wxPoint r0;
bool r0valid = cc1->GetCanvasPointPix( prp0->m_lat, prp0->m_lon, &r0);
int lines = 0;
node = node->GetNext();
while( node ) {
RoutePoint *prp = node->GetData();
wxPoint r1;
bool r1valid = cc1->GetCanvasPointPix( prp->m_lat, prp->m_lon, &r1);
if(r0valid && r1valid) {
dc.StrokeLine( r0.x, r0.y, r1.x, r1.y );
lines++;
}
r0valid = r1valid;
r0 = r1;
node = node->GetNext();
}
if(lines == 0 &&
cc1->GetCanvasPointPix( prp0->m_lat, prp0->m_lon, &r0)) {
dc.StrokeLine( r0.x, r0.y, r0.x + 2, r0.y + 2 );
return;
}
}
// if( m_nPoints < 2 )
// return;
/* determine color and width */
wxColour col;
int width = g_pRouteMan->GetRoutePen()->GetWidth(); //g_route_line_width;
if( m_width != wxPENSTYLE_INVALID )
width = m_width;
if(m_bIsTrack)
width = g_pRouteMan->GetTrackPen()->GetWidth();
if( m_bRtIsActive )
{
col = g_pRouteMan->GetActiveRoutePen()->GetColour();
} else if( m_bRtIsSelected ) {
col = g_pRouteMan->GetSelectedRoutePen()->GetColour();
} else {
if( m_Colour == wxEmptyString ) {
col = g_pRouteMan->GetRoutePen()->GetColour();
// For tracks, establish colour based on first icon name
if(m_bIsTrack) {
wxRoutePointListNode *node = pRoutePointList->GetFirst();
RoutePoint *prp = node->GetData();
if( prp->GetIconName().StartsWith( _T("xmred") ) )
col = GetGlobalColor( _T ( "URED" ) );
else if( prp->GetIconName().StartsWith( _T("xmblue") ) )
col = GetGlobalColor( _T ( "BLUE3" ) );
else if( prp->GetIconName().StartsWith( _T("xmgreen") ) )
col = GetGlobalColor( _T ( "UGREN" ) );
else
col = GetGlobalColor( _T ( "CHMGD" ) );
}
} else {
for( unsigned int i = 0; i < sizeof( ::GpxxColorNames ) / sizeof(wxString); i++ ) {
if( m_Colour == ::GpxxColorNames[i] ) {
col = ::GpxxColors[i];
break;
}
}
}
}
int style = wxSOLID;
if( m_style != wxPENSTYLE_INVALID ) style = m_style;
dc.SetPen( *wxThePenList->FindOrCreatePen( col, width, style ) );
glColor3ub(col.Red(), col.Green(), col.Blue());
glLineWidth( wxMax( g_GLMinSymbolLineWidth, width ) );
dc.SetGLStipple();
glBegin(GL_LINE_STRIP);
float lastlon = 0;
float lastlat = 0;
unsigned short int FromSegNo = 1;
for(wxRoutePointListNode *node = pRoutePointList->GetFirst();
node; node = node->GetNext()) {
RoutePoint *prp = node->GetData();
unsigned short int ToSegNo = prp->m_GPXTrkSegNo;
/* crosses IDL? if so break up into two segments */
int dir = 0;
if(prp->m_lon > 150 && lastlon < -150)
dir = -1;
else if(prp->m_lon < -150 && lastlon > 150)
dir = 1;
wxPoint r;
if (FromSegNo != ToSegNo)
{
glEnd();
FromSegNo = ToSegNo;
glBegin(GL_LINE_STRIP);
}
if(dir)
{
double crosslat = lat_rl_crosses_meridian(lastlat, lastlon, prp->m_lat, prp->m_lon, 180.0);
if(cc1->GetCanvasPointPix( crosslat, dir*180, &r))
glVertex2i(r.x, r.y);
glEnd();
glBegin(GL_LINE_STRIP);
if(cc1->GetCanvasPointPix( crosslat, -dir*180, &r))
glVertex2i(r.x, r.y);
}
lastlat=prp->m_lat;
lastlon=prp->m_lon;
if(cc1->GetCanvasPointPix( prp->m_lat, prp->m_lon, &r))
glVertex2i(r.x, r.y);
else {
glEnd();
glBegin(GL_LINE_STRIP);
}
}
glEnd();
glDisable (GL_LINE_STIPPLE);
/* direction arrows.. could probably be further optimized for opengl */
if( !m_bIsTrack ) {
wxRoutePointListNode *node = pRoutePointList->GetFirst();
wxPoint rpt1, rpt2;
while(node) {
RoutePoint *prp = node->GetData();
cc1->GetCanvasPointPix( prp->m_lat, prp->m_lon, &rpt2 );
if(node != pRoutePointList->GetFirst())
RenderSegmentArrowsGL( rpt1.x, rpt1.y, rpt2.x, rpt2.y, cc1->GetVP() );
rpt1 = rpt2;
node = node->GetNext();
}
}
/* Route points */
for(wxRoutePointListNode *node = pRoutePointList->GetFirst(); node; node = node->GetNext()) {
RoutePoint *prp = node->GetData();
if ( !m_bVisible && prp->m_bKeepXRoute )
prp->DrawGL( VP );
else if (m_bVisible)
prp->DrawGL( VP );
}
#endif
}
static void ddDrawPlane(const Plane& plane, const AABB& bounds, const Color& color)
{
vec3 points[6];
struct edge_t
{
int start;
int end;
};
static const edge_t edges[12] =
{
// bottom
{0, 1},
{1, 3},
{3, 2},
{2, 0},
// top
{4, 5},
{5, 7},
{7, 6},
{6, 4},
// top to bottom sides
{0, 4},
{1, 5},
{2, 6},
{3, 7},
};
// clip plane to bounds and render a quad
vec3 corners[8];
const vec3 *minmax[2] = { &bounds.m_min, &bounds.m_max };
for(int j = 0; j < 8; ++j)
{
int iz = j & 1;
int ix = (j >> 1) & 1;
int iy = (j >> 2) & 1;
corners[j].Set(minmax[ix]->x, minmax[iy]->y, minmax[iz]->z);
}
int numPoints = 0;
// add corners as points if they are close to the plane
for(int j = 0; j < 8; ++j)
{
float planeDist = PlaneDist(plane, corners[j]);
if(fabs(planeDist) < EPSILON)
points[numPoints++] = corners[j];
}
// add edge intersections
for(int j = 0; j < 12; ++j)
{
vec3 a = corners[edges[j].start],
b = corners[edges[j].end],
ab = b - a;
// intersect edge with plane
float t = (-plane.m_d - Dot(plane.m_n, a)) / Dot(plane.m_n, ab);
if(t >= 0.f && t <= 1.f)
{
vec3 pt = a + t * ab,
ptA = a - pt,
ptB = b - pt;
float distSqA = LengthSq(ptA);
float distSqB = LengthSq(ptB);
if(distSqA > EPSILON_SQ && distSqB > EPSILON_SQ)
{
points[numPoints++] = pt;
if(numPoints == 6)
break;
}
}
}
if(numPoints < 3)
return;
// Sort results
const float inv_num = 1.f / numPoints;
vec3 center = {0,0,0};
for(int j = 0; j < numPoints; ++j)
center += inv_num * points[j];
vec3 sideVec = Normalize(points[0] - center);
vec3 upVec = Normalize(Cross(plane.m_n, sideVec));
for(int j = 1; j < numPoints; ++j)
{
vec3 toPointJ = points[j] - center;
float angleJ = AngleWrap(atan2(Dot(upVec, toPointJ), Dot(sideVec, toPointJ)));
for(int k = j+1; k < numPoints; ++k)
{
vec3 toPointK = points[k] - center;
float angleK = AngleWrap(atan2(Dot(upVec, toPointK), Dot(sideVec, toPointK)));
if(angleK < angleJ)
{
angleJ = angleK;
std::swap(points[j], points[k]);
}
}
}
// Draw outline
const ShaderInfo* shader = g_dbgdrawShader.get();
GLint posLoc = shader->m_attrs[GEOM_Pos];
GLint colorLoc = shader->m_attrs[GEOM_Color];
glVertexAttrib3fv(colorLoc, &color.r);
glLineWidth(2.f);
glBegin(GL_LINES);
for(int j = 0; j < numPoints; ++j)
{
int next = (j + 1) % numPoints;
glVertexAttrib3fv(posLoc, &points[j].x);
glVertexAttrib3fv(posLoc, &points[next].x);
}
glEnd();
glLineWidth(1.f);
// Draw triangles
glVertexAttrib3fv(colorLoc, &color.r);
glBegin(GL_TRIANGLE_FAN);
glVertexAttrib3fv(posLoc, ¢er.x);
for(int j = 0; j < numPoints; ++j)
glVertexAttrib3fv(posLoc, &points[j].x);
glVertexAttrib3fv(posLoc, &points[0].x);
glEnd();
glBegin(GL_TRIANGLE_FAN);
glVertexAttrib3fv(posLoc, ¢er.x);
for(int j = numPoints-1; j >= 0; --j)
glVertexAttrib3fv(posLoc, &points[j].x);
glVertexAttrib3fv(posLoc, &points[numPoints-1].x);
glEnd();
}
void SetLineWidth(int widthInPixels)
/*****************************************************************************/
{
glLineWidth(widthInPixels);
}
/* CTextureCanvas::drawTexture
* Draws the currently opened composite texture
*******************************************************************/
void CTextureCanvas::drawTexture()
{
// Push matrix
glPushMatrix();
// Translate to middle of the canvas
glTranslated(GetSize().x * 0.5, GetSize().y * 0.5, 0);
// Zoom
double yscale = (tx_arc ? scale * 1.2 : scale);
glScaled(scale, yscale, 1);
// Draw offset guides if needed
drawOffsetLines();
// Apply texture scale
double tscalex = 1;
double tscaley = 1;
if (tex_scale)
{
tscalex = texture->getScaleX();
if (tscalex == 0) tscalex = 1;
tscaley = texture->getScaleY();
if (tscaley == 0) tscaley = 1;
glScaled(1.0 / tscalex, 1.0 / tscaley, 1);
}
// Calculate top-left position of texture (for glScissor, since it ignores the current translation/scale)
point2_t screen_tl = texToScreenPosition(0, 0);
int left = screen_tl.x;
int top = screen_tl.y;
// Translate by offsets if needed
if (view_type == 0) // No offsets
glTranslated(texture->getWidth() * -0.5, texture->getHeight() * -0.5, 0);
if (view_type >= 1) // Sprite offsets
glTranslated(-texture->getOffsetX(), -texture->getOffsetY(), 0);
if (view_type == 2) // HUD offsets
glTranslated(-160 * tscalex, -100 * tscaley, 0);
// Draw the texture border
drawTextureBorder();
// Enable textures
glEnable(GL_TEXTURE_2D);
// First, draw patches semitransparently (for anything outside the texture)
// But only if we are drawing stuff outside the texture area
if (draw_outside)
{
for (uint32_t a = 0; a < texture->nPatches(); a++)
drawPatch(a, true);
}
// Reset colouring
OpenGL::setColour(COL_WHITE);
// If we're currently dragging, draw a 'basic' preview of the texture using opengl
if (dragging)
{
glEnable(GL_SCISSOR_TEST);
glScissor(left, top, texture->getWidth() * scale * (1.0 / tscalex), texture->getHeight() * yscale * (1.0 / tscaley));
for (uint32_t a = 0; a < texture->nPatches(); a++)
drawPatch(a);
glDisable(GL_SCISSOR_TEST);
}
// Otherwise, draw the fully generated texture
else
{
// Generate if needed
if (!tex_preview.isLoaded())
{
// Determine image type
SIType type = PALMASK;
if (blend_rgba) type = RGBA;
// CTexture -> temp Image -> GLTexture
SImage temp(type);
texture->toImage(temp, parent, &palette, blend_rgba);
tex_preview.loadImage(&temp, &palette);
}
// Draw it
tex_preview.draw2d();
}
// Disable textures
glDisable(GL_TEXTURE_2D);
// Now loop through selected patches and draw selection outlines
OpenGL::setColour(70, 210, 220, 255, BLEND_NORMAL);
glEnable(GL_LINE_SMOOTH);
glLineWidth(1.5f);
for (size_t a = 0; a < selected_patches.size(); a++)
{
// Skip if not selected
if (!selected_patches[a])
continue;
// Get patch
CTPatch* patch = texture->getPatch(a);
CTPatchEx* epatch = (CTPatchEx*)patch;
// Check for rotation
if (texture->isExtended() && (epatch->getRotation() == 90 || epatch->getRotation() == -90))
{
// Draw outline, width/height swapped
glBegin(GL_LINE_LOOP);
glVertex2i(patch->xOffset(), patch->yOffset());
glVertex2i(patch->xOffset(), patch->yOffset() + (int)patch_textures[a]->getWidth());
glVertex2i(patch->xOffset() + (int)patch_textures[a]->getHeight(), patch->yOffset() + (int)patch_textures[a]->getWidth());
glVertex2i(patch->xOffset() + (int)patch_textures[a]->getHeight(), patch->yOffset());
glEnd();
}
else
{
// Draw outline
glBegin(GL_LINE_LOOP);
glVertex2i(patch->xOffset(), patch->yOffset());
glVertex2i(patch->xOffset(), patch->yOffset() + (int)patch_textures[a]->getHeight());
glVertex2i(patch->xOffset() + (int)patch_textures[a]->getWidth(), patch->yOffset() + (int)patch_textures[a]->getHeight());
glVertex2i(patch->xOffset() + (int)patch_textures[a]->getWidth(), patch->yOffset());
glEnd();
}
}
// Finally, draw a hilight outline if anything is hilighted
if (hilight_patch >= 0 && hilight_patch < (int)texture->nPatches())
{
// Set colour
OpenGL::setColour(255, 255, 255, 150, BLEND_ADDITIVE);
// Get patch
CTPatch* patch = texture->getPatch(hilight_patch);
CTPatchEx* epatch = (CTPatchEx*)patch;
GLTexture* patch_texture = patch_textures[hilight_patch];
// Check for rotation
if (texture->isExtended() && (epatch->getRotation() == 90 || epatch->getRotation() == -90))
{
// Draw outline, width/height swapped
glBegin(GL_LINE_LOOP);
glVertex2i(patch->xOffset(), patch->yOffset());
glVertex2i(patch->xOffset(), patch->yOffset() + (int)patch_texture->getWidth());
glVertex2i(patch->xOffset() + (int)patch_texture->getHeight(), patch->yOffset() + (int)patch_texture->getWidth());
glVertex2i(patch->xOffset() + (int)patch_texture->getHeight(), patch->yOffset());
glEnd();
}
else
{
// Draw outline
glBegin(GL_LINE_LOOP);
glVertex2i(patch->xOffset(), patch->yOffset());
glVertex2i(patch->xOffset(), patch->yOffset() + (int)patch_texture->getHeight());
glVertex2i(patch->xOffset() + (int)patch_texture->getWidth(), patch->yOffset() + (int)patch_texture->getHeight());
glVertex2i(patch->xOffset() + (int)patch_texture->getWidth(), patch->yOffset());
glEnd();
}
}
glDisable(GL_LINE_SMOOTH);
glLineWidth(1.0f);
// Pop matrix
glPopMatrix();
}
void Lines::draw()
{
//Draw, calls update when required
Geometry::draw();
if (drawcount == 0) return;
// Undo any scaling factor for arrow drawing...
glPushMatrix();
if (view->scale[0] != 1.0 || view->scale[1] != 1.0 || view->scale[2] != 1.0)
glScalef(1.0/view->scale[0], 1.0/view->scale[1], 1.0/view->scale[2]);
//Draw any 3d rendered tubes
tris->draw();
// Re-Apply scaling factors
glPopMatrix();
// Draw using vertex buffer object
glPushAttrib(GL_ENABLE_BIT);
clock_t t0 = clock();
double time;
int stride = 3 * sizeof(float) + sizeof(Colour); //3+3+2 vertices, normals, texCoord + 32-bit colour
int offset = 0;
if (geom.size() > 0 && elements > 0 && glIsBuffer(vbo))
{
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glVertexPointer(3, GL_FLOAT, stride, (GLvoid*)0); // Load vertex x,y,z only
glColorPointer(4, GL_UNSIGNED_BYTE, stride, (GLvoid*)(3*sizeof(float))); // Load rgba, offset 3 float
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
//Disable depth test on 2d models
if (view->is3d)
glEnable(GL_DEPTH_TEST);
else
glDisable(GL_DEPTH_TEST);
for (unsigned int i=0; i<geom.size(); i++)
{
Properties& props = geom[i]->draw->properties;
if (drawable(i) && props.getBool("flat", true) && !props["tubes"])
{
//Set draw state
setState(i, drawstate.prog[lucLineType]);
//Lines specific state
float scaling = props["scalelines"];
//Don't apply object scaling to internal lines objects
if (!internal) scaling *= (float)props["scaling"];
float lineWidth = (float)props["linewidth"] * scaling * view->scale2d; //Include 2d scale factor
if (lineWidth <= 0) lineWidth = scaling;
glLineWidth(lineWidth);
if (props["link"])
glDrawArrays(GL_LINE_STRIP, offset, counts[i]);
else
glDrawArrays(GL_LINES, offset, counts[i]);
}
offset += counts[i];
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
GL_Error_Check;
//Restore state
glPopAttrib();
glBindTexture(GL_TEXTURE_2D, 0);
time = ((clock()-t0)/(double)CLOCKS_PER_SEC);
if (time > 0.05)
debug_print(" %.4lf seconds to draw %d lines\n", time, offset);
GL_Error_Check;
}
void cc2DLabel::drawMeOnly2D(CC_DRAW_CONTEXT& context)
{
if (!m_dispIn2D)
return;
assert(!m_points.empty());
//standard case: list names pushing
bool pushName = MACRO_DrawEntityNames(context);
if (pushName)
glPushName(getUniqueID());
//we should already be in orthoprojective & centered omde
//glOrtho(-halfW,halfW,-halfH,halfH,-maxS,maxS);
int strHeight = 0;
int titleHeight = 0;
QString title(getName());
QStringList body;
GLdouble arrowDestX=-1.0,arrowDestY=-1.0;
QFont bodyFont,titleFont;
if (!pushName)
{
/*** line from 2D point to label ***/
//compute arrow head position
CCVector3 arrowDest;
m_points[0].cloud->getPoint(m_points[0].index,arrowDest);
for (unsigned i=1;i<m_points.size();++i)
arrowDest += *m_points[i].cloud->getPointPersistentPtr(m_points[i].index);
arrowDest /= (PointCoordinateType)m_points.size();
//project it in 2D screen coordinates
int VP[4];
context._win->getViewportArray(VP);
const double* MM = context._win->getModelViewMatd(); //viewMat
const double* MP = context._win->getProjectionMatd(); //projMat
GLdouble zp;
gluProject(arrowDest.x,arrowDest.y,arrowDest.z,MM,MP,VP,&arrowDestX,&arrowDestY,&zp);
/*** label border ***/
bodyFont = context._win->getTextDisplayFont(); //takes rendering zoom into account!
titleFont = QFont(context._win->getTextDisplayFont()); //takes rendering zoom into account!
titleFont.setBold(true);
QFontMetrics titleFontMetrics(titleFont);
QFontMetrics bodyFontMetrics(bodyFont);
strHeight = bodyFontMetrics.height();
titleHeight = titleFontMetrics.height();
if (m_showFullBody)
body = getLabelContent(context.dispNumberPrecision);
//base box dimension
int dx = 150;
dx = std::max(dx,titleFontMetrics.width(title));
int dy = c_margin; //top vertical margin
dy += titleHeight; //title
if (!body.empty())
{
dy += c_margin; //vertical margin above separator
for (int j=0; j<body.size(); ++j)
{
dx = std::max(dx,bodyFontMetrics.width(body[j]));
dy += strHeight; //body line height
}
dy += c_margin; //vertical margin below text
}
else
{
dy += c_margin; // vertical margin (purely for aesthetics)
}
dy += c_margin; // bottom vertical margin
dx += c_margin*2; // horizontal margins
//main rectangle
m_labelROI[0]=0;
m_labelROI[1]=0;
m_labelROI[2]=dx;
m_labelROI[3]=dy;
//close button
/*m_closeButtonROI[2]=dx-c_margin;
m_closeButtonROI[0]=m_closeButtonROI[2]-c_buttonSize;
m_closeButtonROI[3]=c_margin;
m_closeButtonROI[1]=m_closeButtonROI[3]+c_buttonSize;
//*/
//automatically elide the title
//title = titleFontMetrics.elidedText(title,Qt::ElideRight,m_closeButtonROI[0]-2*c_margin);
}
int halfW = (context.glW>>1);
int halfH = (context.glH>>1);
//draw label rectangle
int xStart = m_lastScreenPos[0] = (int)((float)context.glW * m_screenPos[0]);
int yStart = m_lastScreenPos[1] = (int)((float)context.glH * (1.0f-m_screenPos[1]));
//colors
bool highlighted = (!pushName && isSelected());
//default background color
colorType defaultBkgColor[4];
memcpy(defaultBkgColor,context.labelDefaultCol,sizeof(colorType)*3);
defaultBkgColor[3] = (colorType)((float)context.labelsTransparency*(float)MAX_COLOR_COMP/100.0f);
//default border color (mustn't be totally transparent!)
colorType defaultBorderColor[4];
if (highlighted)
memcpy(defaultBorderColor,ccColor::red,sizeof(colorType)*3);
else
memcpy(defaultBorderColor,context.labelDefaultCol,sizeof(colorType)*3);
defaultBorderColor[3] = (colorType)((float)(50+context.labelsTransparency/2)*(float)MAX_COLOR_COMP/100.0f);
glPushAttrib(GL_COLOR_BUFFER_BIT);
glEnable(GL_BLEND);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(static_cast<GLfloat>(-halfW+xStart),static_cast<GLfloat>(-halfH+yStart),0);
if (!pushName)
{
//compute arrow base position relatively to the label rectangle (for 0 to 8)
int arrowBaseConfig = 0;
int iArrowDestX = (int)arrowDestX-xStart;
int iArrowDestY = (int)arrowDestY-yStart;
{
if (iArrowDestX < m_labelROI[0]) //left
arrowBaseConfig += 0;
else if (iArrowDestX > m_labelROI[2]) //Right
arrowBaseConfig += 2;
else //Middle
arrowBaseConfig += 1;
if (iArrowDestY > -m_labelROI[1]) //Top
arrowBaseConfig += 0;
else if (iArrowDestY < -m_labelROI[3]) //Bottom
arrowBaseConfig += 6;
else //Middle
arrowBaseConfig += 3;
}
//we make the arrow base start from the nearest corner
if (arrowBaseConfig != 4) //4 = label above point!
{
glColor4ubv(defaultBorderColor);
glBegin(GL_TRIANGLE_FAN);
glVertex2d(arrowDestX-xStart,arrowDestY-yStart);
switch(arrowBaseConfig)
{
case 0: //top-left corner
glVertex2i(m_labelROI[0], -m_labelROI[1]-2*c_arrowBaseSize);
glVertex2i(m_labelROI[0], -m_labelROI[1]);
glVertex2i(m_labelROI[0]+2*c_arrowBaseSize, -m_labelROI[1]);
break;
case 1: //top-middle edge
glVertex2i(std::max(m_labelROI[0],iArrowDestX-c_arrowBaseSize), -m_labelROI[1]);
glVertex2i(std::min(m_labelROI[2],iArrowDestX+c_arrowBaseSize), -m_labelROI[1]);
break;
case 2: //top-right corner
glVertex2i(m_labelROI[2], -m_labelROI[1]-2*c_arrowBaseSize);
glVertex2i(m_labelROI[2], -m_labelROI[1]);
glVertex2i(m_labelROI[2]-2*c_arrowBaseSize, -m_labelROI[1]);
break;
case 3: //middle-left edge
glVertex2i(m_labelROI[0], std::min(-m_labelROI[1],iArrowDestY+c_arrowBaseSize));
glVertex2i(m_labelROI[0], std::max(-m_labelROI[3],iArrowDestY-c_arrowBaseSize));
break;
case 4: //middle of rectangle!
break;
case 5: //middle-right edge
glVertex2i(m_labelROI[2], std::min(-m_labelROI[1],iArrowDestY+c_arrowBaseSize));
glVertex2i(m_labelROI[2], std::max(-m_labelROI[3],iArrowDestY-c_arrowBaseSize));
break;
case 6: //bottom-left corner
glVertex2i(m_labelROI[0], -m_labelROI[3]+2*c_arrowBaseSize);
glVertex2i(m_labelROI[0], -m_labelROI[3]);
glVertex2i(m_labelROI[0]+2*c_arrowBaseSize, -m_labelROI[3]);
break;
case 7: //bottom-middle edge
glVertex2i(std::max(m_labelROI[0],iArrowDestX-c_arrowBaseSize), -m_labelROI[3]);
glVertex2i(std::min(m_labelROI[2],iArrowDestX+c_arrowBaseSize), -m_labelROI[3]);
break;
case 8: //bottom-right corner
glVertex2i(m_labelROI[2], -m_labelROI[3]+2*c_arrowBaseSize);
glVertex2i(m_labelROI[2], -m_labelROI[3]);
glVertex2i(m_labelROI[2]-2*c_arrowBaseSize, -m_labelROI[3]);
break;
}
glEnd();
}
}
//main rectangle
glColor4ubv(defaultBkgColor);
glBegin(GL_QUADS);
glVertex2i(m_labelROI[0], -m_labelROI[1]);
glVertex2i(m_labelROI[0], -m_labelROI[3]);
glVertex2i(m_labelROI[2], -m_labelROI[3]);
glVertex2i(m_labelROI[2], -m_labelROI[1]);
glEnd();
//if (highlighted)
{
glPushAttrib(GL_LINE_BIT);
glLineWidth(3.0f);
glColor4ubv(defaultBorderColor);
glBegin(GL_LINE_LOOP);
glVertex2i(m_labelROI[0], -m_labelROI[1]);
glVertex2i(m_labelROI[0], -m_labelROI[3]);
glVertex2i(m_labelROI[2], -m_labelROI[3]);
glVertex2i(m_labelROI[2], -m_labelROI[1]);
glEnd();
glPopAttrib();
}
//draw close button
/*glColor3ubv(ccColor::black);
glBegin(GL_LINE_LOOP);
glVertex2i(m_closeButtonROI[0],-m_closeButtonROI[1]);
glVertex2i(m_closeButtonROI[0],-m_closeButtonROI[3]);
glVertex2i(m_closeButtonROI[2],-m_closeButtonROI[3]);
glVertex2i(m_closeButtonROI[2],-m_closeButtonROI[1]);
glEnd();
glBegin(GL_LINES);
glVertex2i(m_closeButtonROI[0]+2,-m_closeButtonROI[1]+2);
glVertex2i(m_closeButtonROI[2]-2,-m_closeButtonROI[3]-2);
glVertex2i(m_closeButtonROI[2]-2,-m_closeButtonROI[1]+2);
glVertex2i(m_closeButtonROI[0]+2,-m_closeButtonROI[3]-2);
glEnd();
//*/
//display text
if (!pushName)
{
int xStartRel = c_margin;
int yStartRel = -c_margin;
yStartRel -= titleHeight;
const colorType* defaultTextColor = (context.labelsTransparency<40 ? context.textDefaultCol : ccColor::darkBlue);
context._win->displayText(title,xStart+xStartRel,yStart+yStartRel,ccGenericGLDisplay::ALIGN_DEFAULT,0,defaultTextColor,&titleFont);
yStartRel -= c_margin;
if (!body.empty())
{
//line separation
glColor4ubv(defaultBorderColor);
glBegin(GL_LINES);
glVertex2i(xStartRel,yStartRel);
glVertex2i(xStartRel+m_labelROI[2]-m_labelROI[0]-2*c_margin,yStartRel);
glEnd();
//display body
yStartRel -= c_margin;
for (int i=0; i<body.size(); ++i)
{
yStartRel -= strHeight;
context._win->displayText(body[i],xStart+xStartRel,yStart+yStartRel,ccGenericGLDisplay::ALIGN_DEFAULT,0,defaultTextColor,&bodyFont);
}
}
}
glPopAttrib();
glPopMatrix();
if (pushName)
glPopName();
}
/**
* This method is call on press of key
*/
void Visualizer::onKeyboard(unsigned char key, int, int)
{
if (key>='A' && key<='Z') key+='a'-'A'; /* convert upper char on lower */
switch (key) { /* press key */
case '1' : /* show vertex */
glPolygonMode(GL_FRONT, GL_POINT);
glPolygonMode(GL_BACK, GL_POINT);
glutPostRedisplay();
break;
case '2' : /* show wireframe */
glPolygonMode(GL_FRONT, GL_LINE);
glPolygonMode(GL_BACK, GL_LINE);
glutPostRedisplay();
break;
case '3' : /* show fill polygons */
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_FILL);
glutPostRedisplay();
break;
case '5' : /* decrease vision angle */
if (fov>0) fov--;
onReshape(WindowWidth, WindowHeight);
glutPostRedisplay();
break;
case '6' :
if (fov<180) fov++; /* increase vision angle */
onReshape(WindowWidth, WindowHeight);
glutPostRedisplay();
break;
case '7' : /* zoom in trim plain */
if (line_width > 0) line_width -= 0.5;
glLineWidth(line_width);
glPointSize(line_width);
onReshape(WindowWidth, WindowHeight);
glutPostRedisplay();
break;
case '8' : /* zoom out trim plain */
if (line_width < 10) line_width += 0.5;
glLineWidth(line_width);
glPointSize(line_width);
onReshape(WindowWidth, WindowHeight);
glutPostRedisplay();
break;
case 's' : /* print to bitmap - screenshot */
saveScreenshot(screenshotFileName);
break;
case 27 : /* Escape */
case 'q' :
exit(0); /* exit */
break;
case 'm' :
colorInput = INTERPOLATE_RADIOSITY; /* interpolate radiosity */
createCallList();
glutPostRedisplay();
break;
case 'b' :
colorInput = INTERPOLATE_RADIOSITY_RAW; /* interpolate radiosity */
createCallList();
glutPostRedisplay();
break;
case 'v' :
colorInput = RADIOSITY; /* radiosity */
createCallList();
glutPostRedisplay();
break;
case 'n' :
colorInput = RADIOSITY_LAST; /* radiosity */
createCallList();
glutPostRedisplay();
break;
case 'z' :
colorInput = REFLECTIVITY; /* reflectivity + emission */
createCallList();
glutPostRedisplay();
break;
case 'x' :
colorInput = EMISSION; /* reflectivity */
createCallList();
glutPostRedisplay();
break;
case 'c' :
colorInput = REFLECT_EMISS; /* emission */
createCallList();
glutPostRedisplay();
break;
case 'f' :
glutFullScreen(); /* fullscrean */
break;
case 'w' :
glutReshapeWindow(WindowWidth, WindowHeight); /* go back to window */
break;
default:
break;
}
}
void UVWidget::paintGL()
{
glPushAttrib( GL_ALL_ATTRIB_BITS );
glMatrixMode( GL_PROJECTION );
glPushMatrix();
glLoadIdentity();
setupViewport( width(), height() );
glMatrixMode( GL_MODELVIEW );
glPushMatrix();
glLoadIdentity();
qglClearColor( Options::bgColor() );
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
glDisable( GL_DEPTH_TEST );
glDepthMask( GL_FALSE );
// draw texture
glPushMatrix();
glLoadIdentity();
glEnable( GL_TEXTURE_2D );
if ( aTextureBlend->isChecked() )
glEnable( GL_BLEND );
else
glDisable( GL_BLEND );
if( !texfile.isEmpty() )
bindTexture( texfile );
else
bindTexture( texsource );
glTranslatef( -0.5f, -0.5f, 0.0f );
glTranslatef( -1.0f, -1.0f, 0.0f );
for( int i = 0; i < 3; i++ )
{
for( int j = 0; j < 3; j++ )
{
if( i == 1 && j == 1 ) {
glColor4f( 0.75f, 0.75f, 0.75f, 1.0f );
}
else {
glColor4f( 0.5f, 0.5f, 0.5f, 1.0f );
}
glDrawArrays( GL_QUADS, 0, 4 );
glTranslatef( 1.0f, 0.0f, 0.0f );
}
glTranslatef( -3.0f, 1.0f, 0.0f );
}
glTranslatef( 1.0f, -2.0f, 0.0f );
glDisable( GL_TEXTURE_2D );
glPopMatrix();
// draw grid
glPushMatrix();
glLoadIdentity();
glEnable( GL_BLEND );
glLineWidth( 0.8f );
glBegin( GL_LINES );
int glGridMinX = qRound( qMin( glViewRect[0], glViewRect[1] ) / glGridD );
int glGridMaxX = qRound( qMax( glViewRect[0], glViewRect[1] ) / glGridD );
int glGridMinY = qRound( qMin( glViewRect[2], glViewRect[3] ) / glGridD );
int glGridMaxY = qRound( qMax( glViewRect[2], glViewRect[3] ) / glGridD );
for( int i = glGridMinX; i < glGridMaxX; i++ )
{
GLdouble glGridPos = glGridD * i;
if( ( i % ( GRIDSEGS * GRIDSEGS ) ) == 0 ) {
glLineWidth( 1.4f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.4f );
}
else if( zoom > ( GRIDSEGS * GRIDSEGS / 2.0 ) ) {
continue;
}
else if( ( i % GRIDSEGS ) == 0 ) {
glLineWidth( 1.2f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.2f );
}
else if( zoom > ( GRIDSEGS / 2.0 ) ) {
continue;
}
else {
glLineWidth( 0.8f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.1f );
}
glVertex2d( glGridPos, glViewRect[2] );
glVertex2d( glGridPos, glViewRect[3] );
}
for( int i = glGridMinY; i < glGridMaxY; i++ )
{
GLdouble glGridPos = glGridD * i;
if( ( i % ( GRIDSEGS * GRIDSEGS ) ) == 0 ) {
glLineWidth( 1.4f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.4f );
}
else if( zoom > ( GRIDSEGS * GRIDSEGS / 2.0 ) ) {
continue;
}
else if( ( i % GRIDSEGS ) == 0 ) {
glLineWidth( 1.2f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.2f );
}
else if( zoom > ( GRIDSEGS / 2.0 ) ) {
continue;
}
else {
glLineWidth( 0.8f );
glColor4f( 1.0f, 1.0f, 1.0f, 0.1f );
}
glVertex2d( glViewRect[0], glGridPos );
glVertex2d( glViewRect[1], glGridPos );
}
glEnd();
glPopMatrix();
drawTexCoords();
glDisable( GL_DEPTH_TEST );
glDepthMask( GL_FALSE );
if( ! selectRect.isNull() )
{
glLoadIdentity();
glHighlightColor();
glBegin( GL_LINE_LOOP );
glVertex( mapToContents( selectRect.topLeft() ) );
glVertex( mapToContents( selectRect.topRight() ) );
glVertex( mapToContents( selectRect.bottomRight() ) );
glVertex( mapToContents( selectRect.bottomLeft() ) );
glEnd();
}
if ( ! selectPoly.isEmpty() )
{
glLoadIdentity();
glHighlightColor();
glBegin( GL_LINE_LOOP );
foreach ( QPoint p, selectPoly )
{
glVertex( mapToContents( p ) );
}
static void glInit()
{
// Enable Texture Mapping
glEnable(GL_TEXTURE_2D);
// Use trilinear interpolation (GL_LINEAR_MIPMAP_LINEAR)
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glClearColor( 1.f, 0.f, 1.f, 1.f ); //0.15f, 0.15f, 0.20f, 1.f);
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Testing To Do
glDepthMask(GL_TRUE);
if( 1 )
{
/*
GLfloat light_ambient[] = { 0.0, 0.0, 0.0, 1.0 };
GLfloat light_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_specular[] = { 1.0, 1.0, 1.0, 1.0 };
GLfloat light_position[] = { 1.0, 1.0, 0.0, 0.0 };
glLightfv (GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv (GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv (GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv (GL_LIGHT0, GL_POSITION, light_position);
*/
GLfloat global_ambient[] = { 0.6f, 0.6f, 1.0, 1.0 };
glLightModelfv (GL_LIGHT_MODEL_AMBIENT, global_ambient);
// Enable Lighting
glDisable(GL_LIGHTING);
glDisable(GL_LIGHT0);
//glLightfv(GL_LIGHT0, GL_POSITION, lightpos);
// Enable Material Coloring (color texture maps)
//glMaterial will control the polygon's specular and emission colours and the ambient and diffuse will both be set using glColor
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
}
glShadeModel(GL_SMOOTH); // Enable Smooth Shading
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Nice Perspective Correction
glEnable( GL_LINE_SMOOTH );
glHint( GL_LINE_SMOOTH_HINT, GL_NICEST );
glLineWidth( 1.0f );
glEnable( GL_BLEND );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
/* decal */
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glDisable( GL_CULL_FACE ); //glDisable
//glCullFace( GL_FRONT );
//glCullFace( GL_BACK );
/* small opt */
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glFrontFace(GL_CCW);
}
/* draw the paddle */
int draw_paddle( ARPaddleInfo *paddleInfo, PaddleItemInfo *paddleItemInfo )
{
double gl_para[16];
int i;
argDrawMode3D();
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
argDraw3dCamera( 0, 0 );
argConvGlpara(paddleInfo->trans, gl_para);
glMatrixMode(GL_MODELVIEW);
glLoadMatrixd( gl_para );
glColor3f( 1.0, 0.0, 0.0 );
glLineWidth(4.0);
glBegin(GL_LINE_LOOP);
glVertex2f( -25.0, -25.0 );
glVertex2f( 25.0, -25.0 );
glVertex2f( 25.0, 25.0 );
glVertex2f( -25.0, 25.0 );
glEnd();
glColor3f( 0.0, 0.0, 1.0);
glBegin(GL_LINE_LOOP);
for( i = 0; i < 16; i++ ) {
double x, y;
x = PADDLE_RADIUS * cos(i*3.141592*2/16);
y = PADDLE_RADIUS * sin(i*3.141592*2/16);
glVertex2d( x, y );
}
glEnd();
glBegin(GL_LINE_LOOP);
glVertex2f( -7.5, 0.0 );
glVertex2f( 7.5, 0.0 );
glVertex2f( 7.5, -105.0 );
glVertex2f( -7.5, -105.0 );
glEnd();
glEnable(GL_BLEND);
glBlendFunc(GL_ZERO,GL_ONE);
glColor4f(1,1,1,0);
glBegin(GL_POLYGON);
for( i = 0; i < 16; i++ ) {
double x, y;
x = 40.0 * cos(i*3.141592*2/16);
y = 40.0 * sin(i*3.141592*2/16);
glVertex2d( x, y );
}
glEnd();
glBegin(GL_POLYGON);
glVertex2f( -7.5, 0.0 );
glVertex2f( 7.5, 0.0 );
glVertex2f( 7.5, -105.0 );
glVertex2f( -7.5, -105.0 );
glEnd();
glDisable(GL_BLEND);
/* draw any objects on the paddle */
if( (i=paddleItemInfo->item) !=-1) {
glPushMatrix();
glTranslatef( paddleItemInfo->x, paddleItemInfo->y, 10.0 );
glRotatef( paddleItemInfo->angle * 180.0/3.141592, 0.0, 0.0, 1.0 );
glColor3f(0.0,1.0,0.0);
glutSolidSphere(10,10,10);
// glutSolidTeapot(10.);
glPopMatrix();
}
glDisable(GL_DEPTH_TEST);
argDrawMode2D();
return 0;
}
/*************************************************************************************
**
** drawGroundGrid - draws a ground plane
**
***************************************************************************************/
int drawGroundGrid( double trans[3][4], int divisions, float x, float y, float height)
{
double gl_para[16];
int i;
float x0,x1,y0,y1;
float deltaX, deltaY;
argDrawMode3D();
argDraw3dCamera( 0, 0 );
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
/* load the camera transformation matrix */
glMatrixMode(GL_MODELVIEW);
argConvGlpara(trans, gl_para);
glLoadMatrixd( gl_para );
glTranslatef(x/2.,-y/2.,0.);
//draw the grid
glColor3f(1,0,0);
glLineWidth(6.0);
glBegin(GL_LINE_LOOP);
glVertex3f( -x, y, height );
glVertex3f( x, y, height );
glVertex3f( x, -y, height );
glVertex3f( -x, -y, height );
glEnd();
glLineWidth(3.0);
//draw a grid of lines
//X direction
x0 = -x; x1 = -x;
y0 = -y; y1 = y;
deltaX = (2*x)/divisions;
for(i=0;i<divisions;i++){
x0 = x0 + deltaX;
glBegin(GL_LINES);
glVertex3f(x0,y0,height);
glVertex3f(x0,y1,height);
glEnd();
}
x0 = -x; x1 = x;
deltaY = (2*y)/divisions;
for(i=0;i<divisions;i++){
y0 = y0 + deltaY;
glBegin(GL_LINES);
glVertex3f(x0,y0,height);
glVertex3f(x1,y0,height);
glEnd();
}
glLineWidth(1.0);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambi);
glLightfv(GL_LIGHT0, GL_DIFFUSE, lightZeroColor);
glDisable( GL_LIGHTING );
glDisable( GL_DEPTH_TEST );
argDrawMode2D();
return 0;
}
/* main loop */
static void mainLoop(void)
{
ARUint8 *dataPtr;
ARMarkerInfo *marker_info;
int marker_num;
float curPaddlePos[3];
int i;
double err;
double angle;
err=0.;
/* grab a video frame */
if( (dataPtr = (ARUint8 *)arVideoGetImage()) == NULL ) {
arUtilSleep(2);
return;
}
if( count == 0 ) arUtilTimerReset();
count++;
/* detect the markers in the video frame */
if( arDetectMarkerLite(dataPtr, thresh, &marker_info, &marker_num) < 0 ) {
cleanup();
exit(0);
}
argDrawMode2D();
if( !arDebug ) {
argDispImage( dataPtr, 0,0 );
}
else {
argDispImage( dataPtr, 1, 1 );
if( arImageProcMode == AR_IMAGE_PROC_IN_HALF )
argDispHalfImage( arImage, 0, 0 );
else
argDispImage( arImage, 0, 0);
glColor3f( 1.0, 0.0, 0.0 );
glLineWidth( 1.0 );
for( i = 0; i < marker_num; i++ ) {
argDrawSquare( marker_info[i].vertex, 0, 0 );
}
glLineWidth( 1.0 );
}
arVideoCapNext();
for( i = 0; i < marker_num; i++ )
marker_flag[i] = 0;
/* get the paddle position */
paddleGetTrans(paddleInfo, marker_info, marker_flag,
marker_num, &cparam);
/* draw the 3D models */
glClearDepth( 1.0 );
glClear(GL_DEPTH_BUFFER_BIT);
/* get the translation from the multimarker pattern */
if( (err=arMultiGetTransMat(marker_info, marker_num, config)) < 0 ) {
argSwapBuffers();
return;
}
// printf("err = %f\n", err);
if(err > 100.0 ) {
argSwapBuffers();
return;
}
//draw a red ground grid
drawGroundGrid( config->trans, 15, 150.0, 110.0, 0.0);
/* find the paddle position relative to the base */
if (paddleInfo->active)
findPaddlePosition(curPaddlePos,paddleInfo->trans,config->trans);
/* checking for paddle gesture */
if( paddleInfo->active)
{
int findItem=-1;
if (myPaddleItem.item!=-1)
{
if( check_incline(paddleInfo->trans, config->trans, &angle) ) {
myPaddleItem.x += 2.0 * cos(angle);
myPaddleItem.y += 2.0 * sin(angle);
if( myPaddleItem.x*myPaddleItem.x +
myPaddleItem.y*myPaddleItem.y > 900.0 ) {
myPaddleItem.x -= 2.0 * cos(angle);
myPaddleItem.y -= 2.0 * sin(angle);
myListItem.item[myPaddleItem.item].onpaddle=0;
myListItem.item[myPaddleItem.item].pos[0]=curPaddlePos[0];
myListItem.item[myPaddleItem.item].pos[1]=curPaddlePos[1];
myPaddleItem.item = -1;
}
}
}
else
{
if ((findItem=check_pickup(paddleInfo->trans, config->trans,&myListItem, &angle))!=-1) {
myPaddleItem.item=findItem;
myPaddleItem.x =0.0;
myPaddleItem.y =0.0;
myPaddleItem.angle = 0.0;
myListItem.item[myPaddleItem.item].onpaddle=1;
}
}
}
/* draw the item */
drawItems(config->trans,&myListItem);
/* draw the paddle */
if( paddleInfo->active ){
draw_paddle(paddleInfo,&myPaddleItem);
}
argSwapBuffers();
}
void Audio::render(int screenWidth, int screenHeight) {
if (_stream) {
glLineWidth(2.0);
glBegin(GL_LINES);
glColor3f(1,1,1);
int startX = 20.0;
int currentX = startX;
int topY = screenHeight - 40;
int bottomY = screenHeight - 20;
float frameWidth = 20.0;
float halfY = topY + ((bottomY - topY) / 2.0);
// draw the lines for the base of the ring buffer
glVertex2f(currentX, topY);
glVertex2f(currentX, bottomY);
for (int i = 0; i < RING_BUFFER_LENGTH_FRAMES / 2; i++) {
glVertex2f(currentX, halfY);
glVertex2f(currentX + frameWidth, halfY);
currentX += frameWidth;
glVertex2f(currentX, topY);
glVertex2f(currentX, bottomY);
}
glEnd();
// Show a bar with the amount of audio remaining in ring buffer beyond current playback
float remainingBuffer = 0;
timeval currentTime;
gettimeofday(¤tTime, NULL);
float timeLeftInCurrentBuffer = 0;
if (_lastCallbackTime.tv_usec > 0) {
timeLeftInCurrentBuffer = AUDIO_CALLBACK_MSECS - diffclock(&_lastCallbackTime, ¤tTime);
}
if (_ringBuffer.getEndOfLastWrite() != NULL)
remainingBuffer = _ringBuffer.diffLastWriteNextOutput() / PACKET_LENGTH_SAMPLES * AUDIO_CALLBACK_MSECS;
if (_wasStarved == 0) {
glColor3f(0, 1, 0);
} else {
glColor3f(0.5 + (_wasStarved / 20.0f), 0, 0);
_wasStarved--;
}
glBegin(GL_QUADS);
glVertex2f(startX, topY + 2);
glVertex2f(startX + (remainingBuffer + timeLeftInCurrentBuffer)/AUDIO_CALLBACK_MSECS*frameWidth, topY + 2);
glVertex2f(startX + (remainingBuffer + timeLeftInCurrentBuffer)/AUDIO_CALLBACK_MSECS*frameWidth, bottomY - 2);
glVertex2f(startX, bottomY - 2);
glEnd();
if (_averagedLatency == 0.0) {
_averagedLatency = remainingBuffer + timeLeftInCurrentBuffer;
} else {
_averagedLatency = 0.99f * _averagedLatency + 0.01f * (remainingBuffer + timeLeftInCurrentBuffer);
}
// Show a yellow bar with the averaged msecs latency you are hearing (from time of packet receipt)
glColor3f(1,1,0);
glBegin(GL_QUADS);
glVertex2f(startX + _averagedLatency / AUDIO_CALLBACK_MSECS * frameWidth - 2, topY - 2);
glVertex2f(startX + _averagedLatency / AUDIO_CALLBACK_MSECS * frameWidth + 2, topY - 2);
glVertex2f(startX + _averagedLatency / AUDIO_CALLBACK_MSECS * frameWidth + 2, bottomY + 2);
glVertex2f(startX + _averagedLatency / AUDIO_CALLBACK_MSECS * frameWidth - 2, bottomY + 2);
glEnd();
char out[40];
sprintf(out, "%3.0f\n", _averagedLatency);
drawtext(startX + _averagedLatency / AUDIO_CALLBACK_MSECS * frameWidth - 10, topY - 9, 0.10, 0, 1, 0, out, 1,1,0);
// Show a red bar with the 'start' point of one frame plus the jitter buffer
glColor3f(1, 0, 0);
int jitterBufferPels = (1.f + (float)getJitterBufferSamples() / (float)PACKET_LENGTH_SAMPLES_PER_CHANNEL) * frameWidth;
sprintf(out, "%.0f\n", getJitterBufferSamples() / SAMPLE_RATE * 1000.f);
drawtext(startX + jitterBufferPels - 5, topY - 9, 0.10, 0, 1, 0, out, 1, 0, 0);
sprintf(out, "j %.1f\n", _measuredJitter);
if (Application::getInstance()->shouldDynamicallySetJitterBuffer()) {
drawtext(startX + jitterBufferPels - 5, bottomY + 12, 0.10, 0, 1, 0, out, 1, 0, 0);
} else {
drawtext(startX, bottomY + 12, 0.10, 0, 1, 0, out, 1, 0, 0);
}
glBegin(GL_QUADS);
glVertex2f(startX + jitterBufferPels - 2, topY - 2);
glVertex2f(startX + jitterBufferPels + 2, topY - 2);
glVertex2f(startX + jitterBufferPels + 2, bottomY + 2);
glVertex2f(startX + jitterBufferPels - 2, bottomY + 2);
glEnd();
}
}
void CUnitManager::render()
{
float shift_un = 640/units.size();
glBegin(GL_TRIANGLES);
for(unsigned int i = 0 ; i < units.size(); i++)
{
if(units[i].health > 0)
{
float curr_x,curr_y;
float last_x,last_y;
float surf_x,surf_y;
curr_x = units[i].x*32;
curr_y = units[i].y*32;
last_x = units[i].lx*32;
last_y = units[i].ly*32;
surf_x = ((curr_x - last_x)/SimSpeed) * Accum;
surf_y = ((curr_y - last_y)/SimSpeed) * Accum;
last_x += surf_x;
last_y += surf_y;
glColor3ub(units[i].Rcolor,units[i].Gcolor,units[i].Bcolor);
switch(units[i].r)
{
case 1:
glVertex3f(last_x+8,last_y+8,0);
glVertex3f(last_x+24,last_y+8,0);
glVertex3f(last_x+16,last_y+24,0);
break;
case 2:
glVertex3f(last_x+8,last_y+24,0);
glVertex3f(last_x+8,last_y+8,0);
glVertex3f(last_x+24,last_y+16,0);
break;
case 3:
glVertex3f(last_x+8,last_y+24,0);
glVertex3f(last_x+24,last_y+24,0);
glVertex3f(last_x+16,last_y+8,0);
break;
case 4:
glVertex3f(last_x+24,last_y+24,0);
glVertex3f(last_x+24,last_y+8,0);
glVertex3f(last_x+8,last_y+16,0);
break;
default:
break;
}
glVertex3f(660+16 ,16 + shift_un * i,0);
glVertex3f(660+48 ,16 + shift_un * i,0);
glVertex3f(660+32 ,48+ shift_un * i,0);
glEnd();
glColor3ub(255,255,0);
glPolygonMode( GL_FRONT_AND_BACK, GL_LINE );
glLineWidth(units[i].arrmor);
if(units[i].arrmor != 0)
{
glBegin(GL_QUADS);
glVertex2f(last_x+4,last_y+4);
glVertex2f(last_x+28,last_y+4);
glVertex2f(last_x+28,last_y+28);
glVertex2f(last_x+4,last_y+28);
glEnd();
}
glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
glBegin(GL_TRIANGLES);
glColor3ub(255,0,0);
float shift_hp = 36 / units[i].health;
for(unsigned int h = 0; h < units[i].health; h++)
{
glVertex3f(716+8 + shift_hp * h ,8 + shift_un * i,0);
glVertex3f(716+8 + shift_hp * h ,24 + shift_un * i,0);
glVertex3f(716+24+ shift_hp * h ,16 + shift_un * i,0);
}
glColor3ub(255,255,0);
if(units[i].arrmor > 0)
{
float shift_ar = 36 / units[i].arrmor;
for(unsigned int h = 0; h < units[i].arrmor; h++)
{
glVertex3f(716+8 + shift_ar * h ,34 + shift_un * i,0);
glVertex3f(716+8 + shift_ar * h ,50 + shift_un * i,0);
glVertex3f(716+24+ shift_ar * h ,42 + shift_un * i,0);
}
}
glColor3ub(0,0,255);
if(units[i].kills > 0)
{
float shift_kl = 36 / units[i].kills;
for(unsigned int h = 0; h < units[i].kills; h++)
{
if(units[i].kills < 4)
glColor3ub(255,0,0);
else if(units[i].kills >= 4 and units[i].kills < 8)
glColor3ub(204,204,255);
else if(units[i].kills >= 8 and units[i].kills < 12)
glColor3ub(0,0,255);
else if(units[i].kills >= 12)
glColor3ub(125,255,0);
glVertex3f(716-40 ,24 + shift_un * i + shift_kl*h,0);
glVertex3f(716-54 ,24 + shift_un * i + shift_kl*h,0);
glVertex3f(716-54 ,8 + shift_un * i + shift_kl*h,0);
}
}
}
}
//player
glEnd();
}
void MyFrameHandler(unsigned long windowID, unsigned int viewport, void *)
{
glLineWidth(8.0);
glColor3f(1, 1, 1);
glBegin(GL_LINES);
glVertex3f(-1, 0, 0);
glVertex3f(1, 0, 0);
glVertex3f(0, 1, 0);
glVertex3f(0, -1, 0);
for (unsigned int x = 0; x < points.size(); x++)
{
if (points[x].val)
glColor3f(0, 1, 0);
else
glColor3f(1, 0, 0);
glVertex3f(points[x].loc.x-0.02, points[x].loc.y-0.02, 0);
glVertex3f(points[x].loc.x+0.02, points[x].loc.y+0.02, 0);
glVertex3f(points[x].loc.x-0.02, points[x].loc.y+0.02, 0);
glVertex3f(points[x].loc.x+0.02, points[x].loc.y-0.02, 0);
}
glEnd();
if (!CLASSIFIER)
{
glBegin(GL_LINE_STRIP);
for (double x = -1; x <= 1; x += 1.0/64.0)
{
glColor3f(1, 1, 0);
std::vector<double> in(2);
in[0] = x;
in[1] = x*x;
double res = *l->test(in);
res = (res-0.5)*scale;
glVertex3f(x, res, 0);
}
glEnd();
}
else {
glPointSize(4.0);
glBegin(GL_POINTS);
std::vector<double> in(3);
for (double x = -1; x <= 1; x += 0.03125*0.5)
{
for (double y = -1; y <= 1; y += 0.03125*0.5)
{
in[0] = x;
in[1] = y;
in[2] = x*y;//sqrt(x*x+y*y);//x*y;
double res = *cl->test(in);
if (threshold)
{
if (res > 0.5)
glColor4f(0, 1, 0, 0.75);
else
glColor4f(1, 0, 0, 0.75);
}
else {
glColor3f((1-res)*(1-res), res*res, 0);
}
glVertex3f(x, y, 0);
}
}
glEnd();
}
}
void GLUTRedraw(void)
{
// Check scene
if (!scene) return;
// Set viewing transformation
viewer->Camera().Load();
// Clear window
RNRgb background = scene->Background();
glClearColor(background.R(), background.G(), background.B(), 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Load lights
LoadLights(scene);
// Draw camera
if (show_camera) {
glDisable(GL_LIGHTING);
glColor3d(1.0, 1.0, 1.0);
glLineWidth(5);
DrawCamera(scene);
glLineWidth(1);
}
// Draw lights
if (show_lights) {
glDisable(GL_LIGHTING);
glColor3d(1.0, 1.0, 1.0);
glLineWidth(5);
DrawLights(scene);
glLineWidth(1);
}
// Draw rays
if (show_rays) {
glDisable(GL_LIGHTING);
glColor3d(0.0, 1.0, 0.0);
glLineWidth(3);
DrawRays(scene);
glLineWidth(1);
}
// Draw rays
if (show_photons) {
glDisable(GL_LIGHTING);
glColor3d(1.0, 1.0, 1.0);
glLineWidth(1);
DrawPhotonPaths(scene);
glLineWidth(1);
}
// Draw rays
if (show_global_samples) {
glDisable(GL_LIGHTING);
glColor3d(1.0, 1.0, 1.0);
glLineWidth(1);
DrawGlobalSamples(scene);
glLineWidth(1);
}
// Draw rays
if (show_caustic_samples) {
glDisable(GL_LIGHTING);
glColor3d(1.0, 1.0, 1.0);
glLineWidth(1);
DrawCausticSamples(scene);
glLineWidth(1);
}
// Draw scene nodes
if (show_shapes) {
glEnable(GL_LIGHTING);
R3null_material.Draw();
DrawShapes(scene, scene->Root());
R3null_material.Draw();
}
// Draw bboxes
if (show_bboxes) {
glDisable(GL_LIGHTING);
glColor3d(1.0, 0.0, 0.0);
DrawBBoxes(scene, scene->Root());
}
// Draw frame time
if (show_frame_rate) {
char buffer[128];
static RNTime last_time;
double frame_time = last_time.Elapsed();
last_time.Read();
if ((frame_time > 0) && (frame_time < 10)) {
glDisable(GL_LIGHTING);
glColor3d(1.0, 1.0, 1.0);
sprintf(buffer, "%.1f fps", 1.0 / frame_time);
DrawText(R2Point(100, 100), buffer);
}
}
// Capture screenshot image
if (screenshot_image_name) {
if (print_verbose) printf("Creating image %s\n", screenshot_image_name);
R2Image image(GLUTwindow_width, GLUTwindow_height, 3);
image.Capture();
image.Write(screenshot_image_name);
screenshot_image_name = NULL;
}
// Swap buffers
glutSwapBuffers();
}
void cc2DLabel::drawMeOnly3D(CC_DRAW_CONTEXT& context)
{
assert(!m_points.empty());
//standard case: list names pushing
bool pushName = MACRO_DrawEntityNames(context);
if (pushName)
{
//not particularily fast
if (MACRO_DrawFastNamesOnly(context))
return;
glPushName(getUniqueIDForDisplay());
}
const float c_sizeFactor = 4.0f;
bool loop = false;
size_t count = m_points.size();
switch (count)
{
case 3:
{
glPushAttrib(GL_COLOR_BUFFER_BIT);
glEnable(GL_BLEND);
//we draw the triangle
glColor4ub(255,255,0,128);
glBegin(GL_TRIANGLES);
for (unsigned i=0; i<count; ++i)
ccGL::Vertex3v(m_points[i].cloud->getPoint(m_points[i].index)->u);
glEnd();
glPopAttrib();
loop=true;
}
case 2:
{
//segment width
glPushAttrib(GL_LINE_BIT);
glLineWidth(c_sizeFactor);
//we draw the segments
if (isSelected())
glColor3ubv(ccColor::red);
else
glColor3ubv(ccColor::green);
glBegin(GL_LINES);
for (unsigned i=0; i<count; i++)
{
if (i+1<count || loop)
{
ccGL::Vertex3v(m_points[i].cloud->getPoint(m_points[i].index)->u);
ccGL::Vertex3v(m_points[(i+1)%count].cloud->getPoint(m_points[(i+1)%count].index)->u);
}
}
glEnd();
glPopAttrib();
}
case 1:
{
//display point marker as spheres
{
if (!c_unitPointMarker)
{
c_unitPointMarker = QSharedPointer<ccSphere>(new ccSphere(1.0f,0,"PointMarker",12));
c_unitPointMarker->showColors(true);
c_unitPointMarker->setVisible(true);
c_unitPointMarker->setEnabled(true);
}
//build-up point maker own 'context'
CC_DRAW_CONTEXT markerContext = context;
markerContext.flags &= (~CC_DRAW_ENTITY_NAMES); //we must remove the 'push name flag' so that the sphere doesn't push its own!
markerContext._win = 0;
if (isSelected() && !pushName)
c_unitPointMarker->setTempColor(ccColor::red);
else
c_unitPointMarker->setTempColor(ccColor::magenta);
for (unsigned i=0; i<count; i++)
{
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
const CCVector3* P = m_points[i].cloud->getPoint(m_points[i].index);
ccGL::Translate(P->x,P->y,P->z);
glScalef(context.pickedPointsRadius,context.pickedPointsRadius,context.pickedPointsRadius);
c_unitPointMarker->draw(markerContext);
glPopMatrix();
}
}
if (m_dispIn3D && !pushName) //no need to display label in point picking mode
{
QFont font(context._win->getTextDisplayFont()); //takes rendering zoom into account!
//font.setPointSize(font.pointSize()+2);
font.setBold(true);
//draw their name
glPushAttrib(GL_DEPTH_BUFFER_BIT);
glDisable(GL_DEPTH_TEST);
for (unsigned j=0; j<count; j++)
{
const CCVector3* P = m_points[j].cloud->getPoint(m_points[j].index);
QString title = (count == 1 ? getName() : QString("P#%0").arg(m_points[j].index));
context._win->display3DLabel( title,
*P + CCVector3( context.pickedPointsTextShift,
context.pickedPointsTextShift,
context.pickedPointsTextShift),
ccColor::magenta,
font );
}
glPopAttrib();
}
}
}
if (pushName)
glPopName();
}
void CglList::Draw()
{
// dont call Mouse[XY] if we're being used in CPreGame (when gu or mouse is still NULL)
float mx = (gu && mouse) ? MouseX(mouse->lastx) : 0;
float my = (gu && mouse) ? MouseY(mouse->lasty) : 0;
glDisable(GL_TEXTURE_2D);
glDisable(GL_ALPHA_TEST);
glEnable(GL_BLEND);
glLoadIdentity();
glColor4f(0.2f,0.2f,0.2f,guiAlpha);
DrawBox(box);
glColor4f(1,1,0.4f,0.8f);
font->glPrintAt(box.x1 + 0.01f, box.y2 - 0.05f, itemFontScale*0.7f, name.c_str());
/****************************************
* Insert Robert Diamond's section here *
* <*****@*****.**> *
****************************************/
/****************************************
* TODO: *
* *
* This part of the code will need some *
* math, and it's been a while since I *
* did any 3D coding... the idea is to *
* keep the selected item in the middle *
* 60% of the screen, but don't scroll *
* till we reach one end, or the other *
* of that boundary. We'd also need the *
* "oldPlace" variable to do this *
* properly. *
* *
****************************************
// Get screen res, so that the selected item is always within the middle 60% of screen
int iResX = configHandler.GetInt("XResolution", 1024);
int iResY = configHandler.GetInt("YResolution", 768);
// Keep tabs on the last place. change this ONLY AFTER a scroll
static int siOldPlace = place;
if (we're scrolling up) siOldPlace = place;
if (we're scrolling down) siOldPlace = place;
if (we're not scrolling) siOldPlace = siOldPlace;
**************************************
* Hey remove me when TODO is done XD *
**************************************/
int nCurIndex = 0; // The item we're on
int nDrawOffset = 0; // The offset to the first draw item
ContainerBox b = box;
b.x1 += 0.01f;
b.x2 -= 0.01f;
// Get list started up here
std::vector<std::string>::iterator ii = filteredItems->begin();
// Skip to current selection - 3; ie: scroll
while ((nCurIndex + 7) <= place && nCurIndex+13 <= filteredItems->size()) { ii++; nCurIndex++; }
for (/*ii = items.begin()*/; ii != filteredItems->end() && nDrawOffset < 12; ii++)
{
glLoadIdentity();
b.y2 = box.y2 - 0.06f - (nDrawOffset * 0.06f);
b.y1 = b.y2 - 0.05f;
// TODO lots of this should really be merged with GuiHandler.cpp
// (as in, factor out the common code...)
glColor4f(1,1,1,0.1f);
DrawBox(b, GL_LINE_LOOP);
if (nCurIndex == place) {
glBlendFunc(GL_ONE, GL_ONE); // additive blending
glColor4f(0.2f,0,0,1);
DrawBox(b);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1,0,0,0.5f);
glLineWidth(1.49f);
DrawBox(b, GL_LINE_LOOP);
glLineWidth(1.0f);
} else if (InBox(mx, my, b)) {
glBlendFunc(GL_ONE, GL_ONE); // additive blending
glColor4f(0,0,0.2f,1);
DrawBox(b);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(1,1,1,0.5f);
glLineWidth(1.49f);
DrawBox(b, GL_LINE_LOOP);
glLineWidth(1.0f);
}
const float dShadow = 0.002f;
const float xStart = box.x1 + itemXMargin;
const float yStart = b.y1 + 0.002f;
glColor4f(0.0f, 0.0f, 0.0f, 0.8f);
font->glPrintAt(xStart + dShadow, yStart - dShadow, itemFontScale, ii->c_str());
glColor4f(1,1,1,0.8f);
font->glPrintAt(xStart, yStart, itemFontScale, ii->c_str());
// Up our index's
nCurIndex++; nDrawOffset++;
}
/**************
* End insert *
**************/
glLoadIdentity();
}
void CylinderPrimitive::initContext(GLContextData& contextData) const
{
/* Create a data item and store it in the context: */
DataItem* dataItem=new DataItem;
contextData.addDataItem(this,dataItem);
/* Create a coordinate system for the cylinder: */
Vector cx=Geometry::normal(axis);
cx.normalize();
Vector cy=Geometry::cross(axis,cx);
cy.normalize();
Vector cz=axis*(length/Scalar(2));
/* Create the cylinder rendering display lists: */
glNewList(dataItem->displayListId,GL_COMPILE);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glBegin(GL_QUAD_STRIP);
glNormal(1.0,0.0,0.0);
glVertex(center+cx*radius+cz);
glVertex(center+cx*radius-cz);
for(int x=1;x<72;++x)
{
Scalar angle=Math::rad(Scalar(x)*Scalar(360/72));
Vector d=cx*Math::cos(angle)+cy*Math::sin(angle);
glNormal(d);
d*=radius;
glVertex(center+d+cz);
glVertex(center+d-cz);
}
glNormal(1.0,0.0,0.0);
glVertex(center+cx*radius+cz);
glVertex(center+cx*radius-cz);
glEnd();
glEndList();
glNewList(dataItem->displayListId+1,GL_COMPILE);
glBlendFunc(GL_ONE,GL_ONE);
glLineWidth(1.0f);
glBegin(GL_LINES);
for(int x=0;x<numX;++x)
{
Scalar angle=Math::rad(Scalar(x)*Scalar(360)/Scalar(numX));
Vector d=cx*Math::cos(angle)+cy*Math::sin(angle);
d*=radius;
glVertex(center+d+cz);
glVertex(center+d-cz);
}
glEnd();
for(int y=0;y<=numY;++y)
{
Point center2=center+axis*((Scalar(y)/Scalar(numY)-Scalar(0.5))*length);
glBegin(GL_LINE_LOOP);
for(int x=0;x<72;++x)
{
Scalar angle=Math::rad(Scalar(x)*Scalar(360/72));
Vector d=cx*Math::cos(angle)+cy*Math::sin(angle);
d*=radius;
glVertex(center2+d);
}
glEnd();
}
glEndList();
}
//
// Draw_Title
//
void Draw_Title(void)
{
float offset = 34.0f;
float begin = 120.0f;
// Also draw game over
// if it is turned on
if (ant_globals->_menu_state == MENU_DEAD_MODE) {
Draw_GameOver();
} // end of the if
switch(ant_globals->menu_mode)
{
case MENU_HELP_MODE:
glLineWidth(2.0f);
Title_Begin();
Draw_HelpScreen();
glDisable(GL_LIGHTING);
Draw_IntroScreen();
glEnable(GL_LIGHTING);
Title_End();
glLineWidth(1.0f);
break;
case MENU_TITLE_MODE:
glLineWidth(2.0f);
Title_Begin();
Draw_Shadow();
glColor4ub(255,255,255,255);
// title, newgame, exit, demo
if (cursor_index == 0)
glColor4ub(255,255,0,255);
Render_BText(6, 192.0f, begin+(0*offset), 0.03f);
glColor4ub(255,255,255,255);
if (cursor_index == 1)
glColor4ub(255,255,0,255);
Render_BText(5, 192.0f, begin+(1*offset), 0.016f);
glColor4ub(255,255,255,255);
if (cursor_index == 2)
glColor4ub(255,255,0,255);
Render_BText(4, 192.0f, begin+(2*offset), -0.015f);
glColor4ub(255,255,255,255);
if (cursor_index == 3)
glColor4ub(255,255,0,255);
Render_BText(3, 192.0f, begin+(3*offset), -0.041f);
glColor4ub(255,255,255,255);
if (cursor_index == 4)
glColor4ub(255,255,0,255);
Render_BText(1, 192.0f, begin+(4*offset), 0.01f);
// draw the selection tool --
Draw_Cursor(cursor_heights[cursor_index]);
//Draw_HelpScreen();
Draw_IntroScreen();
Title_End();
glLineWidth(1.0f);
break;
default: break;
};
} // end of the function
/**
* Method for create a window
*/
void Visualizer::createWindow(const char * title)
{
xnew=0; ynew=0; znew=0; /* actual position */
xold=0; yold=0; zold=0; /* old position */
xx1=0; yy1=0; zz1=0; /* mouse position*/
mouseState=0; /* mouse button state */
xshift=0; yshift=0; /* shifting in space*/
xnew=0; ynew=0; znew=0; /* actual position */
xold=0; yold=0; zold=0; /* old position */
xx1=0; yy1=0; zz1=0; /* mouse position*/
mouseState=0; /* mouse button state */
xshift=0; yshift=0; /* shifting in space*/
fov=45.0; /* field of view */
near_plane=1; /* trim plain */
far_plane=1000.0; /* farther trim plain */
line_width=1.0; /* width of line */
WindowWidth=1024; /* width and height of window */
WindowHeight=768;
ObjectType=0; /* type of paint object */
Solid=1; /* fill or wireframe model */
char * dummy_argv[1];
dummy_argv[0] = const_cast<char *>("run");
int dummy_argc = 1;
glutInit(&dummy_argc, dummy_argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE ); /* graphic mod of window */
glutInitWindowSize(WindowWidth,WindowHeight); /* original window size */
glutInitWindowPosition(10,10); /* original window position */
glutCreateWindow(title); /* create window */
glutDisplayFunc(onDisplay); /* set function for redisplay */
glutReshapeFunc(onReshape); /* set function for change of size window */
glutKeyboardFunc(onKeyboard); /* set function for press key */
glutSpecialFunc(onSpecial);
glutMouseFunc(onMouseClick); /* set function for press mouse button */
glutMotionFunc(onMouseMotion); /* set function for mouse move */
glClearColor(0.0, 0.0, 0.0, 0.0); /* color for clearing of color-buffer */
glClearDepth(1.0f); /* color for clearing of z-buffer */
glEnable(GL_DEPTH_TEST); /* configure function for testing value in z-buffer */
glDepthFunc(GL_LESS); /* select function */
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); /* improvement display */
glEnable(GL_CULL_FACE);
glPolygonMode(GL_FRONT, GL_FILL); /* configure draw of fill polygons */
//glCullFace(GL_FRONT);
glLineWidth(line_width); /* line width */
glPointSize(line_width);
//glEnable(GL_MULTISAMPLE);
#ifdef FREEGLUT
#ifdef GLUT_AUX
int *sampleNumbers = NULL;
int sampleNumbersSize = 0;
sampleNumbers = glutGetModeValues(GLUT_MULTISAMPLE, &sampleNumbersSize);
if(sampleNumbers != NULL)
{
glutSetOption(GLUT_MULTISAMPLE, sampleNumbers[sampleNumbersSize - 1]);
printf("Multisampling with %i samples.\n", sampleNumbers[sampleNumbersSize - 1]);
free(sampleNumbers);
}
else
{
printf("Multisampling is not available.\n");
}
#endif
#endif
scene_ = glGenLists(1); /* get number of calllist */
createCallList(); /* initialization */
glutMainLoop();
}
// Affichage de la scène
void SceneToon::Render()
{
ResourceManager& res = ResourceManager::getInstance();
VarManager& var = VarManager::getInstance();
glPushAttrib(GL_ENABLE_BIT | GL_POLYGON_BIT | GL_LINE_BIT);
vec4 white(1.0f, 1.0f, 1.0f, 1.0f);
vec4 red(1.0f, 0.0f, 0.0f, 1.0f);
vec4 blue(0.0f, 0.0f, 1.0f, 1.0f);
vec4 zeros(0.0f, 0.0f, 0.0f, 0.0f);
vec4 marron(0.95, 0.6, 0.25,1.0);
vec4 jaune(1.0, 0.8, 0.0,1.0);
glColor3f(1.0f, 1.0f, 1.0f);
glPushMatrix();
glDisable(GL_LIGHTING);
glTranslatef(m_vLightPos.x, m_vLightPos.y, m_vLightPos.z);
glutSolidSphere(0.1, 16, 16);
glPopMatrix();
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glLightfv(GL_LIGHT0, GL_POSITION, m_vLightPos);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, zeros);
glLightfv(GL_LIGHT0, GL_AMBIENT, &white.r);
glLightfv(GL_LIGHT0, GL_DIFFUSE, white);
glLightfv(GL_LIGHT0, GL_SPECULAR, white);
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 1.0f/512);
glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, 1.0f/512);
// glDisable(GL_CULL_FACE);
m_shadeToon->Activate();
{
m_shadeToon->UniformTexture("myText", 0);
m_shadeToon->Uniform("enable_texture", true);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, white/4);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, white/2);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, zeros);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0f);
// Le sol
m_pMyTexGround->Bind(0);
m_pScene->Draw(0);
m_pMyTexGround->Unbind(0);
//Les murs
m_pMyTexWall->Bind(0);
m_pScene->Draw(3);
m_pMyTexWall->Unbind(0);
// Le plafond
m_pMyTexTop->Bind(0);
m_pScene->Draw(1);
m_pMyTexTop->Unbind(0);
m_shadeToon->Uniform("enable_texture", false);
glPushMatrix();
{
glTranslatef(0.0,4.0,0.0);
// TORE
glPushMatrix();
{
glRotatef(m_fAngle, 1.0f, 1.0f, 0.0f);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, red/4);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, red/2);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0f);
glutSolidTorus(1.0,3.0,100,100);
}
glPopMatrix();
// TEAPOT
glPushMatrix();
{
glTranslatef(0.0,0.0,-12.0);
glRotatef(m_fAngle, 0.0f, 1.0f, 0.0f);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, marron/4);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, marron/2);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0f);
m_teapot->Draw();
}
glPopMatrix();
// LAPIN
glPushMatrix();
{
glTranslatef(0.0,2.0,9.0);
glScalef(25.0,25.0,25.0);
glRotatef(m_fAngle, 0.0f, 1.0f, 0.0f);
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, jaune/4);
glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, jaune/2);
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, white);
glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 60.0f);
m_objHomer->Draw();
}
glPopMatrix();
}
glPopMatrix();
}
m_shadeToon->Deactivate();
// Affichage des contours
glDisable(GL_LIGHTING);
glLineWidth(5.0);
glPolygonMode(GL_BACK, GL_LINE);
glDepthFunc(GL_LEQUAL);
glCullFace(GL_FRONT);
glColor3f(0.0,0.0,0.0);
glPushMatrix();
{
glTranslatef(0.0,4.0,0.0);
// TORE
glPushMatrix();
{
glRotatef(m_fAngle, 1.0f, 1.0f, 0.0f);
glutSolidTorus(1.0,3.0,100,100);
}
glPopMatrix();
// TEAPOT
glPushMatrix();
{
glTranslatef(0.0,0.0,-12.0);
glRotatef(m_fAngle, 0.0f, 1.0f, 0.0f);
m_teapot->Draw();
}
glPopMatrix();
// LAPIN
glPushMatrix();
{
glTranslatef(0.0,2.0,9.0);
glScalef(25.0,25.0,25.0);
glRotatef(m_fAngle, 0.0f, 1.0f, 0.0f);
m_objHomer->Draw();
}
glPopMatrix();
}
glPopMatrix();
glPopAttrib();
}
/* CTextureCanvas::drawTextureBorder
* Draws a black border around the texture
*******************************************************************/
void CTextureCanvas::drawTextureBorder()
{
// Draw the texture border
double ext = 0.11;
glLineWidth(2.0f);
OpenGL::setColour(COL_BLACK);
glBegin(GL_LINE_LOOP);
glVertex2d(-ext, -ext);
glVertex2d(-ext, texture->getHeight()+ext);
glVertex2d(texture->getWidth()+ext, texture->getHeight()+ext);
glVertex2d(texture->getWidth()+ext, -ext);
glEnd();
glLineWidth(1.0f);
// Draw vertical ticks
int y = 0;
glColor4f(0.0f, 0.0f, 0.0f, 0.6f);
while (y <= texture->getHeight())
{
glBegin(GL_LINES);
glVertex2i(-4, y);
glVertex2i(0, y);
glVertex2i(texture->getWidth(), y);
glVertex2i(texture->getWidth() + 4, y);
glEnd();
y += 8;
}
// Draw horizontal ticks
int x = 0;
while (x <= texture->getWidth())
{
glBegin(GL_LINES);
glVertex2i(x, -4);
glVertex2i(x, 0);
glVertex2i(x, texture->getHeight());
glVertex2i(x, texture->getHeight() + 4);
glEnd();
x += 8;
}
// Draw grid
if (show_grid)
{
// Draw inverted grid lines
glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
// Vertical
y = 8;
while (y <= texture->getHeight() - 8)
{
glBegin(GL_LINES);
glVertex2i(0, y);
glVertex2i(texture->getWidth(), y);
glEnd();
y += 8;
}
// Horizontal
x = 8;
while (x <= texture->getWidth() - 8)
{
glBegin(GL_LINES);
glVertex2i(x, 0);
glVertex2i(x, texture->getHeight());
glEnd();
x += 8;
}
// Darken grid lines
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
// Vertical
y = 8;
while (y <= texture->getHeight() - 8)
{
glBegin(GL_LINES);
glVertex2i(0, y);
glVertex2i(texture->getWidth(), y);
glEnd();
y += 8;
}
// Horizontal
x = 8;
while (x <= texture->getWidth() - 8)
{
glBegin(GL_LINES);
glVertex2i(x, 0);
glVertex2i(x, texture->getHeight());
glEnd();
x += 8;
}
}
}
void TableMap3D::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0,0,-2.4); //Move back 3 units
glRotatef(m_xrot, 1.0, 0.0, 0.0); //Rotate it up/down
glRotatef(m_yrot, 0.0, 0.0, 1.0); //Rotate it left/right
glTranslatef(-0.5,-1+(0.5 * ((double)m_tableData->yAxis().size() / (double)m_tableData->xAxis().size())),-0.5); //Center the graph in view
//float minx = 0;
float maxx = 1;
float miny = 0;
float maxy = 1;
if (m_tableData->xAxis().size() < m_tableData->yAxis().size())
{
maxx = maxy * ((float)m_tableData->yAxis().size()/(float)m_tableData->xAxis().size());
}
else
{
maxy = maxx * ((float)m_tableData->xAxis().size() / (float)m_tableData->yAxis().size());
}
Q_UNUSED(miny);
glColor4f(1,1,1,1);
//Draw 10 horizontal lines for VE values
for (int i=0;i<=10;i++)
{
glBegin(GL_LINE_STRIP);
glVertex3f(maxx/*-(((float)1)/((float)m_tableData->xAxis().size()))*/,0,(float)i/10.0);
glVertex3f(maxx/*-(((float)1)/((float)m_tableData->xAxis().size()))*/,maxy/*+((float)2)/((float)m_tableData->xAxis().size())*/,(float)i/10.0);
glVertex3f(0,maxy/*+((float)2)/((float)m_tableData->xAxis().size())*/,(float)i/10.0);
glEnd();
this->renderText(-0.1,maxy + 0.1,(float)i/10.0,QString::number((m_tableData->maxZAxis()) * (i/10.0),'f',2));
}
//Longer X axis (RPM)
for (int i=0;i<m_tableData->xAxis().size();i+=1)
{
glBegin(GL_LINES);
float tmpf2=0;
tmpf2 = (float)(i * maxy)/((float)m_tableData->xAxis().size());
glVertex3f(maxx,tmpf2 * (maxx / 1.0),0);
glVertex3f(maxx,tmpf2 * (maxx / 1.0),1);
glEnd();
//this->renderText(0,tmpf2,-0.05,QString::number(m_tableData->xAxis()[i]));
}
//Shorter Y Axis (KPA)
for (int i=0;i<m_tableData->yAxis().size();i+=1)
{
glBegin(GL_LINES);
float tmpf1 = (float)(i * maxx)/((float)m_tableData->yAxis().size());
glVertex3f(tmpf1 * (maxx / 1.0),maxy,0);
glVertex3f(tmpf1 * (maxx / 1.0),maxy,1);
glEnd();
//this->renderText(0,tmpf1,-0.05,QString::number(m_tableData->yAxis()[i]));
}
//Middle vertical
glBegin(GL_LINES);
glVertex3f(maxx,maxy,0);
glVertex3f(maxx,maxy,1);
glEnd();
//Line around the top of the graph
glBegin(GL_LINE_STRIP);
glVertex3f(0,maxy,1);
glVertex3f(maxx,maxy,1);
glVertex3f(maxx,0,1);
glEnd();
//Square outline around the bottom of the graph
glBegin(GL_LINE_STRIP);
glVertex3f(0,maxy,0);
glVertex3f(0,0,0);
glVertex3f(maxx,0,0);
glVertex3f(maxx,maxy,0);
glVertex3f(0,maxy,0);
glEnd();
for(int x=0;x<m_tableData->xAxis().size()-1;x++)
{
for (int i=0;i<3;i++)
{
if (i == 0 || i == 2)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBlendFunc(GL_ONE, GL_ZERO);
glLineWidth(1.25);
}
else if (i == 1)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glBlendFunc(GL_ONE, GL_ZERO);
glLineWidth(1.25);
}
glBegin(GL_QUADS);
for(int y=0;y<m_tableData->yAxis().size()-1;y++)
{
double r=0;
double g=0;
double b=0;
double val = m_tableData->values()[y][x];
if (val < m_tableData->maxZAxis()/4)
{
r=0;
g=(255*((val)/(m_tableData->maxZAxis()/4.0)));
b=255;
}
else if (val < ((m_tableData->maxZAxis()/4)*2))
{
r=0;
g=255;
b=255-(255*((val-((m_tableData->maxZAxis()/4.0)))/(m_tableData->maxZAxis()/4.0)));
}
else if (val < ((m_tableData->maxZAxis()/4)*3))
{
r=(255*((val-((m_tableData->maxZAxis()/4.0)*2))/(m_tableData->maxZAxis()/4.0)));
g=255;
b=0;
}
else
{
r=255;
g=255-(255*((val-((m_tableData->maxZAxis()/4.0)*3))/(m_tableData->maxZAxis()/4.0)));
b=0;
}
if (i == 0 || i == 2)
{
r = 0;
g = 0;
b = 0;
}
else if (i == 1)
{
r = r/255.0;
g = g/255.0;
b = b/255.0;
}
//X and Y are reversed here, to allow for the graph to look the proper way.
float y0 = ((float)x * maxy)/((float)m_tableData->xAxis().size()-1.0);
float x0 = ((float)y)/((float)m_tableData->yAxis().size()-1.0);
float z0 = (float)m_tableData->values()[y][x] / m_tableData->maxZAxis();
glColor4f(r,g,b,1);
//glVertex3f(x0+((i==1) ? MAP3DCELLSPACING : 0),(maxy-y0)-((i==1) ? MAP3DCELLSPACING : 0),z0);
glVertex3f(x0,(maxy-y0),z0+((i==0) ? 0.001 : ((i==2) ? -0.001 : 0)));
float y1 = ((float)x * maxy)/((float)m_tableData->xAxis().size()-1.0);
float x1 = ((float)y+1)/((float)m_tableData->yAxis().size()-1.0);
float z1 = (float)m_tableData->values()[y+1][x] / m_tableData->maxZAxis();
glColor4f(r,g,b,1);
//glVertex3f(x1-((i==1) ? MAP3DCELLSPACING : 0),(maxy-y1)-((i==1) ? MAP3DCELLSPACING : 0),z1);
glVertex3f(x1,(maxy-y1),z1+((i==0) ? 0.001 : ((i==2) ? -0.001 : 0)));
float y2 = ((float)((x+1.0) * maxy))/((float)m_tableData->xAxis().size()-1.0);
float x2 = ((float)y+1.0)/((float)m_tableData->yAxis().size()-1.0);
float z2 = (float)m_tableData->values()[y+1][x+1] / m_tableData->maxZAxis();
glColor4f(r,g,b,1);
//glVertex3f(x2-((i==1) ? MAP3DCELLSPACING : 0),(maxy-y2)+((i==1) ? MAP3DCELLSPACING : 0),z2);
glVertex3f(x2,(maxy-y2),z2+((i==0) ? 0.001 : ((i==2) ? -0.001 : 0)));
float y3 = ((float)(x+1) * maxy)/((float)m_tableData->xAxis().size()-1.0);
float x3 = ((float)y)/((float)m_tableData->yAxis().size()-1.0);
float z3 = (float)m_tableData->values()[y][x+1]/m_tableData->maxZAxis();
glColor4f(r,g,b,1);
//glVertex3f(x3+((i==1) ? MAP3DCELLSPACING : 0),(maxy-y3)+((i==1) ? MAP3DCELLSPACING : 0),z3);
glVertex3f(x3,(maxy-y3),z3+((i==0) ? 0.001 : ((i==2) ? -0.001 : 0)));
}
glEnd();
}
}
}
void MD5Node::DebugDrawJointTransforms(float size, bool worldSpace) {
//Temporary VAO and VBO
unsigned int skeletonArray;
unsigned int skeletonBuffer;
unsigned int skeletonColourBuffer;
glGenVertexArrays(1, &skeletonArray);
glGenBuffers(1, &skeletonBuffer);
glGenBuffers(1, &skeletonColourBuffer);
//Temporary chunk of memory to keep our joint positions in
int numVerts = currentSkeleton.numJoints * 6;
Vector3* skeletonVertices = new Vector3[numVerts];
Vector4* skeletonColours = new Vector4[numVerts];
for (int i = 0; i < currentSkeleton.numJoints; ++i) {
Matrix4 transform = (worldSpace ? currentSkeleton.joints[i].transform : currentSkeleton.joints[i].localTransform);
Vector3 start = transform.GetPositionVector();
transform.SetPositionVector(Vector3(0, 0, 0));
Vector4 endX = transform * Vector4(1, 0, 0, 1);
Vector4 endY = transform * Vector4(0, 1, 0, 1);
Vector4 endZ = transform * Vector4(0, 0, 1, 1);
skeletonVertices[(i * 6) + 0] = currentSkeleton.joints[i].transform.GetPositionVector();
skeletonVertices[(i * 6) + 1] = currentSkeleton.joints[i].transform.GetPositionVector() + (endX.ToVector3() * size);
skeletonVertices[(i * 6) + 2] = currentSkeleton.joints[i].transform.GetPositionVector();
skeletonVertices[(i * 6) + 3] = currentSkeleton.joints[i].transform.GetPositionVector() + (endY.ToVector3() * size);
skeletonVertices[(i * 6) + 4] = currentSkeleton.joints[i].transform.GetPositionVector();
skeletonVertices[(i * 6) + 5] = currentSkeleton.joints[i].transform.GetPositionVector() + (endZ.ToVector3() * size);
skeletonColours[(i * 6) + 0] = Vector4(1, 0, 0, 1);
skeletonColours[(i * 6) + 1] = Vector4(1, 0, 0, 1);
skeletonColours[(i * 6) + 2] = Vector4(0, 1, 0, 1);
skeletonColours[(i * 6) + 3] = Vector4(0, 1, 0, 1);
skeletonColours[(i * 6) + 4] = Vector4(0, 0, 1, 1);
skeletonColours[(i * 6) + 5] = Vector4(0, 0, 1, 1);
}
//You should know what this all does by now, except we combine it with the draw operations in a single function
glBindVertexArray(skeletonArray);
glBindBuffer(GL_ARRAY_BUFFER, skeletonBuffer);
glBufferData(GL_ARRAY_BUFFER, currentSkeleton.numJoints*sizeof(Vector3) * 6, skeletonVertices, GL_STREAM_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, skeletonColourBuffer);
glBufferData(GL_ARRAY_BUFFER, currentSkeleton.numJoints*sizeof(Vector4) * 6, skeletonColours, GL_STREAM_DRAW);
glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
glLineWidth(2.0f);
glDrawArrays(GL_LINES, 0, currentSkeleton.numJoints * 6); // draw Bones
glLineWidth(1.0f);
glBindVertexArray(0);
//Delete the VBO and VAO, and the heap memory we allocated earlier
glDeleteVertexArrays(1, &skeletonArray);
glDeleteBuffers(1, &skeletonBuffer);
glDeleteBuffers(1, &skeletonColourBuffer);
delete[]skeletonVertices;
delete[]skeletonColours;
}
void SpaceShip::draw() {
Point abc[4];
// Right & Left Carriers
glLineWidth(2);
glColor3f(0.799, 0.1098, 0.0588);
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(startX + 10, (startY + 0));
glVertex2i(startX + 20, (startY + 10));
glVertex2i(startX + 7, (startY + 23));
glVertex2i(startX + 17, (startY + 30));
glEnd();
glBegin(GL_TRIANGLE_STRIP);
glVertex2i(startX + 68, (startY + 0));
glVertex2i(startX + 58, (startY + 10));
glVertex2i(startX + 72, (startY + 23));
glVertex2i(startX + 62, (startY + 30));
glEnd();
// Main Body
glLineWidth(4);
glColor3f(0.925, 0.925, 0.925);
abc[0].setxy(startX + 22, (startY + 9));
abc[1].setxy(startX + 14, (startY + 28));
abc[2].setxy(startX + 16, (startY + 86));
abc[3].setxy(startX + 39, (startY + 97));
basicShapes.drawCurve(abc[0], abc[1], abc[2], abc[3]);
abc[0].setxy(startX + 56, (startY + 9));
abc[1].setxy(startX + 66, (startY + 28));
abc[2].setxy(startX + 62, (startY + 86));
abc[3].setxy(startX + 39, (startY + 97));
basicShapes.drawCurve(abc[0], abc[1], abc[2], abc[3]);
abc[0].setxy(startX + 22, (startY + 9));
abc[1].setxy(startX + 34, (startY + 16));
abc[2].setxy(startX + 44, (startY + 16));
abc[3].setxy(startX + 56, (startY + 9));
basicShapes.drawCurve(abc[0], abc[1], abc[2], abc[3]);
basicShapes.solidCircle(startX + 39, (startY + 82), 13);
basicShapes.solidCircle(startX + 39, (startY + 65), 20);
basicShapes.solidCircle(startX + 39, (startY + 53), 22);
basicShapes.solidCircle(startX + 39, (startY + 35), 23);
basicShapes.solidCircle(startX + 27, (startY + 20), 9);
basicShapes.solidCircle(startX + 52, (startY + 20), 9);
// Glass Window
glColor3f(0.827, 0.96, 1);
basicShapes.solidCircle(startX + 39, (startY + 60), 10);
// Middle Carrier
glLineWidth(2.8);
glColor3f(0.799, 0.1098, 0.0588);
glBegin(GL_LINES);
glVertex2i(startX + 39, (startY + 0));
glVertex2i(startX + 39, (startY + 30));
glEnd();
// Glass Frame
glLineWidth(2);
basicShapes.hallowCircle(startX + 39, (startY + 60), 10);
}
void FenceSegment::render() const
{
// HAUKAP - need spike::render to reduce code
glPushMatrix();
{
glTranslatef( m_point.x, m_point.y, m_point.z);
glRotatef( m_fenceAngle, 0.0f, 0.0f, 1.0f);
glLineWidth(1);
//glColor3f(0.0f, 0.0f, 0.0f);
glScalef( m_scale, m_scale, m_scale );
// first spike
glPushMatrix();
{
glRotatef( m_spikeAngles[0], 0.0f, 0.0f, 1.0f);
glBegin( GL_LINES );
glVertex3f( 0, 0, 0.0f );
glVertex3f( 0, 1.0, 0.0f);
glEnd();
}
glPopMatrix();
// second spike
glPushMatrix();
{
glRotatef( m_spikeAngles[1], 0.0f, 0.0f, 1.0f);
glBegin( GL_LINES );
glVertex3f( 0, 0, 0.0f );
glVertex3f( 0, 1.0, 0.0f);
glEnd();
}
glPopMatrix();
// third spike
glPushMatrix();
{
glRotatef( m_spikeAngles[2], 0.0f, 0.0f, 1.0f);
glBegin( GL_LINES );
glVertex3f( 0, 0, 0.0f );
glVertex3f( 0, 1.0, 0.0f);
glEnd();
}
glPopMatrix();
// fourth spike
glPushMatrix();
{
glRotatef( m_spikeAngles[3], 0.0f, 0.0f, 1.0f);
glBegin( GL_LINES );
glVertex3f( 0, 0, 0.0f );
glVertex3f( 0, 1.0, 0.0f);
glEnd();
}
glPopMatrix();
// fifth spike
glPushMatrix();
{
glRotatef( m_spikeAngles[4], 0.0f, 0.0f, 1.0f);
glBegin( GL_LINES );
glVertex3f( 0, 0, 0.0f );
glVertex3f( 0, 1.0, 0.0f);
glEnd();
}
glPopMatrix();
}
glPopMatrix();
}
void GLGSRender::ExecCMD()
{
//return;
if(!LoadProgram())
{
ConLog.Error("LoadProgram failed.");
Emu.Pause();
return;
}
if(!m_fbo.IsCreated() || RSXThread::m_width != last_width || RSXThread::m_height != last_height || last_depth_format != m_surface_depth_format)
{
ConLog.Warning("New FBO (%dx%d)", RSXThread::m_width, RSXThread::m_height);
last_width = RSXThread::m_width;
last_height = RSXThread::m_height;
last_depth_format = m_surface_depth_format;
m_fbo.Create();
checkForGlError("m_fbo.Create");
m_fbo.Bind();
m_rbo.Create(4 + 1);
checkForGlError("m_rbo.Create");
for(int i=0; i<4; ++i)
{
m_rbo.Bind(i);
m_rbo.Storage(GL_RGBA, RSXThread::m_width, RSXThread::m_height);
checkForGlError("m_rbo.Storage(GL_RGBA)");
}
m_rbo.Bind(4);
switch(m_surface_depth_format)
{
case 1:
m_rbo.Storage(GL_DEPTH_COMPONENT16, RSXThread::m_width, RSXThread::m_height);
checkForGlError("m_rbo.Storage(GL_DEPTH_COMPONENT16)");
break;
case 2:
m_rbo.Storage(GL_DEPTH24_STENCIL8, RSXThread::m_width, RSXThread::m_height);
checkForGlError("m_rbo.Storage(GL_DEPTH24_STENCIL8)");
break;
default:
ConLog.Error("Bad depth format! (%d)", m_surface_depth_format);
assert(0);
break;
}
for(int i=0; i<4; ++i)
{
m_fbo.Renderbuffer(GL_COLOR_ATTACHMENT0 + i, m_rbo.GetId(i));
checkForGlError(wxString::Format("m_fbo.Renderbuffer(GL_COLOR_ATTACHMENT%d)", i));
}
m_fbo.Renderbuffer(GL_DEPTH_ATTACHMENT, m_rbo.GetId(4));
checkForGlError("m_fbo.Renderbuffer(GL_DEPTH_ATTACHMENT)");
if(m_surface_depth_format == 2)
{
m_fbo.Renderbuffer(GL_STENCIL_ATTACHMENT, m_rbo.GetId(4));
checkForGlError("m_fbo.Renderbuffer(GL_STENCIL_ATTACHMENT)");
}
}
if(!m_set_surface_clip_horizontal)
{
m_surface_clip_x = 0;
m_surface_clip_w = RSXThread::m_width;
}
if(!m_set_surface_clip_vertical)
{
m_surface_clip_y = 0;
m_surface_clip_h = RSXThread::m_height;
}
m_fbo.Bind();
if(Ini.GSDumpDepthBuffer.GetValue())
WriteDepthBuffer();
static const GLenum draw_buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2, GL_COLOR_ATTACHMENT3 };
switch(m_surface_colour_target)
{
case 0x0:
break;
case 0x1:
glDrawBuffer(draw_buffers[0]);
break;
case 0x2:
glDrawBuffer(draw_buffers[1]);
break;
case 0x13:
glDrawBuffers(2, draw_buffers);
break;
case 0x17:
glDrawBuffers(3, draw_buffers);
break;
case 0x1f:
glDrawBuffers(4, draw_buffers);
break;
default:
ConLog.Error("Bad surface colour target: %d", m_surface_colour_target);
break;
}
if(m_set_color_mask)
{
glColorMask(m_color_mask_r, m_color_mask_g, m_color_mask_b, m_color_mask_a);
checkForGlError("glColorMask");
}
if(m_set_viewport_horizontal && m_set_viewport_vertical)
{
glViewport(m_viewport_x, RSXThread::m_height-m_viewport_y-m_viewport_h, m_viewport_w, m_viewport_h);
checkForGlError("glViewport");
}
if(m_set_scissor_horizontal && m_set_scissor_vertical)
{
glScissor(m_scissor_x, RSXThread::m_height-m_scissor_y-m_scissor_h, m_scissor_w, m_scissor_h);
checkForGlError("glScissor");
}
if(m_clear_surface_mask)
{
GLbitfield f = 0;
if (m_clear_surface_mask & 0x1)
{
glClearDepth(m_clear_surface_z / (float)0xffffff);
f |= GL_DEPTH_BUFFER_BIT;
}
if (m_clear_surface_mask & 0x2)
{
glClearStencil(m_clear_surface_s);
f |= GL_STENCIL_BUFFER_BIT;
}
if (m_clear_surface_mask & 0xF0)
{
glClearColor(
m_clear_surface_color_r / 255.0f,
m_clear_surface_color_g / 255.0f,
m_clear_surface_color_b / 255.0f,
m_clear_surface_color_a / 255.0f);
f |= GL_COLOR_BUFFER_BIT;
}
glClear(f);
}
if(m_set_front_polygon_mode)
{
glPolygonMode(GL_FRONT, m_front_polygon_mode);
checkForGlError("glPolygonMode");
}
Enable(m_depth_test_enable, GL_DEPTH_TEST);
Enable(m_set_alpha_test, GL_ALPHA_TEST);
Enable(m_set_depth_bounds_test, GL_DEPTH_BOUNDS_TEST_EXT);
Enable(m_set_blend, GL_BLEND);
Enable(m_set_logic_op, GL_LOGIC_OP);
Enable(m_set_cull_face_enable, GL_CULL_FACE);
Enable(m_set_dither, GL_DITHER);
Enable(m_set_stencil_test, GL_STENCIL_TEST);
Enable(m_set_line_smooth, GL_LINE_SMOOTH);
Enable(m_set_poly_smooth, GL_POLYGON_SMOOTH);
Enable(m_set_poly_offset_fill, GL_POLYGON_OFFSET_FILL);
Enable(m_set_poly_offset_line, GL_POLYGON_OFFSET_LINE);
Enable(m_set_poly_offset_point, GL_POLYGON_OFFSET_POINT);
//Enable(m_set_restart_index, GL_PRIMITIVE_RESTART); //Requires OpenGL 3.1+
if(m_set_clip_plane)
{
Enable(m_clip_plane_0, GL_CLIP_PLANE0);
Enable(m_clip_plane_1, GL_CLIP_PLANE1);
Enable(m_clip_plane_2, GL_CLIP_PLANE2);
Enable(m_clip_plane_3, GL_CLIP_PLANE3);
Enable(m_clip_plane_4, GL_CLIP_PLANE4);
Enable(m_clip_plane_5, GL_CLIP_PLANE5);
checkForGlError("m_set_clip_plane");
}
checkForGlError("glEnable");
if(m_set_two_sided_stencil_test_enable)
{
if(m_set_stencil_fail && m_set_stencil_zfail && m_set_stencil_zpass)
{
glStencilOpSeparate(GL_FRONT, m_stencil_fail, m_stencil_zfail, m_stencil_zpass);
checkForGlError("glStencilOpSeparate");
}
if(m_set_stencil_mask)
{
glStencilMaskSeparate(GL_FRONT, m_stencil_mask);
checkForGlError("glStencilMaskSeparate");
}
if(m_set_stencil_func && m_set_stencil_func_ref && m_set_stencil_func_mask)
{
glStencilFuncSeparate(GL_FRONT, m_stencil_func, m_stencil_func_ref, m_stencil_func_mask);
checkForGlError("glStencilFuncSeparate");
}
if(m_set_back_stencil_fail && m_set_back_stencil_zfail && m_set_back_stencil_zpass)
{
glStencilOpSeparate(GL_BACK, m_back_stencil_fail, m_back_stencil_zfail, m_back_stencil_zpass);
checkForGlError("glStencilOpSeparate(GL_BACK)");
}
if(m_set_back_stencil_mask)
{
glStencilMaskSeparate(GL_BACK, m_back_stencil_mask);
checkForGlError("glStencilMaskSeparate(GL_BACK)");
}
if(m_set_back_stencil_func && m_set_back_stencil_func_ref && m_set_back_stencil_func_mask)
{
glStencilFuncSeparate(GL_BACK, m_back_stencil_func, m_back_stencil_func_ref, m_back_stencil_func_mask);
checkForGlError("glStencilFuncSeparate(GL_BACK)");
}
}
else
{
if(m_set_stencil_fail && m_set_stencil_zfail && m_set_stencil_zpass)
{
glStencilOp(m_stencil_fail, m_stencil_zfail, m_stencil_zpass);
checkForGlError("glStencilOp");
}
if(m_set_stencil_mask)
{
glStencilMask(m_stencil_mask);
checkForGlError("glStencilMask");
}
if(m_set_stencil_func && m_set_stencil_func_ref && m_set_stencil_func_mask)
{
glStencilFunc(m_stencil_func, m_stencil_func_ref, m_stencil_func_mask);
checkForGlError("glStencilFunc");
}
}
if(m_set_shade_mode)
{
glShadeModel(m_shade_mode);
checkForGlError("glShadeModel");
}
if(m_set_depth_mask)
{
glDepthMask(m_depth_mask);
checkForGlError("glDepthMask");
}
if(m_set_depth_func)
{
glDepthFunc(m_depth_func);
//ConLog.Warning("glDepthFunc(0x%x)", m_depth_func);
checkForGlError("glDepthFunc");
}
if(m_set_depth_bounds)
{
//ConLog.Warning("glDepthBounds(%f, %f)", m_depth_bounds_min, m_depth_bounds_max);
glDepthBounds(m_depth_bounds_min, m_depth_bounds_max);
checkForGlError("glDepthBounds");
}
if(m_set_clip)
{
//ConLog.Warning("glDepthRangef(%f, %f)", m_clip_min, m_clip_max);
glDepthRangef(m_clip_min, m_clip_max);
checkForGlError("glDepthRangef");
}
if(m_set_line_width)
{
glLineWidth(m_line_width / 255.f);
checkForGlError("glLineWidth");
}
if(m_set_blend_equation)
{
glBlendEquationSeparate(m_blend_equation_rgb, m_blend_equation_alpha);
checkForGlError("glBlendEquationSeparate");
}
if(m_set_blend_sfactor && m_set_blend_dfactor)
{
glBlendFuncSeparate(m_blend_sfactor_rgb, m_blend_dfactor_rgb, m_blend_sfactor_alpha, m_blend_dfactor_alpha);
checkForGlError("glBlendFuncSeparate");
}
if(m_set_blend_color)
{
glBlendColor(m_blend_color_r, m_blend_color_g, m_blend_color_b, m_blend_color_a);
checkForGlError("glBlendColor");
}
if(m_set_cull_face)
{
glCullFace(m_cull_face);
checkForGlError("glCullFace");
}
if(m_set_alpha_func && m_set_alpha_ref)
{
glAlphaFunc(m_alpha_func, m_alpha_ref);
checkForGlError("glAlphaFunc");
}
if(m_set_fog_mode)
{
glFogi(GL_FOG_MODE, m_fog_mode);
checkForGlError("glFogi(GL_FOG_MODE)");
}
if(m_set_fog_params)
{
glFogf(GL_FOG_START, m_fog_param0);
checkForGlError("glFogf(GL_FOG_START)");
glFogf(GL_FOG_END, m_fog_param1);
checkForGlError("glFogf(GL_FOG_END)");
}
if(m_set_restart_index)
{
ConLog.Warning("m_set_restart_index requires glPrimitiveRestartIndex()");
//glPrimitiveRestartIndex(m_restart_index); //Requires OpenGL 3.1+
//checkForGlError("glPrimitiveRestartIndex");
}
if(m_indexed_array.m_count && m_draw_array_count)
{
ConLog.Warning("m_indexed_array.m_count && draw_array_count");
}
for(u32 i=0; i<m_textures_count; ++i)
{
if(!m_textures[i].IsEnabled()) continue;
glActiveTexture(GL_TEXTURE0 + i);
checkForGlError("glActiveTexture");
m_gl_textures[i].Create();
m_gl_textures[i].Bind();
checkForGlError(wxString::Format("m_gl_textures[%d].Bind", i));
m_program.SetTex(i);
m_gl_textures[i].Init(m_textures[i]);
checkForGlError(wxString::Format("m_gl_textures[%d].Init", i));
}
m_vao.Bind();
if(m_indexed_array.m_count)
{
LoadVertexData(m_indexed_array.index_min, m_indexed_array.index_max - m_indexed_array.index_min + 1);
}
EnableVertexData(m_indexed_array.m_count ? true : false);
InitVertexData();
InitFragmentData();
if(m_indexed_array.m_count)
{
switch(m_indexed_array.m_type)
{
case 0:
glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_INT, nullptr);
checkForGlError("glDrawElements #4");
break;
case 1:
glDrawElements(m_draw_mode - 1, m_indexed_array.m_count, GL_UNSIGNED_SHORT, nullptr);
checkForGlError("glDrawElements #2");
break;
default:
ConLog.Error("Bad indexed array type (%d)", m_indexed_array.m_type);
break;
}
DisableVertexData();
m_indexed_array.Reset();
}
if(m_draw_array_count)
{
//ConLog.Warning("glDrawArrays(%d,%d,%d)", m_draw_mode - 1, m_draw_array_first, m_draw_array_count);
glDrawArrays(m_draw_mode - 1, 0, m_draw_array_count);
checkForGlError("glDrawArrays");
DisableVertexData();
}
if(Ini.GSDumpColorBuffers.GetValue())
WriteBuffers();
}
void GLWidget::drawCoordinateCross(void)
{
GLint viewport[4];
glMatrixMode (GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glMatrixMode (GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glGetIntegerv (GL_VIEWPORT, viewport);
glTranslatef (-1, -1, 0.0);
glScalef (40.0 / viewport[2], 40.0 / viewport[3], 1);
glTranslatef (1.25, 1.25, 0.0);
glRotatef(xRot / 16.0, 1.0, 0.0, 0.0);
glRotatef(yRot / 16.0, 0.0, 1.0, 0.0);
glRotatef(zRot / 16.0, 0.0, 0.0, 1.0);
glEnable (GL_COLOR_MATERIAL);
glDisable (GL_LIGHTING);
glLineWidth (1.0f);
glBegin(GL_LINES);
glColor3f(1,0,0);
glVertex3f (0.0f, 0.0f, 0.0f);
glVertex3f (0.9, 0.0f, 0.0f);
glColor3f(0,1,0);
glVertex3f (0.0f, 0.0f, 0.0f);
glVertex3f (0.0f, 0.9, 0.0f);
glColor3f(0,0,1);
glVertex3f (0.0f, 0.0f, 0.0f);
glVertex3f (0.0f, 0.0f, 0.9);
glEnd ();
glColor3f(1,0,0);
glPushMatrix();
glTranslatef(0.5,0,0);
glRotatef(90,0,1,0);
gluCylinder(row,0.1,0,0.4,10,10);
glPopMatrix();
glColor3f(0,1,0);
glPushMatrix();
glTranslatef(0,0.5,0);
glRotatef(-90,1,0,0);
gluCylinder(row,0.1,0,0.4,10,10);
glPopMatrix();
glColor3f(0,0,1);
glPushMatrix();
glTranslatef(0,0,0.5);
gluCylinder(row,0.1,0,0.4,10,10);
glPopMatrix();
glColor3f(1,0,0);
draw2DText(1.1, 0.0, 0.0, (char*)"X");
glColor3f(0,1,0);
draw2DText(0.1, 1.0, 0.0, (char*)"Y");
glColor3f(0,0,1);
draw2DText(0.1, 0.0, 1.0, (char*)"Z");
glEnable(GL_LIGHTING);
glDisable (GL_COLOR_MATERIAL);
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
void Circle3DOverlay::render(RenderArgs* args) {
if (!_visible) {
return; // do nothing if we're not visible
}
float alpha = getAlpha();
if (alpha == 0.0) {
return; // do nothing if our alpha is 0, we're not visible
}
// Create the circle in the coordinates origin
float outerRadius = getOuterRadius();
float innerRadius = getInnerRadius(); // only used in solid case
float startAt = getStartAt();
float endAt = getEndAt();
bool geometryChanged = (startAt != _lastStartAt || endAt != _lastEndAt ||
innerRadius != _lastInnerRadius || outerRadius != _lastOuterRadius);
const float FULL_CIRCLE = 360.0f;
const float SLICES = 180.0f; // The amount of segment to create the circle
const float SLICE_ANGLE = FULL_CIRCLE / SLICES;
//const int slices = 15;
xColor colorX = getColor();
const float MAX_COLOR = 255.0f;
glm::vec4 color(colorX.red / MAX_COLOR, colorX.green / MAX_COLOR, colorX.blue / MAX_COLOR, alpha);
bool colorChanged = colorX.red != _lastColor.red || colorX.green != _lastColor.green || colorX.blue != _lastColor.blue;
_lastColor = colorX;
glDisable(GL_LIGHTING);
glm::vec3 position = getPosition();
glm::vec3 center = getCenter();
glm::vec2 dimensions = getDimensions();
glm::quat rotation = getRotation();
float glowLevel = getGlowLevel();
Glower* glower = NULL;
if (glowLevel > 0.0f) {
glower = new Glower(glowLevel);
}
glPushMatrix();
glTranslatef(position.x, position.y, position.z);
glm::vec3 axis = glm::axis(rotation);
glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
glPushMatrix();
glm::vec3 positionToCenter = center - position;
glTranslatef(positionToCenter.x, positionToCenter.y, positionToCenter.z);
glScalef(dimensions.x / 2.0f, dimensions.y / 2.0f, 1.0f);
glLineWidth(_lineWidth);
auto geometryCache = DependencyManager::get<GeometryCache>();
// for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise
// we just draw a line...
if (getIsSolid()) {
if (_quadVerticesID == GeometryCache::UNKNOWN_ID) {
_quadVerticesID = geometryCache->allocateID();
}
if (geometryChanged || colorChanged) {
QVector<glm::vec2> points;
float angle = startAt;
float angleInRadians = glm::radians(angle);
glm::vec2 firstInnerPoint(cos(angleInRadians) * innerRadius, sin(angleInRadians) * innerRadius);
glm::vec2 firstOuterPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
points << firstInnerPoint << firstOuterPoint;
while (angle < endAt) {
angleInRadians = glm::radians(angle);
glm::vec2 thisInnerPoint(cos(angleInRadians) * innerRadius, sin(angleInRadians) * innerRadius);
glm::vec2 thisOuterPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
points << thisOuterPoint << thisInnerPoint;
angle += SLICE_ANGLE;
}
// get the last slice portion....
angle = endAt;
angleInRadians = glm::radians(angle);
glm::vec2 lastInnerPoint(cos(angleInRadians) * innerRadius, sin(angleInRadians) * innerRadius);
glm::vec2 lastOuterPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
points << lastOuterPoint << lastInnerPoint;
geometryCache->updateVertices(_quadVerticesID, points, color);
}
geometryCache->renderVertices(gpu::QUAD_STRIP, _quadVerticesID);
} else {
if (_lineVerticesID == GeometryCache::UNKNOWN_ID) {
_lineVerticesID = geometryCache->allocateID();
}
if (geometryChanged || colorChanged) {
QVector<glm::vec2> points;
float angle = startAt;
float angleInRadians = glm::radians(angle);
glm::vec2 firstPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
points << firstPoint;
while (angle < endAt) {
angle += SLICE_ANGLE;
angleInRadians = glm::radians(angle);
glm::vec2 thisPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
points << thisPoint;
if (getIsDashedLine()) {
angle += SLICE_ANGLE / 2.0f; // short gap
angleInRadians = glm::radians(angle);
glm::vec2 dashStartPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
points << dashStartPoint;
}
}
// get the last slice portion....
angle = endAt;
angleInRadians = glm::radians(angle);
glm::vec2 lastPoint(cos(angleInRadians) * outerRadius, sin(angleInRadians) * outerRadius);
points << lastPoint;
geometryCache->updateVertices(_lineVerticesID, points, color);
}
if (getIsDashedLine()) {
geometryCache->renderVertices(gpu::LINES, _lineVerticesID);
} else {
geometryCache->renderVertices(gpu::LINE_STRIP, _lineVerticesID);
}
}
// draw our tick marks
// for our overlay, is solid means we draw a ring between the inner and outer radius of the circle, otherwise
// we just draw a line...
if (getHasTickMarks()) {
if (_majorTicksVerticesID == GeometryCache::UNKNOWN_ID) {
_majorTicksVerticesID = geometryCache->allocateID();
}
if (_minorTicksVerticesID == GeometryCache::UNKNOWN_ID) {
_minorTicksVerticesID = geometryCache->allocateID();
}
if (geometryChanged) {
QVector<glm::vec2> majorPoints;
QVector<glm::vec2> minorPoints;
// draw our major tick marks
if (getMajorTickMarksAngle() > 0.0f && getMajorTickMarksLength() != 0.0f) {
float tickMarkAngle = getMajorTickMarksAngle();
float angle = startAt - fmod(startAt, tickMarkAngle) + tickMarkAngle;
float angleInRadians = glm::radians(angle);
float tickMarkLength = getMajorTickMarksLength();
float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;
float endRadius = startRadius + tickMarkLength;
while (angle <= endAt) {
angleInRadians = glm::radians(angle);
glm::vec2 thisPointA(cos(angleInRadians) * startRadius, sin(angleInRadians) * startRadius);
glm::vec2 thisPointB(cos(angleInRadians) * endRadius, sin(angleInRadians) * endRadius);
majorPoints << thisPointA << thisPointB;
angle += tickMarkAngle;
}
}
// draw our minor tick marks
if (getMinorTickMarksAngle() > 0.0f && getMinorTickMarksLength() != 0.0f) {
float tickMarkAngle = getMinorTickMarksAngle();
float angle = startAt - fmod(startAt, tickMarkAngle) + tickMarkAngle;
float angleInRadians = glm::radians(angle);
float tickMarkLength = getMinorTickMarksLength();
float startRadius = (tickMarkLength > 0.0f) ? innerRadius : outerRadius;
float endRadius = startRadius + tickMarkLength;
while (angle <= endAt) {
angleInRadians = glm::radians(angle);
glm::vec2 thisPointA(cos(angleInRadians) * startRadius, sin(angleInRadians) * startRadius);
glm::vec2 thisPointB(cos(angleInRadians) * endRadius, sin(angleInRadians) * endRadius);
minorPoints << thisPointA << thisPointB;
angle += tickMarkAngle;
}
}
xColor majorColorX = getMajorTickMarksColor();
glm::vec4 majorColor(majorColorX.red / MAX_COLOR, majorColorX.green / MAX_COLOR, majorColorX.blue / MAX_COLOR, alpha);
geometryCache->updateVertices(_majorTicksVerticesID, majorPoints, majorColor);
xColor minorColorX = getMinorTickMarksColor();
glm::vec4 minorColor(minorColorX.red / MAX_COLOR, minorColorX.green / MAX_COLOR, minorColorX.blue / MAX_COLOR, alpha);
geometryCache->updateVertices(_minorTicksVerticesID, minorPoints, minorColor);
}
geometryCache->renderVertices(gpu::LINES, _majorTicksVerticesID);
geometryCache->renderVertices(gpu::LINES, _minorTicksVerticesID);
}
glPopMatrix();
glPopMatrix();
if (geometryChanged) {
_lastStartAt = startAt;
_lastEndAt = endAt;
_lastInnerRadius = innerRadius;
_lastOuterRadius = outerRadius;
}
if (glower) {
delete glower;
}
}
