void
init(char *filename)
{
stl_error_t err;
GLfloat *vertices = NULL;
GLuint triangle_cnt = 0;
int i = 0, base = 0;
stl = stl_alloc();
if (stl == NULL) {
fprintf(stderr, "Unable to allocate memoryfor the stl object");
exit(1);
}
err = stl_load(stl, filename);
if (err != STL_ERR_NONE) {
fprintf(stderr, "Problem loading the stl file, check lineno %d\n",
stl_error_lineno(stl));
exit(1);
}
err = stl_vertices(stl, &vertices);
if (err) {
fprintf(stderr, "Problem getting the vertex array");
exit(1);
}
triangle_cnt = stl_facet_cnt(stl);
model = glGenLists(1);
glNewList(model, GL_COMPILE);
glBegin(GL_TRIANGLES);
for (i = 0; i < triangle_cnt; i++) {
base = i*18;
drawTriangle(vertices[base], vertices[base + 1], vertices[base + 2],
vertices[base + 6], vertices[base + 7], vertices[base + 8],
vertices[base + 12], vertices[base + 13], vertices[base + 14]);
}
glEnd();
glEndList();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glClearColor(135.0 / 255, 206.0 / 255.0, 250.0 / 255.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glColor3f(120.0 / 255.0 , 120.0 / 255.0, 120.0 / 255.0);
glEnable(GL_NORMALIZE);
glEnable(GL_COLOR_MATERIAL);
glFlush();
}
int main(void)
{
GLFWwindow* window;
/* Initialize the library */
if (!glfwInit())
return -1;
//使用OpenGL 3.2
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
/* Create a windowed mode window and its OpenGL context */
window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
if (!window)
{
glfwTerminate();
return -1;
}
/* Make the window's context current */
glfwMakeContextCurrent(window);
if(false==LoadImg("/Users/wistoneqqx/Documents/opengl/github/texture-maps-gl7/texture-maps/test01.jpg",0))
printf("加载图片1失败！\n");
if(false==LoadImg("/Users/wistoneqqx/Documents/opengl/github/texture-maps-gl7/texture-maps/test02.jpg",1))
printf("加载图片2失败！\n");
initShader();
initTriangle();
/* Loop until the user closes the window */
while (!glfwWindowShouldClose(window))
{
/* Render here */
glClearColor(0.0f,0.0f,0.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
drawTriangle();
/* Swap front and back buffers */
glfwSwapBuffers(window);
/* Poll for and process events */
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void Light::shine(sf::RenderWindow* win)
{
for(int i=0;i<lights.size();i++)
{
std::vector<PointID> pnt;
for(int j=0;j<tab.size();j++)
{
pnt.push_back(PointID(lights[i].first,tab[j].first,j));
pnt.push_back(PointID(lights[i].first,tab[j].second,j));
}
sort(pnt.begin(), pnt.begin() + pnt.size(), cmp);
for(int i=0;i<pnt.size()-1;i++)
if(pnt[i].p==pnt[i+1].p)
{
pnt.erase(pnt.begin()+i);
i--;
}
std::vector<Point> res;
for(int j=0;j<pnt.size();j++)
{
res.push_back(pnt[j].p-lights[i].first);
for(int k=0;k<tab.size();k++)
{
if(cross(lights[i].first,pnt[j].p,tab[k].first,tab[k].second))
{
res.pop_back();
break;
}
}
}
for(int j=0;j<res.size()-1;j++)
{
drawTriangle(win,lights[i].first,res[j],res[j+1],lights[i].second);
}
drawTriangle(win,lights[i].first,res[0],res[res.size()-1],lights[i].second);
sf::CircleShape circle(5);
circle.setFillColor(lights[i].second);
circle.move(lights[i].first-Point(5,5));
win->draw(circle);
}
}
void capturePoints(int button,int state,int x,int y)
{
if(points_count==0 || points_count==1)
points_count++;
else if((points_count%2==1) && (points_count < (2*max_points)+1))
{
printf("count=%d\n",points_count);
points_count++;
}
else if((points_count%2==1) && (points_count==(2*max_points)+1))
{
printf("count=%d\n",points_count);
points_count=2;
}
else if(points_count==2*max_points)
{
printf("need to add the points\n");
printf("count=%d\n",points_count);
end_points[(points_count/2)-1][0]=x;
end_points[(points_count/2)-1][1]=500-y;
points_count++;
printf("%d %d\n",end_points[0][0],end_points[0][1]);
printf("%d %d\n",end_points[1][0],end_points[1][1]);
switch(global_primitive)
{
case 2 :
drawLine();
break;
case 3 :
{
int rad=distance(end_points[0][0],end_points[0][1],end_points[1][0],end_points[1][1]);
printf("%d\n",rad);
drawCircle(rad,end_points[0][0],end_points[0][1]);
break;
}
case 4 :
drawTriangle();
break;
}
}
else
{
printf("need to add the points\n");
printf("count=%d\n",points_count);
end_points[(points_count/2)-1][0]=x;
end_points[(points_count/2)-1][1]=500-y;
points_count++;
}
}
void testtriangles()
{
fillScreen(BLACK);
uint16_t i;
for (i=0; i<width()/2; i+=5)
{
drawTriangle(width()/2, height()/2-i,
width()/2-i, height()/2+i,
width()/2+i, height()/2+i, Color565(0, 0, i));
}
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//glTranslatef(0, 0 , 0);
drawTriangle(0.0,2.0,4);
//glFlush();
glutSwapBuffers();
}
int triangleBinding(lua_State *L) {
int x1,y1,x2,y2,x3,y3;
x1 = lua_tonumber(L,-6);
y1 = lua_tonumber(L,-5);
x2 = lua_tonumber(L,-4);
y2 = lua_tonumber(L,-3);
x3 = lua_tonumber(L,-2);
y3 = lua_tonumber(L,-1);
drawTriangle(l81.fb,x1,y1,x2,y2,x3,y3,l81.r,l81.g,l81.b,l81.alpha);
return 0;
}
int main(void)
{
GLFWwindow* window;
/* Initialize the library */
if (!glfwInit())
return -1;
//使用OpenGL 3.2
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
/* Create a windowed mode window and its OpenGL context */
window = glfwCreateWindow(640, 480, "Hello World", NULL, NULL);
if (!window)
{
glfwTerminate();
return -1;
}
/* Make the window's context current */
glfwMakeContextCurrent(window);
/*设置键盘事件监听*/
glfwSetKeyCallback(window,keyboardCallbackHandler);
initData();
initShader();
/* Loop until the user closes the window */
while (!glfwWindowShouldClose(window))
{
/* Render here */
glClearColor(0.0f,0.0f,0.0f,0.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
drawTriangle();
/* Swap front and back buffers */
glfwSwapBuffers(window);
/* Poll for and process events */
glfwPollEvents();
}
glfwDestroyWindow(window);
glfwTerminate();
return 0;
}
void drawArc(int depart, int arrivee)
{ //Dessine un arc colorié entre le sommet de départ et le sommet d'arrivée, chaque sommet étant repréré par un indice (voir sommets.txt)
if (G[depart][arrivee].poids != 1000) //si l'arc existe
{
switch(G[depart][arrivee].couleur)
{
case 0 : drawBigLine(points[depart],points[arrivee],vert);
drawTriangle(points[arrivee],5,vert);
break;
case 1 : drawBigLine(points[depart],points[arrivee],bleu);
drawTriangle(points[arrivee],5,bleu);
break;
case 2 : drawBigLine(points[depart],points[arrivee],rouge);
drawTriangle(points[arrivee],5,rouge);
break;
case 3 : drawBigLine(points[depart],points[arrivee],gris);
drawTriangle(points[arrivee],5,gris);
break;
case 4 : drawBigLine(points[depart],points[arrivee],noir);
drawTriangle(points[arrivee],5,noir);
break;
default : drawBigLine(points[depart],points[arrivee],blanc);
drawTriangle(points[arrivee],5,blanc);
break;
}
}
}
void display(void)
{
//カラーバッファのクリア
glClear(GL_COLOR_BUFFER_BIT);
//描画
// シェーダプログラムの適用
glUseProgram(shaderProg);
drawTriangle();
// シェーダプログラムの適用を解除
glUseProgram(0);
//終了
glFlush();
}
void Widget::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
// gluLookAt(radius*qCos(AngToRad*xRot), yRot, radius*qSin(AngToRad*xRot), 0, 0, 0, 0, 1, 0);
if(isObjOn){
drawObj();
}
else {
drawTriangle();
}
glFlush();
}
Mat BodyModel::generateMat()
{
_mask = Mat::zeros(_img_heigh, _img_width, CV_8UC3);
// draw waist
drawPolygon(_right_waist, _left_waist, _right_hip, _left_hip);
// draw chest
drawPolygon(_right_shoulder, _left_shoulder, _right_waist, _left_waist);
// draw neck
drawPolygon(Point(_center_x + _neck_width, _center_y - _neck_heigh),
Point(_center_x - _neck_width, _center_y - _neck_heigh),
Point(_center_x + _neck_width, _center_y),
Point(_center_x - _neck_width, _center_y));
// draw left arm
drawPolygon(_left_shoulder, _left_arm_lower, _left_elbow_upper, _left_elbow_lower);
// draw left hand
drawBodyShape(_left_elbow_upper, _left_elbow_lower, _left_hand_upper, _left_hand_lower, -5);
// draw right arm
drawPolygon(_right_shoulder, _right_arm_lower, _right_elbow_upper, _right_elbow_lower);
// draw right hand
drawBodyShape(_right_elbow_upper, _right_elbow_lower, _right_hand_upper, _right_hand_lower, 5);
// draw head
drawCircle(_head_center, _head_radius);
// draw left leg
drawPolygon(_left_hip, _mid_hip, _left_knee, _left_knee_inner);
// draw right leg
drawPolygon(_right_hip, _mid_hip, _right_knee, _right_knee_inner);
// draw left limb
drawBodyShape(_left_knee, _left_knee_inner, _left_footrope, _left_heel, -10);
// draw right limb
drawBodyShape(_right_knee, _right_knee_inner, _right_footrope, _right_heel, 10);
// draw left foot
drawTriangle(_left_heel, _left_toe, _left_heel_upper);
// draw right foot
drawTriangle(_right_heel, _right_toe, _right_heel_upper);
// draw shoulder
drawTriangle(_right_shoulder, _left_shoulder, Point(_center_x, _center_y - _shoulder_heigh));
return _mask;
}
void gePropertyTransform::drawNode()
{
drawRect(&m_cVBClientArea);
geFontManager::g_pFontArial10_84Ptr->drawString(m_szName, 35, geFontManager::g_pFontArial10_84Ptr->getLineHeight(), m_cSize.x);
if(m_vControls.size() && m_bHaveAtleastOneTreeNodeChild)
{
if(m_bNodeOpen)
drawTriangle(&m_cVBLayoutToggleButtonLine[3*2], 0.3f, 0.3f, 0.3f, 1.0f, 3);
else
drawTriangle(&m_cVBLayoutToggleButtonLine[0], 0.3f, 0.3f, 0.3f, 1.0f, 3);
}
for(std::vector<geGUIBase*>::iterator it = m_vControls.begin(); it != m_vControls.end(); ++it)
{
geGUIBase* tvnode = *it;
tvnode->draw();
}
if(m_pSprite)
m_pSprite->draw();
}
int main(int argc, char** argv) {
// start GL context and O/S window using the GLFW helper library
if (!glfwInit ()) {
fprintf (stderr, "ERROR: could not start GLFW3\n");
return 1;
}
GLFWwindow* window = glfwCreateWindow (640, 480, "Hello Triangle", NULL, NULL);
if (!window) {
fprintf (stderr, "ERROR: could not open window with GLFW3\n");
glfwTerminate();
return 1;
}
glfwMakeContextCurrent (window);
glewInit ();
printMachineSpecification();
// tell GL to only draw onto a pixel if the shape is closer to the viewer
glEnable (GL_DEPTH_TEST); // enable depth-testing
glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer"
glShadeModel(GL_SMOOTH);
float points[] = {
0.0f, 1.0f, 0.0f,
1.0f, -1.0f, 0.0f,
-1.0f, -1.0f, 0.0f
};
GLuint vao;
createTriangle(&vao, points);
GLuint shader_programme;
createShader(&shader_programme, fragment_shader, vertex_shader);
while (!glfwWindowShouldClose (window)) {
// wipe the drawing surface clear
glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
drawTriangle(vao, shader_programme);
// update other events like input handling
glfwPollEvents ();
// put the stuff we've been drawing onto the display
glfwSwapBuffers (window);
}
glfwTerminate();
return 0;
}
void draw_cube()
{
sglClear(0.0, 0.0, 1.0);
sglModLoadIdentity();
sglViewLoadIdentity();
sglLookAt(20, 10, 20, 0, 0, 0,0,0,1);
sglModTranslate(0.0f, 0.0f, -10.0f);
sglModRotate(angle, 1.0 ,1.0,1.0);
drawTriangle();
sglShow();
angle += 0.075;
}
void testfilltriangles()
{
fillScreen(BLACK);
uint16_t i;
for (i=width()/2; i>10; i-=5)
{
fillTriangle(width()/2, height()/2-i,
width()/2-i, height()/2+i,
width()/2+i, height()/2+i,
Color565(0, i, i));
drawTriangle(width()/2, height()/2-i,
width()/2-i, height()/2+i,
width()/2+i, height()/2+i, Color565(i, i, 0));
}
}
void flashShape(int shape, WinDrawLine_fn WinDrawLine)
{
switch(shape){
case 0:
drawRectangle(14+5,24+5,50-10,50-10,WinDrawLine);
break;
case 1:
drawTriangle(90+5+5,34+5,70-10-10,WinDrawLine);
break;
case 2:
drawDiamond(14+5,90+5,60-10, WinDrawLine);
break;
case 3:
drawCircle(90+27,90+27,27+27-10,WinDrawLine);
break;
}
}
// will be called with next end as the last begin
// match == on begin only, otherwise get double markings
void drawKeepEupEScreen(void)
{
DEBUGBOX("drawKeepEupEScreen","");
clearScreen();
drawRectangleSafe(14,24,50,50);
DEBUGBOX("drawKeepEupEScreen","b4rect");
// messes up &WinDrawLineF ptr setup somewhere here
drawRectangle(14,24,50,50,&WinDrawLineF);
DEBUGBOX("drawKeepEupEScreen","");
drawTriangle(90,34,70,&WinDrawLineF);
DEBUGBOX("drawKeepEupEScreen","");
drawDiamond(14,90,60,&WinDrawLineF);
DEBUGBOX("drawKeepEupEScreen","");
drawCircle(90+27,90+27,27+27,&WinDrawLineF);
DEBUGBOX("drawKeepEupEScreen","");
}
//*****************************************************************************
void testtriangles() {
int color = 0xF800;
int t;
int w = width() / 2;
int x = height() - 1;
int y = 0;
int z = width() - 1;
fillScreen(BLACK);
for (t = 0; t <= 15; t += 1) {
drawTriangle(w, y, y, x, z, x, color);
x -= 4;
y += 4;
z -= 4;
color += 100;
delay(10);
}
}
void display(void){
//calcWheelVert();
calcTriangle();
glGenBuffers(NumBuffers, Buffers);
glBindBuffer(GL_ARRAY_BUFFER, Buffers[ArrayBuffer]);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glGenVertexArrays(NumVAOs, VAOs);
glBindVertexArray(VAOs[Triangles]);
glVertexAttribPointer(vPosition, 2, GL_FLOAT, GL_FALSE, 0, (void*)0);
glEnableVertexAttribArray(vPosition);
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
glClearColor(0.9, 0.9, 0.9, 1);
glClear(GL_COLOR_BUFFER_BIT);
drawTriangle();
glBindVertexArray(VAOs[Triangles]);
glutSwapBuffers();
}
void drawSierpinski(Point a, Point b, Point c, int level)
{ Point m0, m1, m2;
//Example rendering function
if (level > 0)
{
m0.x = (a.x+b.x) /2.0;
m0.y = (a.y+b.y) /2.0;
m1.x = (a.x+c.x) /2.0;
m1.y = (a.y+c.y) /2.0;
m2.x = (b.x+c.x) /2.0;
m2.y = (c.y+b.y) /2.0;
drawSierpinski(a,m0,m1,level-1);
drawSierpinski(b,m2,m0,level-1);
drawSierpinski(c,m1,m2,level-1);
}
else
drawTriangle(a,b,c);
} // end draw Sierpinski
void AnnotationItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *options, QWidget *widget)
{
Q_UNUSED(options);
Q_UNUSED(widget);
painter->save();
painter->setClipRect(boundingRect().adjusted(0, 0, 1, 1));
render(painter, _rect);
if(_showborder || _text.isEmpty()) {
QColor border = QApplication::palette().color(QPalette::Highlight);
border.setAlpha(255);
QPen bpen(_highlight && _showborder ? Qt::DashLine : Qt::DotLine);
bpen.setCosmetic(true);
bpen.setColor(border);
painter->setPen(bpen);
painter->drawRect(_rect);
// Draw resizing handles
if(_highlight) {
QPen pen(border);
pen.setCosmetic(true);
painter->setPen(pen);
drawTriangle(painter, RS_TOPLEFT, _rect.topLeft() + QPoint(2, 2));
drawTriangle(painter, RS_TOP, _rect.topLeft() + QPoint(_rect.width()/ 2 + 2, 2));
drawTriangle(painter, RS_TOPRIGHT, _rect.topRight() + QPoint(-2, 2));
drawTriangle(painter, RS_LEFT, _rect.center() - QPoint(_rect.width()/2 - 2, 0));
drawTriangle(painter, RS_RIGHT, _rect.center() + QPoint(_rect.width()/2 - 2, 0));
drawTriangle(painter, RS_BOTTOMLEFT, _rect.bottomLeft() + QPoint(2, -2));
drawTriangle(painter, RS_BOTTOM, _rect.bottomLeft() + QPoint(_rect.width()/ 2 + 2, -2));
drawTriangle(painter, RS_BOTTOMRIGHT, _rect.bottomRight() + QPoint(-2, -2));
}
}
painter->restore();
}
void scaling(float sx, float sy)
{
int i;
Point new_p[3];
for(i=0;i<3;i++)
{
if(sx !=0)
new_p[i].x = p[i].x * sx;
else
new_p[i].x=p[i].x;
if(sy!=0)
new_p[i].y = p[i].y * sy;
else
new_p[i].y=p[i].y;
}
drawTriangle(new_p);
}
int main_SDL(int argc, char *argv[])
{
SDL_Init(SDL_INIT_VIDEO);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_Window* window = SDL_CreateWindow("OpenGL - SDL", 100, 100, 800, 600, SDL_WINDOW_OPENGL);
SDL_GLContext context = SDL_GL_CreateContext(window);
initOpenGLProgram();
SDL_Event windowEvent;
while (true)
{
if (SDL_PollEvent(&windowEvent))
{
if (windowEvent.type == SDL_QUIT)
{
break;
}
if (windowEvent.type == SDL_KEYUP &&
windowEvent.key.keysym.sym == SDLK_ESCAPE)
{
break;
}
}
drawTriangle();
SDL_GL_SwapWindow(window);
}
SDL_GL_DeleteContext(context);
SDL_Quit();
return 0;
}
HyperGraphElementAction* VertexSE3DrawAction::operator()(HyperGraph::HyperGraphElement* element,
HyperGraphElementAction::Parameters* params_){
if (typeid(*element).name()!=_typeName)
return 0;
if (! _cacheDrawActions){
_cacheDrawActions = HyperGraphActionLibrary::instance()->actionByName("draw");
}
refreshPropertyPtrs(params_);
if (! _previousParams)
return this;
if (_show && !_show->value())
return this;
VertexSE3* that = static_cast<VertexSE3*>(element);
glColor3f(0.5f,0.5f,0.8f);
glPushMatrix();
glTranslatef((float)that->estimate().translation().x(),(float)that->estimate().translation().y(),(float)that->estimate().translation().z());
AngleAxisd aa(that->estimate().rotation());
glRotatef((float)RAD2DEG(aa.angle()),(float)aa.axis().x(),(float)aa.axis().y(),(float)aa.axis().z());
if (_triangleX && _triangleY){
drawTriangle(_triangleX->value(), _triangleY->value());
}
CacheContainer* caches=that->cacheContainer();
if (caches){
for (CacheContainer::iterator it=caches->begin(); it!=caches->end(); it++){
Cache* c = it->second;
(*_cacheDrawActions)(c, params_);
}
}
OptimizableGraph::Data* d=that->userData();
while (d && _cacheDrawActions ){
(*_cacheDrawActions)(d, params_);
d=d->next();
}
glPopMatrix();
return this;
}
void problem18() {
GLubyte black[] = {0,0,0};
glm::vec3 v1(100,200,1), v2(200,300,1), v3(300,200,1);
glm::mat3 mat(0.5, 0, 0,
0, 0.5, 0,
0, 0, 1);
glm::vec3 midPoint(((v1.x + v2.x + v3.x) / 3.0), ((v1.y + v2.y + v3.y) / 3.0), 1);
v1 -= midPoint;
v2 -= midPoint;
v3 -= midPoint;
v1 = mat * v1;
v2 = mat * v2;
v3 = mat * v3;
v1 += midPoint;
v2 += midPoint;
v3 += midPoint;
drawTriangle(v1,v2,v3, black);
}
///
/// \brief Draws the Ship rotated at the correct angle and at the
/// correct position.
/// \return void
///
void Ship::draw() const
{
const vector2& center_pos = center_ + pos_;
// TODO: this is messy because of subtracting center_. Find a more
// intuitive way to do it.
// subtract the center to get back to the original pos_
// in the new co-ordinate system
const vector2& A_mc = A_ - center_;
const vector2& B_mc = B_ - center_;
const vector2& C_mc = C_ - center_;
glPushMatrix();
// rotate around the center of the triangle, so move the
// co-ordinate system there
glTranslatef(center_pos[0], center_pos[1], 0);
glRotatef(rot_angle_, 0.0, 0.0, 1.0);
glColor3fv(color_);
drawTriangle(A_mc, B_mc, C_mc);
// translate back to the original co-ordinate system
glTranslatef(-center_pos[0], -center_pos[1], 0);
glPopMatrix();
const Area& b = bounding();
glColor3f(0.6, 0.6, 0.6);
drawRectangle(b.start, b.end, true);
// draw all the ship's bullets
for (AmmoClip::const_iterator it = ammo_.begin();
it != ammo_.end(); ++it) {
it->draw();
}
}
static void clipTriangle(double x1,double y1,double z1,double u1,double v1,double w1, double x2,double y2,double z2,double u2,double v2,double w2, double x3,double y3,double z3,double u3,double v3, double w3) {
//http://www.cubic.org/docs/3dclip.htm
double
s12 = w1/(w1-w2),
s13 = w1/(w1-w3),
x01 = x1 + s12 * (x2 - x1),
y01 = y1 + s12 * (y2 - y1),
z01 = z1 + s12 * (z2 - z1),
u01 = u1 + s12 * (u2 - u1),
v01 = v1 + s12 * (v2 - v1),
x02 = x1 + s13 * (x3 - x1),
y02 = y1 + s13 * (y3 - y1),
z02 = z1 + s13 * (z3 - z1),
u02 = u1 + s13 * (u3 - u1),
v02 = v1 + s13 * (v3 - v1);
drawTriangle(
x1,y1,z1,u1,v1,
x01,y01,z01,u01,v01,
x02,y02,z02,u02,v02,1);
}
void draw()
{
static float counter = 0.0;
counter +=.01;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2, 2, -2, 2, 1, -1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
for (int i=0; i<draw_count; ++i) {
float t =(float)i/draw_count;
glPushMatrix();
glTranslatef(t*sin(counter), 0, 0);
glRotatef(360*t*counter, 0, 0, 1);
glScalef(1-t,1-t, 1-t);
drawTriangle();
glPopMatrix();
}
}
void ODEDrawer::DrawTriMeshes()
{
setColor(0.5,0.5,0.4,0.51);
for (ODETriMesh *b : m_domain->getTriMeshes())
{
glPushMatrix();
setTransform (b->getGeomPosition(),b->getGeomRotation());
int numi = b->numi;
for (int i=0; i<numi/3; i++)
{
int i0 = b->world_indices[i*3+0];
int i1 = b->world_indices[i*3+1];
int i2 = b->world_indices[i*3+2];
double *v0 = (b->world_vertices+i0*3);
double *v1 = (b->world_vertices+i1*3);
double *v2 = (b->world_vertices+i2*3);
drawTriangle(v0, v1, v2, false);
}
glPopMatrix();
}
}
