Как узнать какой opengl установлен

Как определить какая версия opengl на компьютере ?

Как определить какая версия opengl на компьютере ?
У меня нетбук, видеоадптер Intel(r) Graphic Media Accelerator 3150, пытаюсь изучать opengl (C++ , visual studio 2012).
Windows 7 начальная.
И можно ли установить opengl 4 ?

#1
21:09, 25 янв 2014

Попытаться создать контекст(wglCreateContextAttribsARB) нужной версии?

#2
21:11, 25 янв 2014

Скинь исходный код.

#3
21:22, 25 янв 2014

можно OpenGL Extension Viewer запустить
http://www.realtech-vr.com/glview/download.php
Но скачала конечно последние драйвера поставить.

#4
21:42, 25 янв 2014
#5
21:47, 25 янв 2014

Ещё есть версия в цифровом виде у новых ГЛ.
Лень искать какая там конкретно константа.

#6
5:52, 26 янв 2014

Андрей1234
> И можно ли установить opengl 4 ?
Это все же не notepad++, который всегда можно установить самой последней версии,:)
Версия OpenGL зависит в первую очередь от возможностей аппаратной части + драйвер. Почитай в свойствах драйвера, скорее всего там есть информация о поддерживаемой версии OpenGL.
Так же можно ознакомится с краткими характеристиками здесь
Так что одного желания использовать OGL 4.x мало, надо чтобы «железка» была соответствующая.

#7
18:05, 26 янв 2014

Андрей1234
> И можно ли установить opengl 4 ?
Нет, там только OpenGL 1.4 вроде поддерживается. Даже GLSL нет. Надо было покупать нормальный нетбук, не на атоме. Моему с AMD уже вроде года 2, а он поддерживает даже OpenGL 4.3. А если драйвера новые выйдут с поддержкой 4.4, то и 4.4 будет.

#8
23:59, 26 янв 2014

А я то дурак, себе карточку новую брал Radeon R9 280X, 16 косарей отдал (OpenGL 4.3 только), а надо было брать нетбук двух летней давности.

#9
18:02, 27 янв 2014

Monte-Kristo
> А я то дурак, себе карточку новую брал Radeon R9 280X, 16 косарей отдал (OpenGL
> 4.3 только), а надо было брать нетбук двух летней давности.
Да, весь нетбук стоил дешевле — около 14000. Правда производительность наверное у его карточки в 15 раз меньше, чем у R9 280X. Но для моего движка пока хватает.

#10
18:04, 27 янв 2014

gammaker
чем atom плох? Просто надо было брать со вторым ионом.

#11
13:58, 28 янв 2014

Monte-Kristo
И к чему твои понты. Человек за за свои деньги взял полноценный девайс, а ты только кусок компьютера, пусть и «жирный», но сам по себе ни на что не способный. Поставит себе Linux получит OpenGL 2.1, если захочет сможет и GLSL запрогать. А под win7 официально только OpenGL 1.5

#12
15:21, 28 янв 2014

RigoN
> Человек за за свои деньги взял полноценный девайс

насчет полноценного для графики — сомнительно.

у тебя точно нет второй карточки на нем?

#13
15:54, 28 янв 2014

unnamed
> насчет полноценного для графики — сомнительно.
Карту надо еще куда-то «вставить», сама по себе она как девайс==0.

#14
15:56, 28 янв 2014

RigoN
Так в моём тезисе нет никаких понтов — я же сказал, что я — лох, я — дурак, который купил кусок компьютера.

Как узнать версию OpenGL?

Определить версию opengl
Нужен код на opengl es 2, а в сети полно кода для первой версии как можно быстро определять.

OpenGL. Как узнать конечные координаты объекта?
Добрый день. Подскажите как нарисовать линию от нулевой точке в пространстве до центра объекта.

Какую версию OpenGL выбрать, чтобы приложение поддерживало наибольшее количество видеокарт?
Здравствуйте! Вопрос ровно такой же, как и в топике: какую версию OpenGL выбрать, чтобы приложение.

Как узнать версию ОС?
Здравствуйте, подскажите, как узнать версию операционной системы, тип и частоту процессора.

Регистрация: 16.11.2009
Сообщений: 156

Для своей видеокарты можно в вики посмотреть. Примерно, OpenGL 2.x = DirectX 9, OpenGL 3.x = DirectX 10, OpenGL 4.x = Самое последнее поколение видеокарт. Естественно нужны последние драйвера. Например, даже Radeon HD 2xxx, поддерживает OpenGL 3.3. Но эта поддержка появилась только в предпоследней версии драйверов — Catalyst 10.6.

