b'\n_START_ARTICLE_\nComparaci\xc3\xb3n entre Direct3D y OpenGL\n_START_PARAGRAPH_\nDirect3D y OpenGL son interfaces para la programaci\xc3\xb3n de aplicaciones (API acr\xc3\xb3nimo del ingl\xc3\xa9s Application Programing Interfaces) competitivas que pueden ser usadas en aplicaciones para representar gr\xc3\xa1ficos por computadora (o tambi\xc3\xa9n llamado computaci\xc3\xb3n gr\xc3\xa1fica) en 2D y 3D, tomando como ventaja de la aceleraci\xc3\xb3n por hardware cuando se dispone de esta. Las unidades de procesamiento gr\xc3\xa1fico (GPU acr\xc3\xb3nimo del ingl\xc3\xa9s Graphics Processing Unit) modernas, pueden implementar una versi\xc3\xb3n particular de una o ambas de estas interfaces.\n_START_SECTION_\nPortatibilidad\n_START_PARAGRAPH_\nDirect3D esta oficialmente implementado s\xc3\xb3lo en la familia de sistemas operativos de Microsoft Windows, incluyendo las versiones integradas utilizadas en la familia de videoconsolas Xbox de Microsoft Corporation y Dreamcast de Sega. Varios puertos en su mayor\xc3\xada funcionales de las API de Direct3D son construidos por Wine, un proyecto para lograr APIs de Windows con puerto com\xc3\xban en sistemas operativos de tipo Unix-Like, y Cedega, pero esto se ve obstaculizado debido a la interdependencia de DirectX en muchos otros componentes de Windows._NEWLINE_OpenGL tiene implementaciones disponibles en muchas plataformas, incluyendo Microsoft Windows y sistemas Unix como Mac OS X, GNU / Linux. Es un error pensar que las variantes de OpenGL se utilizan en Nintendo y las plataformas de Sony, ya que han desarrollado sus propias bibliotecas. La consola de juegos PlayStation 3 tiene una implementaci\xc3\xb3n de OpenGL, pero sigue sin ser utilizado por la mayor\xc3\xada de los desarrolladores debido a problemas de rendimiento. Un subconjunto de OpenGL fue elegido como biblioteca principal de gr\xc3\xa1ficos para Android, BlackBerry, iOS y Symbian en la versi\xc3\xb3n llamada OpenGLES._NEWLINE_El controlador de Microsoft OpenGL ofrece aceleraci\xc3\xb3n de hardware en Windows Vista, el soporte fue eliminado de Windows XP, no mucho despu\xc3\xa9s de que no pudo salir al mercado el soporte Fahrenheit de bajo nivel para una fusi\xc3\xb3n OpenGL / DirectX a finales de 1990. La aceleraci\xc3\xb3n por hardware de OpenGL en Windows est\xc3\xa1 disponible desde la primera vez que son instalados por los usuarios los controladores instalables del cliente (CIC) desarrollados por los fabricantes de GPU.\xe2\x80\x8b Estos CIC, en casi todos los casos, son incluidos en el paquete de controlador est\xc3\xa1ndar del proveedor de hardware (IHV), por lo que instalar los \xc3\xbaltimos controladores de gr\xc3\xa1ficos es suficiente para proporcionar soporte de hardware OpenGL.\xe2\x80\x8b\n_START_SECTION_\nDirect3D\n_START_PARAGRAPH_\nLa primera versi\xc3\xb3n de Direct3D suscit\xc3\xb3 cr\xc3\xadticas generalizadas porque las operaciones m\xc3\xa1s simples, tales como cambios de estado, requer\xc3\xadan la creaci\xc3\xb3n de objetos llamados "buffers ejecutables". En contraste, la mayor\xc3\xada de los cambios de estado de OpenGL se pod\xc3\xadan realizar con solo llamar a una funci\xc3\xb3n. Por su parte el modelo de Direct3D para esto frustro a muchos programadores. Una queja muy famosa fue realizada probablemente por el alto perfil de desarrollador de juegos John D. Carmack en el archivo.plan en el cual incit\xc3\xb3 a Microsoft a abandonar Direct3D y unirse a la idea de OpenGL.\xe2\x80\x8b Chris Hecker hizo una petici\xc3\xb3n similar en una "Carta Abierta a Microsoft "en el per\xc3\xadodo abril-mayo de 1997 en la revista Game Developer.\xe2\x80\x8b_NEWLINE_La Versi\xc3\xb3n 5 (la segunda versi\xc3\xb3n, llamada a reflejar su lanzamiento como parte de DirectX 5) sustituye los "buffers ejecutables" por la nueva API DrawPrimitive, pero todav\xc3\xada era considerado engorroso. En otra "Carta abierta a Microsoft" Chris Hecker se refer\xc3\xada a DrawPrimitive como "un clon inmaduro y mal dise\xc3\xb1ado de OpenGL al que le faltan algunas de las decisiones arquitect\xc3\xb3nicas que hacen r\xc3\xa1pido a OpenGL".\xe2\x80\x8b_NEWLINE_A pesar de la controversia, Microsoft sigui\xc3\xb3 evolucionando el API. Una historia detallada de las versiones y las caracter\xc3\xadsticas agregadas se da en las p\xc3\xa1ginas web de Microsoft Direct3D._NEWLINE_Algunos cr\xc3\xadticos anteriores de Direct3D reconocen que ahora es tan bueno o mejor que OpenGL en t\xc3\xa9rminos de capacidades y facilidad de uso. En enero de 2007, John Carmack dijo que "[...] DirectX9 ha alcanzado realmente un buen nivel como API, incluso en la concepci\xc3\xb3n de Direct3D de las cosas, donde s\xc3\xa9 que tienen una larga historia de gente que piensa que soy antag\xc3\xb3nico en contra. Microsoft ha hecho un muy, muy buen trabajo de sensatez que evoluciona a cada paso, no est\xc3\xa1 preocupado por no romper la compatibilidad hacia atr\xc3\xa1s y es una API bastante limpia. Me gusta especialmente el trabajo que estoy haciendo en el 360, y es probablemente la mejor API gr\xc3\xa1fica en la que he trabajado".\xe2\x80\x8b_NEWLINE_Algunas de las caracter\xc3\xadsticas de dise\xc3\xb1o de Direct3D se han mantenido sin cambios desde la versi\xc3\xb3n uno, m\xc3\xa1s notablemente su dependencia del COM (acr\xc3\xb3nimo del ingl\xc3\xa9s: Component Object Model) de Microsoft. Una ventaja de usar COM es que la API se puede utilizar en cualquier lenguaje COM, sobre todo Delphi y Microsoft Visual C++, C# y Visual Basic NET.\n_START_SECTION_\nOpenGL\n_START_PARAGRAPH_\nOpenGL esta espec\xc3\xadficamente implementado en el lenguaje C, aunque se puede usar en otros lenguajes de programaci\xc3\xb3n. Se basa en el concepto de una m\xc3\xa1quina de estados o aut\xc3\xb3matas, aunque las versiones m\xc3\xa1s recientes de OpenGL han transformado en mucho m\xc3\xa1s que un sistema basado en objetos. Como toda API, OpenGL no depende de ninguna caracter\xc3\xadstica de lenguaje particular, y puede llamarse desde casi cualquier lenguaje de programaci\xc3\xb3n con los enlaces apropiados. Estos enlaces existen para Ada, BASIC (BlitzMax (a menudo utilizado para programar juegos), \'PureBasic, Visual Basic), C#, Delphi, Fortran, Haskell, Java, Lisp, Lua, Pascal, Perl, Python y Ruby por nombrar algunos.\n_START_SECTION_\nComparaci\xc3\xb3n\n_START_PARAGRAPH_\nEn general, Direct3D est\xc3\xa1 dise\xc3\xb1ado para virtualizar interfaces 3D de hardware. Direct3D libera al programador de juegos de acomodar el hardware de gr\xc3\xa1ficos. OpenGL, por otro lado, est\xc3\xa1 dise\xc3\xb1ado para ser un sistema de representaci\xc3\xb3n de aceleraci\xc3\xb3n 3D por hardware que puede ser emulado en software. Estos dos APIs est\xc3\xa1n orientadas fundamentalmente bajo dos modos diferentes de pensamiento._NEWLINE_Como tal, existen diferencias funcionales en la forma de trabajo de las dos APIs. Direct3D espera por la aplicaci\xc3\xb3n para gestionar los recursos de hardware, OpenGL hace que la implementaci\xc3\xb3n se encargue de esto. Este equilibrio para OpenGL disminuye la dificultad en el desarrollo de la API, mientras que al mismo tiempo aumenta la complejidad en la creaci\xc3\xb3n de una aplicaci\xc3\xb3n (o controlador) que se comporte de manera correcta. Con Direct3D, el programador debe gestionar los recursos de hardware de forma independiente. Sin embargo, la implementaci\xc3\xb3n es m\xc3\xa1s sencilla, y los desarrolladores tienen flexibilidad para asignar recursos de la manera m\xc3\xa1s eficiente posible para su aplicaci\xc3\xb3n._NEWLINE_Hasta alrededor del 2005, otra diferencia funcional entre estas dos API, era la forma en que manejaron la representaci\xc3\xb3n de las texturas. El m\xc3\xa9todo de Direct3D (SetRenderTarget ()) es conveniente, mientras que las versiones anteriores de OpenGL requieren la manipulaci\xc3\xb3n de buffers de p\xc3\xadxel (P-buffers). Esto era complicado y arriesgado: si el c\xc3\xb3digo base del programador era diferente del previsto por el fabricante del controlador, el c\xc3\xb3digo estar\xc3\xada de nuevo ante un problema en la representaci\xc3\xb3n del software, causando una ca\xc3\xadda de rendimiento considerable._NEWLINE_Aparte de estas pocas diferencias funcionales que, en su mayor\xc3\xada han sido abordados a trav\xc3\xa9s de los a\xc3\xb1os, las dos APIs proporcionan casi el mismo nivel de funcionamiento. Los fabricantes de hardware y software en general responden r\xc3\xa1pidamente a los cambios en DirectX, por ejemplo, el procesador de pixel shader y los requerimientos de shader en DirectX 9 o los procesadores de flujo en DirectX 10, mientras que las nuevas funciones de OpenGL se realizan principalmente por primera vez por los vendedores y despu\xc3\xa9s se aplican con car\xc3\xa1cter retroactivo a los est\xc3\xa1ndares.\n_START_SECTION_\nRendimiento\n_START_PARAGRAPH_\nPoco despu\xc3\xa9s del establecimiento de las dos APIs, Direct3D y OpenGL como librer\xc3\xadas gr\xc3\xa1ficas viables (cerca de 1995), Microsoft y SGI (del acr\xc3\xb3nimo en ingl\xc3\xa9s Silicon Graphics Inc) se dedican a lo que se ha denominado la \xc2\xabGuerra de las API\xc2\xbb. Gran parte de la discusi\xc3\xb3n gir\xc3\xb3 en torno a cual ofrece un rendimiento superior. Esta pregunta es pertinente debido al alto costo que ten\xc3\xadan los aceleradores de gr\xc3\xa1ficos durante este tiempo, lo que significa que el mercado de los consumidores estaba usando renderizadores de software implementados por Microsoft, tanto para Direct3D como para OpenGL.\n_START_SECTION_\nDebate inicial\n_START_PARAGRAPH_\nDOS es un software empresarial, como AutoCAD y los juegos de DOS tales como Doom, distribuido por la empresa id-Software, originalmente ten\xc3\xadan que ser optimizados para funcionar en muchos chipsets gr\xc3\xa1ficos diferentes. Cuando los fabricantes de hardware como 3Dlabs (miembro del OpenGL Architecture Review Board) hicieron aceleradores de gr\xc3\xa1ficos OpenGL compatibles (por ejemplo, el GLint chip ), los desarrolladores como John Carmack de id-Software optimizaron sus productos para OpenGL. En entornos multitarea, como Microsoft Windows en el PC y el sistema X Window (X11) en sistemas tipo Unix-Like lleg\xc3\xb3 a ser un factor dominante, por lo que la relevancia de este hardware se desvaneci\xc3\xb3._NEWLINE_Microsoft hab\xc3\xada comercializado Direct3D r\xc3\xa1pidamente sobre la base de comparaciones de rendimiento interno entre estas dos bibliotecas de software. El d\xc3\xa9ficit de rendimiento se atribuy\xc3\xb3 a la especificaci\xc3\xb3n rigurosa. Esta percepci\xc3\xb3n fue modificada en 1996 en la conferencia del Grupo de Inter\xc3\xa9s Especial de gr\xc3\xa1ficos y T\xc3\xa9cnicas Interactivas (SIGGRAPH). En ese momento, SGI desafi\xc3\xb3 a Microsoft con su propia implementaci\xc3\xb3n optimizada de OpenGLn para Windows llamado CosmoGL que en varias demostraciones igual\xc3\xb3 o super\xc3\xb3 el rendimiento de Direct3D. Para SGI, este fue un hito fundamental, ya que demostr\xc3\xb3 que el pobre rendimiento de OpenGL renderizado por software se debi\xc3\xb3 a las referencias de Microsoft en la implementaci\xc3\xb3n de OpenGL, y no debido a fallas de dise\xc3\xb1o supuestas en el propio OpenGL._NEWLINE_Por otra parte, la representaci\xc3\xb3n de software usando API 3D fue en gran medida irrelevante para aplicaciones Direct3D y OpenGL. No muchas aplicaciones de DirectX utilizan software Direct3D para representar, y prefieren realizar su propio software de representaci\xc3\xb3n utilizando las instalaciones de DirectDraw para acceder al hardware de la pantalla. En cuanto a las aplicaciones de OpenGL, el soporte de hardware que se esperaba, y el hardware, era mucho m\xc3\xa1s r\xc3\xa1pido que el software de reserva de la aplicaci\xc3\xb3n OpenGL esto constituy\xc3\xb3 una desagradable sorpresa para el desarrollador de OpenGL._NEWLINE_En cualquier caso, por el momento SGI ha demostrado que el software OpenGL tiene un rendimiento de representaci\xc3\xb3n que puede ser competitivo con el de Direct3D, la representaci\xc3\xb3n del software se est\xc3\xa1 convirtiendo en irrelevante debido a la amplia disponibilidad de hardware baratos para gr\xc3\xa1ficos 3D. En 1998, incluso el acelerador de gr\xc3\xa1ficos S3 ViRGE fue considerablemente m\xc3\xa1s r\xc3\xa1pido que el m\xc3\xa1s r\xc3\xa1pido Pentium II funcionando con el rasterizador MMX de Direct3D.\n_START_SECTION_\nModo de conmutaci\xc3\xb3n (en Microsoft Windows)\n_START_PARAGRAPH_\nUna diferencia de rendimiento m\xc3\xa1s sustantiva y moderna surge debido a la estructura de los controladores de hardware proporcionados por los desarrolladores de hardware. Por detr\xc3\xa1s de DirectX trabajan los controladores IHV que son, en cierto modo, controladores instalados en el sistema operativo. La parte de modo de usuario de la API es manejada por el runtime de DirectX que proporciona Microsoft. En OpenGL sin embargo, el controlador IHV se divide en dos partes: una parte en modo de usuario que implementa la API OpenGL, y un controlador de modo kernel que se llama por la parte de modo de usuario._NEWLINE_Esto es un problema porque llamar a las operaciones en modo kernel de modo de usuario requiere la realizaci\xc3\xb3n de una llamada al sistema (es decir, hacer el cambio de CPU al modo kernel). Esta es una operaci\xc3\xb3n lenta donde el tiempo de demora en completarse se encuentra en el orden de los microsegundos.\xe2\x80\x8b Durante este tiempo, la CPU no puede realizar ninguna operaci\xc3\xb3n. Como tal, si se minimiza el n\xc3\xbamero de veces que esta operaci\xc3\xb3n de conmutaci\xc3\xb3n se realiza se optimizaria el rendimiento. Por ejemplo, si el buffer de la GPU de mando est\xc3\xa1 lleno de datos para la representaci\xc3\xb3n, la API podr\xc3\xada simplemente almacenar el pedido solicitado en un buffer temporal y, cuando el b\xc3\xbaffer de comandos est\xc3\xa1 cerca de ser vac\xc3\xado, se puede realizar un cambio de modo de kernel y agregar una serie de comandos almacenados todos a la vez. Esto se conoce como marchaling._NEWLINE_Debido a que los controladores de Direct3D IHV est\xc3\xa1n en modo de kernel y el c\xc3\xb3digo en modo usuario est\xc3\xa1 fuera del control del IHV, no hay ninguna posibilidad de que se produzcan tales optimizaciones. Debido al runtime de Direct3D, la parte de modo de usuario que implementa la API no puede tener conocimiento expl\xc3\xadcito del funcionamiento interno del conductor, por lo que el proceso de marchaling no puede ser apoyado con eficacia. Esto significa que en cada llamada Direct3D env\xc3\xada comandos para el hardware el cual debe realizar una conmutaci\xc3\xb3n en modo de kernel que a su vez, tarda un tiempo en el orden de los microsegundos en completarse. Esto ha conducido a un n\xc3\xbamero de dudas con respecto al uso de Direct3D, siendo la m\xc3\xa1s importante la necesidad de presentar grandes lotes de tri\xc3\xa1ngulos en una llamada de funci\xc3\xb3n. [8]_NEWLINE_Dado que los controladores IHV de OpenGL tienen un componente de modo de usuario en ellos, IHVs posee la capacidad de implementar el marchaling mejorando as\xc3\xad el rendimiento. Todav\xc3\xada es necesaria la conmutaci\xc3\xb3n en modo de kernel pero el n\xc3\xbamero m\xc3\xa1ximo te\xc3\xb3rico de veces en los que es realizado en la mayor\xc3\xada de las implementaciones de OpenGL es simplemente igual al comportamiento est\xc3\xa1ndar de Direct3D._NEWLINE_Direct3D 10, la versi\xc3\xb3n incluida en Windows Vista,\xe2\x80\x8b permite que porciones de los controladores funcionen en modo de usuario, por lo que es posible para IHV implementar el marshalling, por lo que las dos partes equilibran su rendimiento relativo. El OpenGL para el sistema Mac OS X es muy similar, IHV implementa una versi\xc3\xb3n m\xc3\xa1s simple de la API OpenGL (con ambos usuarios y los componentes de modo kernel), y las adiciones de Apple al runtime proporcionan la interfaz directa para el c\xc3\xb3digo de usuario, y algunas tareas b\xc3\xa1sica para hacer el trabajo de IHV m\xc3\xa1s f\xc3\xa1cil.\n_START_SECTION_\nEstructura\n_START_PARAGRAPH_\nOpenGL, originalmente dise\xc3\xb1ado para estaciones de trabajo SGI entonces poderosas, incluye una serie de caracter\xc3\xadsticas, como la representaci\xc3\xb3n de m\xc3\xbasica y el "subconjunto de im\xc3\xa1genes", que se consideraron en general de poca utilidad para los juegos, aunque han despertado mayor inter\xc3\xa9s a partir del 2011 con los juegos estereosc\xc3\xb3picos. La API en su conjunto contiene alrededor de 250 llamadas, pero s\xc3\xb3lo un subconjunto de quiz\xc3\xa1s 100 son \xc3\xbatiles para el desarrollo de juegos. Sin embargo, ning\xc3\xban subgrupo espec\xc3\xadfico para juegos oficiales se defini\xc3\xb3 alguna vez. MiniGL, publicado por 3Dfx como una medida temporal para apoyar GlQuake, podr\xc3\xada haber servido como punto de partida, pero las caracter\xc3\xadsticas adicionales como la plantilla fueron adoptadas luego por los juegos, y el apoyo continuo para todo el est\xc3\xa1ndar OpenGL. Hoy en d\xc3\xada, las estaciones de trabajo y las m\xc3\xa1quinas de los consumidores utilizan las mismas arquitecturas y sistemas operativos, y encarnaciones modernas del est\xc3\xa1ndar de OpenGL todav\xc3\xada incluyen estas caracter\xc3\xadsticas, aunque s\xc3\xb3lo algunas estaciones de trabajo con tarjetas de video especiales lo aceleran.\n_START_SECTION_\nExtensiones\n_START_PARAGRAPH_\nEl mecanismo de extensi\xc3\xb3n OpenGL es probablemente la diferencia m\xc3\xa1s fuertemente disputada entre los dos APIs. OpenGL incluye un mecanismo en el que cualquier conductor puede conocer sus propias extensiones a la API, lo que introduce nuevas funciones como modos de mezcla, nuevas formas de transferir datos a GPUs o diferentes par\xc3\xa1metros de envoltura de textura. Esto permite que las funciones exponer nuevas r\xc3\xa1pidamente, pero puede provocar confusi\xc3\xb3n si diferentes proveedores implementan extensiones similares con diferentes APIs. Muchas de estas extensiones son peri\xc3\xb3dicamente estandarizadas por el OpenGL Architecture Review Board (ARB), y algunos se hacen una parte fundamental de las futuras revisiones de OpenGL._NEWLINE_Por otro lado, Direct3D es especificado por un proveedor \xc3\xbanico (Microsoft), lo cual asegura una API m\xc3\xa1s consistente, pero sin embargo deniegan el acceso a las caracter\xc3\xadsticas espec\xc3\xadficas del proveedor. La tecnolog\xc3\xada NVIDIA UltraShadow, por ejemplo, no est\xc3\xa1 disponible en el API Direct3D en tiempo de escritura. Cabe se\xc3\xb1alar que Direct3D hace de soporte para extensiones de formato de textura (por FourCC). Estas fueron una vez poco conocido y utilizado en raras ocasiones, pero ahora se utilizan para Compresi\xc3\xb3n de texturas S3._NEWLINE_Cuando las tarjetas gr\xc3\xa1ficas han a\xc3\xb1adido soporte para pixel shaders (conocidos en OpenGL como "Fragment Shader"), Direct3D ha proporcionado un est\xc3\xa1ndar "de Pixel Shader 1.1" (PS1.1) con la que la GeForce 3 o superior, y Radeon 8500 o superior, son totalmente compatibles. Bajo las mismas funciones OpenGL se accede a trav\xc3\xa9s de una variedad de extensiones personalizadas._NEWLINE_En teor\xc3\xada, el enfoque de Microsoft permite una ruta de c\xc3\xb3digo para apoyar a las marcas de tarjeta, mientras que en OpenGL, los programadores deben escribir dos sistemas separados. En realidad a causa de los l\xc3\xadmites de los p\xc3\xadxeles de las tarjetas iniciales, Pixel Shader 1.1 no era m\xc3\xa1s que una versi\xc3\xb3n en pseudo-montaje de las extensiones espec\xc3\xadficas de NVIDIA OpenGL. En su mayor parte, las \xc3\xbanicas tarjetas PS 1,1 que permiten esta funcionalidad son las NVIDIA, y eso se debe a que fueron construidas para ello de forma nativa. Cuando la Radeon 8500 fue lanzado, Microsoft public\xc3\xb3 una actualizaci\xc3\xb3n de Direct3D que incluye Pixel Shader 1.4, que no era m\xc3\xa1s que una versi\xc3\xb3n en pseudo-montaje de las extensiones espec\xc3\xadficas de ATI OpenGL._NEWLINE_Esta situaci\xc3\xb3n s\xc3\xb3lo existi\xc3\xb3 durante un corto tiempo bajo ambos APIs. La segunda generaci\xc3\xb3n de tarjetas de sombreado de p\xc3\xadxeles funcion\xc3\xb3 mucho m\xc3\xa1s similar, con cada arquitectura evolucionando hacia el mismo tipo de conclusi\xc3\xb3n de p\xc3\xadxeles de procesamiento. Como tal Shader, Pixel 2.0 permite una ruta de c\xc3\xb3digo unificado bajo Direct3D. Por la misma \xc3\xa9poca OpenGL introdujo sus propias extensiones de sombreado de v\xc3\xa9rtices y p\xc3\xadxeles aprobados por la ARB (GL ARB Vertex Program y GL ARB Fragment Program), y los dos conjuntos de tarjetas apoyaron esta norma tambi\xc3\xa9n.\n_START_SECTION_\nGr\xc3\xa1ficos Profesionales\n_START_PARAGRAPH_\nOpenGL siempre ha visto un uso m\xc3\xa1s profesional en el mercado de gr\xc3\xa1ficos que DirectX, DirectX por su parte se utiliza principalmente para juegos de ordenador. (El t\xc3\xa9rmino profesional se utiliza aqu\xc3\xad para referirse a la producci\xc3\xb3n profesional y visualizaci\xc3\xb3n de gr\xc3\xa1ficos, tales como en pel\xc3\xadculas de animaci\xc3\xb3n por ordenador y la visualizaci\xc3\xb3n cient\xc3\xadfica, no en los juegos donde los gr\xc3\xa1ficos obtenidos son para uso personal, en lugar de profesional, del usuario final.) actualmente, tanto OpenGL y DirectX tienen un solapamiento suficientemente grande en la funcionalidad que bien puede utilizarse para la mayor\xc3\xada de prop\xc3\xb3sitos comunes, con el sistema operativo en s\xc3\xad mismo a menudo siendo el que dicta el criterio principal que se utiliza, con DirectX la opci\xc3\xb3n com\xc3\xban es Windows, mientras que OpenGL se utiliza en casi todo lo dem\xc3\xa1s.\n_START_SECTION_\nJugabilidad\n_START_PARAGRAPH_\nEn los primeros d\xc3\xadas de los juegos acelerados en 3D, el rendimiento y la fiabilidad eran los puntos de referencia clave y varias tarjetas aceleradoras 3D compet\xc3\xadan entre s\xc3\xad por el dominio. El software fue escrito espec\xc3\xadficamente para una determinada marca de tarjeta gr\xc3\xa1fica. Sin embargo, con los a\xc3\xb1os, OpenGL y Direct3D han construido varias capas de software por encima del hardware, principalmente debido al apoyo de la industria para una biblioteca cruzada para hardware de gr\xc3\xa1ficos.\n_START_SECTION_\nTel\xc3\xa9fonos m\xc3\xb3viles y otros dispositivos integrados\n_START_PARAGRAPH_\nOpenGL para sistemas integrados (tambi\xc3\xa9n conocido como OpenGL ES) es un subconjunto de la API OpenGL para gr\xc3\xa1ficos 3D dise\xc3\xb1ado para dispositivos integrados. Varias versiones de sistemas operativos de smartphones son compatibles con OpenGL ES, como Android, iOS (iPad, iPhone, iPod Touch), Maemo (Nokia N900), y Symbian._NEWLINE_OpenGL ES est\xc3\xa1 disponible en 3 variantes, OpenGL ES 1.0, 1.1, y 2.0. Comenzando con el lanzamiento de la 2.0, la compatibilidad hacia atr\xc3\xa1s con las anteriores variantes fue eliminada, debido a la extensa gama de funciones programables disponibles en GL ES 2.0._NEWLINE_Direct3D Mobile es un derivado de Direct3D compatible con Windows CE._NEWLINE_\xe2\x80\x8b En la actualidad todos los dispositivos Windows Phone 7 utiliza una interfaz de usuario. NET Framework.'