Graphics OpenGL трёхмерное и прочее

[algoritm]

И так как правильно сделать программу на opengl ?
Ответ пишите только на русском языке и специфические обозначения на английском,
смайлы приветствуются. :leader: :34: :) :cool: :bis: :rolleyes: :cheer: :angel:

[Слоник Трурль]

И так как правильно сделать программу на опенгл ?
Ответ пишите только на русском языке и специфические обозначения на английском, смайлы приветствуются. :леадер: :34: :чеер:

А ничего если в ответе будут проблемы с пунктуацией? (а то я комплексую)

[algoritm]

А ничего если в ответе будут проблемы с пунктуацией? (а то я комплексую)
Ничего нормально, никаких проблем, мы ведь не о проблемах а о творчестве. :leader:

[ATILLA]

И так как правильно сделать программу на opengl ?
Ответ пишите только на русском языке и специфические обозначения на английском,
смайлы приветствуются. :leader: :34: :) :cool: :bis: :rolleyes: :cheer: :angel:
Как платить будешь в баксах или рублями?

[algoritm]

Как платить будешь в баксах или рублями?
Здесь только обсуждение мнений, так что финансы не в тему.;)
Кстати сказать я свой аватар сделал сам.:34: :cool: :cheer:

[ATILLA]

Здесь только обсуждение мнений, так что финансы не в тему.;)
Кстати сказать я свой аватар сделал сам.:34: :cool: :cheer:
малевич корчится от зависти...

[algoritm]

малевич корчится от зависти...
thanks :leader: :cheer: , просто хотелось что-то своё оригинальное :cool:

[ATILLA]

thanks :leader: :cheer: , просто хотелось что-то своё оригинальное :cool:
ну все, теперь уже и не жаль что Малевич умер...

[смешно]

малевич корчится от зависти...

Я сейчас бы сьел аватар Атилы.

[смешно]

И так как правильно сделать программу на opengl ?
Ответ пишите только на русском языке и специфические обозначения на английском,
смайлы приветствуются. :leader: :34: :) :cool: :bis: :rolleyes: :cheer: :angel:

http://glprogramming.com/red/index.html
http://glprogramming.com/red/appendixg.html

OpenGL Correctness Tips


