dfdsf

#include<iostream>
#include<cmath>
#include <cstdlib>
#include <glut.h>

using namespace std;


void Draw() {
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(0.3, 1.0, 0.3);
    int wybor;

    cout<<"Wybierz opcje"<<endl;
    cout<<"1. rysowanie kwadratu"<<endl;
    cout<<"2. rysowanie trojkata"<<endl;
    cout<<"3. rysowanie wstegi"<<endl;
    cout<<"4. rysowanie wachlarza (trojkaty)"<<endl;
    cout<<"5. rysowanie punktu o podanej wielkosci"<<endl;
    cout<<"6. rysowanie linii o podanej grubosc i wzorze"<<endl;
    cout<<"7. rysowanie wachlarza (kolo)"<<endl;

    cin>>wybor;

    switch(wybor)
    {
    case 1://czworokąt
        {
            double x1, y1, x2, y2, x3, y3, x4, y4;
            x1=-0.2;
            y1=-0.2;
            x2=0.2;
            y2=-0.2;
            x3=0.2;
            y3=0.2;
            x4=-0.2;
            y4=0.2;
            //cin>>x1>>y1;
            //cin>>x2>>y2;
            //cin>>x3>>y3;
            //cin>>x4>>y4;

            glBegin(GL_POLYGON);
            glVertex2d(x1,y1);
            glVertex2d(x2,y2);
            glVertex2d(x3,y3);
            glVertex2d(x4,y4);
            glEnd();
            break;

        }
    case 2://trójkąt
        {
            double x1, x2, x3, y1, y2, y3;
            x1=0;
            y1=0;
            x2=0;
            y2=0.2;
            x3=0.3;
            y3=0;
            //cin>>x1>>y1;
            //cin>>x2>>y2;
            //cin>>x3>>y3;
            glBegin(GL_TRIANGLES);
                glVertex2d(x1, y1);
                glVertex2d(x2, y2);
                glVertex2d(x3, y3);
            glEnd();
            break;
        }
    case 3://wstęga trójtątów
        {
            int ilosc;
            double delta=0.1;
            cout<<"Podaj ilosc trojkatow"<<endl;
            cin>>ilosc;
            double x1, x2, x3, y1, y2, y3;
            //cin>>x1>>y1;
            //


            x1=0;
            y1=0;
            x2=0;
            y2=0.3;
            x3=0.2;
            y3=0;

            glColor3f(0.1,0.1,0.1);
            glBegin(GL_TRIANGLE_STRIP);
                glVertex2d(x1, y1);
                glVertex2d(x2, y2);
                glVertex2d(x3, y3);
            glEnd();

            for(int i=0; i<ilosc; i++)
            {
                if(i%2==1)
                {

                    glColor3f(0.1+delta*i,0.1, 0.1);
                    glBegin(GL_TRIANGLE_STRIP);
                    glVertex2d(x2,y2);
                    glVertex2d(x2+delta,y2);
                    glVertex2d(x3,y3);
                    glEnd();
                    x2+=delta;

                }
                else
                {
                    glColor3f(0.1,0.1+delta*i, 0.1);
                    glBegin(GL_TRIANGLE_STRIP);
                    glVertex2d(x3,y3);
                    glVertex2d(x2,y2);
                    glVertex2d(x3+delta,y3);
                    glEnd();
                    x3+=delta;
                }
            }

            }
            break;
    case 4://wachlarz trójkątów
        {
            int ilosc;
            double delta=0.05;
            cout<<"Podaj ilosc trojkatow"<<endl;
            cin>>ilosc;
            double x, x2, x3, y, y2, y3;


            x=0;
            y=0;
            x2=0;
            y2=0.3;
            x3=0.2;
            y3=0;
            //cin>>x>>y;
            //cin>>x2>>y2;
            //cin>>x3>>y3;

            glColor3f(0.1,0.1,0.1);
            glBegin(GL_TRIANGLE_FAN);
                glVertex2d(x, y);
                glVertex2d(x2, y2);
                glVertex2d(x3, y3);
            glEnd();

            for(int i=0; i<ilosc-1; i++)
            {
            glColor3f(0.1+delta*i,0.1+delta*(i/2),0.3);
            glBegin(GL_TRIANGLE_FAN);
                glVertex2d(x, y);
                glVertex2d(x3, y3);
                glVertex2d(x3-delta, y3-delta);
            glEnd();
            x3-=delta;
            y3-=delta;
            }
            break;
        }
    case 5://punkty o różnej szerokości
    {
        double x,y;
        //cin>>x>>y;
        x=0;
        y=0;
        cout<<"Podaj wielkosc punktu"<<endl;
        float rozmiar;
        cin>>rozmiar;
        glPointSize(rozmiar);
        glBegin(GL_POINTS);
        glVertex2d(x,y);
        glEnd();
    }
    break;

    case 6://linie o róznej grubości i wzorze
        {

            double grubosc;
            cout<<"Podaj grubosc linii"<<endl;
            cin>>grubosc;
            glLineWidth(grubosc);
            double x1, x2, y1, y2;
            x1=-0.3;
            y1=-0.3;
            x2=0.3;
            y2=0.3;
            //cin>>x1>>y1;
            //cin>>x2>>y2;

            glBegin(GL_LINES);
                glVertex2d(x1, y1);
                glVertex2d(x2, y2);
            glEnd();

            glFlush();
            glEnable(GL_LINE_STIPPLE);
            double wzor, factor;
            cout<<"Podaj kod wzoru"<<endl;
            cin>>wzor;
            cout<<"Podaj factor"<<endl;
            cin>>factor;

            //glColor3f(0.7,0.2,0.1);
            //glLineStipple(1, 0x00FF);
            glColor3f(0.3, 0.2, 0.8);
            glLineStipple(factor, wzor);
            glBegin(GL_LINES);
                glVertex2d(x1, y1);
                glVertex2d(x2, y2);
            glEnd();
            glFlush();



        }
        break;
    case 7:
        {
            glColor3f(0,0,0);
            double delta = 0.01;
            double r; //promien
            r=0.5;
            double n;
            cout<<"Podaj ilosc trojkatow"<<endl;
            cin>>n;
            double angle;
            double PI = 22/7;
            double a,b;
            a=0;
            b=0;
            //cin>>a>>b;

            double pom_x, pom_y;
            pom_x=0;
            pom_y=0;

            double x, y; //wsp
    glBegin(GL_TRIANGLE_FAN);
        for(double i=0; i<=n; i++)
        {
            glColor3d(0+(i*delta),0+(i*delta/2),0+(i*delta/3));
            glVertex2d(a,b);
            glVertex2d(pom_x, pom_y);
            angle = 2*i*PI/n;
            x=r*cos(angle)*1.4;
            pom_x=x;
            y=r*sin(angle)*1.4;
            pom_y=y;

            glVertex2f(x, y);
        }
    glEnd();
        }
        break;
    }

    glFlush();
}
void Initialize() {
    glClearColor(0.3, 0.1, 0.1, 0.1);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
}

int main(int argc, char** argv) {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(500, 500);
    glutInitWindowPosition(200, 200);
    glutCreateWindow("środowisko");
    Initialize();
    glutDisplayFunc(Draw);
    glutMainLoop();
    return 0;
}