Как подключить opengl в visual studio 2019

3. Нажимаем кнопку «Обзор» и находим файл библиотеки C:\Program Files\TaoFramework\bin\Tao.Platform.Windows.dll.

Сегодня мы узнаем всё (реально всё), что нужно, чтобы запустить программу на C/C++, использующую OpenGL на Windows. Прикреплённые проекты сделаны в Visual Studio 2019. В уроке мы рассмотрим полную инициализацию OpenGL.

Список библиотек я брал из вики для OpenGL. Для урока я выбрал наиболее простые варианты в настройке.

Версия 4.6, которую мы будем рассматривать вышла довольно давно (июль 2017). Поэтому, у вас не должно возникнуть проблем, но, на всякий случай, установите последнюю версию драйверов. Драйвера, поддерживающие OpenGL 4.6, для видеокарт AMD и NVidia вышли в 2018. Аппаратная поддержка доступна начиная c AMD Radeon HD 5000 (2009г.) и NVidia GeForce 400 (2010г.). Драйвера для встроенных адаптеров Intel вышли в первой половине 2019г. В случае, если ваша видеокарта не поддерживает четвёртую версию OpenGL, рекомендую обратить внимание на Mesa3D — это программная реализация OpenGL.

Так как OpenGL является кроссплатформенным API, то не существует стандартного способа инициализации. Для использования OpenGL в программе необходимо сделать две вещи: создать OpenGL контекст и загрузить функции OpenGL API. Для каждой из этих задач существуют разные библиотеки.

Начнём мы с загрузки OpenGL функций.

Загрузка функций OpenGL API

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

В спецификации имена OpenGL функций выглядят так: GenVertexArrays, BindVertexArray, BeginQuery. В реальном коде к этим именам нужно добавлять префикс gl (зависит от библиотеки, в некоторых это не так): glGenVertexArrays, glBindVertexArray, glBeginQuery, glUseProgram.

GLEW (OpenGL Extension Wrangler)

Скачиваем GLEW (первый файл для Windows, на данный момент это glew-2.1.0-win32.zip). Распаковываем в любую папку. В настройках проекта добавляем папку include и lib (lib\Release\x64). Из папки bin\Release\x64 копируем файл glew32.dll в папку с нашим проектом.

В коде после создание контекста (об этом ниже) нужно вызвать функцию glewInit. Вот весь код, касающийся GLEW:

После вызова glewInit мы можем пользоваться функциями OpenGL.

По поводу имени библиотеки GLEW. GLEW расшифровывается как OpenGL Extension Wrangler. Wrangler — пастух. Соотвественно, название библиотеки можно понимать как: тот, кто управляет расширенями OpenGL. Про расширения мы будем говрить позже.

glatter

Теперь в коде осталось только включить заголовочный файл и можно вызывать OpenGL функции. Инициализировать ничего не надо (вызов функций можно делать только после создания OpenGL контекста):

Я не смог найти значение названия библиотеки glatter. Автор из Германии и там это слово есть — одна из форм слова «блестящий».

Другие библиотеки для загрузки OpenGL API

Существуют и другие библиотеки для загрузки OpenGL функций, но они требуют больше действий чем GLEW или glatter. Некоторые из этих вариантов: GL3W (использует скрипт на Python для генерациий заголовочных файлов OpenGL), glLoadGen (использует Lua скрипт), Galogen (командная утилита), Glad (приложение на Python или веб страница). В этих библиотеках используются дополнительные зависимости.

Кроме того, вы можете самостоятельно загрузить OpenGL функции, не используя вышеперечисленные библиотеки. В Windows для этого используется функция wglGetProcAddress. В качестве аргумента мы передаём имя функции (в виде строки char*), которую мы хотим получить, а возвращает она, соответственно, адрес этой функции. При таком способе вам нужно будет самостоятельно загружать каждую OpenGL функцию. wglGetProcAddress объявлена в wingdi.h, а для её использования необходимо подключить библиотеки Opengl32.lib, Opengl32.dll. Это информация для общего развития, в дальнейших уроках мы будем пользоваться только GLEW или glatter.

Теперь мы переходим к созданию контекста OpenGL.

Создание OpenGL контекста

Важно: При создании проекта для любой библиотеки выбирайте консольное приложение. Все библиотеки используют консольное приложение и самостоятельно создают окна. При этом, мы будем использовать следующую форму main:

freeglut требует аргументы arc и argv, а SDL2 требует именно этот вариант main. Для GLFW аргументы main не имеют значения.

Также, обратите внимание, в какой момент вызывается glewInit (после создания контекста).

Ещё одна ремарка: во всех случаях необходимо подключить библиотеку OpenGL32.lib. В ней определены самые старые функции OpenGL (ещё с первой версии), такие как, glClear, glClearColor. Архиктура не имеет значения, x86 и x64 должны использовать один и тот же файл.

Приложения на всех библиотеках имеют одинаковую структуру:

• Инициализация OpenGL
• Инициализация GLEW
• Главный цикл:
  • Проверка событий (нажатие клавиш клавиатуры/мышки. ) в очереди
  • Очистка буфера кадра (glClear, glClearColor)
  • Рендеринг кадра (именно здесь будут использоваться функции OpenGL, загруженные с помощью GLEW). В этом уроке этого не будет
  • Смена кадров (вывод буфера на экран). У нас есть две 2д картинки — фоновый буфер и основной. Основной буфер — это то, что пользователь видит на экране. Пока пользователь смотрит на основной буфер, мы рисуем в фоновом следующий кадр. Кода мы отрисовали кадр, мы меняем указатели буферов местами: фоновый становится основным и наоборот. Теперь пользователь видит новый кадр, а мы можем рисовать новый в фоновом буфере

  Скачиваем GLFW (Graphics Library Framework). Под заголовком Windows pre-compiled binaries выбираем 64-bit Windows binaries. Распаковываем. У меня это папка C:\prog\libs\glfw-3.3.2.bin.WIN64. Заголовочные файлы, как обычно в папке include, а библиотеки в lib-vc2019. Нужно скопировать glfw3.dll в папку с вашим проектом.

  

  Теперь полный код:

  В программе с GLFW мы используем следующие функции: glfwInit, glfwCreateWindow, glfwMakeContextCurrent, glfwWindowShouldClose, glfwGetKey, glfwSetWindowShouldClose, glfwSwapBuffers, glfwPollEvents, glfwTerminate.

  Сначала инициализируем GLFW, создаём окно и присваиваем ему контекст. При создании окна с помощью glfwCreateWindow мы указываем ширину/высоту окна и заголовок, остальные аргументы не важны. Затем инициализируем GLEW.

  В основном цикле мы проверяем, была ли нажата клавиша Escape, и если да, то устанавливливаем закрывающий флаг (его мы проверяем в условии цикла с помощью glfwWindowShouldClose). Обратите внимание, что для управления вводом GLFW определяет свои константы (GLFW_KEY_ESCAPE, GLFW_PRESS), их имена говорят сами за себя.

  Затем, в основном цикле мы очищаем буфер кадра, выводим содержимое на экран и проверяем события в очереди событий.

  После окончания основного цикла мы вызываем glfwTerminate.

  glClearColor задаёт цвет, которым будет заполняться фоновый буфер (это 2д картинка, в которой происходит рисование кадра) при очистке. glClear очищает фоновый буфер. Здесь мы очищаем только цвет — GL_COLOR_BUFFER_BIT. Ещё мы можем очищать буфер глубины, но об этом позже.

  glfwSwapBuffers выводит содержимое на экран. Имя функции — swap buffers — поменять буферы местами. В других библиотеках тоже есть подобная функция.

  Библиотека SDL (Simple DirectMedia Layer), помимо OpenGL, имеет возможности для работы с 2д графикой и звуком.

  Переходим. В разделе Development Libraries выбираем файл SDL2-devel-2.0.10-VC.zip. Распаковываем архив и настраиваем папки проекта.

  

  В SDL2 мы используем следующие функции: SDL_Init, SDL_CreateWindow, SDL_GL_CreateContext, SDL_PollEvent, SDL_GL_SwapWindow, SDL_GL_DeleteContext, SDL_DestroyWindow, SDL_Quit. Сначала мы инициализируем SDL, используя флаг SDL_INIT_EVERYTHING (everything — всё), который говорит, что мы хотим инициализировать все системы SDL: графику, звук, таймеры, устройства ввода. В нашем случае можно обойтись только SDL_INIT_VIDEO. После этого мы создаём окно и OpenGL контекст.

  В основном цикле мы проверяем очередь событий (SDL_PollEvent), очищаем буфер и выводим содержимое на экран с помощью смены кадров (SDL_GL_SwapWindow).

  Если произошло событие SDL_QUIT, мы заканчиваем цикл, изменяя переменную quit, затем удаляем контекст, окно, и освобождаем все ресурсы.

  freeglut

  Я упоминаю здесь freeglut (The Open-Source OpenGL Utility Toolkit) только для соотстветсвия с английской версией урока, который я писал несколько лет назад. На данный момент рекомендую использовать GLFW или SDL. freeglut больше подходит для Linux.

  FreeGLUT основывается на библиотеке GLUT, которая была создана в 1994г. (да и устарела GLUT уже как двадцать лет).

  Проходим по Ссылке и ищем там «Download freeglut 3.0.0 for MSVC» в разделе freeglut 3.0.0 MSVC Package. После распаковки архива указываем в своём проекте пути к заголовчным файлам и библиотеке. Также, необходимо скопировать freeglut.dll в папку с проектом.

  

  Здесь мы используем функции из freeglut: glutInit, glutInitWindowSize, glutCreateWindow, glutDisplayFunc, glutMainLoop, glutSwapBuffers. Собственно, инициализируем саму библиотеку, задаём размер окна и затем создаём его, указываем функцию, которая будет вызываться каждый кадр (displayFunc), запускаем основной цикл. В каждом кадре мы очищаем буфер и выводим содержимое буфера на экран с помощью glutSwapBuffers.

  Заключение

  В прикреплённом решении для Visual Studio 2019 есть три проекта для GLFW, SDL, freeglut. Везде используется GLEW. В данных проектах есть все нужные файлы: включаемые файлы и библиотеки, и они находятся в папках проектов. В следующих уроках вам нужно будет самостоятельно добавлять библиотеки. Я постраюсь поддерживать код для GLFW/SDL2 в связке с GLEW.

  Я бы, конечно, хотел добавить проекты для VSCode и Linux, но не уверен, что это кому-нибудь нужно, а на проверку и написание уходит много времени.

  Теперь, когда есть основа программы, версию OpenGL можно проверить с помощью функции glGetString:

  Значение можно посмотреть в отладчике или привести тип и вывести в консоль (все приложения GLFW, SDl2 и freeglut — консольные).

  За рамками урока, как обычно, осталась проверка возвращаемых значений разных функций. Если возникнут проблемы, пишите в комментарии (это позволит дополнить урок), отвечу, по возможности, быстро.

  

  В прошлом уроке мы разобрались с тем, что такое OpenGL. В этом уроке мы поговорим о причине необходимости использования GLFW, GLEW и CMake, а также рассмотрим как их использовать. А также освежим в памяти, разницу между статической и динамической линковкой.

  Заинтересовавшихся прошу под кат.

  Прежде чем начать создавать умопомрочительную графику нам надо создать контекст и окно приложения, в котором мы будет эту графику рисовать. Но, к сожалению, эти операции специфичны для каждой операционной системы и OpenGL всеми силами старается абстрагироваться от этих операций. Это означает, что создавать окно, определять контекст и работать с пользовательским вводом нам придется самим.

  GLFW — это библиотека, написанная на C, специально нацеленная для предоставления OpenGL самого необходимого для отрисовки контента на экран. Она позволяет нам создать контекст, определить параметры окна и работать с пользовательским вводом, а это все что там сейчас нужно.

  В основном в этом и следующем уроке мы будем заставлять GLFW нормально работать, проверять правильность создания OpenGL контекста и производить отрисовку окна в котором мы будет рисовать графику. Этот урок пошагово расскажет о сборке и линковке GLFW библиотеки. Для этого урока мы будем использовать Microsoft Visual Studio 2012 (заметьте, что процесс будет мало отличаться для других версий VS). Если вы не используете VS — то не волнуйтесь, этот процесс очень похож для всех IDE.

  Сборка GLFW

  GLFW можно скачать со страницы загрузки официального сайта. GLFW поставляется с прекомпилированными бинарниками и заголовочными файлами для VS, но для полноты картины мы соберем GLFW собственноручно. Так что давайте скачаем пакет с исходным кодом (Source package).

  Если вы используете прекомпилированные бинарники — удостоверьтесь, что вы скачали 32 битную версию, а не 64 битную. (Если вы не знаете в чем существенная разница). Так как 64 битная версия генерирует довольно странное поведение для большинства читателей.

  После того, как вы скачаете пакет — разархивируйте его. Нам интересны следующие элементы:

  • Результат компиляции
  • Папка include

  CMake

  CMake — это инструмент для генерации файлов Проекта/Решения для IDE, выбранного пользователем (Visual Studio, Code::Blocks, Eclipse) из набора исходных кодов и CMake скриптов. Такая конфигурация позволяет сгенерировать Visual Studio 2012 проектные файлы, чтобы мы могли без труда собрать библиотеку. Для начала нам надо скачать CMake, сделать это можно на странице загрузки. Я использую Win32 установщик.

  Как только CMake установится, вы сможете выбрать запуск CMake из консоли или в качестве графического приложения. Так как мы стараемся не перегружать уроки — то мы выберем графическое приложение. CMake требует указать директорию с исходным кодом и папку, куда будет записан результат в виде бинарных файлов. В качества директории с исходным кодом мы укажем корневую папку разархивированного GLFW пакета с исходным кодом, а в качестве папки для бинарных файлов мы укажем новую директорию .

  

  После установки требуемых директорий, нажмите Configure, что бы CMake считал требуемые настройки и исходный код. Затем нам требуется выбрать генератор для проекта. Так как мы собираемся использовать Visual Studio 2012 мы выбираем Visual Studio 11 (Visual Studio 2012 также известна как Visual Studio 11). Далее CMake отобразит возможные настройки сборки, их можно оставить без изменения, нажав еще раз на Configure для их сохранения. После сохранения настроек можем приступать к генерации проекта, для этого нажмите на Generate и в папке build будут созданы файлы проекта.

  Компиляция

  В папке build появился файл GLFW.sln, открываем его Visual Studio. CMake должен был сгенерировать проект со всеми требуемыми настройками, поэтому просто начинаем сборку, нажимая на Build Solution и в качестве результата мы получае glfw3.lib (мы используем 3 версию) в папке src/Debug,

  После того, как библиотека сгенерировалась надо удостовериться, что IDE знает где искать библиотеку и заголовочные файлы. Есть 2 способа сделать это:

  Мы ищем /lib и /include папки IDE или Компилятора и добавляем туда папку include и libиз GLFW. Это будет работать, но так лучше не делать. Такой метод сложно отследить и вы потеряете все файлы при переустановке или смене компилятора/IDE.

  Наш первый проект

  Для начала давайте откроем Visual Studio и создадим новый проект. Выберите Visual C++ и Пустой проект (не забудьте выдать проекту приемлемое имя). Теперь у нас есть рабочее пространство для создания нашего первого приложения с использованием OpenGL.

  Линковка

  Для использования GLFW нам также требуется его связать с нашим проектом. Это делаеться, указанием, что мы хотим использовать glfw3.lib в настройках линковщика, но наш проект все еще не знает, где искать glfw3.lib (если вы не выбрали 1 вариант во время решения проблемы с местонахождением файлов библиотек), соответственно нам надо добавить эти директории в проект.

  Мы можем добавить те директории, для этого перейдите в VC++ Directories, как показано на изображении ниже:

  

  И оттуда вы можете добавить собственные директории, чтобы проект знал где искать требуемые файлы. Это можно сделать ручным способом, просто вставив путь в текстовое поле, либо нажав на Edit…, где вы сможете добавить значения в специальном окне.

  

  Здесь вы можете добавить такое количество директорий, какое вам захочется, а IDE также будет искать требуемые файлы там. Теперь, когда Include папка указана для среды вы сможете найти все требуемые заголовочные файлы GLFW в . Тоже самое применимо и для директории с библиотеками.

  И уже после того, как Visual Studio узнал, где искать требуемые библиотеки, мы наконец можем связать GLFW и наш проект:

  

  Здесь требуется указать название линкуемой библиотеки, в нашем случае это glfw3.lib и добавляем мы ее в поле Additional Dependencies (сделать это также можно изменив руками или использовав кнопку ) и теперь GLFW будет линковаться к проекту во время компиляции. Также требуется указать OpenGL библиотеки, но этот процесс отличается для разных ОС.

  OpenGL библиотека для Windows

  Если вы используете Windows — то библиотека, называющаяся opengl32.lib поставляется с Microsoft SDK, которая ставится по умолчанию при установке Visual Studio. Так как в этом уроке мы и так использует Visual Studio — то здесь будет достаточно просто добавить opengl32.lib в настройки линковщика.

  OpenGL библиотека для Linux

  На Linux системах вам требуется использовать libGL.so библиотеку, использовав флаг -lGL в настройках линковщика. Если вы не можете найти эту библиотеку — то вам, вероятно, требуется поставить Mesa, NVidia или AMD dev пакеты, но я не буду вдаваться в подробности, так как это очень специфично для платформы (плюс я не являюсь Linux экспертом).

  По окончанию добавления GLFW и OpenGL библиотеки в настройки линковщика вы можете подключать GLFW следующим образом:

  Это финальный этап установки и настройки OpenGL.

  Но мы еще не закончили с настройкой OpenGL. Кое что еще придется сделать. Поскольку OpenGL — это лишь спецификация — то реализация ложится на плечи разработчиков видеокарт. По этой причине, поскольку существует множество реализаций OpenGL реальное расположение OpenGL функций не доступно на этапе компиляции и их приходится получать на этапе исполнения. Фактически получение адресов функций ложится на плечи программиста. Процесс получения адресов специфичес для каждой платформы, для Windows это выглядит примерно так:

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

  Сборка и линковка GLEW

  GLEW расшифровывается как OpenGL Extension Wrangler Library и управляем всей той громоздкой работой о которой говорилось выше. Поскольку GLEW это тоже библиотека — то нам опять придется собрать ее и связать с нашим проектом. GLEW может быть скачан с официальной страницы, там вы найдете как уже прекомпилированные библиотеки, так и исходный код. И опять же повторюсь: если вы не уверены какую битность использовать — используйте 32 битную версию.

  Мы будем использовать статическую версию GLEW, которая называется glew32s.lib (заметьте приставку `s`). Поэтому добавьте ее в вашу папку с библиотеками, а также добавьте заголовочные файлы в вашу папку с заголовочными файлами. Теперь мы можем линкануть GLEW к проекту, добавив glew32s.lib в настройки линковщика в Visual Studio. Заметьте, что GLFW3 по умолчанию собирается как статическая библиотека.

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

  Динамическая линковка осуществляется посредством .dll и .so файлов, осуществляя разделение кода библиотеки и кода приложения, уменьшая размер исполняемого файла и упрощая обновление библиотеки. Недостатком такого подхода является тот факт, что вам придется выпускать DLL файлы вместе с финальным приложением.

  Если вы хотите использовать GLEW как статическую библиотеку — то перед подключением GLEW следует задать переменную препроцессора GLEW_STATIC.

  Если вы хотите динамическое связывание — то вы можете опустить задачу переменной препроцессора GLEW_STATIC. Помните, что если вы используете динамическое связывание то вам придется скопировать .DLL файл в папку с исполняемым файлом.

  Для пользователей Linux, собирающих проект с помощью GCC в сборке могут помочь следующие ключи:

  -lGLEW -lglfw3 -lGL -lX11 -lpthread -lXrandr -lXi.

  Неправильное использование данных ключей может привести к большому количеству неопределенного поведения.

  Теперь, когда мы наконец то собрали и связали GLFW и GLEW у нас все готово для следующего урока в котором мы обсудим как использовать GLFW и GLEW для настройки OpenGL контекста и создания окна. Удостоверьтесь, что ваши директории с заголовочными файлами и файлами библиотек указаны верно и что в названиях библиотек в настройках линковщика нет ошибок. Если вы застряли — проверьте комментарии к исходной статье или другие источники, возможно вы допустили некоторую специфическую ошибку.

  После установки ссылаться на пакет в коде можно с помощью using , где соответствует используемому пакету. После указания ссылки можно обращаться к пакету посредством его интерфейса API.

  Предварительные требования

  Создание проекта

  Visual Studio создаст проект и откроет его в обозревателе решений.

  Добавление пакета NuGet Newtonsoft.Json

  Для установки пакета можно использовать диспетчер пакетов NuGet или консоль диспетчера пакетов. При установке пакета NuGet регистрирует зависимость в файле проекта или файле packages.config (в зависимости от формата проекта). Дополнительные сведения см. в разделе Обзор использования пакетов и рабочий процесс.

  Диспетчер пакетов NuGet

  В обозревателе решений щелкните правой кнопкой мыши узел Ссылки и выберите пункт Управление пакетами NuGet.

  

  

  См. подробнее о диспетчере пакетов NuGet в руководстве по установке пакетов и управлении ими с помощью Visual Studio.

  Примите все запросы касательно лицензии.

  (Только в Visual Studio 2017.) Если вам будет предложено выбрать формат управления пакетом, выберите PackageReference в файле проекта.

  

  В запросе на проверку изменений нажмите кнопку ОК.

  Консоль диспетчера пакетов

  Последовательно выберите Сервис > Диспетчер пакетов NuGet > Консоль диспетчера пакетов.

  После открытия консоли убедитесь, что в раскрывающемся списке Проект по умолчанию показан проект, в который требуется установить пакет. Если в решении всего лишь один проект, он автоматически выбран.

  Введите команду Install-Package Newtonsoft.Json (см. сведения о ней в этой статье). В окне консоли отображаются выходные данные команды. Ошибки обычно означают, что пакет не совместим с целевой платформой проекта.

  Использование интерфейса API Newtonsoft.Json в приложении

  Добавив пакет Newtonsoft.Json в проект, вы можете вызывать его метод JsonConvert.SerializeObject для преобразования объекта в удобную для восприятия строку.

  Откройте файл MainWindow.xaml и замените существующий элемент Grid следующим кодом:

  Откройте файл MainWindow.xaml.cs (который находится в обозревателе решений в узле MainWindow.xaml ) и вставьте в класс MainWindow следующий код.

  Несмотря на то что вы добавили пакет Newtonsoft.Json в проект, JsonConvert подчеркивается красной волнистой линией, так как оператор using требуется в верхней части файла кода.

  Выполните сборку и запустите приложение, нажав клавишу F5 или выбрав команду Отладка > Начать отладку.

  Читайте также:

  • Как зайти на сайт если пишет угроза безопасности яндекс браузер
  • Топ программ для просмотра аниме на пк
  • Как в опере скопировать адрес ссылки
  • Как восстановить удаленную программу на компьютере windows 7
  • Не работают плагины в fl studio 20

  Как подключить opengl в visual studio 2019

  1. Откройте программу установки Visual Studio, чтобы изменить:
  
  2. Нажмите, чтобы изменить:
  
  3. Проверьте настольную разработку на C ++:
  
  4. Проверьте диспетчер пакетов NuGet:
  

  Во-вторых, настройте OpenGL

  Ссылка для скачивания: https://www.opengl.org/resources/libraries/glut/glutdlls37beta.zip
  Ссылка на сетевой диск: https://pan.baidu.com/s/1O0eFXG-EPDR_9PzD0se1qg Код извлечения: 7dmk

  

  После загрузки и распаковки сжатого пакета есть следующие файлы:

  Просто поместите файл в соответствующую папку:
  ①Поместите glut.h в C: \ Program Files (x86) \ Microsoft Visual Studio \ community \ VC \ Tools \ MSVC \ 14.24.28314 \ include \ gl
  ②Поместите glut.lib и glut32.lib в . \ Microsoft VisualStudio \ community \ VC \ Tools \ MSVC \ 14.24.28314 \ lib \ x86
  ③ Поместите glut.dll и glut32.dll в C: \ Windows \ SysWOW64

  Примечание:
  ① Если папки gl нет, создайте новую
  ②Windows 64-битная, просто выполните описанную выше операцию, если она 32-битная, поместите glut.dll и glut32.dll в C: \ Windows \ System32

  3. Новый проект OpenGL

  1. Откройте Visual Studio2019 и выберите создание нового проекта:
  
  2. Выберите Мастер рабочего стола Windows:
  
  3. Проверьте пустой проект:
  
  4. Выберите «Инструменты-NuGet Package Management-NuGet Packages for Management Solutions» и найдите «nupengl» в браузере.
  
  5. Должны быть установлены и nupengl.core, и nupengl.core.redist:
  
  Он был успешно настроен, и затем вы можете создать новый файл .cpp для тестирования кода в только что созданном проекте.

  Как добавить opengl в visual studio 2019

  Инициализация OpenGL в Windows

  

  Загрузка функций OpenGL API

  GLEW (OpenGL Extension Wrangler)

  

  glatter

  

  Другие библиотеки для загрузки OpenGL API

  Создание OpenGL контекста

  • Инициализация OpenGL
  • Инициализация GLEW
  • Главный цикл:
  • Проверка событий (нажатие клавиш клавиатуры/мышки. ) в очереди
  • Очистка буфера кадра (glClear, glClearColor)
  • Рендеринг кадра (именно здесь будут использоваться функции OpenGL, загруженные с помощью GLEW). В этом уроке этого не будет
  • Смена кадров (вывод буфера на экран). У нас есть две 2д картинки — фоновый буфер и основной. Основной буфер — это то, что пользователь видит на экране. Пока пользователь смотрит на основной буфер, мы рисуем в фоновом следующий кадр. Кода мы отрисовали кадр, мы меняем указатели буферов местами: фоновый становится основным и наоборот. Теперь пользователь видит новый кадр, а мы можем рисовать новый в фоновом буфере

  

  

  freeglut

  

  How to setup OpenGL with Visual Studio 2019 on Windows 10?

  OpenGL is a 2D and 3D graphics API that provides a cross-platform application programming interface for a wide variety of computer platforms. It is operating system independent and has a transparent network. Application developers use it to develop high-performing and visually compelling graphics software applications.

  Prerequisites:

  • Visual Studio 2019 (Download)

  Installation:

  Now let’s jump into the setup of OpenGL. To do so follow the below steps:

  Step 1: First we have to download Visual Studio 2019 for windows10.

  Step 2: Now we have installed Visual Studio2019 from its downloaded the .exe file with Windows installer.

  

  Select Visual Stdio community 2019 and click Modify, now select the requited components as shown in below image and click install while Downloading :

  

  It will take some time after it will be complete restart the computer after the installation take place.

  • Now download GLUT header file, the .LIB, and .DLL files all pre-compiled for Intel platforms, you can simply download the glutdlls37beta.zip file from the website.
  • File inside folder look like this:

  

  Take a look at the below video for installation:

  Here is one sample code for running to check whether it is working or not

  C++ — OpenGL — Setting up Visual Studio

  The Visual Studio version for this tutorial will be the 2017 (seems to work with the 2015 and 2019 as well).
  The glew version will be the 2.2.0.
  The freeglut version will be the 3.0.0.

  The glew library stands for GL Extension Wrangler.

  At the end of this OpenGL tutorial you will be able to display a window with a white square displayed on a black background.

  First of all

  We are going to use the 32-bit or the 64-bit version.

  You have the choice, and it will be specified in the tutorial.

  Notice that the version is only based on which platform you want to compile for.

  If you plan to create a program to be executed on a 32-bit platform, so use the 32-bit version.

  Every platform accept 32-version, so the 64-bit version is only for specific purpose only.

  And so the 32-bit version will work on every Windows system.

  You’ll need glew headers that could be find on the sourceforge website of the OpenGL Extension Wrangler Library:

  freeglut

  You’ll also need the freeglut version for Microsoft Visual Studio:

  Click the link inside the part freeglut 3.0.0 MSVC Package.

  The name of the file you have to download is: freeglut-MSVC-3.0.0-2.mp.zip.

  Once you have downloaded it, there is a folder named freeglut inside.

  Extract it and rename it to freeglut-3.0.0 in order to have exactly the same name used in this tutorial.

  Paths and directories for this setup

  The general directory for our setup will be:

  The directory where projects are:

  The directory where libraries are:

  Visual Studio

  Open it and create an empty project > File > New > Project > Templates > Visual C++ > Empty Project.

  • Name: Shapes2D
  • Location: C:\dev\visual-studio-c++\
  • Solution: Create a new solution
  • Solution name: BadprogTutorial

  Your Shapes2D project has been created into your BadprogTutorial solution.

  Let’s add a main.cpp > Right click your project > Add > New Item > Visual C++ > C++ File > write the name main.cpp > Add.

  Setting all configurations

  Right click your Shapes2D project > Properties > On the top left there is a drop down menu > Configuration > Select All Configurations (instead of Debug)

  Including header files (includes)

  Right click your Shapes2D project > Properties > Configuration Properties > C/C++ > General > Additional Include Directories > Click it.

  On the right there is a drop down menu, click .

  A new window has appeared: Additional Include Directories.

  Click the New Line icon > Click the browse button > Then select the two following folders:

  1. C:\dev\lib\glew-2.0.0\include
  2. C:\dev\lib\freeglut-3.0.0\include

  Click OK > Apply

  Including libraries

  Library folders

  Right click your Shapes2D project > Properties > Configuration Properties > Linker > General > Additional Library Directories > Click it.

  On the right there is a drop down menu, click .

  A new window has appeared: Additional Library Directories.

  Click the New Line icon > Click the browse button > Then select the two following folders:

  For the 64-bit version

  1. C:\dev\lib\glew-2.0.0\lib\Release\x64
  2. C:\dev\lib\freeglut-3.0.0\lib\x64

  For the 32-bit version

  1. C:\dev\lib\glew-2.0.0\lib\Release\Win32
  2. C:\dev\lib\freeglut-3.0.0\lib

  Click OK > Apply

  Library files

  Right click your Shapes2D project > Properties > Configuration Properties > Linker > Input > Additional Dependencies > Click it.

  On the right there is a drop down menu, click .

  A new window has appeared: Additional Dependencies.

  Click the white area and write:

  • freeglut.lib (click enter to go the next line)
  • glew32.lib

  Click OK > Apply > OK.

  Your Visual Studio IDE is now ready to play with OpenGL!

  Testing the setup

  To test the setup, let’s code the most basic code HelloWorld! that you can write with OpenGL.

  On the Visual Studio’s top menu there is a dropdown menu with x86 selected.

  Click the black tiny triangle on the right of the x86 and select Configuration Manager.

  A new window has appeared: Configuration Manager.

  On the right select x86 in the dropdown menu and click New.

  A new window has appeared: New Solution Platform.

  On the right click the the Active solution platform dropdown menu and select:

  • Type or select the new platform: x64
  • Copy settings from: x86 (or Empty)

  You could now close the Configuration Manager and as you can see the platform is now specified as x64.

  And you could easily click either x86 or x64 (depending of your libraries version).

  freeglut.dll and glew32.dll

  Before building it, let’s copy (not move!) the .dll of these two libraries:

  For the 64-bit version

  • C:\dev\lib\glew-2.0.0\bin\Release\x64\glew32.dll (yes this is the right one)
  • and
  • C:\dev\lib\freeglut-3.0.0\bin\x64\freeglut.dll

  To the following directory:

  • C:\dev\visual-studio-c++\BadprogTutorial\x64\Debug
    Or if it doesn’t work in:
  • C:\dev\visual-studio-c++\BadprogTutorial

  For the 32-bit version

  • C:\dev\lib\glew-2.0.0\bin\Release\Win32\glew32.dll
  • and
  • C:\dev\lib\freeglut-3.0.0\bin\freeglut.dll

  To the following directory:

  • C:\dev\visual-studio-c++\BadprogTutorial\Debug
    Or if it doesn’t work in:
  • C:\dev\visual-studio-c++\BadprogTutorial

  For both versions (x86 and x64) and to avoid having copy/paste .DLL

  If you don’t want to copy/paste your freeglut.dll and glew32.dll from the library directory to your project directory then you have to set their paths directly in your Environment variables.

  If you don’t know where to find your Environment variables, open your Windows settings and search for Environment variables.

  A system properties window should appear > Advanced tab > Environment variables > In the System variables click New. > Enter, for example for the x64 Freeglut version, the following:

  • Variables name: FREEGLUT_LIB
  • Variable value: C:\dev\lib\freeglut-3.0.0\bin\x64\

  And for the x64 Glew32 version the following:

  • Variables name: GLEW32_LIB
  • Variable value: C:\dev\lib\glew-2.0.0\bin\Release\x64\

  Then click OK > OK.

  Do the same for the x86 version except the paths that must, of course, correspond to your x86 versions.

  Then close your Visual Studio IDE (yes close it if it still open) in order to get the last Environment variables set.

  And you are done, this time you won’t have to copy/paste your .DLL because Windows is now able to find them automatically.

  Open Visual Studio again to build and compile your first OpenGL application.

  Building the project

  On the Visual Studio’s top menu, select either x86 or x64 and build the project.

  If there is no error, right click the Shapes2D project > Debug > Start new instance.

  If all is OK, you should see a black window with a white square.

  Possible Errors

  If you had some errors like these ones, it’s because you try to play with a different version from the one specified in the setup configuration.

  For example if you have set up the configuration with the 64-bit version, you have to build it with the x64 configuration.

  Same thing for the 32-bit version, set up with the 32-bit library version and build it as a x86 configuration.

  So double check the paths you’ve just entered in the setup configuration.

  Here the errors:

  Conclusion

  Now that your Visual Studio has been set up, you could start creating OpenGL applications.

  Как подключить opengl в visual studio 2019

  Copy raw contents

  Copy raw contents

  Подготовка к первому проекту OpenGL: настройка GLFW, CMake и GLAD

  Первое, что нам нужно сделать, прежде чем мы начнем программировать графику, — это создать контекст OpenGL и окно приложения для рисования. Однако данные операции являются специфичными для каждой операционной системы, поэтому OpenGL целенаправленно пытается абстрагироваться от них. Это означает, что мы самостоятельно должны создать окно, определить контекст и обрабатывать пользовательский ввод.

  К счастью, существует довольно много библиотек, которые обеспечивают необходимый нам функционал, при этом некоторые из них специально нацелены на работу с OpenGL. Эти библиотеки избавят нас от всей специфической работы, связанной с особенностями конкретной операционной системы. Одними из наиболее популярных библиотек являются: GLUT, SDL, SFML и GLFW. На этих уроках мы будем использовать библиотеку GLFW. Вы также можете использовать и любую другую библиотеку из предоставленного списка, т.к. установка и настройка для большинства из них аналогична установке и настройке GLFW.

  GLFW (англ. «Graphics Library FrameWork») — это библиотека, написанная на языке Си, специально предназначенная для работы с OpenGL. Библиотека GLFW предоставит нам все необходимые инструменты, которые потребуется для рендеринга на экран различных объектов. Благодаря этому мы сможем создавать контексты OpenGL, определять параметры окна и обрабатывать пользовательский ввод, что вполне коррелирует с нашими целями.

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

  Примечание: На момент написания данной статьи в качестве среды разработки мы будем использовать Microsoft Visual Studio 2019 (обратите внимание, что наши действия будут аналогичными и с более старыми версиями Visual Studio). Если же вы используете более старую версию Visual Studio (или вообще другую среду разработки), то можете быть спокойны, т.к. процесс установки и настройки GLFW аналогичен в большинстве IDE.

  Библиотеку GLFW можно скачать с официального сайта. Стоит отметить, что GLFW уже имеет предварительно скомпилированные бинарные и заголовочные файлы для Visual Studio 2010-2019, но для полноты картины их мы использовать не будем, а вместо этого вручную скомпилируем GLFW из исходного кода. Это делается для того, чтобы вы сами прочувствовали процесс компиляции библиотек с открытым исходным кодом, поскольку не каждая подобная библиотека будет предоставлять возможность скачать предварительно скомпилированные бинарные файлы. Итак, давайте загрузим пакет с исходным кодом.

  Примечание: Мы будем собирать все библиотеки в формате 64-битных бинарных файлов, поэтому убедитесь, что скачиваете и используете именно 64-битные бинарные файлы.

  После загрузки пакета с файлами исходного кода, извлеките и откройте его содержимое. Нас интересуют следующие вещи:

  • библиотека, которая будет получена в результате компиляции;
  • папка include .

  Компиляция библиотек из исходного кода гарантирует, что полученная нами библиотека идеально подойдет для нашего процессора и операционной системы, в то время как предварительно скомпилированные бинарные файлы не всегда могут этим похвастаться (иногда они вообще недоступны для вашей системы). Однако проблема проектов, распространяющихся под эгидой открытого программного обеспечения, заключается в том, что не все используют одну и ту же IDE или систему сборки для разработки своего приложения, а это значит, что предоставленные файлы проекта/решения могут быть несовместимы с настройками IDE у других людей. Следовательно, каждый конечный пользователь должен настроить свой собственный проект/решение с учетом полученных *.с / *.cpp и *.h / *.hpp файлов, что почти всегда является довольно трудоемким и громоздким процессом. Но не спешите расстраиваться, для решения данной проблемы уже существует удобный инструмент сборки проектов под названием CMake.

  CMake — это инструмент, который, с использованием заранее определенных сценариев, может из коллекции файлов исходного кода сгенерировать файлы проектов/решений под выбранную пользователем IDE (например, для Visual Studio, Code::Blocks или Eclipse). Он позволит нам из исходного пакета файлов GLFW создать файл проекта под среду разработки Visual Studio 2019, а затем данный файл мы сможем использовать для компиляции библиотеки. Но сначала нам нужно его скачать, а затем установить.

  После установки CMake у вас будет 2 варианта:

  • запустить CMake из командной строки;
  • запустить Cmake через графический интерфейс.

  Поскольку мы не стремимся всё усложнять, то остановимся на варианте с использованием графического интерфейса. Для работы с CMake нам потребуется указать папку с файлами исходного кода проекта (в нашем случае glfw-3.3.2 ) и папку назначения для бинарных файлов. Для папки исходного кода мы собираемся выбрать корневую папку загруженного исходного пакета GLFW, а для папки сборки мы создадим новый каталог build :

  

  После того, как мы прописали пути для исходной и целевой папок, нам нужно нажать кнопку Configure , чтобы CMake cмог просмотреть исходные файлы GLFW и выбрать необходимые параметры для сборки.

  В следующем окне необходимо задать используемую версию Visual Studio. Т.к. работать мы будем в Visual Studio 2019, то выбираем опцию Visual Studio 16 2019 :

  

  Далее CMake отобразит возможные варианты сборки библиотеки. Можно оставить значения по умолчанию и снова нажать кнопку Configure , чтобы сохранить настройки:

  

  После установки параметров мы нажимаем кнопку Generate , в результате чего в папке build будут созданы необходимые файлы проекта.

  Теперь, зайдя в папку build , среди всего прочего можно увидеть файл с именем GLFW.sln , открываем его с помощью Visual Studio 2019:

  

  Поскольку CMake сгенерировал файл проекта, который уже содержит соответствующие параметры конфигурации, нам остается лишь построить решение. При этом CMake должен был автоматически настроить вариант компилирования решения в виде 64-битной библиотеки. Благодаря этому мы получим скомпилированный файл библиотеки с именем glfw3.lib , который будет находиться в папке build/src/Debug .

  После того, как мы создали библиотеку, нужно убедиться, что IDE знает, где найти данный файл, а также другие подключаемые файлы нашей программы OpenGL. Решить этот вопрос можно двумя способами:

  • Способ №1: Можно скопировать содержимое папки include проекта GLFW в соответствующую папку include вашей IDE или компилятора, а также скопировать полученный файл glfw3.lib в соответствующую папку /lib вашей IDE или компилятора. Данный способ вполне рабочий, но мы его не рекомендуем, так как новая установка IDE или компилятора приведет к тому, что вам заново придется подключать необходимые файлы.
  • Способ №2: Вы можете создать новую папку, которая будет содержать все заголовочные файлы и файлы из сторонних библиотек, на которую вы впоследствии сможете ссылаться из своей IDE или компилятора. Например, можно создать папку, в которой будут находиться папки Lib и Includ e. В них мы будем хранить все наши библиотечные и подключаемые файлы, которые собираемся использовать для наших OpenGL-проектов. Получается, что все сторонние библиотеки будут организованы в одном месте (и их можно будет совместно использовать на нескольких компьютерах). Однако, каждый раз при создании нового проекта, мы должны будем указывать IDE соответствующие пути к этим папкам.

  Как только необходимые файлы будут сохранены в выбранном вами месте, мы сможем приступить к созданию нашего первого OpenGL-GLFW-проекта.

  Наш первый проект

  Для начала давайте откроем Visual Studio и создадим новый проект. Для этого нужно выбрать тип проекта C++ , а далее — Пустой проект (не забудьте дать проекту подходящее имя):

  

  Теперь у нас есть рабочее пространство для создания нашего самого первого OpenGL-приложения!

  Для того, чтобы наш проект мог использовать GLFW, нам нужно связать с ним полученную библиотеку. Это можно сделать, указав в настройках линкера, что мы хотим использовать библиотеку glfw3.lib , но проект пока не знает где её искать, т.к. все подобные файлы мы переместили в другую папку. Таким образом, сначала мы должны добавить эту папку в наш проект.

  Для этого нажмите правой кнопкой мышки на имя проекта в Обозреватель Решений > Свойства . В появившемся окне выберите Каталоги VC++ > Каталоги библиотек «:

  

  Здесь вы можете добавить свои собственные каталоги, чтобы проект знал, где искать необходимые файлы. Это можно сделать, вставив вручную путь до каталога или щелкнув по соответствующей строке и выбрав пункт , в результате чего откроется следующее окно:

  

  Здесь вы можете добавить столько дополнительных каталогов, сколько захотите, и с этого момента IDE при поиске файлов библиотек также будет просматривать и эти директории. Поэтому, как только вы подключите папку Lib из проекта GLFW, вы сможете использовать все файлы библиотек из этой папки. Аналогично обстоят дела и с добавлением папки Include для заголовочных файлов.

  Поскольку для VS были указаны все необходимые файлы, то мы, наконец, можем связать GLFW с нашим проектом, перейдя в раздел Компоновщик > Ввод :

  

  Чтобы связать библиотеку нам нужно указать для компоновщика её имя. Так как библиотека называется glfw3.lib , то мы добавляем название этого файла в раздел Дополнительные зависимости (вручную или же через пункт ) и с этого момента при запуске процесса компиляции GLFW будет связан с нашим проектом. В дополнение к GLFW мы также должны добавить ссылки на библиотеку OpenGL, но данные действия будут отличаться в зависимости от (вашей) используемой операционной системы:

  • Библиотека OpenGL в Windows. Если вы используете операционную систему Windows, то необходимый нам файл библиотеки opengl32.lib , входящий в пакет Microsoft SDK, уже есть вместе с Visual Studio и не требует отдельной установки. Поскольку мы используем компилятор VS и работаем под операционной системой Windows, то всё, что вам нужно сделать — это добавить название файла opengl32.lib к общему списку параметров компоновщика.
  • Библиотека OpenGL в Linux. Если вы работаете в операционной системе Linux, то вам нужно подключить библиотеку libGL.so с помощью ключей –lGL , добавляемых к параметрам вашего компоновщика. Если вы не можете найти данную библиотеку, то вам, вероятно, необходимо установить любой из пакетов Mesa, NVidia или AMD dev.

  Затем, после добавления библиотек GLFW и OpenGL в настройки компоновщика, вы сможете подключить заголовочные файлы GLFW следующей строкой кода:

  Примечание: Для пользователей Linux, использующих компилятор GCC, помочь скомпилировать проект помогут следующие параметры командной строки:

  Неправильное линкование соответствующих библиотек приведет к возникновению ошибок.

  На этом установка и настройка GLFW завершена.

  Поскольку OpenGL на самом деле является лишь стандартом/спецификацией, то производитель драйверов должен реализовать спецификацию для драйвера, поддерживаемого конкретной видеокартой. Из-за того, что существует множество различных версий драйверов OpenGL, расположение большинства OpenGL-функций во время компиляции не известно и должно быть запрошено во время выполнения программы. Задача разработчика состоит в том, чтобы получить расположение нужных ему функций и сохранить их в виде указателей на функции для последующего использования. Получение мест расположений этих функций зависит от конкретной операционной системы.

  В Windows это выглядит примерно следующим образом:

  How to Set Up OpenGL GLFW GLEW GLM on a Project with Visual Studio

  wikiHow is a “wiki,” similar to Wikipedia, which means that many of our articles are co-written by multiple authors. To create this article, 14 people, some anonymous, worked to edit and improve it over time.

  This article has been viewed 52,619 times.

  This guide will help you get over the first challenge of using OpenGL, GLFW, GLEW, and GLM: Installing and setting them up, and creating your first project with GLFW-GLEW-GLM Template in Visual Studio 2022. It will assume your platform is Windows 10 or 11. During Visual Studio installation, check the Desktop development with C++ workload box, also click «Language pack» and check «English» box. It is addressing the beginner. He can set up GLFW-GLEW-GLM in project with Visual Studio by 3 ways: 1st targeting x32 platform, 2nd targeting x64 platform, and 3rd set up GLFW-GLEW-GLM source compiled by CMake and Visual Studio. Visual Studio 2022 is by default x64, however works interchangeably with x32 (x86).

  GLUT on VS 2019 [closed]

  I’m trying to use opengl on visual studio 2019 But whenever I want to compile my project I get error saying glut.h is not defined What I tried: Copy on glut32.dll “C:\Program Files (x86)\Windows Kits\8.1\Include\um\gl” and copy glut32.lib on “C:\Program Files (x86)\Windows Kits\8.1\Lib\winv6.3\um\x64”

  #include #include #define GAP 10 int main_w, w1, w2, w3, w4; void display(void) < glClear(GL_COLOR_BUFFER_BIT); glFlush(); >void vis(int visState) < printf("VIS: win=%d, v=%d\n", glutGetWindow(), visState); >void reshape(int w, int h) < int width = 50; int height = 50; glViewport(0, 0, w, h); if (w >50) < width = (w - 3 * GAP) / 2; >else < width = 10; >if (h > 50) < height = (h - 3 * GAP) / 2; >else < height = 10; >glutSetWindow(w1); glutPositionWindow(GAP, GAP); glutReshapeWindow(width, height); glutSetWindow(w2); glutPositionWindow(GAP + width + GAP, GAP); glutReshapeWindow(width, height); glutSetWindow(w3); glutPositionWindow(GAP, GAP + height + GAP); glutReshapeWindow(width, height); glutSetWindow(w4); glutPositionWindow(GAP + width + GAP, GAP + height + GAP); glutReshapeWindow(width, height); > int main(int argc, char **argv) < glutInit(&argc, argv); glutInitDisplayMode(GLUT_RGB); glutInitWindowSize(210, 210); main_w = glutCreateWindow("4 subwindows"); glutDisplayFunc(display); glutVisibilityFunc(vis); glutReshapeFunc(reshape); glClearColor(1.0, 1.0, 1.0, 1.0); w1 = glutCreateSubWindow(main_w, 10, 10, 90, 90); glutDisplayFunc(display); glutVisibilityFunc(vis); glClearColor(1.0, 0.0, 0.0, 1.0); w2 = glutCreateSubWindow(main_w, 110, 10, 90, 90); glutDisplayFunc(display); glutVisibilityFunc(vis); glClearColor(0.0, 1.0, 0.0, 1.0); w3 = glutCreateSubWindow(main_w, 10, 110, 90, 90); glutDisplayFunc(display); glutVisibilityFunc(vis); glClearColor(0.0, 0.0, 1.0, 1.0); w4 = glutCreateSubWindow(main_w, 110, 110, 90, 90); glutDisplayFunc(display); glutVisibilityFunc(vis); glClearColor(1.0, 1.0, 0.0, 1.0); glutMainLoop(); return 0; /* ANSI C requires main to return int. */ >

  E1696 cannot open source file «GL/glut.h» What I have to do to fix the issue? PS: I know I can Cmake the source and include them on my project but don’t want to fix it only for one project I want to make my visual stdio working with Open GL because I have many other opengl projects

  Похожие публикации:

  1. Как отформатировать карту памяти на телефоне samsung
  2. Как подключить фон в css
  3. Сколько стоит сход развал на bmw x4
  4. Что такое конверсия в яндекс директ