А если нужно во время работы программы проверять. Можно воспользоваться GLEW, после инициализации он объявляет переменный для всех экстеншенов и версий OGL. Например

1 2 3 4 5 6 7 8 9

if (GLEW_VERSION_1_3) { /* Yay! OpenGL 1.3 is supported! */ } if (GLEW_ARB_vertex_program) { /* It is safe to use the ARB_vertex_program extension here. */ glGenProgramsARB(. ); }

Как узнать какой opengl установлен

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

Структура API OpenGL

API OpenGL описан на языке C без применения C++ ради простоты и платформонезависимости. Он состоит только из функций, констант и примитивных типов, объявленных через typedef , таких как «typedef int GLenum;» .

Функции делятся на две группы:

• команды (англ. commands) для изменения состояния драйвера
• запросы (англ. queries) состояния драйвера

Вот несколько примеров:

• функция-команда void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) устанавливает цвет очистки; RGBA компоненты цвета передаются как число с плавающей точкой на отрезке [0..1] .
• функция-команда void glClear() очищает буфер кадра путём заливки пикселей цветом очистки.
• функция-запрос const GLubyte *glGetString(GLenum name) возвращает строковое значение некоторой константы или величины в видеодрайвере, выбор величины зависит от параметра name ; при этом const GLubyte* можно преобразовать в const char* с помощью reinterpret_cast .
• тип данных GLclampf означает “число с плавающей точкой на отрезке [0..1] ”; при этом никаких проверок принадлежности диапазону компилятор делать не будет, потому что тип объявлен просто как typedef float GLclampf .

Функции-команды ничего не возвращают, даже статуса своего выполнения. Это даёт возможность выполнить команду асинхронно, не заставляя приложение ждать, пока видеодрайвер отправит данные на видеокарту и получит от неё ответ.

Обработка ошибок

OpenGL старательно обрабатывает ошибки, такие как “недопустимый аргумент”, “неправильная константа enum”, “несвоевременный вызов команды”. Узнать о наличии общей ошибки в одной из предыдущих функций-команд можно функцией-запросом GLenum glGetError() .

• Если функция возвращает GL_NO_ERROR , ошибок не было
• В противном случае код ошибки обозначает категорию ошибки без конкретных указаний
• Функция не только возвращает код ошибки, но и очищает флаг ошибки в драйвере

Условно, код может выглядеть так:

void ValidateGLErrors()  GLenum error = glGetError(); if (error != GL_NO_ERROR)  std::string message; // с помощью switch превращаем GLenum в строковое описание // печатаем строку или делаем ещё что-то в целях отладки > > 

Функцию можно улучшить, если учесть следующее:

• Распечатать строку ошибки можно в поток ошибок std::cerr
• Любую ошибку можно считать фатальной, вызывая std::abort для аварийного завершения программы после вывода текста ошибки
• Функцию можно сделать статическим методом класса CUtils

Представим улучшенную версию:

void CUtils::ValidateOpenGLErrors()  GLenum error = glGetError(); if (error != GL_NO_ERROR)  std::string message; switch (error)  case GL_INVALID_ENUM: message = "invalid enum passed to GL function (GL_INVALID_ENUM)"; break; case GL_INVALID_VALUE: message = "invalid parameter passed to GL function (GL_INVALID_VALUE)"; break; case GL_INVALID_OPERATION: message = "cannot execute some of GL functions in current state (GL_INVALID_OPERATION)"; break; case GL_STACK_OVERFLOW: message = "matrix stack overflow occured inside GL (GL_STACK_OVERFLOW)"; break; case GL_STACK_UNDERFLOW: message = "matrix stack underflow occured inside GL (GL_STACK_UNDERFLOW)"; break; case GL_OUT_OF_MEMORY: message = "no enough memory to execute GL function (GL_OUT_OF_MEMORY)"; break; default: message = "error in some GL extension (framebuffers, shaders, etc)"; break; > std::cerr  <"OpenGL error: "  <message  <std::endl; std::abort(); > > 

После добавления этого метода можно улучшить основной цикл приложения:

// Очистка буфера кадра, обновление и рисование сцены, вывод буфера кадра. if (running)  m_pImpl->Clear(); const float deltaSeconds = chronometer.GrabDeltaTime(); OnUpdateWindow(deltaSeconds); OnDrawWindow(m_pImpl->GetWindowSize()); CUtils::ValidateOpenGLErrors(); m_pImpl->SwapBuffers(); > 

Расширения OpenGL

В целях максимальной гибкости, все изменения в OpenGL вносятся в виде расширений. Расширение OpenGL — это задокументированная спецификация, которая описывает новые функции и их поведение, изменения в поведении старых функций и новые константы. Каждое расширение имеет имя, например, «GL_ARB_multitexture» . При выпуске новой версии OpenGL часть расширений попадает в новую версию и становится частью ядра OpenGL. Таким образом, в версии OpenGL 3.0 и выше вы автоматически получаете ряд возможностей, которые в OpenGL 1.2 были доступны только как расширения.

• В UNIX-системах и на мобильных устройствах доступны достаточно свежие версии OpenGL (обычно 3.0 и выше), где многие важные расширения уже стали частью ядра стандарта.
• В Windows версии старше OpenGL 1.1 напрямую недоступны, но разработчики драйверов дают доступ к ним через механизм расширений. Если видеодрайвер не установлен, будет доступен только OpenGL 1.1, обладающий весьма ограниченными возможностями.

Функция, описанная в расширении, может не существовать в конкретной реализации OpenGL (если она не поддерживает данное расширение). Поэтому программист должен

• либо запросить адрес функции и использовать её, только если адрес ненулевой
• либо проверить наличие поддержки расширения по его имени и потом смело запрашивать адреса описанных в расширении функций

В стандарте OpenGL не описан способ получения адреса, и каждая операционная система или мультимедийная библиотека предоставляет свой способ. В SDL2 есть функция void *SDL_GL_GetProcAddress(const char *proc) , которая по имени OpenGL-функции возвращает её адрес или nullptr , если функция недоступна.

Получение информации о версии OpenGL

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

Для получения информации мы применим функцию-запрос glGetString с тремя различными параметрами. На эту тему есть статья Get Context Info (opengl.org).

• константа с именем GL_VERSION возвращает строку версии OpenGL, причём в начале строки обязательно стоит «. » , а остальная часть строки не определена. Например, строка «3.0 Mesa 10.3.2» обозрачает “OpenGL версии 3.0, реализуемый подсистемой графики Mesa версии 10.3.2”.
• константа с именем GL_VENDOR возвращает имя поставщика реализации OpenGL. Например, строка «Intel Open Source Technology Center» обозначает “Видеодрайвер предоставлен OpenSource-подразделением корпорации Intel”.
• константа с именем GL_EXTENSIONS содержит полный список расширений, разделённый пробелами. Список обычно насчитывает свыше ста расширений.

Функция печати информации о контексте

void PrintOpenGLInfo()  std::string version = reinterpret_castconst char *>(glGetString(GL_VERSION)); std::string vendorInfo = reinterpret_castconst char *>(glGetString(GL_VENDOR)); std::string extensionsInfo = reinterpret_castconst char *>(glGetString(GL_EXTENSIONS)); std::cerr  <"OpenGL version: "  <version  <std::endl; std::cerr  <"OpenGL vendor: "  <vendorInfo  <std::endl; std::cerr  <"Full OpenGL extensions list: "  <extensionsInfo  <std::endl; > 

Следуя “правилу трёх ударов”, можно отрефакторить этот код:

void PrintOpenGLInfo()  auto printOpenGLString = [](const char *description, GLenum name)  std::string info = reinterpret_castconst char *>(glGetString(name)); std::cerr  <description  <info  <std::endl; >; printOpenGLString("OpenGL version: ", GL_VERSION); printOpenGLString("OpenGL vendor: ", GL_VENDOR); printOpenGLString("Full OpenGL extensions list: ", GL_EXTENSIONS); > 

Библиотека GLEW

• Сайт проекта: http://glew.sourceforge.net/
• В Debian/Ubuntu доступна в пакете libglew-dev

Запрашивать функции и проверять расширения вручную не всегда удобно. Для решения этой типовой задачи создана библиотека GLEW (сокращение от “openGL Extensions Wrapper”). С помощью макросов и отложенной загрузки адресов функций эта библиотека позволяет использовать расширения так, как будто бы никаких расширений не существует:

• вы просто вызываете функции по имени; если функции нет, произойдёт разыменование нулевого указания
• также вы можете использовать модифицированное имя расширения (с префиксом “GLEW_” вместо “GL_”) как целочисленную переменную со значением 0 или 1; 1 означает, что расширение есть и доступно, 0 означает, что расширения нет или оно недоступно
• если расширение недоступно, вы не должны вызывать функции расширения, чтобы не получить разыменование нулевого указателя
• если при создании контекста OpenGL вы потребовали и получили контекст не ниже определённой версии, то можно даже не проверять расширения, вошедшие в эту версию: они есть.

Подключать заголовок glew.h следует до первого включения gl.h , иначе вы получите ошибку при компиляции.

// Правильно #include #include  // Неправильно! #include #include 

Библиотека GLEW требует явного вызова функции glewInit для своей инициализации. Сделать вызов следует только один раз. Чтобы не накладывать на класс CAbstractWindow лишних ограничений, нужно гарантировать, что при первом конструировании объекта CAbstractWindow функция будет вызвана, а при последующих — уже нет. Также надо установить глобальную переменную-флаг glewExperimental , чтобы GLEW оборачивала функции из версий OpenGL 3.x и 4.x.

Для этой цели можно использовать два подхода

• взять из стандартного заголовка функцию std::call_once
• завести в функции статическую переменную типа bool, которая будет устанавливаться в false в инициализаторе (который для статических переменных внутри функции вызывается ровно один раз)

В многопоточной среде было бы правильным использовать call_once, чтобы исключить возможность повторного вызова инициализации во время выполнения “glewInit” в другом потоке. Однако, ни контекст OpenGL, ни GLEW не могут использоваться из нескольких потоков одновременно. Поэтому call_once нам не потребуется, и достаточно статической переменной типа bool:

void CUtils::InitOnceGLEW()  static bool didInit = false; if (!didInit)  glewExperimental = GL_TRUE; GLenum status = glewInit(); if (status != GLEW_OK)  std::cerr  <"GLEW initialization failed: "  <glewGetErrorString(status)  <std::endl; std::abort(); > > > 

Узнаём о расширениях через GLEW

Читать полный список расширений, полученный через glGetString(GL_EXTENSIONS) , не очень удобно. Сканировать его программно слишком трудоёмко в плане вычислений.

Для удобного получения расширений у GLEW есть переменные-флаги, которые устанавливаются при вызове glewInit() . Для проверки наличия расширения надо:

• найти идентификатор расширения в реестре расширений (opengl.org), например, GL_ARB_vertex_shader
• заменить префикс GL_ на GLEW_
• написать проверку переменной-флага с таким именем

Теперь можно улучшить функцию PrintOpenGLInfo :

void PrintOpenGLInfo()  auto printOpenGLString = [](const char *description, GLenum name)  std::string info = reinterpret_castconst char *>(glGetString(name)); std::cerr  <description  <info  <std::endl; >; printOpenGLString("OpenGL version: ", GL_VERSION); printOpenGLString("OpenGL vendor: ", GL_VENDOR); if (GLEW_ARB_vertex_shader)  std::cerr  <"Has vertex shaders"  <std::endl; > else  std::cerr  <"Has no vertex shaders"  <std::endl; > if (GLEW_ARB_fragment_shader)  std::cerr  <"Has fragment shaders"  <std::endl; > else  std::cerr  <"Has no fragment shaders"  <std::endl; > if (GLEW_ARB_vertex_buffer_object)  std::cerr  <"Has vertex buffers"  <std::endl; > else  std::cerr  <"Has vertex busffers"  <std::endl; > if (GLEW_ARB_framebuffer_object)  std::cerr  <"Has framebuffers"  <std::endl; > else  std::cerr  <"Has framebuffers"  <std::endl; > > 

void PrintOpenGLInfo()  auto printOpenGLString = [](const char *description, GLenum name)  std::string info = reinterpret_castconst char *>(glGetString(name)); std::cerr  <description  <info  <std::endl; >; printOpenGLString("OpenGL version: ", GL_VERSION); printOpenGLString("OpenGL vendor: ", GL_VENDOR); auto testExtension = [](const char *description, GLboolean supportFlag)  const char *prefix = supportFlag ? "Has " : "Has no "; std::cerr  <prefix  <description  <std::endl; >; testExtension("vertex shaders", GLEW_ARB_vertex_shader); testExtension("fragment shaders", GLEW_ARB_fragment_shader); testExtension("vertex buffers", GLEW_ARB_vertex_buffer_object); testExtension("framebuffers", GLEW_ARB_framebuffer_object); > 

На машине с Ubuntu 14.04 и встроенной видеокартой Intel программа выводит следующее:

OpenGL version: 3.0 Mesa 10.3.2 OpenGL vendor: Intel Open Source Technology Center Has vertex shaders Has fragment shaders Has vertex buffers Has framebuffers 

На машине с Windows 8 и видеокартой Intel вывод отличается:

OpenGL version: 4.4.0 - Build 20.19.15.4377 OpenGL vendor: Intel Has vertex shaders Has fragment shaders Has vertex buffers Has framebuffers 

Создаём работоспособное приложение

Код запроса версии OpenGL разместим в классе CWindow , потому что в дальнейших примерах нам уже не нужно будет печатать что-либо в консоль.

Файл Window.h

#pragma once #include "AbstractWindow.h" class CWindow : public CAbstractWindow  // CAbstractWindow interface protected: void OnWindowEvent(const SDL_Event &event) override; void OnUpdateWindow(float deltaSeconds) override; void OnDrawWindow(const glm::ivec2 &size) override; private: void PrintOpenGLInfo(); >; 

листинг Window.cpp

#include "stdafx.h" #include "Window.h" #include #include #include #include #include namespace  std::once_flag g_didPrintOpenGLInfo; > void CWindow::OnWindowEvent(const SDL_Event &event)  (void)event; > void CWindow::OnUpdateWindow(float deltaSeconds)  (void)deltaSeconds; > void CWindow::OnDrawWindow(const glm::ivec2 &size)  (void)size; std::call_once(g_didPrintOpenGLInfo, &CWindow::PrintOpenGLInfo, this); > void CWindow::PrintOpenGLInfo()  auto printOpenGLString = [](const char *description, GLenum name)  std::string info = reinterpret_castconst char *>(glGetString(name)); std::cerr  <description  <info  <std::endl; >; printOpenGLString("OpenGL version: ", GL_VERSION); printOpenGLString("OpenGL vendor: ", GL_VENDOR); auto testExtension = [](const char *description, GLboolean supportFlag)  const char *prefix = supportFlag ? "Has " : "Has no "; std::cerr  <prefix  <description  <std::endl; >; testExtension("vertex shaders", GLEW_ARB_vertex_shader); testExtension("fragment shaders", GLEW_ARB_fragment_shader); testExtension("vertex buffers", GLEW_ARB_vertex_buffer_object); testExtension("framebuffers", GLEW_ARB_framebuffer_object); > 

PS-Group

• PS-Group
• sshambir@gmail.com

• ps-group
• image/svg+xml sshambir

OpenGL на Apple M1

Apple ведёт активную борьбу с открытыми стандартами и некоторое время назад объявила OpenGL «устаревшим» на своей платформе macOS Mojave 10.14, двигая разработчиков в сторону проприетарного графического API Metal. Анонсы Mac mini на чипсете Apple M1 (ARM) и macOS 11 Big Sur были восприняты с тревогой за судьбу OpenGL на этой платформе, однако различные источники успокаивали — OpenGL всё ещё поддерживается macOS Big Sur.

Оставался один вопрос — какую версию OpenGL может предложить графический процессор «новичка» Apple M1? Официальная документация Apple не обновлялась с 2017го года, и в ней, разумеется, нет упоминаний M1, а доступные на момент написания статьи не освещают данный момент.

Наконец, одним вопросом стало меньше! Как оказалось, macOS заявляет о поддержке OpenGL 4.1 для данного чипа, реализованного поверх Metal — то есть достигает верхней планки OpenGL, доступной на данной платформе для других GPUs, даже GeForce и Radeon.

Для сравнения — сверху скриншот CAD Assistant, запущенного на M1 (Mac mini ‘2020), а снизу на Intel UHD Graphics 630 (Mac mini ‘2018). Скриншот демонстрирует работу трассировки путей (Path Tracing) на GPU реализованного открытым графическим движком Open CASCADE Technology. Path Tracing требует OpenGL 4+ и представляется собой достаточно сложную GLSL программу — так что это неплохой способ проверить работоспособность GPU и реализации OpenGL.

К сведению, самая распространённые реализации OpenGL на Windows давно поддерживают версию OpenGL 4.5 (‘2014) и выше, спецификации которой вышли без малого шесть лет назад, тогда как OpenGL 4.1 (‘2010) уже исполнилось 10 лет! Но удивляться «отсталости» Apple тут нет смысла — компания нигде не объявляла войну OpenGL, но план вытеснения его с платформы macOS прослеживался уже давно, даже до представления общественности проприетарного графического API Metal в 2014ом году — сначала для iOS, а затем и для macOS. И, к сожалению, в отличие от других платформ, производители видеокарт не могут обновить версию OpenGL независимо от Apple.

Счётчик кадров в секунду в простой тестовой сцене со стеклянным шариком демонстрирует преимущество до двух раз M1 над Intel HD 630: 48 FPS против 25 FPS для маленького окошка и 14.8 FPS против 6.5 FPS для разрешения 1080p. Конечно, тут M1 выглядит достойно только по сравнению со слабым GPU процессора Intel i5 — цифры не идут ни в какое сравнение со 100+ FPS для 1080p на мобильных видеокартах среднего сегмента, таких как четырёхлетний GeForce 1060 GTX.

Для простоты эксперимента, CAD Assistant запускался через Rosetta — программное решение Apple для запуска x86-64 приложений на ARM64 процессоре (коим является новый M1). Важность такого инструмента трудно недооценить, ведь на момент анонса 99.9% программного обеспечения, доступного для macOS, рассчитано на процессоры Intel.

И тем удивительнее, как смело Apple играет своими мускулами, ведь Rosetta даже не предустановлена на macOS Big Sur! Приложения .app для Intel в Finder просто не запускаются на свежей системе, при этом система не показывает ни единого сообщения об ошибке. А вот запуск инсталлционного пакета .pkg сразу предложила установить Rosetta, после чего запуск старых приложений стал возможен.

Проблема совместимости со старыми приложениями при появлении новых платформ была актуальна не один раз. IA-64 (64битная архитектура процессоров Intel Itanium) не поддерживала запуск x86 приложений, а вот x86_64 (или AMD64, 64-битная архитектура современных процессоров Intel и AMD) была изначально рассчитана на совместимость с существующими x86 платформами и приложениями. Более того, 64-битная версия Windows XP для процессоров AMD вышла только в 2005 году — то есть спустя два года после выпуска первых процессоров AMD Athlon 64 / Opteron с этой архитектурой. Благодаря обратной совместимости (в том числе реализации WoW64 для прозрачного запуска 32битных приложений на 64битной Windows), 32битные x86 приложения и операционные системы оставались популярными ещё долгие годы.

Процессоры ARM физически не поддерживают инструкции x86 (как и наоборот), поэтому реализация запуска и эффективной работы приложений, написанных для другой архитектуры процессоров, представляет собой определённые сложности. Для Apple этот опыт был уже не первым в истории — первая версия Rosetta использовалась для запуска PowerPC приложений на процессорах Intel в 2006 году.

Подобные решения можно было наблюдать и на других платформах, таких как Android — когда аутсайдер мобильного рынка Intel пытался конкурировать с ARM. Такие версии Android на процессорах Intel позволяли запускать приложения собранные для архитектуры ARM. По моему опыту, работала такая комбинация не очень стабильно — многие приложения падали и работали некорректно. Тем интереснее понаблюдать за работой приложений через Rosetta 2:

• Видеоплеер sView заработал без видимых проблем, но наблюдаются падения приложения при изменении размера окна.
• CAD Assistant запускается и в целом работает, однако вскоре возникают артефакты отображения текста через рендер QtQuick.
• Telegram запустился и вроде бы работает.
• Edge также заработал на паре сайтов.
• Firefox запустился, но работает некорректно (зависает открытие сайтов, падения).

Не могу сказать, связаны ли наблюдаемые проблемы именно с Rosetta, или с самой системой macOS Big Sur, или даже с графическими драйверами Apple M1. В будущем с появлением нативных ARM приложений для macOS этот вопрос может прояснится.

Английская версия публикации может быть найдена по следующей ссылке.

Обновление #1
Похоже артефакты текста в QtQuick (Qt5) связаны с проблемами реализации OpenGL на Apple M1 (судя по комментариям пользователей — проблема не воспроизводится на Intel). В Qt есть даже переменная, которая позволяет обойти проблему:

export QT_ENABLE_GLYPH_CACHE_WORKAROUND=1 open -a "/Applications/CAD Assistant.app"

Падения sView в момент масштабирования окна могут быть связаны с проблемами в обработке OpenGL из не-GUI потока (данная возможность была объявлена «устаревшей» в предыдущем обновлении macOS). Отключить отрисовку в отдельном потоке в sView можно специальным ключом:

/Applications/sView.app/Contents/MacOS/sView --cocoa-threaded=off