3. Отметить максимум и минимум функции на заданном отрезке[-2пи,2пи]

#include <windows.h>
#include <gl\GLU.h>
#include <gl\GL.h>
#include <time.h>
#include <math.h>
//#include "glut.h"
#include "glaux.h"
#include <string.h>
#include <sstream>
 
 
#pragma comment (lib,"opengl32.lib")
#pragma comment (lib,"glu32.lib")
#pragma comment (lib, "glaux.lib")
 
HWND    hWnd; // - дескриптор окна
HDC     hDC; //- контекст устройства
HGLRC   hRC; //- контекст рендеринга
 
typedef double (*pf)(double x);
 
int alpha = 0, beta = 0;
double ax = 0, ay = 0, az = 0;
double ex = 0, ey = 0, ez = 10;
double cx = 0, cy = 0, cz = 0;
 
bool  keys[256];                // Массив, используемый для операций с клавиатурой
 
// Set up pixel format for graphics initialization
void SetupPixelFormat()
{
    PIXELFORMATDESCRIPTOR pfd, *ppfd;
    int pixelformat;
 
    ppfd = &pfd;
 
    ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR); // Размер дескриптора данного формата пикселей
    ppfd->nVersion = 1;      // Номер версии
    ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; // Формат для Окна | Формат для OpenGL | Формат для двойного буфера
    ppfd->dwLayerMask = PFD_MAIN_PLANE; // Главный слой рисования
    ppfd->iPixelType = PFD_TYPE_COLORINDEX; // формат пикселов
    ppfd->cColorBits = 16; // размер цвета, количество бит на один пиксел
    ppfd->cDepthBits = 16; // размер буфера глубины
    ppfd->cAccumBits = 0; // общее число битовых плоскостей в буфере 
    ppfd->cStencilBits = 0; // глубина буфера трафарета
    pixelformat = ChoosePixelFormat(hDC, ppfd);
    SetPixelFormat(hDC, pixelformat, ppfd);
}
 
void InitGraphics()
{
    hDC = GetDC(hWnd); //Определяем, что контекстом устройства будет  наше окно
 
    SetupPixelFormat();
 
    hRC = wglCreateContext(hDC); //здесь создаем контекст рендеринга
    wglMakeCurrent(hDC, hRC); //теперь активируем и связываем контекст рендеринга и контекст устройства
    glClearColor(0, 0, 0, 0); //цвет фона
    glClearDepth(1.0); // Разрешить очистку буфера глубины
    glEnable(GL_ALPHA_TEST);
    glEnable(GL_DEPTH_TEST); //включить тест глубины
}
// Resize graphics to fit window
void ResizeGraphics()
{
    // Get new window size
    RECT rect;
    int width, height;
    GLfloat aspect;
 
    GetClientRect(hWnd, &rect);
    width = rect.right;
    height = rect.bottom;
    aspect = (GLfloat)width / height; // Вычисление соотношения геометрических размеров для окна
 
    // Adjust graphics to window size
    glViewport(0, 0, width, height); //  Сброс текущей области вывода 
    glMatrixMode(GL_PROJECTION);  // Выбор матрицы проекций
    glLoadIdentity();  // восстанавливает выбранную матрицу в первоначальное состояние
    gluPerspective(45.0, aspect, 1.0, 100.0);
    gluLookAt(ex, ey, ez, cx, cy, cz, 0, 1, 0);
    glMatrixMode(GL_MODELVIEW); // Выбор матрицы вида модели
}
void DrawLine(float x1, float y1, float z1, float x2, float y2, float z2, float r, float g, float b)
{//просто линия
    glBegin(GL_LINES);
    glColor3d(r, g, b);
    glVertex3d(x1, y1, z1);
    glVertex3d(x2, y2, z2);
    glEnd();
}
 void DrawOs(int n)
{//рисование осей
    glPushMatrix();
    
    DrawLine(-n, 0, 0, n, 0, 0, 1, 1, 1);
    DrawLine(0, -n, 0, 0, n, 0, 1, 1, 1);
    for (int i=-n; i<=n; i++)
    {
       DrawLine(i, 0.05, 0, i, -0.05, 0, 1, 1, 1);
       DrawLine(0.05, i, 0, -0.05, i, 0, 1, 1, 1);
    }
    glPopMatrix();
}
double myfunc(double x)
{//моя функция
    return sin(x);
}
 
void GenerateMasByFunc(float **mas, float x1, float x2, float dx, int &n, pf f)
{   //получение дискретной функции в mas по f
    //mas - массив значений координат точек
    // [x1,x2] - область значений
    //dx - шаг по оси X
    //n - количество точек
    //f - функция графика
    n = int((x2 - x1)/dx)+1; //n - количество точек
    
    mas[0] = new float [n];
    mas[1] = new float [n];
    for (int i = 0; i<n; i++)
    {
        mas[0][i] = x1 + dx * i; 
        mas[1][i] = f(x1 + dx * i); 
    }
}
void GenerateMasDifFunc(float **mas, float **mas_, float dx, int n)
{   //получение дискретной производной по mas
    //mas - массив значений координат точек
    // [x1,x2] - область значений
    //dx - шаг по оси X
    //n - количество точек
    mas_[0] = new float [n-1];
    mas_[1] = new float [n-1];
    for (int i = 0; i<n-1; i++)
    {
        mas_[0][i] = mas[0][i]; 
        mas_[1][i] = (mas[1][i+1]-mas[1][i])/dx; 
    }
}
void DrawFuncMas(float **mas, int n, float xScale, float yScale, float r, float g, float b)
{   //рисование графика дискретной функции mas
    glBegin(GL_LINE_STRIP);
    glColor3f(r, g, b);
    for (int i = 0; i<n; i++)
    {
        glVertex3f(mas[0][i] * xScale, mas[1][i] * yScale, 0);
    }
 
    glEnd();
}
 
void DrawGraphics()// решение задачи
{ 
 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //очищаем буфер цвета и буфер глубины
 glClearDepth(1);
 static bool createMas = false; 
 float Pi=3.14;
 static int n=1;
 static float x1 = -2*Pi;//-2Pi
 static float x2 = 2*Pi;//2Pi
 static float dx = 0.01;
 static float **masF=new float*[2];
 static float **masD=new float*[2];
 
 if (!createMas) //если дискретная функция не создана, создаем ее в массиве masF
    {
        GenerateMasByFunc(masF, x1, x2, dx, n, myfunc);//дискретная функция
        GenerateMasDifFunc(masF, masD, dx, n);
        createMas = true;
    }
 DrawOs(n);//рисуем оси
 if (createMas)//если дискретная функция создана,рисуем ее график
    {
       DrawFuncMas(masF,n,1,1,1,0,0);//растяжение 1х1
       //DrawFuncMas(masF,n,1,2,1,0.5,0);//растяжение 1х2
       //DrawFuncMas(masF,n,2,1,1,0.6,1);//растяжение 2х1
       DrawFuncMas(masD,n-1,1,1,1,1,0);//график производной, растяжение 1х1
   }
 SwapBuffers(hDC);                  
}
 
void KeyDown(int ikey)
{
    if ((ikey == VK_LEFT) || (ikey == VK_NUMPAD4) || (ikey == VK_NUMPAD1) || (ikey == VK_NUMPAD7))glRotated(-2,0,1,0);
    if ((ikey == VK_RIGHT) || (ikey == VK_NUMPAD6) || (ikey == VK_NUMPAD3) || (ikey == VK_NUMPAD9))glRotated(2,0,1,0);
    if ((ikey == VK_UP) || (ikey == VK_NUMPAD8) || (ikey == VK_NUMPAD7) || (ikey == VK_NUMPAD9)) glRotated(2,1,0,0);
    if ((ikey == VK_DOWN) || (ikey == VK_NUMPAD2) || (ikey == VK_NUMPAD1) || (ikey == VK_NUMPAD3))glRotated(-2,1,0,0);
  
    if (ikey == 65)  // 'a'
    {
        //ex = ex - 1;   
        //cx = cx - 1;   
    }
 
    if (ikey == 68) // 'd'
    {
        //ex = ex + 1;
        //cx = cx + 1;
    }
    if (ikey == 83) // 's'
    {
        ez = ez + 1;
        cz = cz + 1;
    }
    if (ikey == 87) // 'w'
    {
        ez = ez - 1;
        cz = cz - 1;
    }
    if (ikey == 81) // 'q'
    {
        //ex = ex + 1;
    }
    if (ikey == 69) // 'e'
    {
        //ex = ex - 1;
    }
    ResizeGraphics();
}
// Handle window events and messages
LONG WINAPI MainWndProc (HWND hWnd, UINT uMsg, WPARAM  wParam, LPARAM  lParam)
{
    switch (uMsg)
    {
    case WM_SIZE:
        ResizeGraphics();
        break;
 
    case WM_CLOSE: 
        DestroyWindow(hWnd);
        break;
 
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    case WM_KEYDOWN:            // Была ли нажата кнопка?
    {
      keys[wParam] = true;          // Если так, мы присваиваем этой ячейке true
      KeyDown(wParam);
      return 0;            // Возвращаемся
    }
    case WM_KEYUP:              // Была ли отпущена клавиша?
    {
      keys[wParam] = false;          //  Если так, мы присваиваем этой ячейке false
      return 0;            // Возвращаемся
    }
    // Default event handler
    default: 
        return DefWindowProc (hWnd, uMsg, wParam, lParam); 
        break; 
    } 
 
    return 1; 
}
 
int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
 
    const LPCWSTR appname = TEXT("OpenGL Sample");
 
    WNDCLASS wndclass;
    MSG      msg;
 
    // Define the window class
    wndclass.style         = 0;
    wndclass.lpfnWndProc   = (WNDPROC)MainWndProc;
    wndclass.cbClsExtra    = 0;
    wndclass.cbWndExtra    = 0;
    wndclass.hInstance     = hInstance;
    wndclass.hIcon         = LoadIcon(hInstance, appname);
    wndclass.hCursor       = LoadCursor(NULL,IDC_ARROW);
    wndclass.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
    wndclass.lpszMenuName  = appname;
    wndclass.lpszClassName = appname;
 
    // Register the window class
    if (!RegisterClass(&wndclass)) return FALSE;
 
    // Create the window
    hWnd = CreateWindow(
            appname,
            appname,
            WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
            CW_USEDEFAULT,
            CW_USEDEFAULT,
            800,
            600,
            NULL,
            NULL,
            hInstance,
            NULL);
 
    if (!hWnd) return FALSE;
 
    // Initialize OpenGL
    InitGraphics();
 
    // Display the window
    ShowWindow(hWnd, nCmdShow);
    UpdateWindow(hWnd);
 
    // Event loop
    while (1)
    {
        if (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) == TRUE)
        {
            if (!GetMessage(&msg, NULL, 0, 0)) return TRUE;
 
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        DrawGraphics();
    }
 
    wglDeleteContext(hRC);
    ReleaseDC(hWnd, hDC);
}