Perform error checking often. Call glGetError() at least once each time the scene is rendered to make certain error conditions are noticed.
Do not count on the error behavior of an OpenGL implementation - it might change in a future release of OpenGL. For example, OpenGL 1.1 ignores matrix operations invoked between glBegin() and glEnd() commands, but a future version might not. Put another way, OpenGL error semantics may change between upward-compatible revisions.
If you need to collapse all geometry to a single plane, use the projection matrix. If the modelview matrix is used, OpenGL features that operate in eye coordinates (such as lighting and application-defined clipping planes) might fail.
Do not make extensive changes to a single matrix. For example, do not animate a rotation by continually calling glRotate*() with an incremental angle. Rather, use glLoadIdentity() to initialize the given matrix for each frame, then call glRotate*() with the desired complete angle for that frame.
Count on multiple passes through a rendering database to generate the same pixel fragments only if this behavior is guaranteed by the invariance rules established for a compliant OpenGL implementation. (See Appendix H (http://glprogramming.com/red/appendixh.html) for details on the invariance rules.) Otherwise, a different set of fragments might be generated.
Do not expect errors to be reported while a display list is being defined. The commands within a display list generate errors only when the list is executed.
Place the near frustum plane as far from the viewpoint as possible to optimize the operation of the depth buffer.
Call glFlush() to force all previous OpenGL commands to be executed. Do not count on glGet*() or glIs*() to flush the rendering stream. Query commands flush as much of the stream as is required to return valid data but don't guarantee completing all pending rendering commands.
Turn dithering off when rendering predithered images (for example, when glCopyPixels() is called).
Make use of the full range of the accumulation buffer. For example, if accumulating four images, scale each by one-quarter as it's accumulated.
If exact two-dimensional rasterization is desired, you must carefully specify both the orthographic projection and the vertices of primitives that are to be rasterized. The orthographic projection should be specified with integer coordinates, as shown in the following example:gluOrtho2D(0, width, 0, height);where width and height are the dimensions of the viewport. Given this projection matrix, polygon vertices and pixel image positions should be placed at integer coordinates to rasterize predictably. For example, glRecti(0, 0, 1, 1) reliably fills the lower left pixel of the viewport, and glRasterPos2i(0, 0) reliably positions an unzoomed image at the lower left of the viewport. Point vertices, line vertices, and bitmap positions should be placed at half-integer locations, however. For example, a line drawn from (x1, 0.5) to (x2, 0.5) will be reliably rendered along the bottom row of pixels into the viewport, and a point drawn at (0.5, 0.5) will reliably fill the same pixel as glRecti(0, 0, 1, 1).
An optimum compromise that allows all primitives to be specified at integer positions, while still ensuring predictable rasterization, is to translate x and y by 0.375, as shown in the following code fragment. Such a translation keeps polygon and pixel image edges safely away from the centers of pixels, while moving line vertices close enough to the pixel centers.
glViewport(0, 0, width, height);glMatrixMode(GL_PROJECTION);glLoadIdentity ();gluOrtho2D(0, width, 0, height);glMatrixMode(GL_MODELVIEW);glLoadIdentity( );glTranslatef(0.375, 0.375, 0.0);/* render all primitives at integer positions */
Avoid using negative w vertex coordinates and negative q texture coordinates. OpenGL might not clip such coordinates correctly and might make interpolation errors when shading primitives defined by such coordinates.
Do not assume the precision of operations, based upon the data type of parameters to OpenGL commands. For example, if you are using glRotated(), you should not assume that geometric processing pipeline operates with double-precision floating point. It is possible that the parameters to glRotated() are converted to a different data type before processing.

OpenGL Performance Tips


Use glColorMaterial() when only a single material property is being varied rapidly (at each vertex, for example). Use glMaterial() for infrequent changes, or when more than a single material property is being varied rapidly.
Use glLoadIdentity() to initialize a matrix, rather than loading your own copy of the identity matrix.
Use specific matrix calls such as glRotate*(), glTranslate*(), and glScale*() rather than composing your own rotation, translation, or scale matrices and calling glMultMatrix().
Use query functions when your application requires just a few state values for its own computations. If your application requires several state values from the same attribute group, use glPushAttrib() and glPopAttrib() to save and restore them.
Use display lists to encapsulate potentially expensive state changes.
Use display lists to encapsulate the rendering calls of rigid objects that will be drawn repeatedly.
Use texture objects to encapsulate texture data. Place all the glTexImage*() calls (including mipmaps) required to completely specify a texture and the associated glTexParameter*() calls (which set texture properties) into a texture object. Bind this texture object to select the texture.
If the situation allows it, use gl*TexSubImage() to replace all or part of an existing texture image rather than the more costly operations of deleting and creating an entire new image.
If your OpenGL implementation supports a high-performance working set of resident textures, try to make all your textures resident; that is, make them fit into the high-performance texture memory. If necessary, reduce the size or internal format resolution of your textures until they all fit into memory. If such a reduction creates intolerably fuzzy textured objects, you may give some textures lower priority, which will, when push comes to shove, leave them out of the working set.
Use evaluators even for simple surface tessellations to minimize network bandwidth in client-server environments.
Provide unit-length normals if it's possible to do so, and avoid the overhead of GL_NORMALIZE. Avoid using glScale*() when doing lighting because it almost always requires that GL_NORMALIZE be enabled.
Set glShadeModel() to GL_FLAT if smooth shading isn't required.
Use a single glClear() call per frame if possible. Do not use glClear() to clear small subregions of the buffers; use it only for complete or near-complete clears.
Use a single call to glBegin(GL_TRIANGLES) to draw multiple independent triangles rather than calling glBegin(GL_TRIANGLES) multiple times, or calling glBegin(GL_POLYGON). Even if only a single triangle is to be drawn, use GL_TRIANGLES rather than GL_POLYGON. Use a single call to glBegin(GL_QUADS) in the same manner rather than calling glBegin(GL_POLYGON) repeatedly. Likewise, use a single call to glBegin(GL_LINES) to draw multiple independent line segments rather than calling glBegin(GL_LINES) multiple times.
Some OpenGL implementations benefit from storing vertex data in vertex arrays. Use of vertex arrays reduces function call overhead. Some implementations can improve performance by batch processing or reusing processed vertices.
In general, use the vector forms of commands to pass precomputed data, and use the scalar forms of commands to pass values that are computed near call time.
Avoid making redundant mode changes, such as setting the color to the same value between each vertex of a flat-shaded polygon.
Be sure to disable expensive rasterization and per-fragment operations when drawing or copying images. OpenGL will even apply textures to pixel images if asked to!
Unless absolutely needed, avoid having different front and back polygon modes.
<A name=name3>
GLX Tips


Use glXWaitGL() rather than glFinish() to force X rendering commands to follow GL rendering commands.
Likewise, use glXWaitX() rather than XSync() to force GL rendering commands to follow X rendering commands.
Be careful when using glXChooseVisual(), because boolean selections are matched exactly. Since some implementations won't export visuals with all combinations of boolean capabilities, you should call glXChooseVisual() several times with different boolean values before you give up. For example, if no single-buffered visual with the required characteristics is available, check for a double-buffered visual with the same capabilities. It might be available, and it's easy to use.

[Слоник Трурль]

OpenGL правильности советов

Выполните проверку ошибок часто. Звоните glGetError (), по крайней мере один раз каждый раз становится ареной внести определенные условия, ошибку заметили.
Не рассчитывать на ошибку поведение OpenGL осуществление, - она может измениться в последующих версиях OpenGL. Например, OpenGL 1,1 игнорирует матричных операций ссылаться между glBegin () и glEnd () команд, но в будущем, возможно, не версия. Иначе говоря, OpenGL ошибка семантики между могут измениться в сторону повышения-совместимых изменений.
Если нужно, чтобы свернуть все в геометрию одной плоскости, использование проецирования матрицы. Если modelview матрицы используется, OpenGL функции, которые действуют в глаза координат (например, освещения и применения определенных обрезание самолеты) могут потерпеть неудачу.
Не делайте значительные изменения в одной матрицы. Например, не живой ротации постоянно призывая glRotate * () с дополнительными угол. Скорее, используйте glLoadIdentity () для инициализации данной матрицы для каждого кадра, а затем слово glRotate * () с желаемой полный угол для этого кадра.
Рассчитывайте на несколько проходит через оказание данных для генерации пикселя же фрагменты, если только такое поведение гарантирует инвариантности правил, установленных для совместимых OpenGL реализации. (См. Приложение H подробности об инвариантности правил.) Противном случае, разные наборы фрагментов могут быть сгенерированы.
Не ожидайте ошибок представлять отчетность в то время как отображать список в настоящее время определена. Команды в списке отображения порождают ошибки только тогда, когда список казнен.
Место возле frustum плоскости, что и вдали от точки зрения, как можно оптимизировать функционирование глубина буфера.
Звоните glFlush () в силу все предыдущие OpenGL команды должен быть казнен. Не рассчитывать на glGet * () или glIs * () для флеш делает поток. Запрос команды флеш как большая часть потока, как это требуется, чтобы вернуться в силе данных, но не гарантируют завершить все до оказания команд.
Поверните dithering покинуть при оказании predithered изображений (например, когда glCopyPixels () вызывается).
Используйте весь спектр накопления буфера. Например, если в накопительных четыре изображения, масштаб каждого на одну четверть, как это накоплен.
Если точные двумерные rasterization это нужно, Вы должны тщательно определить как orthographic проекции и вершин примитивов, которые должны быть rasterized. Orthographic прогноз должен быть указан с целыми координатами, как показано в следующем примере:
gluOrtho2D (0, ширину 0, высота), где ширина и высота размеров области просмотра. С учетом этого прогноза матрица, полигонов и вершин пиксел изображения позиций должна находиться в целое координаты rasterize предсказуемо. Например, glRecti (0, 0, 1, 1) надежно заполняет левого нижнего пиксела от просмотра, и glRasterPos2i (0, 0) надежно позиций unzoomed изображение в нижней левой части области просмотра. Точка вершин, линия вершин, и растровые позиции должны быть поставлены на половину-целое число мест, однако. Например, строка из (x1, 0,5) до (x2, 0,5), будут надежно оказанные вдоль нижней точек в области просмотра, а также обращено на точку (0,5, 0,5) будет достоверно заполнить же пиксела, как glRecti (0, 0, 1, 1).
Оптимальный компромисс, который позволяет всем примитивов, который будет определен на целое число позиций, в то же время обеспечивая предсказуемый rasterization, заключается в том, чтобы перевести х и 0,375 в год, как это показано в следующий фрагмент кода. Такой перевод держит полигона и пикселя изображения краев спокойно вдали от центров пикселей, в то время перехода линии вершин достаточно близко к пиксельных центров.
glViewport (0, 0, ширина, высота); glMatrixMode (GL_PROJECTION); glLoadIdentity (); gluOrtho2D (0, ширину 0, высота); glMatrixMode (GL_MODELVIEW); glLoadIdentity (); glTranslatef (0,375, 0,375, 0,0); / * Сделать все примитивы в целых позиции * /
Избегайте использования отрицательные ж вершинных координат и негативные q текстуры координат. OpenGL, возможно, не такой клип с координатами правильно и может привести к тому, интерполяция ошибки при закраске примитивов определяется такими координатами.
Не думайте, точность операций, основанных на данных типа параметров для OpenGL команд. Например, если вы используете glRotated (), вы не думайте, что геометрической обработки трубопровода работает с двойной точности с плавающей точкой. Не исключено, что параметры glRotated () преобразуются в различных типа данных перед обработкой.

OpenGL производительность советы

Используйте glColorMaterial (), когда только один материал собственности в настоящее время разнообразные быстро (на каждой вершины, например). Используйте glMaterial () для изменения нечасто, или когда более чем одного материала собственности в настоящее время разнообразные быстро.
Используйте glLoadIdentity () для инициализации матрицы, а не погрузки свой собственный экземпляр идентичность матрицы.
Использование матрицы конкретных вызовов, например, glRotate * (), glTranslate * (), и glScale * (), чем написание собственного вращения, перевод, или масштаб матриц и призывая glMultMatrix ().
Использование запроса функций, когда ваше приложение требует только несколько значений состояния для своих расчетов. Если ваше приложение требует нескольких значений состояния из одной и той же группы атрибутов, используйте glPushAttrib () и glPopAttrib (), чтобы сохранить и восстановить их.
Использование отображения списков включает потенциально дорогостоящие государственные изменения.
Использование отображения списков включает оказание требует жестких объектов, которые будет обращено неоднократно.
Использование текстур на объекты происходят текстуры данных. Место все glTexImage * () звонки (в том числе mipmaps) должна полностью указать текстуру и связанных glTexParameter * () звонки (которые определяют свойства текстуры) в текстуру объекта. Bind эту текстуру объекта для выбора текстуры.
Если ситуация позволяет ей использовать гл TexSubImage * () для замены всех или части существующих текстуру изображения, а не более дорогостоящих операций удаления и создания нового облика всего.
Если ваша реализация поддерживает OpenGL высокопроизводительных рабочих набор текстур резидентов, постараемся сделать все ваши текстуры резидентов, то есть сделать их вписываются в высокопроизводительных текстуры памяти. В случае необходимости уменьшения размеров или внутренний формат вашего разрешения текстур до тех пор, пока все они вписываются в памяти. Если такое снижение создает невыносимо нечеткой текстурированных объектов, можно привести некоторые текстуры с низким приоритетом, который будет, Когда начинается серьезная заварушка, оставьте их из рабочего набора.
Используйте оценке, даже для простых поверхности tessellations к минимуму сетевой трафик в клиент-серверных сред.
Представьте единицу длины нормалей, если можно сделать это и избежать накладные GL_NORMALIZE. Избегайте использования glScale * () при выполнении освещения, поскольку он почти всегда требует, чтобы иметь возможность GL_NORMALIZE.
Установить glShadeModel () для GL_FLAT плавного затенения, если это не требуется.
Использование единого glClear () вызова на фрейм, если это возможно. Не используйте glClear () для очистки небольших субрегионах буферами, поэтому используйте его только для полного или почти полного очищает.
Использование одного звонка на glBegin (GL_TRIANGLES) использовать несколько независимых треугольников, а не требующие glBegin (GL_TRIANGLES) несколько раз, или позвонив glBegin (GL_POLYGON). Даже если только один треугольник, который можно сделать, используйте GL_TRIANGLES, а не GL_POLYGON. Использование одного звонка на glBegin (GL_QUADS) в том же порядке, а не требующие glBegin (GL_POLYGON) повторно. Кроме того, использование одного звонка на glBegin (GL_LINES) использовать несколько независимых отрезков, а не требующие glBegin (GL_LINES) несколько раз.
Некоторые реализации OpenGL выгоды от хранения вершинных данных в вершинных массивов. Использование вершинных массивах уменьшает накладные расходы вызова функции. В некоторых реализациях может повысить производительность, пакетной обработки или повторного использования обработанных вершин.
В целом, использование векторных форм команды precomputed передачи данных и использования скалярной формы команд для передачи ценностей, которые вычисляются возле время вызова.
Избегать излишней режиме изменения, такие как установление цвет же значение в диапазоне от каждой вершине плоского затенены многоугольник.
Не забудьте отключить дороже rasterization и за-фрагмент операций при взятии или копирования изображений. OpenGL будет даже применять текстуры на пиксел изображения, если попросят!
Если абсолютно необходимо, избежать различных передних и задних полигон режимах.
<A Name=name3>
GLX Советы

Используйте glXWaitGL () вместо glFinish (), чтобы заставить X делает команды для оказания последующей GL команд.
Кроме того, используйте glXWaitX (), а не XSync (), чтобы заставить GL делает команды для последующей X оказания команд.
Будьте осторожны при использовании glXChooseVisual (), потому что логическое выбор подбираются точно. Поскольку некоторые реализаций не будет экспортировать изображения со всеми сочетаниями логическое возможностями, вы должны позвонить glXChooseVisual () несколько раз с разными булевы значения, прежде чем бросить. Например, если ни один буферный-визуальное с требуемыми характеристиками можно ознакомиться, проверить, дважды буферизованные визуальный с теми же возможностями. Может быть, и она проста в использовании

[algoritm]

Оу, о чём это, мне интересно как использовать процедуры чтобы отобразить хоть что-то на экране, куда там до хитроумных преобразований моделей мира, хоть что-либо появилось бы на экране. :leader:

[смешно]

Я же тебе целую книгу дал, читай. Гыыыы.

[algoritm]

Я же тебе целую книгу дал, читай. Гыыыы.
Чего-то странно, пишу glViewport(0, 0, 100, 100) и т.п., а цвет окна тот же, а glGetError почему-то равен 2. :leader:

[algoritm]

Я же тебе целую книгу дал, читай. Гыыыы.
Эта книга недостаточно точно и полностью рассказывает про OpenGL. :cheer:

[algoritm]

А в этой книге не указаны элементы структуры PIXELFORMATDESCRIPTOR.
И вообще надо было начать книгу именно с того как включить OpenGL для отображения в разных OS, а не рассказывать чушь про
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
что конечно же ещё работать не будет. :cheer:

[смешно]

Эта книга недостаточно точно и полностью рассказывает про OpenGL. :cheer:


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

[crazy-mike]

И так как правильно сделать программу на opengl ?

Сначала библиотеку libMesa скомпилировать из исходников можно вообще-то...
Там ответа "правильно/неправильно" - почти нет - хотя бы потому , что есть более "высокоуровневые" библиотеки на основе OpenGL (libIrrlicht - к примеру) :leader:

[algoritm]

Напиши свою. Да и вообще по хорошему самому надо писать графические двигатели.
Вот и предлагаю в этой теме рассуждать о всех трудностях и вопросах связанных с чем-либо трёхмерным, так что welcome. :cheer:
О графических двигателях здесь никто пока и слова не сказал.
Сначала как вообще-то хоть что-нибудь нарисовать.
Цитирую из википедии:
"OpenGL (Open Graphics Library — открытая графическая библиотека) — спецификация, определяющая независимый от языка программирования кросс-платформенный программный интерфейс для написания приложений, использующих двумерную и трехмерную компьютерную графику." :cheer:

[algoritm]

Сначала библиотеку libMesa скомпилировать из исходников можно вообще-то...
Там ответа "правильно/неправильно" - почти нет - хотя бы потому , что есть более "высокоуровневые" библиотеки на основе OpenGL (libIrrlicht - к примеру) :leader:
Интересно как самостоятельно включить отображение OpenGL без специальных библиотек, которые часто авторские, то есть по простому без особенностей, но так чтоб треугольник нарисовать к примеру. :cheer:

[algoritm]

Есть интересная статья и пример как сделать OpenGL программу в Delphi для начинающих программистов.
http:// dn.codegear.com/ article/ 26401
где показан один из примеров, увидеть это было радостью

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

Итак чтобы отобразить хоть что-то на экране надо использовать или glut или wgl команды. :cheer:

[crazy-mike]

Интересно как самостоятельно включить отображение OpenGL без специальных библиотек, которые часто авторские, то есть по простому без особенностей, но так чтоб треугольник нарисовать к примеру. :cheer:
:leader: Если чего-то совсем высокоуpовневого хочется - хватит и Java 2D

[смешно]

Вот и предлагаю в этой теме рассуждать о всех трудностях и вопросах связанных с чем-либо трёхмерным, так что welcome. :cheer:
О графических двигателях здесь никто пока и слова не сказал.
Сначала как вообще-то хоть что-нибудь нарисовать.
Цитирую из википедии:
"OpenGL (Open Graphics Library — открытая графическая библиотека) — спецификация, определяющая независимый от языка программирования кросс-платформенный программный интерфейс для написания приложений, использующих двумерную и трехмерную компьютерную графику." :cheer:

Всё прекрасно рисуется и в Java, 3-D, без OpenGL и DirectX.

[crazy-mike]

Всё прекрасно рисуется и в Java, 3-D, без OpenGL и DirectX.
В Java - 3D - как раз и сделано через Open GL ...;)

[algoritm]

придумал юнит :



unit UnitOGL1;

interface
uses Windows, Variants, OpenGL;

{unit is a freeware}
{and for example in main form you can add to call "DC_GL:=getdc(Form1.Handle);" for
procedure StartOpenGLGraphics(DC_GL:HDC);}
{план программы графики OpenGL}

{действующие элементы:
PIXELFORMATDESCRIPTOR структура
wglCreateContext функция создаёт рендеринг контекст
wglDeleteContext функция удаляет рендеринг контекст
ChoosePixelFormat функция выбирает формат пикселя
wglMakeCurrent(hdc,hglrc) функция включает рендеринг контекст
wglMakeCurrent(NULL,NULL) функция выключает рендеринг контекст
SetPixelFormat функция устанавливает формат пикселя}

{правило 1 : сначала выбирают формат пикселя
и устанавливают его, а потом создают и включают
рендеринг контекст, после того как все графические
команды были сделаны рендеринг контекст выключают и удаляют}



procedure StartOpenGLGraphics(DC_GL:HDC);
procedure FinishOpenGLGraphics;

var
DC_GL:HDC;
RC_GL:HGLRC;
pfd_GL:TPIXELFORMATDESCRIPTOR;{это может быть константа}
NumberOfSelectedPixelFormat_GL:integer;
SuccessSelectPixelFormat_GL:boolean;
SuccessSetPixelFormat_GL:boolean;
SuccessStart_GL:boolean;



implementation


procedure StartOpenGLGraphics(DC_GL:HDC);
begin
{устанавливается HDC окна вывода графики}
{параметр процедуры DC_GL:=?;}

{определяется pfd_GL структура формата пикселя}
pfd_GL.nSize:=sizeof(TPIXELFORMATDESCRIPTOR);
pfd_GL.nVersion:=1;
pfd_GL.dwFlags:=PFD_SUPPORT_OPENGL OR PFD_DRAW_TO_WINDOW OR
PFD_DOUBLEBUFFER;
pfd_GL.iPixelType:=PFD_TYPE_RGBA;
pfd_GL.cColorBits:=24;
pfd_GL.cAlphaBits:=0;
pfd_GL.cAccumBits:=0;
pfd_GL.cDepthBits:=16;
pfd_GL.cStencilBits:=0;
pfd_GL.cAuxBuffers:=0;
pfd_GL.iLayerType:=PFD_MAIN_PLANE;


{устанавливаются значения логических переменных-результатов}
SuccessSelectPixelFormat_GL:=true;
SuccessSetPixelFormat_GL:=true;
SuccessStart_GL:=true;
{находится номер выбранного формата пикселя}
NumberOfSelectedPixelFormat_GL:=ChoosePixelFormat( DC_GL,@pfd_GL);
{проверяется значение логической переменной-результата}
{выбора формата пикселя}
if NumberOfSelectedPixelFormat_GL=0 then SuccessSelectPixelFormat_GL:=false;
{устанавливается номер и формат пикселя только если выбор успешен}
if SuccessSelectPixelFormat_GL=true then
SuccessSetPixelFormat_GL:=SetPixelFormat(DC_GL,
NumberOfSelectedPixelFormat_GL,@pfd_GL)
else SuccessSetPixelFormat_GL:=false;
{проверяется значение логической переменной-результата}
{установки номера и формата пикселя}
if (SuccessSelectPixelFormat_GL=true)and
(SuccessSetPixelFormat_GL=true) then
begin
{создаётся рендеринг контекст}
RC_GL:=wglCreateContext(DC_GL);
{включается рендеринг контекста}
wglMakeCurrent(DC_GL,RC_GL);
end
else SuccessStart_GL:=false;

end;


procedure FinishOpenGLGraphics;
begin
{проверяется был ли создан контекст и включён рендеринг}
if SuccessStart_GL=true then
begin
{"However, if a rendering context is the calling
thread's current context, the wglDeleteContext
function changes the rendering context to
being not current before deleting it."
wglMakeCurrent(NULL,NULL);}
wglDeleteContext(RC_GL);

end;

end;





end.
:34: :cool: :leader: :cheer:

[algoritm]

В Гугл есть проект SketchUp, это программа для создания трёхмерных объектов, очень интуитивно понятный интерфейс. :cheer:

[algoritm]

Да и ещё непонятно почему так долго ждали с реализацией "трёхмерного интерфейса менеджера файлов" типа Аеро в Виста, ведь всё это можно было сделать ещё в Виндоус98, в виде софтваре емулейшон точно. Тоже самое можно сказать и о линукс.
Могу представить как много разных вариаций этих интерфейсов можно сделать. Просто удивительно, ведь это можно реализовать в два приёма в любой Visual системе программирования на основе OpenGL к примеру, а может быть даже на DirectX, странно что таких программ ещё не продаётся в изобилии через интернет. :cheer:

[algoritm]

Есть также программа Blender для создания 3d объектов. :cheer:

[algoritm]

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

[crazy-mike]

Также понятно что чем больше комманд построения графики может выполнить видеокарта тем лучше, :cheer:
:bis: Вы в этом уверены????? (хотя на видеокарте может быть даже и не один GPU - а >=2 :grum: )
Там есть одна "особенность" - связанная с использованием памяти (у видеокарты практически всегда есть "своя" - которую нужно каким-нибудь способом "наполнять командами и данными"). Больше команд - чем находится в собственном "буфере команд" - видеокарта просто принципиально не может выполнить. :leader:
Кстати - во всех "открытых системах" библиотека OpenGL чаще всего реализуется средствами библиотеки libMesa. А "OpenGL extentions" - зависящие от конкретной видеокарты - это вообще отдельный разговор. Эти "расширения" вообше не "стандартизированы". Поэтому "кросс-платформные приложения" просто не могут "легальным путём" использовать все эти расширения (правда они в основном в игровых программах и нужны :grum:)

[algoritm]

:bis: Вы в этом уверены????? (хотя на видеокарте может быть даже и не один GPU - а >=2 :grum: )
Там есть одна "особенность" - связанная с использованием памяти (у видеокарты практически всегда есть "своя" - которую нужно каким-нибудь способом "наполнять командами и данными"). Больше команд - чем находится в собственном "буфере команд" - видеокарта просто принципиально не может выполнить. :leader:
Кстати - во всех "открытых системах" библиотека OpenGL чаще всего реализуется средствами библиотеки libMesa. А "OpenGL extentions" - зависящие от конкретной видеокарты - это вообще отдельный разговор. Эти "расширения" вообше не "стандартизированы". Поэтому "кросс-платформные приложения" просто не могут "легальным путём" использовать все эти расширения (правда они в основном в игровых программах и нужны :grum:)
Да уверен, так как просто говорил про скорость работы видеокарты, и имел в виду комманды как таковые сами по себе, то есть те которые находятся в самой видеопамяти, само управление моделями посредством передачи комманд от центрального процессора из оперативной памяти в видеокарту может быть совсем маленьким, это уж как хочется.
Но с уменьшением размера транзисторов хочется видеть более быстрые видеокарты но с меньшим энергопотреблением. :cheer:
А вообще ты правильно пишешь, правда не знаю точно ли о libMesa и некоторые игры всё же делали иключительно для "специфических видеокарт" типа таких как например вуудуу, хотя бы за счёт запрограммированных требований. :)

