opengl课程设计代码

『壹』 计算机课程设计《利用opengl实现 会动的自行车》

啊等等等等等等等等等

『贰』 高分求计算机图形学OpenGL现有的代码

我也不是很懂，你验收一下（有两个参考资料）
CS 535
WEILER-ATHERTON
PROBLEM
Implement Weiler-Atherton. You should draw each polygon in a different color and fill the clip areas generated with a third color.
NOTES:
The Weiler-Atherton algorithm is the most general of the clipping algorithms. We have two 2D polygons (may be convex or concave and they both may have holes). The polygon to be clipped is called the SUBJECT polygon and the polygon defining the clipping area is called the CLIP polygon. To make the algorithm work easier (in the data structures, etc.) we usually assume that the exterior vertices are given clockwise and the hole vertices are given counterclockwise. In clipping we usually want to find the parts of the subject polygon that are inside the clip polygon. However, this algorithm can be used in modeling to find the "union", "intersection", and "difference" of the polygons.
The data structures are several circular linked lists of vertices which are also linked together and the clipping is done by traversing these. The lists could be doubly linked. This enables the traversal in either direction at any node in the list. Starting at a particular node and traversing in one direction will proce the interior polygon(s) while starting at a different node and traversing can proce the outside. Note that procing the exterior does need the doubly linking and care must be taken in performing the traversal.

STEP 1:
The first phase of the building of the data structures occurs when we input the edges and put them in two linked lists - the SUBJ list and the CLIP list. The vertices are place in order from input (thus clockwise). There are separate lists for the exterior and for each hole. Thus, the initial build is a standard queue insert (input a vertex - insert it at end of list). Note that this creates a list in which a standard list traversal is equivalent to "walking around" the polygon edge visiting the vertices in order.
STEP 2:
The second phase of the list building is computing and inserting the INTERSECTION points. If we have a SUBJECT polygon edge (SVi to SVi+1) that intersects a CLIP polygon edge (CVj to CVj+1) at a point INTER. Note that the edges form straight lines that may intersect, we are assuming that the line segments SVi to SVi+1 intersects the line segment CVj to CVj+1. The intersection point INTER is then inserted on BOTH of the linked lists - SUBJ and CLIP. It is inserted BETWEEN SVi and SVi+1 on the SUBJ list and CVj and CVj+1 on the CLIP list. The idea is still that traversing the list using a standard list traversal we would encounter the points in their geometric order. Note that there may be several intersection points between any given pair of vertices and they must be inserted in the correct order in the lists. This is done by using the t and u values computed in the vector line intersection subprogram. Each intersection point thus has TWO nodes - one on each list (SUBJ and CLIP). We link these two entries together which provides a way of getting from one list to the other.
STEP 2.5:
Any straight line divides the plane into two half-planes. Thus each polygon edge (extended to a line) will divide the plane into two half-planes. Because we listed the vertices clockwise, we consider the half-plane to the right as containing the interior of the polygon. Thus the right half-plane is called the interior half-plane. If we consider ourselves as "walking along" a polygon edge, then we can categorize each of the INTERSECTION points as "entering" or "exiting". This is usually done from the SUBJ polygon's point of view. Thus, as we walk along the SUBJ polygon edge SVi to SVi+1 and we encounter intersection point INTER, we can ask the question - am I "entering" the CLIP polygon or am I "exiting" the CLIP polygon? The second part of computing the intersection point is to classify them as "entering" or "exiting". We create one or two lists - one for entering intersections and one for exiting intersections.
STEP3:
Once the lists are built the basic idea to do the clipping is as follows
Pick an entry from the ENTERING list - it will be an intersection point (and delete it)
Locate that point on the SUBJ list
Traverse the current (SUBJ) list until you find the next intersection point - it should be an exiting or entering point. Output each vertex encountered to some data structure, say POLY
Follow the link from the current (SUBJ) list to the other (CLIP) list and
Continue the traversal until you find the next intersection (Note: delete each entering intersection from the ENTERING list - not the linked lists. By deleting it we will get the distinct intersecting polygons and not plicate a polygon multiple times).
Terminate the traversal when you get to an intersection that is the SAME as the initial one that you removed from the ENTERING list. At this point POLY will have one of the clip regions and can be output.
REPEAT the construction and output of POLY until the ENTERING list is empty.
Remark: For the exterior, try starting with an EXITING point. Start the traversal on the SUBJ list (same direction as the Interior). At what point do you need to use the double link and to traverse in the opposite direction? (Hint: look at the CLIP polygon list).
IMPLEMENTATION:
In the below data structures we place all of the vertices and intersection points in a 1D array and use the subscript instead of the actual coordinates.
const int MAXVERT = 500;
const int MAXPOLYV = 50;
const int MAXH = 10;

struct Point2D
{float x,y;
};
typedef Point2D Vertices[MAXVERT];

enum VerType = {Polygon, Intersection};

typedef struct ClipListRec * ClipPtr;
struct ClipListRec
{ int Vindex;
ClipPtr next;
VerType Kind;
float t;
ClipPtr otherList;
}

struct Polygon
{ int nVertex;
int vert[MAXPOLYV];
ClipPtr list;
}
struct GenPolygon
{ Polygon exterior;
int numHoles;
Polygon Holes[MAXH];
}

GenPolygon Sub,Clip;
int entering[MAXVERT],exiting[MAXVERT];
Vertices V;
int numVertex = 0; // size of the array of verticies
int clipPoly[MAXVERT]; // a clip polygon

int readPoint();
{ cin >> inX; cin >> inY;
if (numVertex < MAXVERT)
{ V[numVertex].x = inX;
V[numVertex].y = inY;
idNo = numVertex;
numVertex++;
}
else
idNo = -1;
return idNo;
}

void readPolygon (GenPolygon p)
{ cin >> p.exterior.nVertex;
for (i = 0; i < p.exterior.nVertex; i++)
{ newId = readPoint();
if (newId < 0)
error
else
{ insertAtRear (p.exterior.list,newId);
p.exterior.vert[i] = newId;
}
}
// now do the holes basically the same way
. . .
}
// the "main" program loop would then be (pseudocode)
while (!(entering))
{ nextInter = delete (entering);
SEARCH (SubjectPolygon,nextInter,ptr1);
AddToOutputList (ptr1->. . .)
StartPoint = ptr1->. . .
ptr1 = prt1->next;
while (ptr1->. . . != StartPoint)
{ AddToOutputList (ptr1->. . .);
if (ptr1-> . . == INTERSECTION)
ptr1 = prt1->otherList->next;
else
ptr1 = ptr1->next;
}
FixListForOutput();
DrawPolygon();
EmptyOutputList();
}
参考资料：http://cs1.bradley.e/public/jcm/weileratherton.html
http://tianminghui0210.blog.163.com/blog/static/471909200751041116174/

『叁』 opengl游戏程序设计 中文版

我推荐几本
初学的2D
《Visual C++游戏编程基础》
《Visual C++经典游戏程序设计》
一般现在都可以版直接学3D，学权好3D，2D就不在话下了
《nehe教程》这个是只有电子书，很好的OPENGL教程，让你对3D图形更感兴趣呵呵
《OPENGL游戏编程》，作者徐明亮，感觉算国内比较好的书了
《3D游戏编程大师技巧》，这书跟《Windows游戏编程大师技巧》有点联系，不过不多，反正也是看思想，代码也不要看了。
还有好多书可以去电驴上载。。。太多了，游戏中的每一个部分都可以单独写成一本书。。以后还要更细化的。。祝你成功，为中国游戏做贡献。

『肆』 OPENGL设计小车源代码

别急，哥给你做了...待会给你..

『伍』 关于计算机图形学（OpenGL版）里的代码

登陆 http://www.xmission.com/~nate/glut.html下载glut-3.7.6-bin.zip，然后安源装。。。具体安装方法：.h文件放到VC的安装目录...\VC98\Include\GL下。。。.lib和.dll文件放到系统盘：\windows\system32下。。。

『陆』 OpenGL如何实现B样条曲线和曲面的绘制（C语言）

你说的是计算机图形学的课程设计吧，我有C编写的代码，可以运行，是画B样条曲线和曲面的，我发到你邮箱里了，你参考一下吧。

『柒』 求OpenGL编程指南第四版源代码!

OpenGL贴吧里的资源里就有，直接进入贴吧，找置顶资源，分分钟搞定

『捌』 急！求一个OpenGL编写的源代码，简单的，最好是原创小作品。希望好心人帮帮忙~

//Win32 Console Application

#include <gl/glut.h>
#include <math.h>
const int n = 60;
const GLfloat R = 0.2f;
const GLfloat Pi = 3.1415926536f;
void myDisplay(void)
{
int i;
glClear(GL_COLOR_BUFFER_BIT);

//点
glPointSize(2.0);
glBegin(GL_POINTS);
glVertex2f(0.0f, 0.0f);
glEnd();
//由闭合折线组成的圆
glBegin(GL_LINE_LOOP);
glColor3f(1.0,1.0,0.0);
for(i=0; i<n; ++i)
glVertex2f(R*cos(2*Pi/n*i), R*sin(2*Pi/n*i));
glEnd();
//由不闭合折线组成的两个三角形构成的六星阵图
glBegin(GL_LINE_STRIP);
glColor3f(1.0,0.0,0.0);
glVertex2f(0.0,0.2);
glVertex2f(0.1732,-0.1);
glVertex2f(-0.1732,-0.1);
glVertex2f(0.0,0.2);
glEnd();
glBegin(GL_LINE_STRIP);
glVertex2f(0.0,-0.2);
glVertex2f(0.1732,0.1);
glVertex2f(-0.1732,0.1);
glVertex2f(0.0,-0.2);
glEnd();
//连续三角形组成的扇形
glBegin(GL_TRIANGLE_FAN);
glVertex2f(0.5,0.5);
glVertex2f(0.5,1.0);
glColor3f(0.8,0.2,0.5);
glVertex2f(0.8,0.9);
glColor3f(0.2,0.5,0.8);
glVertex2f(0.9,0.8);
glColor3f(0.8,0.5,0.2);
glVertex2f(1.0,0.5);
glEnd();
//虚线
glLineWidth(3.0);
glEnable(GL_LINE_STIPPLE);
glLineStipple(2, 0x0F0F);
glBegin(GL_LINES);
glColor3f(0.0,0.0,1.0);
glVertex2f(-0.5f, 1.0f);
glColor3f(1.0,1.0,1.0);
glVertex2f(-0.5f,-1.0f);
glEnd();
//线
glLineWidth(0.5);
glDisable(GL_LINE_STIPPLE);
glBegin(GL_LINES);
glColor3f(1.0,0.0,0.0);
glVertex2f(0.5f, 1.0f);
glColor3f(1.0,1.0,1.0);
glVertex2f(1.0f, 0.5f);
glEnd();
glFlush();
}

int main(int argc, char *argv[])
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);
glutInitWindowPosition(0, 0);
glutInitWindowSize(600, 600);
glutCreateWindow("第一个OpenGL程序");
glutDisplayFunc(&myDisplay);
glutMainLoop();
return 0;
}

『玖』 急求opengl程序代码

#include<windows.h>
#include<stdlib.h>
#include<stdio.h>
#include<GL/glut.h>
#include<math.h>

void drawline(float x1,float y1,float x2,float y2) //The function to draw a line from point(x1,y1) to point (x2,y2)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.0, 0.0, 0.0);
glBegin(GL_LINES);
glVertex2f(x1,y1);
glVertex2f(x2,y2);
}

void _display(void)
{
#define pi 3.1415926
GLfloat theta,r=18;
GLint n=16;
theta=2*pi/n;
GLfloat vertex_list[16][2];
for(int i=0;i<n;i++) //Find the vertex
{
vertex_list[i][0]=25+r*cos(i*theta);
vertex_list[i][1]=25+r*sin(i*theta);

}
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.0, 0.0, 0.0);
glBegin(GL_LINE_LOOP);
for(int j=0;j<n;j++)
{

for(int k=j;k<n;k++)
{
drawline(vertex_list[j][0],vertex_list[j][1],vertex_list[k][0],vertex_list[k][1]);

}
}

glEnd();
glFlush ();
}

void _init (void)
{
glClearColor (1.0, 1.0, 1.0, 0.0);
glColor3f(1.0, 0.0, 0.0) ;

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 50.0, 0.0, 50.0);
glMatrixMode(GL_MODELVIEW);
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (100, 0);
glutCreateWindow ("hello");
_init ();
glutDisplayFunc(_display);
glutMainLoop();

return 0;
}

一个正十六边形 各点相连的图形
我自己写的 你看看行不行

『拾』 计算机图形学(openGL)代码

直接用winAPI写的可以，用glut等写的就不行，得安装其类库。 追问： 就是想知道怎么安装的........ - - 回答： 你用的是glut库吗？或者 程序编译 报什么错误啊 追问： 用dec C ，就是不知道glut 库函数 在哪有下，下载完了放在哪个目录.... 回答： http://www.opengl.org/resources/libraries/glut/glutdlls37beta.zip 这个是官网最新版本，下好之后 将压缩包内的.h文件放到...\Microsoft Visual Studio 10\VC\PlatformSDK\Include\gl目录下 将. lib文件 放到...\Microsoft Visual Studio 10\VC\PlatformSDK\Lib目录下 将. dll文件 放到C:\windows\system32目录下