// TODO: Make border radius true 1-point wide, even for low poly scenarios (by adjusting the inner radius intelligently, not just -1)
void DrawCircle(Vector2n Position, Vector2n Size, Color BackgroundColor, Color BorderColor)
{
glDisable(GL_TEXTURE_2D);
const auto TwoPi = std::atan(1) * 8;
const uint32 x = 64;
glBegin(GL_TRIANGLE_FAN);
glColor3dv(BorderColor.GetComponents());
glVertex2i(Position.X(), Position.Y());
for (int i = 0; i <= x; ++i)
{
glVertex2d(Position.X() + std::sin(TwoPi * i / x) * Size.X() / 2, Position.Y() + std::cos(TwoPi * i / x) * Size.Y() / 2);
}
glEnd();
glBegin(GL_TRIANGLE_FAN);
glColor3dv(BackgroundColor.GetComponents());
glVertex2i(Position.X(), Position.Y());
for (int i = 0; i <= x; ++i)
{
glVertex2d(Position.X() + std::sin(TwoPi * i / x) * (Size.X() / 2 - 1), Position.Y() + std::cos(TwoPi * i / x) * (Size.Y() / 2 - 1));
}
glEnd();
glEnable(GL_TEXTURE_2D);
}
/// Malt das H"ohenfeld
void CGView::drawHeight() {
glPushMatrix();
glTranslated(-5.0, 0.0, -5.0);
glScaled(10.0 / (sizeX - 1), 3.0, 10.0 / (sizeY - 1));
glLineWidth(1);
Vector3d c(1, 1, 1);
if (!wire) glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
else glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
for (int i = 0; i < (sizeX - 1); i++) {
glBegin(GL_TRIANGLE_STRIP);
for (int j = 0; j < (sizeY); j++) {
glColor3dv(c.ptr());
glVertex3d(i, height_vector[i][j], j);
glColor3dv(c.ptr());
glVertex3d(i + 1, height_vector[i + 1][j], j);
}
glEnd();
}
glPopMatrix();
}
void drawSquare( double Corner00Color[3]
, double Corner01Color[3]
, double Corner11Color[3]
, double Corner10Color[3]
, unsigned int texture
, bool enableTextures)
{
ErrCheck("Before drawSquare");
glPushMatrix();
glBindTexture(GL_TEXTURE_2D,texture);
if(enableTextures)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D,texture);
}
glBegin(GL_QUADS);
glNormal3f(0,0,1);
glColor3dv(Corner00Color);
if(enableTextures)
{
glTexCoord2f(0,0);
}
glVertex2f(0,0);
glNormal3f(0,0,1);
glColor3dv(Corner01Color);
if(enableTextures)
{
glTexCoord2f(0,1);
}
glVertex2f(0,1);
glNormal3f(0,0,1);
glColor3dv(Corner11Color);
if(enableTextures)
{
glTexCoord2f(1,1);
}
glVertex2f(1,1);
glNormal3f(0,0,1);
glColor3dv(Corner10Color);
if(enableTextures)
{
glTexCoord2f(1,0);
}
glVertex2f(1,0);
glEnd();
if(enableTextures)
{
glDisable(GL_TEXTURE_2D);
}
glPopMatrix();
ErrCheck("After drawSquare");
}
/**************************************************************************//**
* @author Caitlin Taggart
*
* @par Description:
* The Display function which is the callback for displaying the generated fractal
* window.
*****************************************************************************/
void GenWindow::Display()
{
//set the appropriate window and cleat the screen
glutSetWindow(_windowID);
glClear(GL_COLOR_BUFFER_BIT);
//draw the object
glBegin(GL_LINE_STRIP);
glColor3dv(color);
for (unsigned int i = 0; i < points.size(); i++)
{
glVertex2d(points[i].x, points[i].y);
}
glEnd();
//draw the generated points
glBegin(GL_POINTS);
for (unsigned int i = 0; i < genPoints.size(); i++)
{
ColorPoint pnt = genPoints[i];
glColor3d(pnt.r, pnt.g, pnt.b);
glVertex2d(pnt.x, pnt.y);
}
glEnd();
//swap buffers
glutSwapBuffers();
}
void display(){
int i, j;
// Zバッファの有効化
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glTranslated(-0.5, -0.5, -5.0);
glRotated(30.0, 1.0, 1.0, 0.0);
glBegin(GL_QUADS);
for (j = 0; j<6; j++){
glColor3dv(col[j]);
for (i = 0; i<4; i++){
glVertex3dv(vertex[face[j][i]]);
}
}
glEnd();
glDisable(GL_DEPTH_TEST);
glPopMatrix();
glFlush();
}
void MakePolygon()
{
glClear(GL_COLOR_BUFFER_BIT);
glClearColor(1.0,1.0,1.0,1.0);
for(int i=0;i<=VertInd;i++)
MakeDot(ToDraw->LocalSpaceList[i]);
glColor3dv(ToDraw->Color);
glBegin(GL_POLYGON);
for(int i=0;i<=VertInd;i++)
glVertex2dv(ToDraw->LocalSpaceList[i]);
glEnd();
glLineWidth(2.0);
glColor3d(0.0,0.0,0.0);
glBegin(GL_LINE_LOOP);
for(int i=0;i<=VertInd;i++)
glVertex2dv(ToDraw->LocalSpaceList[i]);
glEnd();
MakeDot(0,0);
no2[0]=(ToDraw->NumVertices-VertInd)/10+'0';
no2[1]=(ToDraw->NumVertices-VertInd)%10+'0';
strcpy(hello3,"Vertices Left: ");
strcat(hello3,no2);
text(hello3,-0.22,-0.15,1);
text(instructions,-0.2,-0.05,0);
glutSwapBuffers();
}
void CALLBACK vertexCallback(GLvoid *vertex)
{
const GLdouble *pointer;
pointer = (GLdouble *) vertex;
glColor3dv(pointer+3);
glVertex3dv(vertex);
}
void PolygonRect::drawGL() {
glColor3dv(material->getDif());
glBegin(GL_LINE_LOOP);
for (int i = 0; i < points.size(); ++i) {
glVertex3d(points[i]->x, points[i]->y, -points[i]->z); // OpenGL has the z-axis reversed
}
glEnd();
}
void displaySentenceOnBand(char* str, double color[])
{
glRasterPos2d(sqrSize*(sqrNum / 4 + frame * 0.7), sqrSize*(sqrNum + frame * 2)*1.5 / 3);
for (; *str; str++) {
glColor3dv(color);
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, *str);
}
}
void loop() {
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, WIDTH, HEIGHT, 0, -1, 1);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
physics_start();
while (!glfwWindowShouldClose(window) && running) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if (pthread_mutex_trylock(&lock) == 0) {
for (int i = 0; i < PARTICLES_MAX; i++) {
struct particle *p = &array[i];
if (!p->m) continue;
glPointSize(particle_radius(p) * 2.0f);
double x, y;
double alpha = particle_getcoords(*p, &x, &y);
glColor4d(p->color[0], p->color[1], p->color[2], alpha);
glBegin(GL_POINTS);
glVertex2d(x, y);
glEnd();
}
pthread_mutex_unlock(&lock);
}
if (mouse.is_dragging) {
double x, y;
glfwGetCursorPos(window, &x, &y);
glBegin(GL_LINES);
glColor3dv(next_color);
glVertex2d(mouse.xp, mouse.yp);
glVertex2d(x, y);
glEnd();
}
glfwSwapBuffers(window);
glfwPollEvents();
glfwSetWindowTitle(window, newtitle());
}
physics_stop();
}
void
rect(pp::Color color, pp::Vec2d startPos, pp::Vec2d endPos)
{
glDisable( GL_TEXTURE_2D );
glColor3dv( (double*)&color );
glRectf( startPos.x, startPos.y,
endPos.x,endPos.y );
glEnable( GL_TEXTURE_2D );
}
void GraphicalNode::draw()
{
glPushMatrix();
glColor3dv(clr);
glTranslated(pos[0],pos[1],pos[2]);
// glRotated(0.0,0.0,0.0,0.0);
glCallList(mListIndex);
glPopMatrix();
}
void DisplayWidget::paintGL()
{
timer.stop();
dataMutex.lock();
makeCurrent();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
if(calibrationMode) gluLookAt(0,0,0,0,0,HANDLEDEPTH,0,-1,0); //Camera has opposite default orientation
//else gluLookAt(center.X(),center.Y(),0,center.X(),center.Y(),HANDLEDEPTH,0,1,0); //Camera has opposite default orientation
else gluLookAt(0,0,0,0,0,HANDLEDEPTH,0,1,0); //Camera has opposite default orientation
//Unused area is unlit by default
if(calibrationMode) glClearColor(deepBackgroundColor.X(), deepBackgroundColor.Y(), deepBackgroundColor.Z(),1);
else glClearColor(backgroundColor.X(), backgroundColor.Y(), backgroundColor.Z(),1);
glClear(GL_COLOR_BUFFER_BIT);
glShadeModel(GL_FLAT);
glEnable(GL_LINE_SMOOTH);
glEnable(GL_POLYGON_SMOOTH);
glEnable(GL_POINT_SMOOTH);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_DEPTH_TEST);
glPushMatrix();
glTranslated(center.X(),center.Y()+.05,0);
glScaled(min*(1.0/6.0),min*(1.0/6.0),1.0);
glColor3d(.5,.5,.5); //Grey because...why not?
for(int k=0;k<4;k++)
{
if(drawShapes[k])
{
glCallList(shapeList[k]);
}
}
glPopMatrix();
for(std::vector<Sphere>::iterator it=spheres.begin();it!=spheres.end();++it)
{
if(it->radius<=0) continue;
glColor3dv(it->color);
glPushMatrix();
if(!calibrationMode) glTranslated(0,0,HANDLEDEPTH);
glTranslated(it->position.X(),it->position.Y(),it->position.Z());
glScaled(it->radius,it->radius,it->radius);
glCallList(sphereList);
glPopMatrix();
}
renderText(textLocation.X(),textLocation.Y(),textLocation.Z(),text);
dataMutex.unlock();
swapBuffers();
glFinish(); //Get precise timing by recording time after this, blocks until swap succeeds. Swap happens during refresh.
timer.start(15, this); //60 Hz = 16.6 ms, guarantee a paint in each refresh and almost immediately before refresh to minimize lag.
}
// マス目描画
void displayPiece(int x, int y, double color[])
{
glColor3dv(color);
glBegin(GL_QUADS);
glVertex2d(sqrSize*(x + frame), sqrSize*(y + frame));
glVertex2d(sqrSize*(x + frame + 0.95), sqrSize*(y + frame));
glVertex2d(sqrSize*(x + frame + 0.95), sqrSize*(y + frame + 0.95));
glVertex2d(sqrSize*(x + frame), sqrSize*(y + frame + 0.95));
glEnd();
}
// フラグマス描画
void displayFlagPiece(int x, int y)
{
// 旗の描画
glColor3dv(colors[Red]);
glBegin(GL_TRIANGLES);
glVertex2d(sqrSize*(x + frame) + sqrSize*1.5 / 5.0, sqrSize*(y + frame) + sqrSize*1.0 / 5.0);
glVertex2d(sqrSize*(x + frame) + sqrSize*1.5 / 5.0, sqrSize*(y + frame) + sqrSize*2.6 / 5.0);
glVertex2d(sqrSize*(x + frame) + sqrSize*4.0 / 5.0, sqrSize*(y + frame) + sqrSize*1.8 / 5.0);
glEnd();
// 棒の描画
glColor3dv(colors[Gray]);
glBegin(GL_QUADS);
glVertex2d(sqrSize*(x + frame) + sqrSize*1.5 / 5.0, sqrSize*(y + frame) + sqrSize*1.0 / 5.0);
glVertex2d(sqrSize*(x + frame) + sqrSize*1.5 / 5.0, sqrSize*(y + frame) + sqrSize*4.0 / 5.0);
glVertex2d(sqrSize*(x + frame) + sqrSize*1.0 / 5.0, sqrSize*(y + frame) + sqrSize*4.0 / 5.0);
glVertex2d(sqrSize*(x + frame) + sqrSize*1.0 / 5.0, sqrSize*(y + frame) + sqrSize*1.0 / 5.0);
glEnd();
}
void CALLBACK CMFCTessView::vertexCallback(GLvoid *vertex)
{
GLdouble *pointer;
pointer = (GLdouble *) vertex;
glColor3dv(pointer+3);
glVertex3dv(pointer);
TRACE( "vertexCallback: (%f,%f,%f)\n",pointer[0],pointer[1],pointer[2] ) ;
}
void displayGrayBand()
{
glColor3dv(colors[Gray]);
glBegin(GL_QUADS);
glVertex2d(0, sqrSize*(sqrNum+frame*2)/3);
glVertex2d(0, sqrSize*(sqrNum+frame*2)*2/3);
glVertex2d(sqrSize*(sqrNum + frame * 2), sqrSize*(sqrNum + frame * 2) * 2 / 3);
glVertex2d(sqrSize*(sqrNum + frame * 2), sqrSize*(sqrNum + frame * 2) / 3);
glEnd();
}
// 押されたマス目の描画
void displayPushedPiece(int x, int y, int num)
{
// マス目の色をGrayにする
displayPiece(x, y, colors[Gray]);
// 数字描画
glColor3dv(colors[num]);
glRasterPos2d(sqrSize*(x + frame)+sqrSize*1.5 / 5.0, sqrSize*(y + frame)+sqrSize*4.0 / 5.0);
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, numbers[num]);
}
void cube()
{
glColor3dv(colors[0]);
// set_materials(&brassMaterials);
// glNormal3fv(cubeNomals[0]);
polygon(0, 3, 2, 1);
glColor3dv(colors[1]);
// set_materials(&redPlasticMaterials);
// glNormal3fv(cubeNomals[1]);
polygon(2, 3, 7, 6);
glColor3dv(colors[2]);
// set_materials(&greenPlasticMaterials);
// glNormal3fv(cubeNomals[2]);
polygon(3, 0, 4, 7);
glColor3dv(colors[3]);
// set_materials(&bluePlasticMaterials);
// glNormal3fv(cubeNomals[3]);
polygon(1, 2, 6, 5);
glColor3dv(colors[4]);
// set_materials(&whiteShinyMaterials);
// glNormal3fv(cubeNomals[4]);
polygon(4, 5, 6, 7);
glColor3dv(colors[5]);
// set_materials(&magentaMaterials);
// glNormal3fv(cubeNomals[5]);
polygon(5, 4, 0, 1);
}
void __glXDisp_Color3dv(GLbyte *pc)
{
#ifdef __GLX_ALIGN64
if ((unsigned long)(pc) & 7) {
__GLX_MEM_COPY(pc-4, pc, 24);
pc -= 4;
}
#endif
glColor3dv(
(GLdouble *)(pc + 0)
);
}
// Calculations
void PolygonView::draw(const Point2& pos, real rot, int) const
{
glPushMatrix();
gltTranslate(pos);
glRotated(rot, 0.0, 0.0, 1.0);
const Polygon2& poly = collisionPolygon();
glColor3dv(iColor);
glBegin(iStyle);
gltVertex(poly.begin(), poly.end());
glEnd();
glPopMatrix();
}
void DrawAroundBox(Vector2n Position, Vector2n Size, Color BackgroundColor, Color BorderColor)
{
glDisable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glColor3dv(BorderColor.GetComponents());
glVertex2i(-1 + Position.X(), -1 + Position.Y());
glVertex2i(-1 + Position.X(), +1 + Position.Y() + Size.Y());
glVertex2i(+1 + Position.X() + Size.X(), +1 + Position.Y() + Size.Y());
glVertex2i(+1 + Position.X() + Size.X(), -1 + Position.Y());
glEnd();
glBegin(GL_QUADS);
glColor3dv(BackgroundColor.GetComponents());
glVertex2i(Position.X(), Position.Y());
glVertex2i(Position.X(), Position.Y() + Size.Y());
glVertex2i(Position.X() + Size.X(), Position.Y() + Size.Y());
glVertex2i(Position.X() + Size.X(), Position.Y());
glEnd();
glEnable(GL_TEXTURE_2D);
}
/**
* Zeichnet einen Vertex (glVertex) mit Texturkoordinaten und gegebenfalls Farbinformationen aber ohne Normale.
*/
void SGLVektor::DrawVertex()
{
/*
Setzt wenn gegeben Texturkoordinaten für alle Texturrenderer vom der aktiven bis zu GL_TEXTURE0_ARB herunter.
(Aber immer nur die Selben)
*/
std::stringstream buff;
bool texOK=false;
#ifndef WIN32
if(SGLTextur::TexLoaded)
{
short coord=texKoord.size();
if(coord<SGLTextur::TexLoaded)
{
buff << *this;
SGLprintWarning("Die geladene Textur hat %d Dimensionen, die Texturkoordinaten des Vertex \"%s\" sind aber nur %d-Dimensional",SGLTextur::TexLoaded,buff.str().c_str(),coord);
}
int i=GL_TEXTURE0_ARB+SGLTextur::multitex_layer ;//@todo dirty Hack
switch(SGLTextur::TexLoaded > coord ? coord:SGLTextur::TexLoaded )
{
case 1:
for(;i>=GL_TEXTURE0_ARB;i--)
glMultiTexCoord1f(i,texKoord[0]);
break;
case 2:
for(;i>=GL_TEXTURE0_ARB;i--)
glMultiTexCoord2f(i,texKoord[0], texKoord[1]);
break;
case 3:
for(;i>=GL_TEXTURE0_ARB;i--)
glMultiTexCoord3f(i,texKoord[0], texKoord[1],texKoord[2]);
break;
default:{
buff << *this;
SGLprintError("Texturtyp (%d) passt nicht zu den verfügbaren Texturkoordinaten beim Zeichnen des Vertex \"%s\"",SGLTextur::TexLoaded, coord,buff.str().c_str());}break;
}
texOK=true;//@todo naja nich immer
}
#else
// "Texture loading is currently not supportet for Windows"
#endif
if(!SGLMaterial::MatLoaded && !texOK)
{
if(SGLV_R>=0 || SGLV_G>=0 || SGLV_B>=0)glColor3dv(Color);
else{
buff << *this;
SGLprintWarning("Keine Farbinformationen verfgbar beim Zeichnen des Vertex \"%s\"",buff.str().c_str());
}
}
DrawPureVertex();
}
void DrawInnerBox(Vector2n Position, Vector2n Size, Color BackgroundColor, Color BorderColor)
{
if ( 0 == Size.X()
|| 0 == Size.Y())
{
return;
}
glDisable(GL_TEXTURE_2D);
const auto OuterDistance = 1.5;
glBegin(GL_POLYGON);
glColor3dv(BorderColor.GetComponents());
glVertex2d(Position.X() + OuterDistance, Position.Y());
glVertex2d(Position.X(), Position.Y() + OuterDistance);
glVertex2d(Position.X(), Position.Y() - OuterDistance + Size.Y());
glVertex2d(Position.X() + OuterDistance, Position.Y() + Size.Y());
glVertex2d(Position.X() - OuterDistance + Size.X(), Position.Y() + Size.Y());
glVertex2d(Position.X() + Size.X(), Position.Y() - OuterDistance + Size.Y());
glVertex2d(Position.X() + Size.X(), Position.Y() + OuterDistance);
glVertex2d(Position.X() - OuterDistance + Size.X(), Position.Y());
glEnd();
const auto InnerDistance = sqrt(2.0) + 0.5;
glBegin(GL_POLYGON);
glColor3dv(BackgroundColor.GetComponents());
glVertex2d(Position.X() + InnerDistance, Position.Y() + 1);
glVertex2d(Position.X() + 1, Position.Y() + InnerDistance);
glVertex2d(Position.X() + 1, Position.Y() - InnerDistance + Size.Y());
glVertex2d(Position.X() + InnerDistance, Position.Y() - 1 + Size.Y());
glVertex2d(Position.X() - InnerDistance + Size.X(), Position.Y() - 1 + Size.Y());
glVertex2d(Position.X() - 1 + Size.X(), Position.Y() - InnerDistance + Size.Y());
glVertex2d(Position.X() - 1 + Size.X(), Position.Y() + InnerDistance);
glVertex2d(Position.X() - InnerDistance + Size.X(), Position.Y() + 1);
glEnd();
glEnable(GL_TEXTURE_2D);
}
void Particle::draw()
{
cg::Vector3d min = _position - _size/100.0;
cg::Vector3d max = _position + _size/100.0;
glColor3dv(_color.get());
//glLineWidth(1.5);
glBegin(GL_POLYGON);
glVertex3d(min[0], min[1], -400);
glVertex3d(max[0], min[1], -400);
glVertex3d(max[0], max[1], -400);
glVertex3d(min[0], max[1], -400);
// glVertex3d(min[0], max[1]*2, 10);
glEnd();
}
void DrawBoxBorderless(Vector2n Position, Vector2n Size, Color Color)
{
glDisable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glColor3dv(Color.GetComponents());
glVertex2i(Position.X(), Position.Y());
glVertex2i(Position.X(), Position.Y() + Size.Y());
glVertex2i(Position.X() + Size.X(), Position.Y() + Size.Y());
glVertex2i(Position.X() + Size.X(), Position.Y());
glEnd();
glEnable(GL_TEXTURE_2D);
}
void operator()(DM::System *s, const DM::View& v, DM::Component* cmp, DM::Vector3* point, DM::Vector3* color, iterator_pos pos)
{
if (pos == in_between)
{
double current_tex = 0;
if (attr_span != 0)
{
const ViewMetaData &vmd = l.getViewMetaData();
Attribute *a = cmp->getAttribute(l.getAttribute());
if (a)
{
if (a->getType() == Attribute::DOUBLEVECTOR || a->getType() == Attribute::TIMESERIES)
current_tex = (a->getDoubleVector()[l.getAttributeVectorName()] - vmd.attr_min) / attr_span;
else
current_tex = (a->getDouble() - vmd.attr_min) / attr_span;
}
}
else
current_tex = 0.0;
current_tex *= 255;
if (color)
glColor3dv(&color->x);
else if (current_tex <= 0)
glColor3f(0, 0, 0);
else
{
float r = l.LayerColor[(int)current_tex][0] / 255.;
float g = l.LayerColor[(int)current_tex][1] / 255.;
float b = l.LayerColor[(int)current_tex][2] / 255.;
//float a = l.LayerColor[(int)current_tex][3]/255.;
glColor3f(r, g, b);
}
glVertex3dv(&point->x);
}
else if (pos == before)
{
glPushName(name_start);
glBegin(SD_GL_PRIMITIVE);
}
else if (pos == after)
{
glEnd();
glPopName();
name_start++;
}
}
/**
* Zeichnet ein dreidimensionales Kreuz an den Positionskoordinaten des Vektors.
* @param size die Große des Kreuzes.
*/
void SGLVektor::DrawPkt(double size)
{
glBegin(GL_LINES);
if(SGLV_R>=0 || SGLV_G>=0 || SGLV_B>=0)
glColor3dv(Color);
glVertex3d(SGLV_X-size/2,SGLV_Y,SGLV_Z);
glVertex3d(SGLV_X+size/2,SGLV_Y,SGLV_Z);
glVertex3d(SGLV_X,SGLV_Y-size/2,SGLV_Z);
glVertex3d(SGLV_X,SGLV_Y+size/2,SGLV_Z);
glVertex3d(SGLV_X,SGLV_Y,SGLV_Z-size/2);
glVertex3d(SGLV_X,SGLV_Y,SGLV_Z+size/2);
glEnd();
}
void GeomRenderer::sendColor(GLuint colorIndex)
{
assert(colorData.size == 3 || colorData.size == 4);
switch(colorData.type)
{
case GL_BYTE:
if (colorData.size == 3) glColor3bv((const GLbyte*)((const char*)colorData.pointer + colorIndex*colorData.stride));
if (colorData.size == 4) glColor4bv((const GLbyte*)((const char*)colorData.pointer + colorIndex*colorData.stride));
break;
case GL_UNSIGNED_BYTE:
if (colorData.size == 3) glColor3ubv((const GLubyte*)((const char*)colorData.pointer + colorIndex*colorData.stride));
if (colorData.size == 4) glColor4ubv((const GLubyte*)((const char*)colorData.pointer + colorIndex*colorData.stride));
break;
case GL_SHORT:
if (colorData.size == 3) glColor3sv((const GLshort*)((const char*)colorData.pointer + colorIndex*colorData.stride));
if (colorData.size == 4) glColor4sv((const GLshort*)((const char*)colorData.pointer + colorIndex*colorData.stride));
break;
case GL_UNSIGNED_SHORT:
if (colorData.size == 3) glColor3usv((const GLushort*)((const char*)colorData.pointer + colorIndex*colorData.stride));
if (colorData.size == 4) glColor4usv((const GLushort*)((const char*)colorData.pointer + colorIndex*colorData.stride));
break;
case GL_INT:
if (colorData.size == 3) glColor3iv((const GLint*)((const char*)colorData.pointer + colorIndex*colorData.stride));
if (colorData.size == 4) glColor4iv((const GLint*)((const char*)colorData.pointer + colorIndex*colorData.stride));
break;
case GL_UNSIGNED_INT:
if (colorData.size == 3) glColor3uiv((const GLuint*)((const char*)colorData.pointer + colorIndex*colorData.stride));
if (colorData.size == 4) glColor4uiv((const GLuint*)((const char*)colorData.pointer + colorIndex*colorData.stride));
break;
case GL_FLOAT:
if (colorData.size == 3) glColor3fv((const GLfloat*)((const char*)colorData.pointer + colorIndex*colorData.stride));
if (colorData.size == 4) glColor4fv((const GLfloat*)((const char*)colorData.pointer + colorIndex*colorData.stride));
break;
case GL_DOUBLE:
if (colorData.size == 3) glColor3dv((const GLdouble*)((const char*)colorData.pointer + colorIndex*colorData.stride));
if (colorData.size == 4) glColor4dv((const GLdouble*)((const char*)colorData.pointer + colorIndex*colorData.stride));
break;
}
}
void RenderController::render_string(int x, int y, std::string curr_string, std::vector< GLdouble >* color) {
glPushMatrix();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(0, this->curr_rend_ctrl->width, 0, this->curr_rend_ctrl->height, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glColor3dv(color->data());
glRasterPos2i(x, this->curr_rend_ctrl->height - y);
glutBitmapString(GLUT_BITMAP_TIMES_ROMAN_24, (const unsigned char*)curr_string.data());
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
glPopMatrix();
}