[algoritm]

Видеокарты с пассивным охлаждением лучше чем с кулером так как моторчик кулера тратит электроэнергию. :cheer:

[algoritm]

Кстати очень интересная информация появляется о gpu larrabee
www.en.wikipedia.org/wiki/Larrabee_(GPU)
:cheer:

[MaximKamerer]

Кстати очень интересная информация появляется о gpu larrabee
www.en.wikipedia.org/wiki/Larrabee_(GPU)
:cheer:
А накой оно надо ? че с ним делать ?

[Alergy]

Видеокарты с пассивным охлаждением лучше чем с кулером так как моторчик кулера тратит электроэнергию. :cheer:

Ты ещё наверное не видел водяного охлаждения в Hi-End геймерских системах.

[algoritm]

Чтобы упростить программирование графики, часто используемые команды стали делать встроенными в графичекие карты. Впоследствии наборы команд увеличивались и становились сложнее, о gpu larrabee говорят что он будет программироваться почти как обычный процессор, а это конечно увеличивает эффективность использования графической памяти. :cheer:

[Bips]

Видеокарты с пассивным охлаждением лучше чем с кулером так как моторчик кулера тратит электроэнергию. :cheer:
А с водным нужно что бы перегонять по кругу жидкость тоже электроэнергию нужно.:D

