Напишите программу вывода графика функции y= tg (x)+5*cos (x), с помощью точек, а затем с помощью линий.

С помощью точек

Решение:

#include <windows.h>

#include <gl\gl.h>

#include <gl\glu.h>

#include <gl\glaux.h>

#include <math.h>

GLint windW, windH;

void CALLBACK Reshape(int width, int height)

{ glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(-15,15,-15,15);

glMatrixMode(GL_MODELVIEW);

}

void CALLBACK Draw(void)

{

glClearColor(1.0,1.0,1.0,1);

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_LINES);

glColor3ub(190,190,190);

for (int i=-4; i<=4; i++)

{

glVertex2f(float(i), -6);//явное преобразование типа

glVertex2f(float(i), 15);

}

for (i=-6; i<=15; i++)

{

glVertex2f(-4, float(i));

glVertex2f(4, float(i));

}

glEnd();

glColor3ub(0,0,0);

glBegin(GL_LINES);

glVertex2f (-5, 0);

glVertex2f(5, 0);

glVertex2f(0,16);

glVertex2f(0,-7);

glEnd();

glPointSize(2);

glBegin(GL_POINTS);

glColor3ub(0,0,255);

int n;

double a,b,dx,x,y;

a=-1.415;

b=1.5;

n=20;

dx=(b-a)/(n-1);

x=a;

y=0;

for (i=1; i<=n; i++)

{

y=float(tan(x)+5*cos(x));

glVertex2d (x, y);

x=x+dx;

}

glEnd();

glFinish();

auxSwapBuffers();

}

void main(int argc, char **argv)

{

windW = 800;

windH = 800;

auxInitPosition(100, 100, windW, windH);

auxInitDisplayMode(AUX_RGB | AUX_DOUBLE);

auxInitWindow("v11_01_1");

glTranslated(0,-4,0);

auxReshapeFunc(Reshape);

auxMainLoop(Draw);

}

Результат:

с помощью линий

Решение:

#include <windows.h>

#include <gl\gl.h>

#include <gl\glu.h>

#include <gl\glaux.h>

#include <math.h>

GLint windW, windH;

void CALLBACK Reshape(int width, int height)

{ glViewport(0, 0, width, height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(-15,15,-15,15);

glMatrixMode(GL_MODELVIEW);

}

void CALLBACK Draw(void)

{

glClearColor(1.0,1.0,1.0,1);

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_LINES);

glColor3ub(190,190,190);

for (int i=-4; i<=4; i++)

{

glVertex2f(float(i), -6);//явное преобразование типа

glVertex2f(float(i), 15);

}

for (i=-6; i<=15; i++)

{

glVertex2f(-4, float(i));

glVertex2f(4, float(i));

}

glEnd();

glColor3ub(0,0,0);

glBegin(GL_LINES);

glVertex2f (-5, 0);

glVertex2f(5, 0);

glVertex2f(0,16);

glVertex2f(0,-7);

glEnd();

glBegin(GL_LINE_STRIP);

glColor3ub(0,0,255);

int n;

double a,b,dx,x,y;

a=-1.415;

b=1.5;

n=100;

dx=(b-a)/(n-1);

x=a;

y=0;

for (i=1; i<=n; i++)

{

y=float(tan(x)+5*cos(x));

glVertex2d (x, y);

x=x+dx;

}

glEnd();

glFinish();

auxSwapBuffers();

}

void main(int argc, char **argv)

{

windW = 800;

windH = 800;

auxInitPosition(100, 100, windW, windH);

auxInitDisplayMode(AUX_RGB | AUX_DOUBLE);

auxInitWindow("v11_01_1");

glTranslated(0,-4,0);

auxReshapeFunc(Reshape);

auxMainLoop(Draw);

}

Результат:

Нарисуйте каркас призмы, в основании которой лежит правильный 14-угольник

Решение:

//v11_02

#include <windows.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glaux.h>

#include <math.h>

void CALLBACK resize (int width, int height)

{

glViewport (0,0,width, height);

glMatrixMode (GL_PROJECTION);

glLoadIdentity();

glOrtho(-15,15,-10,10, -10,20);

gluLookAt(1,-1,1, 0,0,0, 0,0,1);

glMatrixMode(GL_MODELVIEW);

}

void CALLBACK display (void)

