Differences
This shows you the differences between two versions of the page.
|
egc:laboratoare:03 [2016/10/24 08:42] anca.morar [Scalarea] |
egc:laboratoare:03 [2021/10/12 11:07] (current) chris.luntraru Filename and class name update |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| ====== Laboratorul 03 ====== | ====== Laboratorul 03 ====== | ||
| + | **Video Laborator 3**: https://youtu.be/G-rR8QFZVuI\\ | ||
| + | **Autor**: [[stefania.cristea1708@gmail.com | Stefania Cristea]] | ||
| + | ===== Transformări 2D ===== | ||
| - | ===== Transformari 2D ===== | + | Obiectele 2D sunt definite într-un sistem de coordonate carteziene 2D, de exemplu, XOY, XOZ sau YOZ. |
| + | În cadrul acestui laborator vom implementa diferite tipuri de transformări ce pot fi aplicate obiectelor definite în planul XOY: translații, rotații și scalări. Acestea sunt definite în format matriceal, în coordonate omgene, așa cum ați învățat deja la curs. Matricile acestor transformări sunt următoarele: | ||
| - | Obiectele 2D sunt definite intr-un sistem de coordonate carteziene 2D, de exemplu, XOY, XOZ sau YOZ. | + | ==== Translația ==== |
| - | In cadrul acestui laborator vom implementa diferite tipuri de transformari ce pot fi aplicate obiectelor definite in planul XOY: translatii, rotatii si scalari. Aceastea sunt definite in format matriceal, in coordonate omgene, asa cum ati invatat deja la curs. Matricile acestor transformari sunt urmatoarele: | + | |
| - | + | ||
| - | ==== Translatia ==== | + | |
| $$ | $$ | ||
| Line 25: | Line 26: | ||
| \end{bmatrix} | \end{bmatrix} | ||
| $$ | $$ | ||
| - | ==== Rotatia ==== | + | ==== Rotația ==== |
| - | === Rotatia fata de origine === | + | === Rotația față de origine === |
| $$ | $$ | ||
| Line 47: | Line 48: | ||
| $$ | $$ | ||
| - | === Rotatia fata de un punct oarecare === | + | === Rotația față de un punct oarecare === |
| - | Rotatia relativa la un punct oarecare se rezolva in cel mai simplu mod prin: | + | Rotația relativă la un punct oarecare se rezolvă în cel mai simplu mod prin: |
| - | - translatarea atat a punctului asupra carui se aplica rotatia cat si a punctului in jurul caruia se face rotatia a.i. cel din urma sa fie originea sistemului de coordonate. | + | - translatarea atât a punctului asupra căruia se aplică rotația cât și a punctului în jurul căruia se face rotația a.î. cel din urmă să fie originea sistemului de coordonate. |
| - | - rotatia normala (in jurul originii), | + | - rotația normală (în jurul originii), |
| - | - translatarea rezultatului a.i. punctul in jurul caruia s-a facut rotatia sa ajunga in pozitia sa initiala | + | - translatarea rezultatului a.î. punctul în jurul căruia s-a făcut rotația să ajungă în poziția sa inițială |
| ==== Scalarea ==== | ==== Scalarea ==== | ||
| - | === Scalarea fata de origine === | + | === Scalarea față de origine === |
| $$ | $$ | ||
| \begin{bmatrix} | \begin{bmatrix} | ||
| Line 75: | Line 76: | ||
| $$ | $$ | ||
| - | Daca $sx = sy$ atunci avem scalare uniforma, altfel avem scalare neuniforma. | + | Dacă $sx = sy$ atunci avem scalare uniformă, altfel avem scalare neuniformă. |
| - | === Scalarea fata de un punct oarecare === | + | === Scalarea față de un punct oarecare === |
| - | Scalarea relativa la un punct oarecare se rezolva similar cu rotatia relativa la un punct oarecare. | + | Scalarea relativă la un punct oarecare se rezolvă similar cu rotația relativă la un punct oarecare. |
| ===== Utilizarea bibliotecii GLM ===== | ===== Utilizarea bibliotecii GLM ===== | ||
| - | In cadrul laboratorului folosim biblioteca GLM care este o biblioteca implementata cu matrici in forma coloana, exact acelasi format ca OpenGL. Forma coloana difera de forma linie prin ordinea de stocare a elementelor maricei in memorie, Matricea de translatie arata in modul urmator in memorie: | + | În cadrul laboratorului folosim biblioteca GLM, care este o bibliotecă implementată cu matrici în formă coloană, exact același format ca OpenGL. Forma coloană diferă de forma linie prin ordinea de stocare a elementelor matricei în memorie, Matricea de translație arată în modul următor în memorie: |
| <code cpp> | <code cpp> | ||
| Line 96: | Line 97: | ||
| </code> | </code> | ||
| - | Din aceasta cauza, este convenabil ca matricile sa fie scrise manual in forma aceasta: | + | Din această cauză, este convenabil ca matricile să fie scrise manual în forma aceasta: |
| <code cpp> | <code cpp> | ||
| Line 103: | Line 104: | ||
| return glm::transpose( | return glm::transpose( | ||
| glm::mat3( 1, 0, tx, | glm::mat3( 1, 0, tx, | ||
| - | 0, 1, ty | + | 0, 1, ty, |
| 0, 0, 1) | 0, 0, 1) | ||
| ); | ); | ||
| Line 110: | Line 111: | ||
| <note> | <note> | ||
| - | In cadrul framework-ului de laborator, in fisierul ''Transform2D.h'' sunt definite functiile pentru calculul matricilor de translatie, rotatie si scalare. In momentul acesta toate functiile intorc matricea identitate. In cadrul laboratorului va trebui sa modificati codul pentru a calcula matricile respective. | + | În cadrul framework-ului de laborator, în fișierul ''transform2D.h'' sunt definite funcțiile pentru calculul matricilor de translație, rotație și scalare. În momentul acesta toate funcțiile întorc matricea identitate. În cadrul laboratorului va trebui să modificați codul pentru a calcula matricile respective. |
| </note> | </note> | ||
| - | ==== Transformari compuse ==== | + | ==== Transformări compuse ==== |
| - | De ce sunt necesare matricile? Pentru a reprezenta printr-o singura matrice de transformari o secventa de transformari elementare, in locul aplicarii unei secvente de transformari elementare pe un anume obiect. | + | De ce sunt necesare matricile? Pentru a reprezenta printr-o singură matrice de transformări o secvență de transformări elementare, în locul aplicării unei secvențe de transformări elementare pe un anume obiect. |
| - | Deci, daca dorim sa aplicam o rotatie, o scalare si o translatie pe un obiect, nu facem rotatia obiectului, scalarea obiectului urmata de translatia lui, ci calculam o matrice care reprezinta transformarea compusa (de rotatie, scalare si translatie), dupa care aplicam aceasta transformare compusa pe obiectul care se doreste a fi transformat. | + | Deci, dacă dorim să aplicăm o rotație, o scalare și o translație pe un obiect, nu facem rotația obiectului, scalarea obiectului urmată de translația lui, ci calculăm o matrice care reprezintă transformarea compusă (de rotație, scalare și translație), după care aplicăm această transformare compusă pe obiectul care se dorește a fi transformat. |
| - | Astfel, daca dorim sa aplicam o rotatie (cu matricea de rotatie $R$), urmata de o scalare ($S$), urmata de o translatie ($T$) pe un punct ($x$,$y$), punctul transformat (${x}'$,${y}'$) se va calcula astfel: | + | Astfel, dacă dorim să aplicăm o rotație (cu matricea de rotație $R$), urmată de o scalare ($S$), urmată de o translație ($T$) pe un punct ($x$,$y$), punctul transformat (${x}'$,${y}'$) se va calcula astfel: |
| Line 153: | Line 154: | ||
| - | Deci, matricea de transformari compuse $M$ este $M = T * S * R$. | + | Deci, matricea de transformări compuse $M$ este $M = T * S * R$. |
| <note> | <note> | ||
| - | In cadrul laboratorului, in fisierul **Laborator3.cpp**, exista o serie de obiecte (patrate) pentru care, in functia ''Update()'', inainte de desenare, se definesc matricile de transformari. Comanda de desenare se da prin functia ''RenderMesh2D()''. | + | În cadrul laboratorului, în fișierul ''lab3.cpp'', există o serie de obiecte (pătrate) pentru care, în funcția ''Update()'', înainte de desenare, se definesc matricile de transformări. Comanda de desenare se dă prin funcția ''RenderMesh2D()''. |
| <code cpp> | <code cpp> | ||
| Line 164: | Line 165: | ||
| </code> | </code> | ||
| - | Pentru exemplul anterior, matricea de translatie creata va avea ca efect translatarea patratului curent cu (150, 250). Pentru efecte de animatie continua, pasii de translatie ar trebui sa se modifice in timp. | + | Pentru exemplul anterior, matricea de translație creată va avea ca efect translatarea pătratului curent cu (150, 250). Pentru efecte de animație continuă, pașii de translație ar trebui să se modifice în timp. |
| Exemplu: | Exemplu: | ||
| Line 175: | Line 176: | ||
| <note tip> | <note tip> | ||
| - | **Retineti:** daca la animatie nu tineti cont de timpul de rulare al unui frame (''deltaTimeSeconds''), veti crea animatii dependente de platforma. | + | **Rețineți:** dacă la animație nu țineți cont de timpul de rulare al unui frame (''deltaTimeSeconds''), veți crea animații dependente de platformă. |
| - | **Exemplu:** daca la fiecare frame cresteti pe tx cu un pas constant (ex: ''tx += 0.01''), atunci animatia se va comporta diferit pe un calculator care merge mai repede fata de unul care merge mai incet. Pe un calculator care ruleaza la 50 FPS, obiectul se va deplasa 0.01 * 50 = 0.5 unitati in dreapta intr-o secunda. In schimb, pe un calculator mai incet, care ruleaza la 10 FPS, obiectul se va deplasa 0.01 * 10 = 0.1 unitati in dreapta intr-o secunda, deci animatia va fi de 5 ori mai lenta. | + | **Exemplu:** dacă la fiecare frame creșteți pe tx cu un pas constant (ex: ''tx += 0.01''), atunci animația se va comporta diferit pe un calculator care merge mai repede față de unul care merge mai încet. Pe un calculator care rulează la 50 FPS, obiectul se va deplasa 0.01 * 50 = 0.5 unități în dreapta într-o secundă. În schimb, pe un calculator mai încet, care rulează la 10 FPS, obiectul se va deplasa 0.01 * 10 = 0.1 unități în dreapta într-o secundă, deci animația va fi de 5 ori mai lentă. |
| - | Din acest motiv este bine sa tineti cont de viteza de rulare a fiecarui calculator (data prin ''deltaTimeSeconds'', care reprezinta timpul de rulare al frame-ului anterior) si sa modificati pasii de translatie, unghiurile de rotatie si factorii de scalare in functie de aceasta variabila. | + | Din acest motiv este bine să țineți cont de viteza de rulare a fiecărui calculator (dată prin ''deltaTimeSeconds'', care reprezintă timpul de rulare al frame-ului anterior) și să modificați pașii de translație, unghiurile de rotație și factorii de scalare în funcție de această variabilă. |
| </note> | </note> | ||
| - | ===== Transformarea fereastra-poarta ===== | + | ===== Transformarea fereastra-poartă ===== |
| - | Desenele reprezentate intr-un program de aplicatie grafica (2D sau 3D) sunt, de regula, raportate la un sistem de coordonate diferit de cel al suprafetei de afisare. | + | Desenele reprezentate într-un program de aplicație grafică (2D sau 3D) sunt, de regulă, raportate la un sistem de coordonate diferit de cel al suprafeței de afișare. |
| <note> | <note> | ||
| - | In exercitiile anterioare din acest laborator, coordonatele obiectelor au fost raportate la dimensiunea ferestrei definita prin ''glViewport()''. | + | În exercițiile anterioare din acest laborator, coordonatele obiectelor au fost raportate la dimensiunea ferestrei definită prin ''glViewport()''. |
| - | Exemplu: Daca viewport-ul meu este are coltul din stanga jos (0, 0) si are latimea 1280 si inaltimea 720, atunci toate obiectele ar trebui desenate in acest interval, daca vreau sa fie vizibile. Acest lucru ma conditioneaza sa imi gandesc toata scena in (0, 0) - (1280, 720). Daca vreau sa scap de aceasta limitare, pot sa imi gandesc scena intr-un spatiu logic (de exemplu imi creez toate obiectele in spatiul (-1, -1) - (1, 1), si apoi sa le desenez in poarta de afisare, dar aplicand ceea ce se numeste **transformarea fereastra poarta**. | + | Exemplu: Dacă viewport-ul meu are colțul din stânga jos (0, 0) și are lățimea 1280 și înălțimea 720, atunci toate obiectele ar trebui desenate în acest interval, dacă vreau să fie vizibile. Acest lucru mă condiționează să îmi gândesc toată scena în (0, 0) - (1280, 720). Dacă vreau să scap de această limitare, pot să îmi gândesc scena într-un spațiu logic (de exemplu îmi creez toate obiectele în spațiul (-1, -1) - (1, 1) și apoi să le desenez în poarta de afișare, dar aplicând ceea ce se numește **transformarea fereastră poartă**. |
| - | In cele ce urmeaza vedem ce presupune aceasta transformare si cum pot sa imi gandesc scena fara sa fiu limitat de dimensiunea viewport-ului. | + | În cele ce urmează vedem ce presupune această transformare și cum pot să imi gândesc scena fără să fiu limitat de dimensiunea viewport-ului. |
| </note> | </note> | ||
| Line 197: | Line 198: | ||
| {{ :egc:laboratoare:transf_fer_poarta1.png?600 |}} | {{ :egc:laboratoare:transf_fer_poarta1.png?600 |}} | ||
| - | ==== Definitia matematica: ==== | + | ==== Definiția matematică: ==== |
| {{ :egc:laboratoare:transf_fer_poarta2.png?550 |}} | {{ :egc:laboratoare:transf_fer_poarta2.png?550 |}} | ||
| Line 205: | Line 206: | ||
| - | Transformarea este definita prin 2 dreptunghiuri, in cele doua sisteme de coordonate, numite fereastra sau spatiul logic si poarta, sau spatiul de afisare. De aici numele de transformarea fereastra-poarta sau transformarea de vizualizare 2D. | + | Transformarea este definită prin 2 dreptunghiuri, în cele două sisteme de coordonate, numite fereastră sau spațiul logic și poartă sau spațiul de afișare. De aici numele de transformarea fereastră-poartă sau transformarea de vizualizare 2D. |
| - | F: un punct din fereastra | + | F: un punct din fereastră |
| - | P: punctual in care se transforma F prin transformarea de vizualizare | + | P: punctul în care se transformă F prin transformarea de vizualizare |
| - | Pozitia relativa a lui P in poarta de afisare trebuie sa fie aceeasi cu pozitia relativa a lui F in fereastra. | + | Poziția relativă a lui P în poarta de afișare trebuie să fie aceeași cu poziția relativă a lui F în fereastră. |
| $$ sx = \frac{xpmax - xpmin}{xfmax - xfmin} $$ | $$ sx = \frac{xpmax - xpmin}{xfmax - xfmin} $$ | ||
| Line 217: | Line 218: | ||
| $$ sy = \frac{ypmax - ypmin}{yfmax - yfmin} $$ | $$ sy = \frac{ypmax - ypmin}{yfmax - yfmin} $$ | ||
| - | * sx, sy depind de dimensiunile celor doua ferestre | + | * sx, sy depind de dimensiunile celor două ferestre |
| - | * tx, ty depind de pozitiile celor doua ferestre fata de originea sistemului de coordonate in care sunt definite. | + | * tx, ty depind de pozițiile celor două ferestre față de originea sistemului de coordonate în care sunt definite |
| $$ tx = xpmin - sx * xfmin $$ | $$ tx = xpmin - sx * xfmin $$ | ||
| $$ ty = ypmin - sy * yfmin $$ | $$ ty = ypmin - sy * yfmin $$ | ||
| - | In final, transformarea fereastra poarta are urmatoarele ecuatii: | + | În final, transformarea fereastră-poartă are următoarele ecuații: |
| $$ xp = xf * sx + tx $$ | $$ xp = xf * sx + tx $$ | ||
| $$ yp = yf * sy + ty $$ | $$ yp = yf * sy + ty $$ | ||
| - | Consideram o aceeasi orientare a axelor celor doua sisteme de coordonate. | + | Considerăm o aceeași orientare a axelor celor două sisteme de coordonate. Dacă acestea au orientări diferite (ca în prima imagine), trebuie aplicată o transformare suplimentară de corecție a coordonatei y. |
| - | ==== Efectele transformarii ==== | + | ==== Efectele transformării ==== |
| - | * marire/micsorare, in functie de dimensiunile ferestrei si ale portii | + | * mărire/micșorare, în funcție de dimensiunile ferestrei și ale porții |
| - | * deformare daca fereastra si poarta nu sunt dreptunghiuri asemenea | + | * deformare dacă fereastra și poarta nu sunt dreptunghiuri asemenea |
| - | * pentru scalare uniforma, $s=min(sx,sy)$, afisarea centrata in poarta presupune o translatie suplimentara pe axa Ox sau pe axa Oy: | + | * pentru scalare uniformă, $s=min(sx,sy)$, afișarea centrată în poartă presupune o translație suplimentară pe axa Ox sau pe axa Oy: |
| $$Tsx = (xpmax - xpmin - s*(xfmax - xfmin)) / 2$$ | $$Tsx = (xpmax - xpmin - s*(xfmax - xfmin)) / 2$$ | ||
| $$Tsy = (ypmax - ypmin - s*(yfmax - yfmin)) / 2$$ | $$Tsy = (ypmax - ypmin - s*(yfmax - yfmin)) / 2$$ | ||
| - | * decuparea primitivelor aflate in afara ferestrei vizuale | + | * decuparea primitivelor aflate în afara ferestrei vizuale |
| - | ==== Matricea transformarii fereastra-poarta ==== | + | ==== Matricea transformării fereastră-poartă ==== |
| - | De retinut este ca transformarea fereastra poarta presupune o scalare si o translatie. Ea are urmatoarea expresie, cu formulele de calcul pentru sx, sy, tx, ty prezentate anterior: | + | De reținut este că transformarea fereastră-poartă presupune o scalare și o translație. Ea are următoarea expresie, cu formulele de calcul pentru sx, sy, tx, ty prezentate anterior: |
| $$ | $$ | ||
| Line 263: | Line 264: | ||
| <note> | <note> | ||
| - | Transformarea de vizualizare este deja implementata in clasa ''Laborator3_Viz2D'': | + | Transformarea de vizualizare este deja implementată în clasa ''lab3_vis2D'': |
| <code cpp> | <code cpp> | ||
| //2D vizualization matrix | //2D vizualization matrix | ||
| - | glm::mat3 Laborator3_Vis2D::VisualizationTransf2D(const LogicSpace & logicSpace, const ViewportSpace & viewSpace) | + | glm::mat3 Lab3_Vis2D::VisualizationTransf2D(const LogicSpace & logicSpace, const ViewportSpace & viewSpace) |
| { | { | ||
| float sx, sy, tx, ty; | float sx, sy, tx, ty; | ||
| Line 284: | Line 285: | ||
| <note> | <note> | ||
| - | In cadrul laboratorului, in clasa ''Laborator3_Vis2D'', este creat un patrat, in spatiul logic (0,0) - (4,4). De retinut este faptul ca acum nu mai trebuie sa raportam coordonatele patratului la spatiul de vizualizare (cum se intampla in exercitiile anterioare), ci la spatiul logic pe care l-am definit noi. | + | În cadrul laboratorului, în clasa ''Lab3_Vis2D'', este creat un pătrat, în spațiul logic (0,0) - (4,4). De reținut este faptul că acum nu mai trebuie să raportăm coordonatele pătratului la spațiul de vizualizare (cum se intamplă în exercițiile anterioare), ci la spațiul logic pe care l-am definit noi. |
| <code cpp> | <code cpp> | ||
| Line 300: | Line 301: | ||
| - | In functia ''Update()'' se deseneaza acelasi patrat creat anterior, de 5 ori: patru patrate in cele patru colturi si un patrat in mijlocul spatiului logic. Se definesc 2 viewport-uri, ambele continand aceleasi obiecte. Primul viewport este definit in jumatatea din stanga a ferestrei de afisare, iar al doilea, in jumatatea din dreapta. Pentru primul viewport se defineste transformarea fereastra poarta default si pentru al doilea viewport, cea uniforma. Observati ca in al doilea viewport patratele raman intotdeauna patrate, pe cand in primul viewport se vad ca dreptunghiuri (adica sunt deformate), daca spatiul logic si spatiul de vizualizare nu sunt reprezentate prin dreptunghiuri asemenea. | + | În funcția ''Update()'' se desenează același pătrat creat anterior, de 5 ori: patru pătrate în cele patru colțuri și un pătrat în mijlocul spațiului logic. Se definesc 2 viewport-uri, ambele conținând aceleași obiecte. Primul viewport este definit în jumătatea din stânga a ferestrei de afișare, iar al doilea, în jumătatea din dreapta. Pentru primul viewport se definește transformarea fereastră-poartă default și pentru al doilea viewport, cea uniformă. Observați că în al doilea viewport pătratele rămân întotdeauna pătrate, pe când în primul viewport se văd ca dreptunghiuri (adică sunt deformate), dacă spațiul logic și spațiul de vizualizare nu sunt reprezentate prin dreptunghiuri asemenea. |
| </note> | </note> | ||
| Line 308: | Line 309: | ||
| - | Unde se poate folosi aceasta transformare fereastra poarta? De exemplu, intr-un joc 2D cu masini de curse, se doreste in dreapta-jos a ecranului vizualizarea masinii proprii, intr-un mini map. Acest lucru se face prin desenarea scenei de doua ori. | + | Unde se poate folosi această transformare fereastră-poartă? De exemplu, într-un joc 2D cu mașini de curse, se dorește în dreapta-jos a ecranului vizualizarea mașinii proprii, într-un minimap. Acest lucru se face prin desenarea scenei de două ori. |
| - | Daca de exemplu toata scena (traseul si toate masinile) este gandita in spatiul logic (-10,-10) - (10,10) (care are dimensiunea 20x20) si spatiul de afisare este (0,0) - (1280, 720), prima data se deseneaza toata scena cu parametrii functiei fereastra-poarta anterior mentionati: | + | Dacă de exemplu toată scena (traseul și toate mașinile) este gândită în spațiul logic (-10,-10) - (10,10) (care are dimensiunea 20x20) și spațiul de afișare este (0,0) - (1280, 720), prima dată se desenează toată scena cu parametrii funcției fereastră-poartă anterior menționați: |
| <code cpp> | <code cpp> | ||
| Line 318: | Line 319: | ||
| </code> | </code> | ||
| - | Daca la un moment dat masina proprie este in spatiul (2,2) - (5,5), adica de dimensiune 3x3 si vreau sa creez un minimap in coltul din dreapta jos al ecranului de rezolutie 280x220, pot desena din nou aceeasi scena, dar cu urmatoarea transformare fereastra-poarta: | + | Dacă la un moment dat mașina proprie este în spațiul (2,2) - (5,5), adică de dimensiune 3x3 și vreau să creez un minimap în colțul din dreapta jos al ecranului de rezoluție 280x220, pot desena din nou aceeași scenă, dar cu urmatoarea transformare fereastră-poartă: |
| <code cpp> | <code cpp> | ||
| Line 330: | Line 331: | ||
| <note tip> | <note tip> | ||
| - | In cadrul acestui laborator aveti de programat in doua clase: | + | În cadrul acestui laborator aveți de programat în două clase: |
| - | * ''Laborator3.cpp'', pentru familiarizarea cu transformarile 2D de translatie, rotatie si scalare | + | * ''lab3.cpp'', pentru familiarizarea cu transformările 2D de translație, rotație și scalare |
| - | * ''Laborator3_Vis2D.cpp'', pentru familiarizarea cu transformarea fereastra-poarta | + | * ''lab3_vis2D.cpp'', pentru familiarizarea cu transformarea fereastră-poartă |
| - | Din clasa ''Main'' puteti sa alegeti ce laborator rulati: | + | Din fisierul ''main.cpp'' puteți să alegeți ce laborator rulați: |
| <code cpp> | <code cpp> | ||
| - | World *world = new Laborator3(); | + | World *world = new Lab3(); |
| </code> | </code> | ||
| Line 342: | Line 343: | ||
| <code cpp> | <code cpp> | ||
| - | World *world = new Laborator3_Vis2D(); | + | World *world = new Lab3_Vis2D(); |
| </code> | </code> | ||
| </note> | </note> | ||
| <note> | <note> | ||
| - | OpenGL este un API 3D. Desenarea obiectelor 2D si aplicarea transformarilor 2D sunt simulate prin faptul ca facem abstractie de coordonata z. | + | OpenGL este un API 3D. Desenarea obiectelor 2D și aplicarea transformărilor 2D sunt simulate prin faptul că facem abstracție de coordonata z. |
| - | Transformarea fereastra-poarta este si ea simulata pentru acest framework, dar veti invata pe parcurs ca ea este de fapt inclusa in lantul de | + | Transformarea fereastră-poartă este și ea simulată pentru acest framework, dar veți învăța pe parcurs că ea este de fapt inclusă în lanțul de transformări OpenGL și că nu trebuie definită explicit. |
| - | transformari OpenGL si ca nu trebuie definita explicit. | + | |
| </note> | </note> | ||
| - | ==== Cerinte laborator ==== | + | ==== Cerințe laborator ==== |
| - | + | ||
| - | - Descarcati [[https://github.com/UPB-Graphics/Framework-EGC/archive/master.zip|framework-ul de laborator]] | + | |
| - | - Completati functiile de translatie, rotatie, scalare din ''/Laborator3/Transform2D.h'' | + | |
| - | - Asteptati restul task-urilor oferite de asistent | + | |
| + | - Descarcăți [[https://github.com/UPB-Graphics/Framework-EGC/archive/master.zip|framework-ul de laborator]] | ||
| + | - Completați funcțiile de translație, rotație și scalare din ''lab3/transform2D.h'' | ||
| + | - Să se modifice pașii de translație, rotație și scalare pentru cele trei pătrate ca să se creeze animații. | ||
| + | - Cu tastele W, A, S, D să se translateze fereastra logică ''lab3_vis2D''. Cu tastele Z și X să se facă zoom in și zoom out pe fereastra logică. | ||
| <hidden> | <hidden> | ||
| - | ---- | ||
| - | - Sa modifice pasii de translatie si rotatie si scalare pentru cele trei patrate ca sa creeze animatie. | ||
| - | - Cu tastele W, A, S, D sa translateze fereastra logica ''Laborator3_Vis2D'' (sa inteleaga ca atunci cand se duce fereastra in jos, pare ca obiectele scenei se duc in sus, cand se duce fereastra in stanga, obiectele se duc in dreapta, etc.). Cu tastele Z si X sa faca zoom in si zoom out pe fereastra logica (sa se inteleaga ca atunci cand micsorezi fereastra, pare ca se maresc obiectele si invers). | ||
| - | |||
| Bonusuri posibile: | Bonusuri posibile: | ||
| - | + | * **[Bonus]** Diverse combinații de transformări (primul pătrat stă pe loc, al doilea se rotește în jurul lui și al treilea în jurul celui de-al doilea - cum sunt soarele, pământul și luna) | |
| - | * **[Bonus]** Diverse combinatii de transformari (gen primul patrat sta pe loc, al doilea se roteste in jurul lui si al treilea in jurul celui de-al doilea - cum sunt soarele, pamantul si luna) | + | |
| </hidden> | </hidden> | ||