[algoritm]

Вот и я говорю видеокарты с пассивным охлаждением, когда просто передачей тепла или радиатор, лучше чем с активным охлаждением вентилятором или жидкостью. :cheer:

[algoritm]

В новых видеокартах где потоковых процессоров более 200 их начинают применять как вспомогательные вычислительные ресурсы. :cheer:

Например http://www.lenta.ru/news/2008/11/19/nvidia/

[algoritm]

А через гугл можно найти сайты где много о терминологии и технологии графики :cheer:
http://www.3dnews.ru/video/3d_glossary/
http://www.ixbt.com/video/3dalltech.html
http://www.ixbt.com/video2/terms2k5.shtml

[algoritm]

Процессор Clarkdale имеет интегрированную графику.
http://www.3dnews.ru/_imgdata/img/2009/02/12/113039.jpg
http://www.3dnews.ru/_imgdata/img/2009/02/12/113040.jpg
http://www.3dnews.ru/_imgdata/img/2009/02/12/113041.jpg
http://www.3dnews.ru/_imgdata/img/2009/02/12/113042.jpg
http://www.3dnews.ru/_imgdata/img/2009/02/12/113046.jpg
http://www.3dnews.ru/_imgdata/img/2009/02/12/113043.jpg
http://www.3dnews.ru/_imgdata/img/2009/02/12/113044.jpg
http://www.3dnews.ru/_imgdata/img/2009/02/12/113044.jpg
http://www.3dnews.ru/_imgdata/img/2009/02/12/113045.jpg
http://www.3dnews.ru/_imgdata/img/2009/02/12/113051.jpg
http://www.3dnews.ru/news/ofitsialno_o_32_nm_protsessorah_intel_semeistva_we stmere
:cheer:

[Orca]

малевич корчится от зависти...

Нет, он крутится в гробу волчком.....

[algoritm]

"Компания Caustic Graphics разработала графический чип, который поддерживает технологию трассировки лучей, позволяющую делать изображение в играх и программах, работающих с трехмерной графикой, гораздо более реалистичным."
"Трассировка лучей подразумевает анализ прохождения лучей света через моделируемую сцену. Для этого во все стороны от наблюдателя выстреливаются миллионы лучей, которым предстоит отразиться, ослабнуть, погаснуть или улететь в никуда. Попавшие в глаз наблюдателя лучи формируют изображения. Применение трассировки лучей требует огромных объемов вычислений."
"Полноценные графические решения для трассировки лучей пока только разрабатываются. Над ней активно работает Intel, чья первая дискретная видеокарта Larrabee с поддержкой этой технологии появится не раньше конца 2009 года. Сторонним компаниям также удалось добавить поддержку трассировки лучей в видеокарты AMD."
http://www.lenta.ru/news/2009/03/09/caustic/

"Новые видеокарты AMD Radeon серии 4800 можно заставить поддерживать метод трассировки лучей"
http://lenta.ru/news/2008/06/30/raytracing/
:cheer:

[algoritm]

"Разработчики Firefox и OpenGL займутся трехмерными браузерными играми"
http://www.lenta.ru/news/2009/03/25/web/
:cheer:

[algoritm]

"Nvidia выпустила новое поколение профессиональных видеокарт"
"Младшая модель новой линейки Quadro - видеокарта Quadro NVS 295. Она позиционируется как решение для бизнеса и поддерживает одновременную работу двух 30-дюймовых дисплеев."
"Видеокарты Nvidia Quadro FX 3800 и FX 4800 поддерживают технологии SDI и SLI Multi-OS и предназначены, в частности, для разработчиков графических приложений. Quadro FX 5800 - топовая модель новой линейки Quadro. Эта карта поддерживает SLI Multi-OS и является первым решением такого уровня с четырьмя гигабайтами памяти."
http://www.lenta.ru/news/2009/03/31/quadro/
:cheer:

[algoritm]

В html5 методы и переменные элемента canvas 2D указаны в "4.8.11.1 The 2D context"
http://dev.w3.org/html5/spec/Overview.html#the-canvas-element
http://dev.w3.org/html5/spec/Overview.html#the-2d-context
:cheer: