• Artykuły
  • Forum
  • Ciekawostki
  • Encyklopedia
  • OpenGL



    Podstrony: [1] [2] 3 [4] [5]
    Przeczytaj także...
    GPGPU (ang. General-Purpose computing on Graphics Processor Units lub General-Purpose computation on Graphics Processing Units – obliczenia ogólnego przeznaczenia na układach GPU, zwany także GPGP, rzadziej GP) – technika, dzięki której GPU, zwykle zajmujący się tylko obliczeniami związanymi z grafiką komputerową, umożliwia wykonywanie obliczeń ogólnego przeznaczenia, tak jak CPU. Dzięki temu wiele obliczeń, głównie obliczenia równoległe, można przeprowadzić znacznie szybciej.Teksturowanie - technika stosowana w grafice trójwymiarowej, której celem jest przedstawienie szczegółów powierzchni obiektów przestrzennych za pomocą obrazów bitmapowych (tekstur) lub funkcji matematycznych (tekstur proceduralnych). Mapowanie tekstury określa w jaki sposób powiązać piksele (nazywane w tym kontekście tekselami) lub wartości funkcji z powierzchnią obiektu. Tekstury niosą informacje o barwie powierzchni, jak również innych parametrach generowanego obrazu, związanych np. z modelem oświetlenia: barwa światła odbitego, rozproszonego, stopień przezroczystości, współczynnik załamania światła itp.
    Rozszerzenia[ | edytuj kod]

    OpenGL został zaprojektowany w taki sposób, aby producenci sprzętu graficznego mogli rozszerzać jego funkcjonalność poprzez własne rozszerzenia. Rozszerzenia takie dystrybuowane są poprzez publikację zarówno sterowników obsługujących dane funkcje, jak również plików nagłówkowych z definicjami tychże, aby z funkcji tych mogli skorzystać programiści piszący oprogramowanie używające OpenGL.

    Software development kit, SDK – zestaw narzędzi dla programistów niezbędny w tworzeniu aplikacji korzystających z danej biblioteki (np. DirectX SDK), pod dany system (np. Microsoft Platform SDK), sprzęt itp.Matrox – kanadyjska firma dostarczająca sprzęt i rozwiązania do obsługi grafiki (w tym karty graficzne i chipsety), edycji wideo oraz przetwarzania obrazów. Firma znana jest głównie z produkcji kart graficznych przez oddział firmy Matrox Graphics Inc. zwanym MGA.

    Funkcje lub stałe występujące w rozszerzeniach oznaczane są skrótami przyporządkowanymi poszczególnym producentom (np. funkcje firmy NVIDIA oznaczane są skrótem NV). Jeśli funkcja jest używana przez więcej niż jednego producenta, oznaczana jest skrótem EXT, a w przypadku, gdy zostanie oficjalnie zaakceptowana przez Architectural Review Board, staje się ona rozszerzeniem standardowym i otrzymuje oznaczenie ARB. Później, rozszerzenie może się stać oficjalnie częścią standardu OpenGL, w kolejnej jego wersji.

    Renderowanie (od ang. rendering) – przedstawienie informacji zawartych w dokumencie elektronicznym w formie najbardziej właściwej dla danego środowiska (np. wizualnie, w tym na ekranie i w druku, czy dźwiękowo). Mechanizm odpowiedzialny w programie komputerowym za renderowanie nazywa się mechanizmem renderującym (ang. rendering engine, czasem silnik renderujący) lub rendererem (z ang.).Khronos Group została założona w styczniu 2000 roku przez wiodące korporacje w dziedzinie systemów multimedialnych (media-centric), w skład których wchodzą między innymi: 3Dlabs, ATI, Discreet, Evans & Sutherland, Intel, NVIDIA Corporation, SGI, Google i Sun Microsystems. Celem tej organizacji jest tworzenie otwartych standardów API umożliwiających authoring i odtwarzanie w szerokim zakresie mediów na różnorodnych platformach i urządzeniach.

    Przykładowy kod[ | edytuj kod]

    Potok programowalny OpenGL 3.3

    Najmniejszy, najprostszy program wykorzystujący możliwości OpenGL składa się z pięciu plików. Głównego pliku programu – main.cpp, klasy wykorzystującej możliwości OpenGL (mainwindow.cpp) oraz nagłówka do tej klasy (mainwindow.h), a także dwóch plików z kodem shaderów.

    NVIDIA Corporation NASDAQ: NVDA – amerykańska firma komputerowa; jeden z największych na świecie producentów procesorów graficznych i innych układów scalonych przeznaczonych na rynek komputerowy. NVIDIA jest także głównym dostawcą (pod względem udziału w rynku) producentów kart graficznych dla komputerów osobistych ze swoją standardową serią GeForce.Sterownik urządzenia to program lub fragment programu odpowiadający za dane urządzenie i pośredniczący pomiędzy nim, a resztą systemu komputerowego. Zwykle uabstrakcyjnia pewne cechy urządzenia, choć może jedynie zajmować się kwestiami uprawnień dostępu i udostępniać urządzenie bez żadnej ingerencji. Wtedy program, który z niego korzysta też jest w pewnym sensie sterownikiem.
    Kolejność przekształceń punktów/wierzchołków

    Przykład został napisany w języku C++ z wykorzystaniem bibliotek Qt. Wykorzystuje on OpenGL w wersji 3.3.

    Niezbędne funkcje i klasy do napisania programu:

    main:

  • QApplication,
  • Nasza nowa klasa wykorzystująca OpenGL,
  • QSurfaceFormat
  • QSufraceFormat::defaultFormat();
  • QSurfaceFormat::setProfile();
  • QSurfaceFormat::setVersion();
  • QSurfaceFormat::setDefaultFormat();
  • mainwindow:

    1) Przygotowanie:

    GLUT (ang. OpenGL Utility Toolkit) – biblioteka użytkowa, która wykonuje głównie operacje wejścia/wyjścia na poziomie systemu operacyjnego.Procesor graficzny, inaczej GPU (ang. Graphics Processing Unit) – jest główną jednostką obliczeniową znajdującą się w nowych kartach graficznych.
  • inicializeOpenGLFunctions();
  • glCreateProgram();
  • glCreateShader();
  • glShaderSource();
  • glCompileShader();
  • glGetShaderiv();
  • glAttachShader();
  • glDeleteShader();
  • glGetShaderInfoLog();
  • glLinkProgram();
  • glGetProgramiv();
  • 3) Obiekty – przygotowanie:

  • glGenVertexArray();
  • glBindVertexArray();
  • glEnableVertexAtribArray();
  • glGenBuffers();
  • glBindBuffer();
  • glBufferData();
  • glVertexAttribPointer();
  • glGenTextures();
  • glActiveTexture();
  • glBindTexture();
  • glTexImage2D()
  • glTexParameteri();
  • 4) Opcjonalne:

  • glGenFramebuffers();
  • glBindFramebuffer();
  • glFramebufferTexture2D();
  • glCheckFramebufferStatus();
  • 5) Rysowanie/Działanie:

    Microsoft Windows (ang. windows „okna”, IPA: [maɪkɹoʊsɑːft ˈwɪndoʊz]) – rodzina systemów operacyjnych stworzonych przez firmę Microsoft. Systemy rodziny Windows działają na serwerach, systemach wbudowanych oraz na komputerach osobistych, z którymi są najczęściej kojarzone. OpenGL Extension Wrangler Library (GLEW) – programistyczna biblioteka międzyplatformowa do języka C/C++, pomagająca w odpytywaniu i ładowaniu rozszerzeń OpenGL. GLEW dostarcza efektywne mechanizmy do określania w czasie uruchamiania programu dostępnych rozszerzeń na danej platformie. Wszystkie rozszerzenia OpenGL są wylistowane w jednym pliku nagłówkowym, który z kolei jest maszynowo generowany na podstawie oficjalnej listy rozszerzeń. GLEW jest dostępny na wielu platformach, np. Windows, Linux, Mac OS X, FreeBSD, IRIX i Solaris. GLEW jest dystrybuowany na warunkach zmodyfikowanej licencji BSD.
  • glGetIntegerv();
  • glBindFramebuffer();
  • glViewport();
  • glClear();
  • glUseProgram();
  • glActiveTexture();
  • glBindTexture()
  • glGetUniformLocation();
  • glUniform1i();
  • glBindVertexArray();
  • glDrawArrays();
  • Niezbędne makra:

  • GL_VERTEX_SHADER,
  • GL_COMPILE_STATUS,
  • GL_FRAGMENT_SHADER,
  • GL_LINK_STATUS,
  • GL_ARRAY_BUFFER,
  • GL_STATIC_DRAW,
  • GL_FALSE,
  • GL_FLOAT,
  • GL_TEXTURE0,
  • GL_TEXTURE_2D,
  • GL_RGBA,
  • GL_BGRA,
  • GL_UNSIGNED_BYTE,
  • GL_TEXTURE_MIN_FILTER,
  • GL_LINEAR,
  • GL_COLOR_BUFFER_BIT,
  • GL_TRIANGLES,
  • Dodatkowe makra:

  • GL_FRAMEBUFFER,,
  • GL_COLOR_ATTACHMENT0,
  • GL_DRAW_FRAMEBUFFER_BINDING,
  • Szczegóły na temat poszczególnych funkcji oraz makr podane są na stronie dokumentacji OpenGL.

    Automat skończony (ang. finite state machine, FSM) – abstrakcyjny, matematyczny, iteracyjny model zachowania systemu dynamicznego oparty na tablicy dyskretnych przejść między jego kolejnymi stanami (diagram stanów).Mipmapping to technika teksturowania bitmapami wykorzystywana w grafice trójwymiarowej, która pozwala uniknąć artefaktów i tym samym uzyskać lepszą jakość obrazów. Także przyspiesza sam proces teksturowania. Mipmapping został opracowany przez Lance Williamsa w 1983 roku.

    Plik main.cpp

    # include "mainwindow.h"
    # include <QApplication>
    # include <QSurfaceFormat>
    
    int main(int argc, char *argv)
    {
        QApplication a(argc, argv);
    
        QSurfaceFormat format = QSurfaceFormat::defaultFormat();
        format.setProfile(QSurfaceFormat::CoreProfile);
        format.setVersion(3,3);
        QSurfaceFormat::setDefaultFormat(format);
    
        MainWindow w;
        w.show();
    
        return a.exec();
    }
    

    Plik mainwindow.h

    DirectX – zestaw funkcji API wspomagających generowanie grafiki (dwu- i trójwymiarowej), dźwięku oraz innych zadań związanych zwykle z grami i innymi aplikacjami multimedialnymi.ATI Technologies Inc. (gdzie ATI jest skrótem od Array Technologies Incorporated) NASDAQ: ATYT – to kanadyjski producent układów scalonych, znany głównie ze swoich kart graficznych. Notowany na giełdach w Toronto i NASDAQ.
    # ifndef MAINWINDOW_H
    # define MAINWINDOW_H
    
    //#include <QMainWindow>
    # include <QOpenGLFunctions_3_3_Core>
    # include <QOpenGLWidget>
    
    class MainWindow : public QOpenGLWidget, protected QOpenGLFunctions_3_3_Core //public QMainWindow,
    {
        //Q_OBJECT
    
        GLuint uchwytProg1; //unsigned int
    
        GLuint VertexArrayO;  // Vertex Array Object
        int ilWierz;   //ilosc wierzcholkow
    
        GLuint tex0;
    
    public:
        MainWindow();
        ~MainWindow();
    
        void initializeGL();
        void paintGL();
        void resizeGL(int w, int h);
    };
    
    # endif // MAINWINDOW_H
    

    Plik mainwindow.cpp

    OpenGL Architecture Review Board (ARB, OpenGL ARB) – zrzeszenie firm, zajmujące się rozwojem biblioteki OpenGL. Utworzone w 1992 roku ustanawia nowe standardy grafiki 3D oraz kierunku rozwoju sektora graficznego, przygotowuje, testuje i zatwierdza zmiany w specyfikacji, a także przygotowuje oficjalne aktualizacje biblioteki. 31 lipca 2006 r. kontrola na biblioteką OpenGL zostały przekazane do Khronos Group.Otwarty standard – standard, do którego pełnej specyfikacji dostęp nie jest limitowany prawnie, finansowo lub tajemnicą handlową firmy, która standard opracowała. Ponadto standard uznawany jako otwarty jest opracowywany, zatwierdzany oraz później ewentualnie modyfikowany przez porozumienie (organizację) zainteresowanych tworzeniem tego standardu podmiotów, działające niedochodowo i zapewniające członkostwo wszystkim zainteresowanym.
    # include "mainwindow.h"
    
    # include <QOpenGLFunctions_3_3_Core>
    # include <QFile>
    # include <Qdebug>
    
    struct vec3 { float x,y,z; };
    
    MainWindow::MainWindow() //QMainWindow(parent)
    { }
    
    MainWindow::~MainWindow()
    { }
    
    void MainWindow::initializeGL()
    {
        initializeOpenGLFunctions();
    
        qDebug() << "initializeGL";
    
        GLint status;
    
        // program kopiujący teksture na ekran
        uchwytProg1 = glCreateProgram();
    
        QFile file("vshaderS.sh");
        if(file.open(QFile::ReadOnly))
        {
            QTextStream stream(&file);
            std::string vshader_zrodlo = stream.readAll().toStdString();
    
            GLuint shader = glCreateShader(GL_VERTEX_SHADER);
            GLchar* srcs = {(GLchar*)vshader_zrodlo.c_str()};
            glShaderSource(shader, 1, srcs, NULL);
            glCompileShader(shader);
    
            glGetShaderiv(shader, GL_COMPILE_STATUS, &status); //skompilowany
            if( status == true )
            {
                glAttachShader(uchwytProg1, shader);
                glDeleteShader(shader);
            } else { qDebug() << "Shadera nie skompilowano. V"; }
             qDebug() << "BB" << vshader_zrodlo.c_str();
        } else qDebug() << "Brak pliku";
        file.close();
    
        QFile file2("fshaderS.sh");
        if(file2.open(QFile::ReadOnly))
        {
            QTextStream stream(&file2);
            std::string vshader_zrodlo = stream.readAll().toStdString();
    
            GLuint shader = glCreateShader(GL_FRAGMENT_SHADER);
            GLchar* srcs = {(GLchar*)vshader_zrodlo.c_str()};
            glShaderSource(shader, 1, srcs, NULL);
            glCompileShader(shader);
            glGetShaderiv(shader, GL_COMPILE_STATUS, &status); //skompilowany
            if( status == true )
            {
                glAttachShader(uchwytProg1, shader);
                glDeleteShader(shader);
            } else {
                qDebug() << "Błąd komp. szhadera. F";
                GLchar infoLog[10240];
                glGetShaderInfoLog(shader, 10240, NULL, infoLog);
                qDebug() << infoLog << endl;
            }
    
            qDebug() << "AA" << srcs;
        } else qDebug() << "Brak pliku";
        file2.close();
    
        glLinkProgram(uchwytProg1);
        glGetProgramiv(uchwytProg1, GL_LINK_STATUS, &status);
        if( status == true) { qDebug() << "Program przygotowany"; }
        else qDebug() << "Problemy z programem.";
    
        glUseProgram(uchwytProg1);
        GLint polozenie = glGetUniformLocation(uchwytProg1, "textura");
        qDebug() << "Polozenie, textura: " << polozenie;
    
        // prostokat na cały ekran
        vec3 wierzcholki = { {-1,-1,0}, {1,-1,0}, //Dwa trójkąty...
                               {1,1,0},    {1,1,0},
                               {-1,1,0},   {-1,-1,0} };
    
        ilWierz = 6;
    
        glGenVertexArrays(1, &VertexArrayO);
            glBindVertexArray(VertexArrayO);
            glEnableVertexAttribArray(0); //włączenie obsługi konkretnej tablicy atrybutów,
    
            //wygenerowanie nazwy bufora dla atrybutu i dodanie do mapy pod konkretnym indexem
                GLuint buforVertex;
                glGenBuffers(1, &buforVertex);
    
            // przypisanie bufora do tablicy vao
                glBindBuffer(GL_ARRAY_BUFFER, buforVertex);
    
            // stworzenie bufora i skopiowanie do niego danych
                glBufferData(GL_ARRAY_BUFFER, ilWierz*sizeof(vec3), wierzcholki, GL_STATIC_DRAW);
    
            // ustawienie odpowiednich typow i wielkosci bufora wierzcholkow vbo
                glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
    
           glBindBuffer(GL_ARRAY_BUFFER, 0);
       glBindVertexArray(0);
    
        glGenTextures(1, & tex0);
    
        glActiveTexture(GL_TEXTURE0);
    
        // tekstura wczytana z pliku
            QImage img("lena.png");
            if(img.width() == 0) qt_assert("QImage not loaded!", __FILE__, __LINE__);
    
            glBindTexture(GL_TEXTURE_2D, tex0);
                glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, img.width(), img.height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, img.bits());
                glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    
            glBindTexture(GL_TEXTURE_2D, 0);
    }
    
    void MainWindow::resizeGL(int w, int h)
    {
        qDebug() << "resizeGL";
    }
    
    void MainWindow::paintGL()
    {
        qDebug() << "PaintGL – rysuje";
    
        GLuint polozenie;
    
        /* niektore implementacje nie przypisuja domyslnego FB ekranu == 0
            wtedy trzeba zapamietac samemu jego numer: */
            GLint screenFB;
            glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &screenFB);
            qDebug() << "Numer dla ScreenFramebuffer:  " << screenFB;
    
            int tryb = 1;
    
        if( tryb == 1 )
        {
            // rysowanie tekstury na domyslnym FrameBufferze
    
            // glBindFramebuffer(GL_FRAMEBUFFER, 0);
            // lub
            glBindFramebuffer(GL_FRAMEBUFFER, screenFB);
            glViewport(0,0,width(), height());
    
            glClear(GL_COLOR_BUFFER_BIT);
    
            glUseProgram(uchwytProg1);
    
                // Ustawienie tekstury
                polozenie = glGetUniformLocation(uchwytProg1, "textura");
                if(polozenie != -1) glUniform1i(polozenie, 0); else qDebug() << "Brak zmiennej Uniform textura";
    
                glActiveTexture(GL_TEXTURE0);
                glBindTexture(GL_TEXTURE_2D, tex0);
    
                glBindVertexArray(VertexArrayO);
                    glDrawArrays(GL_TRIANGLES, 0, ilWierz);
                glBindVertexArray(0);
    
                glBindTexture(GL_TEXTURE_2D, tex0);
                glViewport(width()/2.0, 0, width()/2.0, height());
    
                glBindVertexArray(VertexArrayO);
                    glDrawArrays(GL_TRIANGLES, 0, ilWierz);
                glBindVertexArray(0);
    
            glUseProgram(0);
        }
    }
    

    Plik vshader.glsl – Shader Vertexów – Shader wierzchołków:

    OpenGL Shading Language (GLSL, glslang) – język programowania potoku graficznego składniowo zbliżony do języka C, wykorzystywany przez bibliotekę OpenGL. Program napisany w GLSL wykonywany jest bezpośrednio na GPU.Apple Inc. (wcześniej Apple Computer Inc.) NASDAQ: AAPL – amerykańska korporacja zajmująca się projektowaniem i produkcją elektroniki użytkowej, oprogramowania i komputerów osobistych z siedzibą w Cupertino w Kalifornii. Założona przez Steve’a Wozniaka – projektanta, Steve’a Jobsa i Ronalda Wayne’a. Produkty spółki to m.in.: komputery Mac, iPod, iPhone i iPad. Oprogramowanie Apple obejmuje system operacyjny OS X, przeglądarkę multimediów iTunes, pakiet oprogramowania multimedialnego i kreatywności iLife, pakiet oprogramowania biurowego iWork, profesjonalny pakiet fotografii Aperture, pakiet profesjonalnych rozwiązań wideo Final Cut Studio oraz zestaw narzędzi audio Logic Studio. Od stycznia 2010 roku firma działa poprzez 284 własnych sklepów detalicznych w dziesięciu krajach, oraz za pośrednictwem sklepu internetowego sprzedającego zarówno sprzęt, jak i oprogramowanie.
    # version 330
    
    layout (location=0) in vec3 VertexPosition; //atrybut zerowy,
                       out vec2 textureCoords;
    
    void main()
    {
        //Macierz skalowania,
        mat4 macierz = mat4(1, 0, 0, 0,
                            0, 1, 0, 0,
                            0, 0, 1, 0,
                            0, 0, 0, 1);
    
        vec4 a = vec4(VertexPosition.x, VertexPosition.y, VertexPosition.z, 1);
        vec4 b = a * macierz;
    
        // Macierz translacji – przesuwania
        mat4 macierzTran = mat4(  1, 0, 0, 0,
                                  0, 1, 0, 0,
                                  0, 0, 1, 0,
                                  0, 0, 0, 1);
    
        b = b * macierzTran;
    
        gl_Position = b;
        // lub:
        //gl_Position = vec4(VertexPosition, 1); //-- wówczas będzie bez rotacji i bez translacji
        textureCoords = VertexPosition.xy * 0.5f + 0.5f;
    }
    

    Plik fshader.glsl – Shader Fragmentów:

    Pliki nagłówkowe – przy kompilatorze języka C i pochodnych (C++ itp.) pliki źródłowe o rozszerzeniu "h" (w C++ powinno się dla odróżnienia stosować "hpp", ale w praktyce najczęściej spotykane jest nadal rozszerzenie "h") zawierające opis interfejsu modułu: deklaracje zmiennych, funkcji, klas i innych struktur danych. Używa się ich po to, by nie trzeba było przy każdej najmniejszej zmianie w implementacji jednego modułu rekompilować wszystkich innych odwołujących się do niego. W nowszych językach takich jak Java czy C# nie ma już potrzeby stosowania plików nagłówkowych.freeglut to otwarta implementacja biblioteki GLUT. GLUT (a więc również freeglut) pozwala użytkownikowi tworzyć i zarządzać oknami używającymi OpenGL na wielu platformach. Pozwala również obsługiwać mysz, klawiaturę i dżojstik. freeglut jest w zamierzeniu dokładnym zastępnikiem GLUT i różni się w zaledwie kilku punktach.
    # version 330 //Dyrektywa informująca o wersji OpenGL'a
    
    // Zmienne wbudowane shadera:
    // in vec4 gl_FragCoord
    // in bool gl_FrontFacing
    // in vec2 gl_PointCoord
    
    uniform sampler2D tekstura;
              in vec2 teksturaCoords;
             out vec4 FragColor; //Obowiązkowa zmienna wyjściowa
    
    //fragment shader kopiujacy texele z tekstury na wyjscie
    
    void main()
    {
        //vec2 jest wbudowanym typem [wektor dwuelementowy]
        vec2 tc = vec2(teksturaCoords.x, 1-teksturaCoords.y );
    
        FragColor = texture(tekstura, tc);
        // discard; – spowoduje nie nadanie wartości danemu tekslowi, na danych współrzędnych
    }
    

    Zobacz też[ | edytuj kod]

  • Mesa
  • Direct3D
  • OpenGL Shading Language
  • Shadery
  • OpenGL Extension Wrangler Library (GLEW)
  • Hewlett-Packard Company (HP), NYSE: HPQ - amerykańska firma informatyczna z siedzibą w Palo Alto w Kalifornii. W 2010 roku druga pod względem obrotów największa firma informatyczna świata. Producent m.in. komputerów osobistych, serwerów, drukarek i urządzeń poligraficznych oraz dostawca usług IT. W 1999 z HP wyodrębniono działy produkujące elektroniczny sprzęt pomiarowy, podzespoły oraz sprzęt medyczny i naukowy, formując osobną spółkę Agilent Technologies. W 2002 firma przejęła konkurenta Compaq Computer. W roku 2010 firma zatrudniała na całym świecie ok. 324 tys. osób.Bufor Z (bufor głębokości lub głębi) - wykorzystywany w systemach wyświetlających obrazy trójwymiarowe, przechowuje współrzędną Z (głębokość, odległość od obserwatora) dla każdego piksela obrazu. Stawianie pojedynczego piksela przebiega według algorytmu: jeśli współrzędna Z danego piksela jest mniejsza od współrzędnej Z zapisanej w buforze (piksel znajduje się bliżej obserwatora) można postawić piksel i uaktualnić wpis w buforze.


    Podstrony: [1] [2] 3 [4] [5]



    w oparciu o Wikipedię (licencja GFDL, CC-BY-SA 3.0, autorzy, historia, edycja)

    Warto wiedzieć że... beta

    Shader – krótki program komputerowy, często napisany w specjalnym języku (shader language), który w grafice trójwymiarowej opisuje właściwości pikseli oraz wierzchołków. Technologia ta zastąpiła stosowaną wcześniej jednostkę T&L.
    Dell (właściwie Dell Computer Corporation) NASDAQ: DELL – amerykańska międzynarodowa korporacja z siedzibą w Round Rock w stanie Teksas. Zajmuje się produkcją komputerów i urządzeń peryferyjnych oraz ich serwisowaniem. Spółka jest notowana na 41 miejscu w rankingu Fortune 500.
    Grafika komputerowa – dziedzina informatyki zajmująca się wykorzystaniem technik komputerowych do celów wizualizacji artystycznej oraz wizualizacji rzeczywistości. Grafika komputerowa jest obecnie narzędziem powszechnie stosowanym w nauce, technice oraz rozrywce.
    Klient-serwer ((ang.) client/server, client-server model) – architektura systemu komputerowego, w szczególności oprogramowania, umożliwiająca podział zadań (ról). Polega to na ustaleniu, że serwer zapewnia usługi dla klientów, zgłaszających do serwera żądania obsługi ((ang.) service request).
    Sun Microsystems Inc. (NASDAQ: JAVA, do września 2007 – NASDAQ: SUNW) – nieistniejąca już firma informatyczna, jeden z najważniejszych producentów sprzętu komputerowego, oprogramowania komputerowego i rozwiązań sieciowych. Siedziba główna znajdowała się w Santa Clara w Kalifornii.
    OpenGL ES (ang. OpenGL for Embedded Systems) – podzbiór OpenGL 3D zaprojektowany m.in. dla urządzeń mobilnych typu telefony komórkowe, palmtopy i konsole do gier. Jest zdefiniowany i rozpowszechniany przez Khronos Group.
    IBM (ang. International Business Machines Corporation; potocznie zwany Big Blue, NYSE: IBM) – jeden z najstarszych koncernów informatycznych.

    Reklama

    Czas generowania strony: 0.036 sek.