{

GLUquadricObj *quadObj;

quadObj = gluNewQuadric();

glClearColor(1.0,1.0,1.0,1);

glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glColor3d(0,0,1);

// каркас

gluQuadricDrawStyle(quadObj, GLU_SILHOUETTE);

//призма в основании которой лежит правильный 14-угольник

gluCylinder(quadObj, 2, 2, 5, 14, 14);

glBegin(GL_LINES);

glColor3ub(0, 0, 0);

glVertex2f(6, 0);

glVertex2f(-6, 0);

glVertex2f(0, 6);

glVertex2f(0, -6);

glVertex3f(0, 0, 0);

glVertex3f(0, 0, 8);

for (int i=-5; i<=5; i++)

{

if (i!=0)

{

glColor3ub(190,190,190);

glVertex2f(float(i), -5);

glVertex2f(float(i), 5);

}

}

for (i=-5; i<=5; i++)

{

if (i!=0)

{

glColor3ub(190,190,190);

glVertex2f(-5, float(i));

glVertex2f(5, float(i));

}

}

glEnd();

glFinish();

auxSwapBuffers();

}

void main ()

{

auxInitPosition (100,100,800,600);

auxInitDisplayMode (AUX_RGB | AUX_DEPTH | AUX_DOUBLE);

auxInitWindow ("v11_02");

glScaled(1.5, 1.5, 1.5);

glTranslated(0,0,-1);

auxIdleFunc (display);

auxReshapeFunc(resize);

glEnable (GL_DEPTH_TEST);

auxMainLoop(display);

}

Результат:

Напишите программу вывода графика функции x=2*sin(z)*cos(y)-3*tg(y) используя алгоритм плавающего горизонта. Модифицируйте программу таким образом, чтобы поверхность состояла из четырехугольников

Решение:

#include <windows.h>

#include <gl\gl.h>

#include <gl\glu.h>

#include <gl\glaux.h>

#include <math.h>

// запретить вывод предупреждений о преобразовании данных

#pragma warning(disable: 4305) // MIPS

#pragma warning(disable: 4244) // MIPS

GLint windW, windH;

void CALLBACK Reshape(int width, int height)

{

windW = (GLint)width;

windH = (GLint)height;

}

int alpha=0, beta=0;

void CALLBACK Key_LEFT(void)

{

alpha -= 5;

}

void CALLBACK Key_RIGHT(void)

{

alpha += 5;

}

void CALLBACK Key_UP(void)

{

beta += 5;

}

void CALLBACK Key_DOWN(void)

{

beta -= 5;

}

void CALLBACK InitViewport(int x, int y, int width, int height)

{

glViewport(x, y, width, height);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glOrtho(-windW,windW, -windH,windH, windH/1000,windH*1000);

gluLookAt(0,0,windH, 0,0,0, 1,0,0);

glMatrixMode(GL_MODELVIEW);

}

void CALLBACK Draw(void)

{

float x,y,z;

float d=10;

InitViewport(0,0, windW, windH);

glColor3d(0,1,0);

glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

for (y=-windH/1.3; y<=windH/1.3; y+=10)

{glBegin(GL_QUADS);

for (z=-windW/1.3; z<=windW/1.3; z+=10)

{

x=2*sin(z)*cos(y)-3*tan(y);

glVertex3f(x,y,z);

glVertex3f(x,y+d,z);

x=2*sin(z+d)*cos(y+d)-3*tan(y+d);

glVertex3f(x,y+d,z+d);

glVertex3f(x,y,z+d);

}

glEnd();

}

glFinish();

}

void CALLBACK Turn(void)

{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glPushMatrix();

glRotated(alpha, 0,1,0);

glRotated(beta, -1,0,0);

Draw();

glPopMatrix();

auxSwapBuffers();

glFinish();

}

void main(int argc, char **argv)

{

windW = 800;

windH = 600;

auxInitPosition(0, 0, windW, windH);

auxInitDisplayMode(AUX_RGB | AUX_DEPTH | AUX_DOUBLE);

if(auxInitWindow("v11_03") == GL_FALSE) {

auxQuit();

}

auxExposeFunc((AUXEXPOSEPROC)Reshape);

auxReshapeFunc((AUXRESHAPEPROC)Reshape);

auxIdleFunc(Turn);

auxKeyFunc(AUX_LEFT, Key_LEFT);

auxKeyFunc(AUX_RIGHT, Key_RIGHT);

auxKeyFunc(AUX_UP, Key_UP);

auxKeyFunc(AUX_DOWN, Key_DOWN);

auxMainLoop(Turn);

}

Результат:

Напишите программу вывода вращающего тора относительно своей оси x, с одновременным движением по следующей траектории z=sin(y)

Решение:

//v11_04

#include <windows.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glaux.h>

#include <math.h>

int flag=1;

void CALLBACK resize (int width, int height)

{

glViewport (0,0,width, height);

glMatrixMode (GL_PROJECTION);

glLoadIdentity();

glOrtho(-15,15,-10,10, -10,20);

gluLookAt(1,-1,1, 0,0,0, 0,0,1);

glMatrixMode(GL_MODELVIEW);

}

void CALLBACK display (void)

{

glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glColor3d(0,1,0);

float pos[4]={0,7.5,7.5,1};

static double time=0;

float y,z;

y=0;

glEnable(GL_LIGHTING);

glEnable(GL_LIGHT0);

glLightfv(GL_LIGHT0, GL_POSITION, pos);

glPushMatrix();

y=float(time/100);

z=float(sin(y)); // float(); преобразование типа

//движением по следующей траектории z=sin(y)

glTranslated(0,y,z);

//вращающего тора относительно оси x

glRotated(time,1,0,0);

if (y>11 && flag==1)

{

flag=2;

}

if (y<-4 && flag==2)

{

flag=1;

}

if (flag==2)

{

time--;

}

else

{

time++;

}

auxSolidTorus(0.15, 0.5);

glPopMatrix();

// система координат XYZ

glBegin(GL_LINES);

glColor3ub(255, 0, 0);

glVertex3f(5, 0, 0);

glVertex3f(-5, 0, 0);

// х красный

glColor3ub(0, 255, 0);

glVertex3f(0, 11, 0);

glVertex3f(0, -4, 0);

// y зеленый

glColor3ub(0, 0, 255);

glVertex3f(0, 0, 0);

glVertex3f(0, 0, 5);

// z синий

glEnd();

glFinish();

auxSwapBuffers();

}

void main ()

{

auxInitPosition (100,100,800,600);

auxInitDisplayMode (AUX_RGB | AUX_DEPTH | AUX_DOUBLE);

auxInitWindow ("v11_04");

glScaled(1.5, 1.5, 1.5);

glTranslated(0,-3,0);

auxIdleFunc (display);

auxReshapeFunc(resize);

glEnable (GL_DEPTH_TEST);

glEnable (GL_COLOR_MATERIAL);

auxMainLoop(display);

}

Результат:

Напишите программу мерцающего звездного неба

Решение:

#include <windows.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glaux.h>

#include<time.h>

#include <stdio.h>

#include <iostream.h>

#include <conio.h>

#include <math.h>

int t_sec() // считывание секунд с системных часов

{

struct tm *newtime;

time_t aclock;

time(&aclock);

newtime = localtime(&aclock);

asctime(newtime);

int s=newtime->tm_sec;

return s;

}

void CALLBACK resize (int width, int height)

{

glViewport (0,0,width, height);

glMatrixMode (GL_PROJECTION);

glLoadIdentity();

gluOrtho2D(-100,100,-100,100);

glMatrixMode(GL_MODELVIEW);

}

void CALLBACK Draw (void)

{

glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

int c, x, y, p;

srand(t_sec());

//задание стартовой точки

//для генерации случайных чисел

for(int i=0; i<1000; i++)

{

c=rand()%255; //генерация случайных чисел от 0 до 255

x=rand()%200; //генерация случайных чисел от 0 до 200

y=rand()%200; //генерация случайных чисел от 0 до 200

p=rand()%3;

glPointSize(p);

glBegin(GL_POINTS);

glColor3ub(c,c,c);

glVertex2d(x,y);

glEnd();

}

auxSwapBuffers();

}

void main ()

{

auxInitPosition (100,100,800,800);

auxInitDisplayMode (AUX_RGB | AUX_DEPTH | AUX_DOUBLE);

auxInitWindow ("v11_06");

glTranslated(-100,-100,0);

auxIdleFunc (Draw);

auxReshapeFunc (resize);

glEnable (GL_DEPTH_TEST);

glEnable (GL_COLOR_MATERIAL);

auxMainLoop(Draw);

}

Результат:

Изобразите радугу состоящую из полигонов, которая освещается прожектором. Направление света прожектора постоянно меняется и скользит вдоль радуги

Решение:

#include <windows.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glaux.h>

#include<time.h>

#include <stdio.h>

#include <iostream.h>

#include <conio.h>

#include <math.h>

int flag=1;

void CALLBACK resize (int width, int height)

{

glViewport (0,0,width, height);

glMatrixMode (GL_PROJECTION);

glLoadIdentity();

//glOrtho(-20,20,-15,15, -10,25);

glOrtho(-6,6,-6,6, -20,20);

gluLookAt(1,-1,1, 0,0,0, 0,0,1);

//gluLookAt(0,-5,0, 0,0,0, 0,0,1);

glMatrixMode(GL_MODELVIEW);

}

void CALLBACK Draw (void)

{

static double time=0;

GLUquadricObj *quadObj;

quadObj = gluNewQuadric();

glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glPushMatrix();

float x=time/100-2.2;

float z=pow((pow(2.4,2)-pow(x,2)),0.5);

if (x>2.2 && flag==1)

{

flag=2;

}

if (x<-2.2 && flag==2)

{

flag=1;

}

if (flag==2)

{

time--;

}

else

{

time++;

}

float dir[3]={x,0.1,z};

float pos[4]={0,-1,0,1};

// включение нулевой лампы

GLfloat light_diffuse[]={3.0,3.0,3.0,1.0};

glLightfv(GL_LIGHT0,GL_DIFFUSE, light_diffuse);

glLightfv(GL_LIGHT0, GL_POSITION, pos);

glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, dir);

glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 90);

glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 9);

glEnable(GL_LIGHTING);

glEnable (GL_LIGHT0);

glEnable (GL_DEPTH_TEST);

glPopMatrix();

glPushMatrix();

glRotated(90,1,0,0);

gluQuadricDrawStyle(quadObj, GLU_FILL);

// К

glColor3ub(255, 0, 0);

gluPartialDisk(quadObj, 2, 2.2, 30, 30, -90, 180);

// О

glColor3ub(255, 125, 0);

gluPartialDisk(quadObj, 2.2, 2.4, 30, 30, -90, 180);

// Ж

glColor3ub(255, 255, 0);

gluPartialDisk(quadObj, 2.4, 2.6, 30, 30, -90, 180);

// З

glColor3ub(0, 255, 0);

gluPartialDisk(quadObj, 2.6, 2.8, 30, 30, -90, 180);

// Г

glColor3ub(0, 255, 255);

gluPartialDisk(quadObj, 2.8, 3, 30, 30, -90, 180);

// С

glColor3ub(0, 0, 255);

gluPartialDisk(quadObj, 3, 3.2, 30, 30, -90, 180);

// Ф

glColor3ub(255, 0, 255);

gluPartialDisk(quadObj, 3.2, 3.4, 30, 30, -90, 180);

glPopMatrix();

glDisable(GL_LIGHTING);

auxSwapBuffers();

}

void main ()

{

auxInitPosition (100,100,800,800);

auxInitDisplayMode (AUX_RGB | AUX_DEPTH | AUX_DOUBLE);

auxInitWindow ("v11_06");

glTranslated(3,-3,2);

glEnable (GL_COLOR_MATERIAL); // установка свойств материала

auxIdleFunc (Draw);

auxReshapeFunc (resize);

auxMainLoop(Draw);

}

Результат:

Напишите программу вывода цилиндра, на котором наложена текстура. Создайте эффект сползания текстуры с цилиндра. Вокруг цилиндра вращается несколько полупрозрачных небольших сфер по спирали

Решение

#include <windows.h>

#include <GL/gl.h>

#include <GL/glu.h>

#include <GL/glaux.h>

#include<time.h>

#include <stdio.h>

#include <iostream.h>

#include <conio.h>

#include <math.h>

int flag0=1;

int flag1=1;

int flag2=1;

int flag3=1;

unsigned int image1_ID;

AUX_RGBImageRec* image1;

void CALLBACK resize (int width, int height)

{

glViewport (0,0,width, height);

glMatrixMode (GL_PROJECTION);

glLoadIdentity();

glOrtho(-6,6,-6,6, -20,20);

gluLookAt(1,-1,1, 0,0,0, 0,0,1);

glMatrixMode(GL_MODELVIEW);

}

void CALLBACK Draw (void)

{

static double time0=0;

static double time1=0;

static double time2=0;

static double time3=0;

GLUquadricObj *quadObj;

glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glColor3d(1,1,1);

float pos[4]={3,-3,5,1};

glLightfv(GL_LIGHT0, GL_POSITION, pos);

glEnable(GL_LIGHTING);

glEnable (GL_LIGHT0);

glEnable (GL_DEPTH_TEST);

quadObj = gluNewQuadric();

float s=0.9-(time0/800);

if (s<0.01 && flag0==1)

{flag0=2;}

if (s>0.9 && flag0==2)

{flag0=1;}

if (flag0==1)

{time0++;}

else

{time0--;}

const float p[4]={0,0,s,0};

glPushMatrix();

glEnable(GL_TEXTURE_2D);

glEnable(GL_TEXTURE_GEN_S);

glEnable(GL_TEXTURE_GEN_T);

glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);

glTexGenfv(GL_T,GL_OBJECT_PLANE,p);

glRotated(-180,1,0,0);

glTranslated(0,0,-3);

glColor3d(1,1,0);

gluCylinder(quadObj, 1, 1, 3, 50, 50);

glDisable(GL_TEXTURE_GEN_S);

glDisable(GL_TEXTURE_2D);

glPopMatrix();

glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

glPushMatrix();

glEnable(GL_ALPHA_TEST);

glEnable(GL_BLEND);

double z1=time1/300;

glRotated(time1,0,0,1);

glTranslated(1.3,0,1);

glTranslated(0,0,z1);

if (z1>2 && flag1==1)

{flag1=2;}

if (z1<-1 && flag1==2)

{flag1=1;}

glColor4d(0,1,0, 0.1);

auxSolidSphere(0.2); //s1

glDisable(GL_BLEND);

glDisable(GL_ALPHA_TEST);

if (flag1==1)

{time1++;}

else

{time1--;}

glPopMatrix();

glPushMatrix();

glEnable(GL_ALPHA_TEST);

glEnable(GL_BLEND);

double z2=time2/600;

glRotated(time2*2,0,0,15);

glTranslated(1.8,0,1);

glTranslated(0,0,z2);

if (z2>2 && flag2==1)

{flag2=2;}

if (z2<-1 && flag2==2)

{flag2=1;}

glColor4d(1,0,0, 0.1);

auxSolidSphere(0.2); //s2

glDisable(GL_BLEND);

glDisable(GL_ALPHA_TEST);

if (flag2==1)

{time2++;}

else

{time2--;}

glPopMatrix();

glPushMatrix();

glEnable(GL_ALPHA_TEST);

glEnable(GL_BLEND);

double z3=time3/400;

glRotated(time3*3,0,0,1);

glTranslated(2.3,0,1);

glTranslated(0,0,z3);

if (z3>2 && flag3==1)

{flag3=2;}

if (z3<-1 && flag3==2)

{flag3=1;}

glColor4d(0,0,1, 0.2);

auxSolidSphere(0.2); //s3

glDisable(GL_BLEND);

glDisable(GL_ALPHA_TEST);

if (flag3==1)

{time3++;}

else

{time3--;}

glPopMatrix();

gluDeleteQuadric(quadObj);

auxSwapBuffers();

}

void main ()

{

auxInitPosition (100,100,800,800);

auxInitDisplayMode (AUX_RGB | AUX_DEPTH | AUX_DOUBLE);

auxInitWindow ("v11_07");

glTranslated(0,0,-1);

glEnable (GL_COLOR_MATERIAL); // установка свойств материала

image1 = auxDIBImageLoad("v11_07.bmp");

glGenTextures(1, &image1_ID);

glBindTexture(GL_TEXTURE_2D, image1_ID);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

glTexImage2D(GL_TEXTURE_2D, 0, 3,

image1->sizeX,

image1->sizeY,

0, GL_RGB, GL_UNSIGNED_BYTE,

image1->data);

auxIdleFunc (Draw);

auxReshapeFunc (resize);

auxMainLoop(Draw);

}

Результат: