# Interpolacja kwaternionów
Celem tego zadania jest przećwiczenie interpolacji obrotów przy użyciu kwaternionów. 

## Opis projektu 
Plik `main7` rysuje futurystyczne miasto i latające samochody, które startują z jednego wieżowca, okrążają miasto i lądują na drugim. Jeżeli rysowanie miasta jest zbyt wymagające dla komputera, to w funkcji `initModels` można podmienić model na mniej złożony, zmniejszenie wartości dla multisamplingu też powinno poprawić wydajność (linijka `glutSetOption(GLUT_MULTISAMPLE, 4);`). Do ładowania obiektów jest wykorzystywana biblioteka Assimp z prostą obsługą materiałów. 

Statki poruszają się po krzywej wyznaczonej przez punkty kontrolne zapisane w `keyPoints` i interpolowane liniowo. Nie mają one zdefiniowanych obrotów, zadaniem jest wyliczenie im obrotów. 

Dla łatwiejszego debugowania kamera została rozwinięta o następujące opcje:

* obroty przy pomocy kwaternionów 
* przyciski **q** i **e** przenoszą kamerę w okolicę następnego/poprzedniego punktu kontrolnego
* przycisk **0** przenosi do pierwszego punktu kontrolnego
* przycisk **1** przyczepia kamerę do statku. 

# Materiały i graf sceny

## Import

modele które importujemy w trakcie tych zajęć mają rozszerzenie **fbx** są to dużo bardziej skomplikowane pliki, mogą one zawierać więcej niż jeden *mesh* lokalne macierze transformacji i informację o materiałach. 

## Materiały

Do tej pory ręcznie wybieraliśmy program, którym rysowaliśmy. wiązało się to z tym, że trzeba było pamiętać jakie parametry należy przesłać do danego obiektu. Rozwiązaniem jest przechowywanie w materiałach. W projekcie w klasie `RenderContext` jest wskaźnik na zmienną typu `Material`, której zadaniem jest przechowywanie tej informacji.

## Graf sceny

Sceny w bardziej złożonych projektach potrafią być skomplikowane. Obiekty w scenie są umieszczane hierarchicznie. przykładowo bohater posiada ręce, które poruszają się razem z nim (z reguły) jednak mogą same z siebie się poruszać, gdy postać atakuje. w ręku tej postaci może znajdować się miecz lub inna broń i ta broń będzie poruszać zawsze gdy bohater się się będzie przemieszczać, ale też gdy się zamachnie. W poprzednich projektach przykładem takich zależności była planeta i krążący wokół niej księżyc. Takich zależności może być więcej i pamiętanie wszystkich poprzednich interakcji staje się kłopotliwe. Rozwiązaniem, które pozwala wprowadzić taką hierarchię jest graf sceny. Graf sceny jest drzewem, w którym każdy węzeł jest jakimś obiektem w grze oraz zawiera informację o lokalnej transformacji względem obiektu nadrzędnego-ojca. To rozwiązanie pozwala myśleć tylko o lokalnych transformacjach, a globalne pobrać z nadrzędnych węzłów. 

###  

W naszym projekcie graf sceny jest zrealizowany w formie tablicy. To znaczy w projekcie znajdują się 2 tablice `city` i `car`. Odpowiadają one za grafy dla miasta i pojazdu, jak nazwa wskazuje. Tablice zawierają struktury `Core::Node`:

```c++
	struct Node {
		std::vector<RenderContext> renderContexts;
		glm::mat4 matrix;
		int parent;
	};
```

Zawiera ona RenderContexty, które składają się na ten obiekt, macierz transformacji oraz indeks obiektu nadrzędnego, czyli np dla `car[3]` jego ojcem będzie `car[car[3].parent]`, jeżeli atrybut `parent` jest równy -1 to znaczy, że dotarliśmy do korzenia, czyli obiektu który już nie ma nadrzędnego. 

### Zadanie 

Prześledź jak ładowane są obiekty w funkcji `initModels()`. 

W tej chwili nic się nie wyświetla. Jak wciśniesz **r** to kamera zostanie przeniesiona do centrum, gdzie znajdują się wszystkie obiekty. Wynika to z tego, że funkcja`renderRecursive` jest niekompletna. Dopisz obliczanie macierzy transformacji. Najpierw przypisz do niej macierz transformacji z obecnego węzła `node`, następnie w pętli domnóż od lewej macierz transformacji nadrzędnego węzła, nadrzędnego nadrzędnego węzła i tak aż do korzenia. Po wykonaniu  powinna pojawić scena, która zwiera miasto i latające statki. W następnych zadaniach skupimy się na poprawieniu ich zachowania.

# Interpolacja

Większość pracy będzie się dziać w funkcji `animationMatrix`, ma ona zmienną `speed`, która może być pomocna przy debugowaniu.

## Interpolacja krzywej

W tej punkty kontrolne są interpolowane liniowo w funkcji `animationMatrix`. Funkcja ta oblicza na podstawie otrzymanego czasu oblicza macierz transformacji obiektu (statku) poruszającego się po krzywej. Oblicza ona pomiędzy jakimi puntami powinien znajdować się obiekt (zmienna `i`) oraz parametr `t` który określa jaki punkt pomiędzy punktami kontrolnymi `i` oraz `i+1`wybrać. Zastąp interpolację liniową na Catmull-Roma w linii: 

```C++
	glm::vec3 pos = (keyPoints[std::max(0, index)] * t + keyPoints[std::min(size, index + 1)] * (1 - t));
```



 Użyj funkcji glm::catmullRom(). Przyjmuje ona cztery argumenty typu glm::vec3 (v1, v2, v3, v4) i jeden argument typu float (s). Zwraca ona glm::vec3, w którym znajduje się zinterpolowana pozycja między punktami v2 i v3 (parametr s wybiera punkt na ścieżce; dla s=0 zwracane jest v2, dla s=1 zwracane jest v3, dla 0<s<1 zwracana jest zinterpolowana pozycja na ścieżce). Punkty v1 i v4 są dodatkowymi punktami kontrolującymi krzywiznę ścieżki. Dla krzywych Catmulla-Roma, należy jako v1,v2,v3,v4 podać po prostu cztery kolejne punkty ze zbioru punktów kontrolnych

## Interpolacja kwaternionów

Celem tego zadania jest przećwiczenie interpolacji obrotów przy użyciu kwaternionów. 


## Obliczenie kierunków 

W pierwszej kolejności potrzebujemy obliczyć kwaterniony odpowiadające obrotom statków między kolejnymi punktami kontrolnymi. Chcemy, żeby statek był skierowany w kierunku lotu. Najpierw musimy uzyskać znormalizowany wektor kierunkowy dla każdej pary 2 kolejnych punktów kontrolnych jak na rysunku poniżej. 

![wektory](vectors.jpg)
Nastęnie należy obliczyć kwaterniony odpowiadające za obrót z początkowej orientacji statku (opisywanej przez wektor (0,0,1)) do orientaci wyznaczonej przez wektory kietunkowe.
Żeby obliczyć obrót między jednym wektorem a drugim, należy obliczyć oś obrotu, oblicza się go za pomocą iloczynu wektorowego, oraz kąt obrotu, oblicza się za pomocą iloczynu skalarnego. 
Może być kuszące policzenie wektora obrotu pomiędzy początkowym wektorem kierunkowym a kolejnymi wektorami, ale takie rozwiązanie może prowadzić do niepożądanych zachowań. Dlatego należy obliczać obroty pomiędzy kolejnymi wektorami i je akumulować.

### Zadanie

Uzupełnij funkcję `initKeyRoation` o wypełnienie `std::vector<glm::quat> keyRotation` kwaternionami. 

1. Zainicjalizuj zmienną `glm::vec3 oldDirection` wektorem o współrzędnych (0,0,1), czyli początkowej orientacji pojazdu
2. Zainicjalizuj zmienną `glm::quat oldRotationCamera` kwaternionem identycznościom (1,0,0,0).
3. W pętli for po i od 0 do liczba keyPoints odjąć 1.
   1. Oblicz nowy kierunek: odejmij od punktu końcowego: `keyPoints[i+1]` punkt początkowy: `keyPoints[i]`.
   2. Oblicz nową rotację, skorzystaj z funkcji `glm::rotationCamera` przemnóż jej wynik przez `oldRotationCamera` od prawej i całość znormalizuj.
   3. Dodaj nowy obrót do `keyRotation`.
   4. Podmień `oldDritection` na nowy kierunek i `oldRotationCamera` na nowy obrót.
4. Po wszystkim kwaternionów jest o jeden mniej niż punktów dodaj jeszcze jeden o wartościach (1,0,0,0) na koniec.

## Interpolacja 

Do interpolacji użyjemy funkcji `slerp` opisanej wzorem

$$ slerp(\hat{q}_i,\hat{q}_{i+1},t) = \frac{\sin(\phi(1-t))}{\sin(\phi)}\hat{q}_i+\frac{\sin(\phi t)}{\sin(\phi)}\hat{q}_{i+1}$$

gdzie $\hat{q_i},\hat{q}_{i+1}$ są interpolowanymi kwaternionami, $t$ jest parametrem od 0 do 1, natomiast $\phi$ można otrzymać z wzoru 
$cos\phi = q_xr_x+q_yr_y+q_zr_z+q_wr_w$. dla $t\in\left[0,1\right]$ `slerp` oblicza najkrótszą ścieżkę pomiędzy kwaternionami p i q w przestrzeni kwaternionów jednostkowych. Nie będziemy jej obliczać samodzielnie, skorzystamy z implementacji `glm::slerp`.

W funkcji `animationMatrix` dodaj interpolację kwaternionów 
```C++

glm::mat4 animationMatrix(float time) {
    ...
	//index of first keyPoint
	int index = 0;

	while (distances[index] <= time) {
		time = time - distances[index];
		index += 1;
	}

	//t coefitient between 0 and 1 for interpolation
	float t = time / distances[index];
    ...
	//implement corect animation
	auto animationRotation = glm::quat(1,0,0,0);

	glm::mat4 result = glm::translate(pos) * glm::mat4_cast(animationRotation);


	return result;

}
```

Pobierz z `keyRotation` kwaterniony o indeksach `index` i `index+1`  wywołaj `glm::slerp` z nimi jako argumentami. Trzecim parametrem powinna być wartość `t`.

> Uwaga! pobierając wartości z wektora `keyRotation` pamiętaj, żeby nie wyjść poza jego zakres, najlepiej weż maksimum z indeksu i zera oraz minimum z indeksu i rozmiaru wektora.

Otrzymana animacja będzie ciągła, ale w punktach kontrolnych będzie widoczne szarpnięcie wywołane przez to, że funkcja slerp nie jest gładka, gdy przechodzimy do kolejnej pary kwaternionów. By zniwelować ten efekt użyjemy funkcji `glm::squat`.

Funkcja squat podobnie jak Catmull-Rom przyjmuje 4 wartości jednak zamiast przyjmować 4 kolejne wektory, przyjmuje 2 kwaterniony interpolowane i 2 kwaterniony pośrednie. opisana jes
t wzorem:

$$squad(\hat{q}_{i},\hat{q}_{i+1},\hat{a}_{i},\hat{a}_{i+1},t)=slerp(slerp(\hat{q}_{i},\hat{q}_{i+1},t),slerp(\hat{a}_{i},\hat{a}_{i+1},t),2t(1-t))$$

gdzie $\hat{q}_{i},\hat{q}_{i+1}$ to interpolowane kwaterniony, $t$ to parametr od 0 do 1. Natomiast $\hat{a}_{i},\hat{a}_{i+1}$ są opisane wzorem:

$$\hat{a}_i = \hat{q}_i\exp\left[-\frac{\log(\hat{q}_i^{-1}\hat{q}_{i-1})+\log(\hat{q}_i^{-1}\hat{q}_{i+1})}{4}\right].$$


### Zadanie

Zamień interpolację kwaternionów ze `slerp` na `squat`. Po pierwsze pobierz wartości $\hat{q}_{i-1}$, $\hat{q}_{i}$, $\hat{q}_{i+2}$, $\hat{q}_{i+2}$ z `keyRotation` ($i$ odpowiada zmiennej `index` jak poprzednio), oblicz $\hat{a}_i$, $\hat{a}_{i+1}$, funkcje, które będą potrzebne to `glm::inverse`, `glm::exp`, `glm::log`. Na koniec podmień `slerp` na `squat`.

Teraz przejścia między obrotami powinny być gładkie. Jedna rzecz, która pozostaje, to poprawić moment lądowania. Ustaw ręcznie kilka ostatnich kwaternionów tak, żeby statek lądował poziomo.