#include <windows.h>
#include <d3d9types.h>
#include <d3dx9math.h>
Idź do kodu źródłowego tego pliku.
Przestrzenie nazw | |
| namespace | common |
Komponenty | |
| struct | common::POINT_ |
| Punkt 2D z liczb całkowitych. Więcej... | |
| struct | common::VEC2 |
| Wektor floatów 2D. Więcej... | |
| struct | common::VEC3 |
| Wektor floatów 3D. Więcej... | |
| struct | common::VEC4 |
| Wektor floatów 4D. Więcej... | |
| struct | common::RECTI |
| Prostokąt z liczb całkowitych. Więcej... | |
| struct | common::RECTF |
| Prostokąt z 4 floatów. Więcej... | |
| struct | common::BOX |
| AABB z 2 punktów 3D. Więcej... | |
| struct | common::COLOR |
| Kolor w formacie A8R8G8B8. Więcej... | |
| struct | common::COLORF |
| Kolor z 4 liczb typu float - R, G, B, A. Więcej... | |
| struct | common::PLANE |
| Płaszczyzna. Więcej... | |
| struct | common::LINE2D |
| Prosta 2D. Więcej... | |
| struct | common::MATRIX |
| Macierz 4 x 4. Więcej... | |
| struct | common::QUATERNION |
| Kwaternion. Więcej... | |
| struct | common::FRUSTUM_PLANES |
| Frustum opisany 6 płaszczyznami z wektorami normalnymi zwróconymi do wewnątrz. Więcej... | |
| struct | common::FRUSTUM_POINTS |
| Frustum zapisany jako 8 wierzchołków. Więcej... | |
| class | common::FRUSTUM_RADAR |
| Frustum - reprezentacja radarowa. Więcej... | |
| class | common::SmoothCD_obj< T > |
| struct | SthToStr_obj< common::POINT_ > |
| struct | StrToSth_obj< common::POINT_ > |
| struct | SthToStr_obj< common::VEC2 > |
| struct | StrToSth_obj< common::VEC2 > |
| struct | SthToStr_obj< common::VEC3 > |
| struct | StrToSth_obj< common::VEC3 > |
| struct | SthToStr_obj< common::VEC4 > |
| struct | StrToSth_obj< common::VEC4 > |
| struct | SthToStr_obj< common::RECTI > |
| struct | StrToSth_obj< common::RECTI > |
| struct | SthToStr_obj< common::RECTF > |
| struct | StrToSth_obj< common::RECTF > |
| struct | SthToStr_obj< common::BOX > |
| struct | StrToSth_obj< common::BOX > |
| struct | SthToStr_obj< common::COLOR > |
| struct | StrToSth_obj< common::COLOR > |
| struct | SthToStr_obj< common::COLORF > |
| struct | StrToSth_obj< common::COLORF > |
| struct | SthToStr_obj< common::PLANE > |
| struct | StrToSth_obj< common::PLANE > |
| struct | SthToStr_obj< common::LINE2D > |
| struct | StrToSth_obj< common::LINE2D > |
| struct | SthToStr_obj< common::MATRIX > |
| struct | StrToSth_obj< common::MATRIX > |
| struct | SthToStr_obj< common::QUATERNION > |
| struct | StrToSth_obj< common::QUATERNION > |
Funkcje | |
| template<typename DestT, typename SrcT> | |
| DestT & | common::math_cast (const SrcT &x) |
| Szablon bazowy do konwersji między typami matematycznymi. | |
| POINT_ | common::operator* (const POINT_ pt, int v) |
| POINT_ | common::operator/ (const POINT_ pt, int v) |
| POINT_ | common::operator* (int v, const POINT_ pt) |
| POINT_ | common::operator/ (int v, const POINT_ pt) |
| template<> | |
| ::POINT & | common::math_cast<::POINT, POINT_ > (const POINT_ &x) |
| Konwersja z common::POINT_ do POINT. | |
| template<> | |
| POINT_ & | common::math_cast< POINT_,::POINT > (const ::POINT &x) |
| Konwersja z POINT do common::POINT_. | |
| void | common::swap (POINT_ &v1, POINT_ &v2) |
| VEC2 | common::operator* (const VEC2 pt, float v) |
| VEC2 | common::operator/ (const VEC2 pt, float v) |
| VEC2 | common::operator* (float v, const VEC2 pt) |
| VEC2 | common::operator/ (float v, const VEC2 pt) |
| void | common::swap (VEC2 &v1, VEC2 &v2) |
| VEC3 | common::operator* (const VEC3 pt, float v) |
| VEC3 | common::operator/ (const VEC3 pt, float v) |
| VEC3 | common::operator* (float v, const VEC3 pt) |
| VEC3 | common::operator/ (float v, const VEC3 pt) |
| void | common::swap (VEC3 &v1, VEC3 &v2) |
| VEC4 | common::operator* (const VEC4 pt, float v) |
| VEC4 | common::operator/ (const VEC4 pt, float v) |
| VEC4 | common::operator* (float v, const VEC4 pt) |
| VEC4 | common::operator/ (float v, const VEC4 pt) |
| void | common::swap (VEC4 &v1, VEC4 &v2) |
| float | common::LengthSq (const VEC2 &v) |
| Zwraca kwadrat długości wektora. | |
| float | common::LengthSq (const VEC3 &v) |
| Zwraca kwadrat długości wektora. | |
| float | common::LengthSq (const VEC4 &v) |
| Zwraca kwadrat długości wektora. | |
| float | common::Length (const VEC2 &v) |
| Zwraca długość wektora. | |
| float | common::Length (const VEC3 &v) |
| Zwraca długość wektora. | |
| float | common::Length (const VEC4 &v) |
| Zwraca długość wektora. | |
| void | common::Min (VEC2 *Out, const VEC2 &v1, const VEC2 &v2) |
| Zwraca wektor złożony z mniejszych składowych podanych wektorów. | |
| void | common::Min (VEC3 *Out, const VEC3 &v1, const VEC3 &v2) |
| void | common::Min (VEC4 *Out, const VEC4 &v1, const VEC4 &v2) |
| void | common::Max (VEC2 *Out, const VEC2 &v1, const VEC2 &v2) |
| Zwraca wektor złożony z większych składowych podanych wektorów. | |
| void | common::Max (VEC3 *Out, const VEC3 &v1, const VEC3 &v2) |
| void | common::Max (VEC4 *Out, const VEC4 &v1, const VEC4 &v2) |
| void | common::Mul (VEC2 *Out, const VEC2 &v, float f) |
| void | common::Mul (VEC3 *Out, const VEC3 &v, float f) |
| void | common::Mul (VEC4 *Out, const VEC4 &v, float f) |
| void | common::Add (VEC2 *Out, const VEC2 &v1, const VEC2 &v2) |
| void | common::Add (VEC3 *Out, const VEC3 &v1, const VEC3 &v2) |
| void | common::Add (VEC4 *Out, const VEC4 &v1, const VEC4 &v2) |
| void | common::Sub (VEC2 *Out, const VEC2 &v1, const VEC2 &v2) |
| void | common::Sub (VEC3 *Out, const VEC3 &v1, const VEC3 &v2) |
| void | common::Sub (VEC4 *Out, const VEC4 &v1, const VEC4 &v2) |
| void | common::Mul (VEC2 *Out, const VEC2 &v1, const VEC2 &v2) |
| void | common::Mul (VEC3 *Out, const VEC3 &v1, const VEC3 &v2) |
| void | common::Mul (VEC4 *Out, const VEC4 &v1, const VEC4 &v2) |
| void | common::Div (VEC2 *Out, const VEC2 &v1, const VEC2 &v2) |
| void | common::Div (VEC3 *Out, const VEC3 &v1, const VEC3 &v2) |
| void | common::Div (VEC4 *Out, const VEC4 &v1, const VEC4 &v2) |
| float | common::Dot (const VEC2 &v1, const VEC2 &v2) |
| Iloczyn skalarny wektorów. | |
| float | common::Dot (const VEC3 &v1, const VEC3 &v2) |
| float | common::Dot (const VEC4 &v1, const VEC4 &v2) |
| void | common::Minus (VEC2 *Out, VEC2 &v) |
| Odwraca znak składowych wektora. | |
| void | common::Minus (VEC3 *Out, VEC3 &v) |
| void | common::Minus (VEC4 *Out, VEC4 &v) |
| void | common::Minus (VEC2 *InOut) |
| void | common::Minus (VEC3 *InOut) |
| void | common::Minus (VEC4 *InOut) |
| float | common::Cross (const VEC2 &v1, const VEC2 &v2) |
| Iloczyn wektorowy dwóch wektorów dający liczbę mówiącą czy drugi wskazuje na lewo, czy na prawo względem pierwszego. | |
| void | common::Cross (VEC3 *Out, const VEC3 &v1, const VEC3 &v2) |
| Iloczyn wektorowy dwóch wektorów 3D. | |
| float | common::DistanceSq (const VEC2 &p1, const VEC2 &p2) |
| Kwadrat odległości między dwoma punktami. | |
| float | common::DistanceSq (const VEC3 &p1, const VEC3 &p2) |
| float | common::DistanceSq (const VEC4 &p1, const VEC4 &p2) |
| float | common::Distance (const VEC2 &p1, const VEC2 &p2) |
| Odległość między dwoma punktami. | |
| float | common::Distance (const VEC3 &p1, const VEC3 &p2) |
| float | common::Distance (const VEC4 &p1, const VEC4 &p2) |
| void | common::Lerp (VEC2 *Out, const VEC2 &v1, const VEC2 &v2, float t) |
| Liniowa interpolacja wektorów. | |
| void | common::Lerp (VEC3 *Out, const VEC3 &v1, const VEC3 &v2, float t) |
| void | common::Lerp (VEC4 *Out, const VEC4 &v1, const VEC4 &v2, float t) |
| void | common::Normalize (VEC2 *Out, const VEC2 &v) |
| Normalizuje wektor, czyli zmienia mu długość na 1. | |
| void | common::Normalize (VEC3 *Out, const VEC3 &v) |
| void | common::Normalize (VEC4 *Out, const VEC4 &v) |
| void | common::Normalize (VEC2 *v) |
| Normalizuje wektor w miejscu. | |
| void | common::Normalize (VEC3 *v) |
| void | common::Normalize (VEC4 *v) |
| void | common::Vec3ToVec4 (VEC4 *Out, const VEC3 &v) |
| Konwersja z wektora 3D na 4D dopisująca W=1. | |
| void | common::Vec4ToVec3_Ignore (VEC3 *Out, const VEC4 &v) |
| Konwersja z wektora 4D na 3D ze zignorowaniem składowej W. | |
| void | common::Vec4ToVec3_Div (VEC3 *Out, const VEC4 &v) |
| Konwersja z wektora 4D na 3D ze podzieleniem składowych przez W. | |
| void | common::MidPoint (VEC2 *Out, const VEC2 &p1, const VEC2 &p2) |
| Zwraca punkt w połowie drogi między podanymi punktami. | |
| void | common::MidPoint (VEC3 *Out, const VEC3 &p1, const VEC3 &p2) |
| void | common::MidPoint (VEC4 *Out, const VEC4 &p1, const VEC4 &p2) |
| bool | common::VecEqual (const VEC2 &v1, const VEC2 &v2) |
| Zwraca true, jeśli podane wektory/punkty są sobie mniej więcej równe. | |
| bool | common::VecEqual (const VEC3 &v1, const VEC3 &v2) |
| bool | common::VecEqual (const VEC4 &v1, const VEC4 &v2) |
| bool | common::Less (const VEC2 &v1, const VEC2 &v2) |
| bool | common::Less (const VEC3 &v1, const VEC3 &v2) |
| bool | common::Less (const VEC4 &v1, const VEC4 &v2) |
| bool | common::LessOrEqual (const VEC2 &v1, const VEC2 &v2) |
| bool | common::LessOrEqual (const VEC3 &v1, const VEC3 &v2) |
| bool | common::LessOrEqual (const VEC4 &v1, const VEC4 &v2) |
| bool | common::Greater (const VEC2 &v1, const VEC2 &v2) |
| bool | common::Greater (const VEC3 &v1, const VEC3 &v2) |
| bool | common::Greater (const VEC4 &v1, const VEC4 &v2) |
| bool | common::GreaterOrEqual (const VEC2 &v1, const VEC2 &v2) |
| bool | common::GreaterOrEqual (const VEC3 &v1, const VEC3 &v2) |
| bool | common::GreaterOrEqual (const VEC4 &v1, const VEC4 &v2) |
| bool | common::around (const VEC2 &v1, const VEC2 &v2, float Epsilon) |
| bool | common::around (const VEC3 &v1, const VEC3 &v2, float Epsilon) |
| bool | common::around (const VEC4 &v1, const VEC4 &v2, float Epsilon) |
| void | common::Perpedicular (VEC2 *Out, const VEC2 &v) |
| Zwraca wektor prostopadły do podanego wektora 2D. | |
| void | common::Reflect (VEC2 *Out, const VEC2 &v, const VEC2 &PlaneNormal) |
| Oblicza wektor kierunku odbicia od płaszczyzny o podanej normalnej. | |
| void | common::Reflect (VEC3 *Out, const VEC3 &v, const VEC3 &PlaneNormal) |
| void | common::Project (VEC2 *Out, const VEC2 &V, const VEC2 &N) |
| Rzutowanie wektora V na wektor N. | |
| void | common::Project (VEC3 *Out, const VEC3 &V, const VEC3 &N) |
| void | common::Project_N (VEC2 *Out, const VEC2 &V, const VEC2 &N) |
| Wersja common::Project, kiedy wektor N jest już na pewno znormalizowany. | |
| void | common::Project_N (VEC3 *Out, const VEC3 &V, const VEC3 &N) |
| void | common::Orthogonalize_Fast (VEC3 *OutR1, VEC3 *OutR2, VEC3 *OutR3, const VEC3 &R1, const VEC3 &R2, const VEC3 &R3) |
| Ortogonalizacja trzech wektorów - Metoda szybka. | |
| void | common::Orthogonalize (VEC3 *OutR1, VEC3 *OutR2, VEC3 *OutR3, const VEC3 &R1, const VEC3 &R2, const VEC3 &R3) |
| Ortogonalizacja trzech wektorów - Metoda dokładna. | |
| void | common::PerpedicularVectors (VEC3 *Out1, VEC3 *Out2, const VEC3 &v) |
| Wyznacza dwa dowolne wektory prostopadłe do podanego. | |
| float | common::TriangleArea (const VEC2 &p1, const VEC2 &p2, const VEC2 &p3) |
| Oblicza signed pole powierzchni trójkąta. | |
| float | common::TriangleArea (const VEC3 &p1, const VEC3 &p2, const VEC3 &p3) |
| float | common::TrianglePerimeter (const VEC2 &p1, const VEC2 &p2, const VEC2 &p3) |
| Znajduje obwód trójkąta. | |
| float | common::TrianglePerimeter (const VEC3 &p1, const VEC3 &p2, const VEC3 &p3) |
| void | common::Barycentric (VEC2 *Out, const VEC2 &p1, const VEC2 &p2, const VEC2 &p3, float f, float g) |
| Oblicza punkt na powierzhchni trójkąta we wsp. barycentrycznych. | |
| void | common::Barycentric (VEC3 *Out, const VEC3 &p1, const VEC3 &p2, const VEC3 &p3, float f, float g) |
| void | common::Barycentric (VEC4 *Out, const VEC4 &p1, const VEC4 &p2, const VEC4 &p3, float f, float g) |
| void | common::CalculateBarycentric (const VEC3 &p, const VEC3 &p1, const VEC3 &p2, const VEC3 &p3, const VEC3 *Normal, float *e, float *f, float *g) |
| Oblicz współrzędne barycentryczne podanego punktu p w ramach trójkąta p1-p2-p3. | |
| void | common::TriangleInscribedCircle (VEC2 *OutCenter, float *OutRadius, const VEC2 &v1, const VEC2 &v2, const VEC2 &v3) |
| Znajduje okrąg wpisany w trójkąt. | |
| void | common::TriangleInscribedCircle (VEC3 *OutCenter, float *OutRadius, const VEC3 &v1, const VEC3 &v2, const VEC3 &v3) |
| void | common::TriangleCircumscribedCircle (VEC2 *OutCenter, float *OutRadius, const VEC2 &v1, const VEC2 &v2, const VEC2 &v3) |
| Znajduje okrąg opisany na trójkącie. | |
| void | common::TriangleCircumscribedCircle (VEC3 *OutCenter, float *OutRadius, const VEC3 &v1, const VEC3 &v2, const VEC3 &v3) |
| void | common::PointOnRay (VEC2 *Out, const VEC2 &Origin, const VEC2 &Direction, float t) |
| Zwraca punkt na promieniu. | |
| void | common::PointOnRay (VEC3 *Out, const VEC3 &Origin, const VEC3 &Direction, float t) |
| template<> | |
| ::RECT & | common::math_cast<::RECT, RECTI > (const RECTI &x) |
| Konwersja z common::RECTI do RECT z WinAPI. | |
| template<> | |
| RECTI & | common::math_cast< RECTI,::RECT > (const ::RECT &x) |
| Konwersja z RECT z WinAPI do common::RECTI. | |
| void | common::swap (RECTI &r1, RECTI &r2) |
| void | common::swap (RECTF &r1, RECTF &r2) |
| bool | common::PointInRect (const POINT_ &p, const RECTI &r) |
| Zwraca true, jeśli punkt należy do prostokąta. | |
| bool | common::PointInRect (const VEC2 &p, const RECTF &r) |
| bool | common::RectInRect (const RECTI &sr, const RECTI &r) |
| Zwraca true, jeśli prostokąt sr zawiera się w całości wewnątrz r. | |
| bool | common::RectInRect (const RECTF &sr, const RECTF &r) |
| bool | common::OverlapRect (const RECTI &r1, const RECTI &r2) |
| Zwraca true, jeśli podane prostokąty zachodzą na siebie. | |
| bool | common::OverlapRect (const RECTF &r1, const RECTF &r2) |
| bool | common::Intersection (RECTI *Out, const RECTI &r1, const RECTI &r2) |
| Jeśli prostokąty posiadają część wspólną, zwraca ją przez Out i zwraca true. | |
| bool | common::Intersection (RECTF *Out, const RECTF &r1, const RECTF &r2) |
| void | common::Union (RECTI *Out, const RECTI &r1, const RECTI &r2) |
| Zwraca prostokąt opisany na podanych dwóch prostokątach. | |
| void | common::Union (RECTF *Out, const RECTF &r1, const RECTF &r2) |
| void | common::swap (BOX &b1, BOX &b2) |
| void | common::Scale (BOX *Out, const BOX &b, float s) |
| Skaluje boks o podaną liczbę. | |
| void | common::Scale (BOX *Out, const BOX &b, const VEC3 &s) |
| Skaluje boks o podane 3 wymiary. | |
| bool | common::PointInBox (const VEC3 &p, const BOX &b) |
| Zwraca true, jeśli punkt należy do boksa. | |
| bool | common::BoxInBox (const BOX &sb, const BOX &b) |
| Zwraca true, jeśli boks sb zawiera się w całości wewnątrz b. | |
| bool | common::OverlapBox (const BOX &b1, const BOX &b2) |
| Zwraca true, jeśli podane boksy zachodzą na siebie. | |
| bool | common::Intersection (BOX *Out, const BOX &b1, const BOX &b2) |
| Jeśli boksy posiadają część wspólną, zwraca ją przez Out i zwraca true. | |
| void | common::Union (BOX *Out, const BOX &b1, const BOX &b2) |
| Zwraca boks opisany na podanych dwóch boksach. | |
| void | common::swap (COLORF &c1, COLORF &c2) |
| COLORF | common::operator* (float s, const COLORF &c) |
| COLORF | common::operator/ (float s, const COLORF &c) |
| COLOR | common::operator* (float s, const COLOR &c) |
| COLOR | common::operator/ (float s, const COLOR &c) |
| template<> | |
| uint4 & | common::math_cast< uint4, COLOR > (const COLOR &x) |
| template<> | |
| unsigned long & | common::math_cast< unsigned long, COLOR > (const COLOR &x) |
| template<> | |
| COLOR & | common::math_cast< COLOR, uint4 > (const uint4 &x) |
| template<> | |
| COLOR & | common::math_cast< COLOR, unsigned long > (const unsigned long &x) |
| template<> | |
| D3DXCOLOR & | common::math_cast< D3DXCOLOR, COLORF > (const COLORF &x) |
| template<> | |
| COLORF & | common::math_cast< COLORF, D3DXCOLOR > (const D3DXCOLOR &x) |
| void | common::ColorToColorf (COLORF *Out, COLOR c) |
| Konwersje między tymi dwoma reprezentacjami kolorów. | |
| COLOR | common::ColorfToColor (const COLORF &c) |
| void | common::ColorToStr (tstring *Out, COLOR Color, char Format= 'X') |
| Konwersja koloru na łańcuch. | |
| void | common::ColorToStr (tstring *Out, const COLORF &Color, char Format= 'F') |
| bool | common::StrToColor (COLOR *Out, const tstring &Str) |
| Konwersja łańcucha na kolor. | |
| bool | common::StrToColor (COLORF *Out, const tstring &Str) |
| void | common::Add (COLORF *Out, const COLORF &c1, const COLORF &c2) |
| void | common::Sub (COLORF *Out, const COLORF &c1, const COLORF &c2) |
| void | common::Mul (COLORF *Out, const COLORF &c1, const COLORF &c2) |
| void | common::Mul (COLORF *Out, const COLORF &c, float s) |
| void | common::Div (COLORF *Out, const COLORF &c, float s) |
| void | common::Negative (COLORF *Out, const COLORF &c) |
| COLOR | common::ARGB_ABGR (COLOR color) |
| Konwertuje kolor między systemami ARGB i ABGR. | |
| void | common::Lerp (COLORF *Out, const COLORF &c1, const COLORF &c2, float t) |
| COLOR | common::Lerp (COLOR c1, COLOR c2, float t) |
| void | common::HsbToRgb (COLORF *Out, float hue, float saturation, float brightness) |
| Konwertuje kolor między HSB a RGB. | |
| void | common::RgbToHsb (float *OutHue, float *OutSaturation, float *OutBrightness, const COLORF &Color) |
| Konwertuje kolor RGB na HSB. | |
| void | common::ColorRainbow (COLORF *Out, float t) |
| Zwraca kolor tęczy od czerwonego (odpowiada mu t = 0) do niebieskiego (t = 1). | |
| float | common::ColorToGrayscale (const COLORF &c) |
| Zwraca jasność podanego koloru (odcień szarości) z zakresu 0..1. | |
| float | common::ColorToGrayscale (COLOR &c) |
| void | common::GrayscaleToColor (COLORF *Out, float t) |
| Zwraca kolor szary o podanej jasności t = 0..1. | |
| void | common::GrayscaleToColor (COLOR *Out, float t) |
| void | common::AdjustContrast (COLORF *Color, float t) |
| Zmienia kolorowi kontrast na miejscu. | |
| void | common::AdjustSaturation (COLORF *Color, float t) |
| Zmienia kolorowi nasycenie na miejscu. | |
| COLOR | common::VectorToColor (const VEC3 &v) |
| Przetwarza znormalizowany wektor na kolor XRGB. A zwraca 0. | |
| void | common::ColorToVector (VEC3 *Out, COLOR color) |
| Przetwarza kolor na wektor. | |
| uint | common::ColorDistance (COLOR Color1, COLOR Color2) |
| Zwraca "odległość" dwóch kolorów wg jakiejśtam byle jakiej metryki. Uwzględnia składowe R, G, B. | |
| PLANE | common::operator* (float s, const PLANE &p) |
| void | common::swap (PLANE &p1, PLANE &p2) |
| VEC3 & | common::GetPlaneNormal (PLANE &Plane) |
| Daje dostęp do wektora normalnego podanej płaszczyzny, czyli jej składowych a, b, c zrzutowanych jako VEC3. | |
| const VEC3 & | common::GetPlaneNormal (const PLANE &Plane) |
| Zwraca wektor normalny płaszczyzny, czyli jej składowe a, b, c zrzutowane jako VEC3. | |
| void | common::GetPlaneMemberPoint (VEC3 *Out, const PLANE &Plane) |
| Zwraca jakiś punkt leżący na tej płaszczyźnie. | |
| void | common::RecalculatePlaneD (PLANE *Plane, const VEC3 &p) |
| Zmienia odległość od początku układu współrzędnych. | |
| bool | common::PlaneEqual (const PLANE &p1, const PLANE &p2) |
| Zwraca true, jeśli podane płaszczyzny są sobie mniej więcej równe. | |
| void | common::PointsToPlane (PLANE *Out, const VEC3 &p1, const VEC3 &p2, const VEC3 &p3) |
| Tworzy płaszczyznę na podstawie trzech punktów. | |
| void | common::PointNormalToPlane (PLANE *Out, const VEC3 &Point, const VEC3 &Normal) |
| Tworzy płaszczyznę z wektora normalnego i punktu leżącego na tej płaszczyźnie. | |
| void | common::Mul (PLANE *Out, const PLANE &p, float s) |
| Skalowanie płaszczyzny. | |
| void | common::Div (PLANE *Out, const PLANE &p, float s) |
| float | common::Dot (const PLANE &p, const VEC4 &pt) |
| Iloczyn skalarny płaszczyzny i punktu we współrzędnych jednorodnych. | |
| float | common::DotCoord (const PLANE &p, const VEC3 &pt) |
| Iloczyn skalarny płaszczyzny z punktem 3D: a*x+b*y+c*z+d*1. | |
| float | common::DotNormal (const PLANE &p, const VEC3 &v) |
| Iloczyn skalarny płaszczyzny z wektorem 3D: a*x+b*y+c*z+d*0. | |
| void | common::Normalize (PLANE *Out, const PLANE &p) |
| Normalizacja płaszczyzny. | |
| void | common::Normalize (PLANE *p) |
| Normalizacja płaszczyzny w miejscu. | |
| LINE2D | common::operator* (float s, const LINE2D &p) |
| LINE2D | common::operator/ (float s, const LINE2D &p) |
| bool | common::LineEqual (const LINE2D &p1, const LINE2D &p2) |
| Zwraca true, jeśli podane proste są sobie mniej więcej równe. | |
| void | common::swap (LINE2D &p1, LINE2D &p2) |
| void | common::PointsToLine (LINE2D *Out, const VEC2 &p1, const VEC2 &p2) |
| Tworzy prostą na podstwie dwóch punktów. | |
| void | common::PointNormalToLine (LINE2D *Out, const VEC2 &Point, const VEC2 &Normal) |
| Tworzy prostą z wektora normalnego i punktu leżącego na tej prostej. | |
| bool | common::LinesParallel (const LINE2D &L1, const LINE2D &L2) |
| Zwraca true, jeśli podane proste są równoległe. | |
| bool | common::LinesPerpedicular (const LINE2D &L1, const LINE2D &L2) |
| Zwraca true, jeśli podane proste są prostopadłe. | |
| float | common::Dot (const LINE2D &L1, const LINE2D &L2) |
| Zwraca dot z wektorów normalnych dwóch prostych. | |
| float | common::LineDistance (const LINE2D &L1, const LINE2D &L2) |
| Zwraca signed odległość dwóch prostych na płaszczyźnie. | |
| bool | common::LinesIntersection (VEC2 *Out, const LINE2D &L1, const LINE2D &L2) |
| Oblicza punkt przeciecia dwóch prostych. | |
| bool | common::PointsColinear (const VEC2 &p1, const VEC2 &p2, const VEC2 &p3) |
| Zwraca true, jeśli podane trzy punkty leżą na jednej prostej. | |
| void | common::Mul (LINE2D *Out, const LINE2D &p, float s) |
| Skalowanie prostej. | |
| void | common::Div (LINE2D *Out, const LINE2D &p, float s) |
| float | common::Dot (const LINE2D &p, const VEC3 &pt) |
| Iloczyn skalarny płaszczyzny i punktu we współrzędnych jednorodnych 2D. | |
| float | common::DotCoord (const LINE2D &p, const VEC2 &pt) |
| Iloczyn skalarny prostej 2D z punktem 2D: a*x + b*y + c*1. | |
| float | common::DotNormal (const LINE2D &p, const VEC2 &v) |
| Iloczyn skalarny prostej 2D z wektorem 2D: a*x + b*y + c*z + d*0. | |
| void | common::Normalize (LINE2D *Out, const LINE2D &p) |
| Normalizacja prostej 2D. | |
| void | common::Normalize (LINE2D *p) |
| Normalizacja prostej w miejscu. | |
| void | common::MatrixToStr (tstring *Out, const MATRIX &m) |
| bool | common::StrToMatrix (MATRIX *Out, const tstring &Str) |
| void | common::swap (MATRIX &m1, MATRIX &m2) |
| bool | common::MatrixEqual (const MATRIX &m1, const MATRIX &m2) |
| Zwraca true, jeśli podane macierze są sobie mniej więcej równe. | |
| void | common::Minus (MATRIX *m) |
| Negacja macierzy w miejscu. | |
| void | common::Add (MATRIX *Out, const MATRIX &m1, const MATRIX &m2) |
| Dodawanie macierzy. | |
| void | common::Sub (MATRIX *Out, const MATRIX &m1, const MATRIX &m2) |
| Odejmowanie macierzy. | |
| void | common::Mul (MATRIX *Out, const MATRIX &m1, const MATRIX &m2) |
| Mnożenie macierzy. | |
| void | common::Mul (MATRIX *m, float s) |
| Mnożenie macierzy przez skalar w miejscu. | |
| void | common::Div (MATRIX *m, float s) |
| Dzielenie macierzy przez skalar w miejscu. | |
| void | common::Transform (VEC4 *Out, const VEC2 &v, const MATRIX &m) |
| Mnożenie wektora 2D jako [x,y,0,1] przez macierz, wychodzi wektor 4D. | |
| void | common::Transform (VEC2 *Out, const VEC2 &v, const MATRIX &m) |
| Mnożenie wektora 2D jako [x,y,0,1] przez macierz z olaniem wyjściowego W. | |
| void | common::TransformCoord (VEC2 *Out, const VEC2 &v, const MATRIX &m) |
| Mnożenie wektora 2D jako [x,y,0,1] przez macierz i sprowadzenie z powrotem do 2D przez podzielenie przez W. | |
| void | common::TransformNormal (VEC2 *Out, const VEC2 &v, const MATRIX &m) |
| Mnożenie wektora 2D jako [x,y,0,0] przez macierz. | |
| void | common::Transform (VEC4 *Out, const VEC3 &v, const MATRIX &m) |
| Mnożenie wektora 3D jako [X,Y,Z,1] przez macierz, wychodzi wektor 4D. | |
| void | common::Transform (VEC3 *Out, const VEC3 &v, const MATRIX &m) |
| Mnożenie wektora 3D jako [X,Y,Z,1] przez macierz z olaniem wyjściowego W. | |
| void | common::TransformCoord (VEC3 *Out, const VEC3 &v, const MATRIX &m) |
| Mnożenie wektora 3D jako [X,Y,Z,1] przez macierz i sprowadzenie z powrotem do 3D przez podzielenie przez W. | |
| void | common::TransformNormal (VEC3 *Out, const VEC3 &v, const MATRIX &m) |
| Mnożenie wektora 3D jako [X,Y,Z,0] przez macierz. | |
| void | common::TransformArray (VEC3 OutPoints[], const VEC3 InPoints[], size_t PointCount, const MATRIX &M) |
| Przekształca na raz całą tablicę wektorów - w miejscu lub z tablicy wejściowej do wyjściowej. | |
| void | common::TransformArray (VEC3 InOutPoints[], size_t PointCount, const MATRIX &M) |
| void | common::TransformNormalArray (VEC3 OutPoints[], const VEC3 InPoints[], size_t PointCount, const MATRIX &M) |
| void | common::TransformNormalArray (VEC3 InOutPoints[], size_t PointCount, const MATRIX &M) |
| void | common::TransformCoordArray (VEC3 OutPoints[], const VEC3 InPoints[], size_t PointCount, const MATRIX &M) |
| void | common::TransformCoordArray (VEC3 InOutPoints[], size_t PointCount, const MATRIX &M) |
| void | common::Transform (VEC4 *Out, const VEC4 &v, const MATRIX &m) |
| Mnożenie wektora 4D przez macierz. | |
| void | common::Transform (PLANE *Out, const PLANE &p, const MATRIX &m) |
| Przekształca płaszczyznę przez macierz. | |
| void | common::TransformRay (VEC3 *OutOrigin, VEC3 *OutDir, const VEC3 &RayOrigin, const VEC3 &RayDir, const MATRIX &m) |
| Przekształca promień przez macierz. | |
| void | common::TransformBox (BOX *Out, const BOX &In, const MATRIX &M) |
| Przekształca AABB przez podaną macierz i wylicza AABB tego co wyszło po przekształceniu. | |
| void | common::TransformBoxCoord (BOX *Out, const BOX &In, const MATRIX &M) |
| Przekształca AABB przez podaną macierz i wylicza AABB tego co wyszło po przekształceniu. | |
| void | common::AxesToMatrix (MATRIX *Out, const VEC3 &AxisX, const VEC3 &AxisY, const VEC3 &AxisZ) |
| Tworzy macierz przekształcającą do lokalnego układu współrzędnych wyznaczonego przez podane 3 osie. | |
| void | common::AxesToMatrixTranslation (MATRIX *Out, const VEC3 &Origin, const VEC3 &AxisX, const VEC3 &AxisY, const VEC3 &AxisZ) |
| Tworzy macierz przekształcającą do lokalnego układu współrzędnych wyznaczonego przez podane 3 osie i pozycję początku tego układu. | |
| void | common::LookAtLH (MATRIX *Out, const VEC3 &Eye, const VEC3 &Forward, const VEC3 &Up) |
| Macierz kamery. | |
| void | common::LookAtRH (MATRIX *Out, const VEC3 &Eye, const VEC3 &Forward, const VEC3 &Up) |
| void | common::Identity (MATRIX *Out) |
| Tworzy macierz identycznościową. | |
| void | common::Translation (MATRIX *Out, float x, float y, float z) |
| Tworzy macierz translacji (przesuwania). | |
| void | common::Translation (MATRIX *Out, const VEC3 &v) |
| void | common::Scaling (MATRIX *Out, float sx, float sy, float sz) |
| Tworzy macierz skalowania (powiększania, pomniejszania, rozciągania). | |
| void | common::Scaling (MATRIX *Out, const VEC3 &sv) |
| void | common::Scaling (MATRIX *Out, float s) |
| void | common::ScalingAxis (MATRIX *Out, const VEC3 &n, float k) |
| Tworzy macierz skalowania wzdłuż podanego kierunku. | |
| void | common::Rotation2D (MATRIX *Out, float Angle) |
| Macierz obrotu 2D. | |
| void | common::RotationX (MATRIX *Out, float Angle) |
| Macierz obrotu wokół osi X. | |
| void | common::RotationY (MATRIX *Out, float Angle) |
| Macierz obrotu wokół osi Y. | |
| void | common::RotationZ (MATRIX *Out, float Angle) |
| Macierz obrotu wokół osi Z. | |
| void | common::RotationAxisLH (MATRIX *Out, const VEC3 &Axis, float Angle) |
| void | common::RotationAxisRH (MATRIX *Out, const VEC3 &Axis, float Angle) |
| void | common::RotationYawPitchRoll (MATRIX *Out, float Yaw, float Pitch, float Roll) |
| Macierz obrotu wokół trzech osi w kolejności Yaw-Pitch-Roll (ZXY) - tzw. kąty Eulera. | |
| void | common::RotationYawPitchRoll (MATRIX *Out, const VEC3 &EulerAngles) |
| void | common::RotationYawPitchRollInv (MATRIX *Out, float Yaw, float Pitch, float Roll) |
| Przekształca ze wsp. świata do obiektu (interial -> object space). | |
| void | common::RotationYawPitchRollInv (MATRIX *Out, const VEC3 &EulerAngles) |
| void | common::OrthoLH (MATRIX *Out, float Width, float Height, float ZNear, float ZFar) |
| Tworzy macierz rzutowania ortogonalnego. | |
| void | common::OrthoRH (MATRIX *Out, float Width, float Height, float ZNear, float ZFar) |
| void | common::OrthoOffCenterLH (MATRIX *Out, float Left, float Right, float Bottom, float Top, float ZNear, float ZFar) |
| void | common::OrthoOffCenterRH (MATRIX *Out, float Left, float Right, float Bottom, float Top, float ZNear, float ZFar) |
| void | common::PerspectiveLH (MATRIX *Out, float Width, float Height, float ZNear, float ZFar) |
| Tworzy macierz rzutowania perspektywicznego. | |
| void | common::PerspectiveRH (MATRIX *Out, float Width, float Height, float ZNear, float ZFar) |
| void | common::PerspectiveFovLH (MATRIX *Out, float FovY, float Aspect, float ZNear, float ZFar) |
| void | common::PerspectiveFovRH (MATRIX *Out, float FovY, float Aspect, float ZNear, float ZFar) |
| void | common::PerspectiveOffCenterLH (MATRIX *Out, float Left, float Right, float Bottom, float Top, float ZNear, float ZFar) |
| void | common::PerspectiveOffCenterRH (MATRIX *Out, float Left, float Right, float Bottom, float Top, float ZNear, float ZFar) |
| void | common::PerspectiveFovLH_Inf (MATRIX *Out, float FovY, float Aspect, float ZNear) |
| Wersja tworząca macierz z Z-Far = INFINITY. | |
| void | common::MatrixShadow (MATRIX *Out, const VEC4 &Light, const PLANE &Plane) |
| Tworzy macierz spłaszczającą geometrię na podaną płaszczyznę w podanym kierunku padania światła. | |
| void | common::MatrixReflect (MATRIX *Out, const PLANE &p) |
| Tworzy macierz odbijającą geometrię względem podanej płaszczyzny. | |
| void | common::Transpose (MATRIX *m) |
| Transpozycja macierzy na miejscu. | |
| void | common::Lerp (MATRIX *Out, const MATRIX &m1, const MATRIX &m2, float t) |
| Interpolacja liniowa macierzy. | |
| float | common::Det (const MATRIX &m) |
| Wyznacznik macierzy. | |
| bool | common::Inverse (MATRIX *Out, const MATRIX &m) |
| Odwrotność macierzy. | |
| QUATERNION | common::operator* (const QUATERNION pt, float v) |
| QUATERNION | common::operator/ (const QUATERNION pt, float v) |
| QUATERNION | common::operator* (float v, const QUATERNION pt) |
| QUATERNION | common::operator/ (float v, const QUATERNION pt) |
| void | common::swap (QUATERNION &v1, QUATERNION &v2) |
| float | common::CalcQuaternionAngle (const QUATERNION &Q) |
| Zwraca kąt obrotu jaki reprezentuje ten kwaternion. | |
| void | common::CalcQuaternionAxis (VEC3 *Out, const QUATERNION &Q) |
| Zwraca oś obrotu jaką reprezentuje ten kwaternion. | |
| bool | common::QuaternionEqual (const QUATERNION &q1, const QUATERNION &q2) |
| Zwraca true, jeśli podane kwaterniony są sobie mniej więcej równe. | |
| void | common::Minus (QUATERNION *q) |
| Ujemny kwaternion. | |
| void | common::Minus (QUATERNION *Out, const QUATERNION &q) |
| void | common::Add (QUATERNION *Out, const QUATERNION &q1, const QUATERNION &q2) |
| Dodawanie, odejmowanie, mnożenie kwaternionów. | |
| void | common::Sub (QUATERNION *Out, const QUATERNION &q1, const QUATERNION &q2) |
| void | common::Mul (QUATERNION *Out, const QUATERNION &q1, const QUATERNION &q2) |
| void | common::Mul (QUATERNION *q, float v) |
| Mnożenie i dzielenie kwaterniona przez skalar. | |
| void | common::Div (QUATERNION *q, float v) |
| void | common::Mul (QUATERNION *Out, const QUATERNION &q, float v) |
| void | common::Div (QUATERNION *Out, const QUATERNION &q, float v) |
| void | common::RotationMatrixToQuaternion (QUATERNION *Out, const MATRIX &RotationMatrix) |
| Tworzy kwaternion na podstawie macierzy obrotu. | |
| void | common::QuaternionToRotationMatrix (MATRIX *Out, const QUATERNION &q) |
| Przekształca kwaternion w macierz obrotu. | |
| void | common::QuaternionTransform (VEC3 *Out, const VEC3 &p, const QUATERNION &q) |
| Przekształca punkt/wektor przez kwaternion obracając go o ten kwaternion. | |
| void | common::EulerAnglesToQuaternionO2I (QUATERNION *Out, float Yaw, float Pitch, float Roll) |
| Konwersja kątów Eulera na kwaternion (który obraca ze wsp. obiektu do świata, czyli object -> interial space) [a może odwrotnie?]. | |
| void | common::EulerAnglesToQuaternionI2O (QUATERNION *Out, float Yaw, float Pitch, float Roll) |
| Konwersja kątów Eulera na kwaternion (który obraca ze wsp. świata do obiektu, czyli interial -> object space) [a może odwrotnie?]. | |
| void | common::QuaternionO2IToEulerAngles (float *Yaw, float *Pitch, float *Roll, const QUATERNION &q) |
| Konwersja kwaterniona który obraca ze wsp. obiektu do świata, czyli object -> interial space, na kąty Eulera. | |
| void | common::QuaternionI2OToEulerAngles (float *Yaw, float *Pitch, float *Roll, const QUATERNION &q) |
| Konwersja kwaterniona który obraca ze wsp. świata do obiektu, czyli interial -> object space, na kąty Eulera. | |
| void | common::QuaternionRotationX (QUATERNION *Out, float a) |
| Tworzy kwaternion obracający wokół osi X. | |
| void | common::QuaternionRotationY (QUATERNION *Out, float a) |
| Tworzy kwaternion obracający wokół osi Y. | |
| void | common::QuaternionRotationZ (QUATERNION *Out, float a) |
| Tworzy kwaternion obracający wokół osi Z. | |
| void | common::AxisToQuaternion (QUATERNION *Out, const VEC3 &Axis, float Angle) |
| Tworzy kwaternion na podstawie osi obrotu i kąta. | |
| void | common::QuaternionDiff (QUATERNION *Out, const QUATERNION &a, const QUATERNION &b) |
| Oblica "różnicę" dwóch kwaternionów reprezentującą taki obrót że a*Out = b. | |
| void | common::Conjugate (QUATERNION *q) |
| Kwaternion sprzężony do danego. | |
| void | common::Conjugate (QUATERNION *Out, const QUATERNION &q) |
| void | common::Inverse (QUATERNION *Out, const QUATERNION &q) |
| Odwrotność kwaterniona. | |
| void | common::Normalize (QUATERNION *Out, const QUATERNION &q) |
| Normalizacja kwaternion. | |
| void | common::Normalize (QUATERNION *InOut) |
| float | common::Dot (const QUATERNION &q1, const QUATERNION &q2) |
| Iloczyn skalarny dwóch kwaternionów. | |
| float | common::LengthSq (const QUATERNION &q) |
| Kwadrat długości kwaterniona. | |
| float | common::Length (const QUATERNION &q) |
| Długość kwaterniona. | |
| void | common::Log (QUATERNION *Out, const QUATERNION &q) |
| void | common::Exp (QUATERNION *Out, const QUATERNION &q) |
| void | common::Pow (QUATERNION *InOut, float t) |
| Podnieś kwaternion do potęgi. | |
| void | common::Pow (QUATERNION *Out, const QUATERNION &q, float t) |
| void | common::Lerp (QUATERNION *Out, const QUATERNION &q1, const QUATERNION &q2, float t) |
| Interpolacja normalna kwaternionów. | |
| void | common::Slerp (QUATERNION *Out, const QUATERNION &q0, const QUATERNION &q1, float t) |
| Interpolacja sferyczna kwaternionów. | |
| void | common::Squad (QUATERNION *Out, const QUATERNION &Q1, const QUATERNION &A, const QUATERNION &B, const QUATERNION &C, float t) |
| void | common::SquadSetup (QUATERNION *OutA, QUATERNION *OutB, QUATERNION *OutC, const QUATERNION &Q0, const QUATERNION &Q1, const QUATERNION &Q2, const QUATERNION &Q3) |
| float | common::CapsuleVolume (const VEC3 &p1, const VEC3 &p2, float R) |
| Objętość kapsuły. | |
| void | common::RandomPointInCapsule (VEC3 *Out, const VEC3 &p1, const VEC3 &p2, float R, RandomGenerator &Rand) |
| Losuje punkt z wnętrza kapsuły. Rozkład równomierny. | |
| void | common::RandomPointInCapsule (VEC3 *Out, const VEC3 &p1, const VEC3 &p2, float R) |
| template<typename T> | |
| void | common::SmoothCD_T (T *InOutPos, const T &Dest, T *InOutVel, float SmoothTime, float TimeDelta) |
| template<> | |
| void | common::SmoothCD_T< float > (float *InOutPos, const float &Dest, float *InOutVel, float SmoothTime, float TimeDelta) |
| template<> | |
| void | common::SmoothCD_T< VEC2 > (VEC2 *InOutPos, const VEC2 &Dest, VEC2 *InOutVel, float SmoothTime, float TimeDelta) |
| template<> | |
| void | common::SmoothCD_T< VEC3 > (VEC3 *InOutPos, const VEC3 &Dest, VEC3 *InOutVel, float SmoothTime, float TimeDelta) |
| void | common::SphericalToCartesian (VEC3 *Out, float Yaw, float Pitch, float R) |
| Tu można podawać co się chce. | |
| void | common::CartesianToSpherical (float *OutYaw, float *OutPitch, float *OutR, const VEC3 &Pos) |
| void | common::ConvexHull2D (std::vector< VEC2 > *OutPoints, const VEC2 InPoints[], size_t InPointCount) |
| Zwraca wypukłą otoczkę zbioru punktów 2D. | |
| float | common::ClosestPointOnLine (const VEC3 &p, const VEC3 &RayOrig, const VEC3 &RayDir) |
| Dany punkt p i promień (RayOrig, RayDir), oblicza parametr t dla punktu na tym promieniu będącego rzutem tego punktu na ten promień. | |
| float | common::PointToLineDistance (const VEC3 &P, const VEC3 &LineOrig, const VEC3 &LineDir) |
| Zwraca odległość punktu od prostej. | |
| bool | common::PointOnLine (const VEC3 &P, const VEC3 &LineOrig, const VEC3 &LineDir) |
| Zwraca true, jeśli punkt leży na prostej. | |
| float | common::PointToLine (const VEC3 &P, const VEC3 &LineOrig, const VEC3 &LineDir) |
| Zwraca parametr T punktu leżącego na prostej. | |
| bool | common::PointInLineSegment (const VEC3 &P, const VEC3 &SegmentBeg, const VEC3 &SegmentEnd) |
| Zwraca true, jeśli punkt leży na odcinku. | |
| void | common::ClosestPointOnLineSegment (VEC3 *Out, const VEC3 &P, const VEC3 &P1, const VEC3 &P2) |
| Wyznacza najbliższy punkt leżący na odcinku P1-P2 względem punktu P. | |
| void | common::ClosestPointInBox (VEC3 *Out, const BOX &Box, const VEC3 &p) |
| Wyznacza najbliższy punkt wewnątrz prostopadłościanu względem punktu p. | |
| float | common::PointToBoxDistance (const VEC3 &p, const BOX &box) |
| Odległość punktu od prostopadłościanu. | |
| bool | common::PointInSphere (const VEC3 &p, const VEC3 &SphereCenter, float SphereRadius) |
| Zwraca true, jeśli podany punkt należy do sfery. | |
| float | common::PointToSphereDistance (const VEC3 &p, const VEC3 &SphereCenter, float SphereRadius) |
| Zwraca odległość punktu od powierzchni sfery. | |
| void | common::ClosestPointOnSphere (VEC3 *Out, const VEC3 &SphereCenter, float SphereRadius, const VEC3 &p) |
| Wyznacza najbliższy punkt na powierzchni sfery względem punktu p. | |
| bool | common::PointOnPlane (const VEC3 &p, const PLANE &plane) |
| Zwraca true, jeśli podany punkt należy do płaszczyzny. | |
| void | common::ClosestPointOnPlane (VEC3 *Out, const PLANE &Plane, const VEC3 &p) |
| Wyznacza najbliższy punkt na płaszczyźnie względem punktu p. | |
| bool | common::PointOnTriangle (const VEC3 &point, const VEC3 &pa, const VEC3 &pb, const VEC3 &pc) |
| Zwraca true, jeśli punkt należy do trójkąta. | |
| bool | common::PointInFrustum (const VEC3 &p, const FRUSTUM_PLANES &Frustum) |
| Zwraca true, jeśli punkt należy do wnętrza podanego frustuma. | |
| bool | common::PointInFrustum (const VEC3 &p, const FRUSTUM_RADAR &Frustum) |
| bool | common::ClosestPointsOnLines (float *OutT1, float *OutT2, const VEC3 &RayOrig1, const VEC3 &RayDir1, const VEC3 &RayOrig2, const VEC3 &RayDir2) |
| Funkcja wyznacza parametry t1 i t2 dla punktów na dwóch prostych, w których te proste są najbliżej siebie. | |
| bool | common::RayToBox (float *OutT, const VEC3 &RayOrig, const VEC3 &RayDir, const BOX &Box) |
| Kolizja promienia z prostopadłościanem. | |
| bool | common::RayToSphere (const VEC3 &RayOrig, const VEC3 &RayDir, const VEC3 &SphereCenter, float SphereRadius, float *OutT) |
| Wylicza kolizję promienia ze sferą. | |
| bool | common::RayToPlane (const VEC3 &RayOrig, const VEC3 &RayDir, const PLANE &Plane, float *OutT, float *OutVD) |
| Przecięcie promienia z płaszczyzną. | |
| bool | common::RayToTriangle (const VEC3 &RayOrig, const VEC3 &RayDir, const VEC3 &p0, const VEC3 &p1, const VEC3 &p2, bool BackfaceCulling, float *OutT) |
| Kolizja promienia z trójkątem. | |
| bool | common::RayToFrustum (const VEC3 &RayOrig, const VEC3 &RayDir, const FRUSTUM_PLANES &Frustum, float *t_near, float *t_far) |
| Kolizja promienia z frustumem. | |
| bool | common::SphereToBox (const VEC3 &SphereCenter, float SphereRadius, const BOX &Box) |
| Zwraca true jeśli kula koliduje z prostopadłościanem (także jeśli jest w jego środku). | |
| bool | common::SphereInBox (const VEC3 &SphereCenter, float SphereRadius, const BOX &Box) |
| Zwraca true, jeśli sfera zawiera się w całości w prostopadłościanie. | |
| bool | common::BoxInSphere (const BOX &Box, const VEC3 &SphereCenter, float SphereRadius) |
| Zwraca true, jeśli prostopadłościan zawiera się w całości w sferze. | |
| bool | common::PlaneToBox (const PLANE &plane, const BOX &box) |
| Kolizja płaszczyzny z prostopadłościanem. | |
| int | common::ClassifyBoxToPlane (const PLANE &plane, const BOX &box) |
| Klasyfikuje położenie prostopadłościanu względem płaszczyzny. | |
| bool | common::TriangleInBox (const VEC3 &p1, const VEC3 &p2, const VEC3 &p3, const BOX &Box) |
| Zwraca true, jeśli trójkąt zawiera się w prostopadłościanie. | |
| bool | common::TriangleToBox (const VEC3 &p1, const VEC3 &p2, const VEC3 &p3, const BOX &Box, const PLANE *OptTrianglePlane=NULL) |
| Zwraca true, jeśli trójkąt przecina prostopadłościan lub się w nim zawiera. | |
| bool | common::BoxToFrustum_Fast (const BOX &Box, const FRUSTUM_PLANES &Frustum) |
| Zwraca true, jeśli podany prostopadłościan jest widoczny choć trochę w bryle widzenia. | |
| bool | common::BoxToFrustum (const BOX &Box, const FRUSTUM_PLANES &FrustumPlanes, const FRUSTUM_POINTS *OptFrustumPoints=NULL) |
| Zwraca true, jeśli podany prostopadłościan jest widoczny choć trochę w bryle widzenia. | |
| bool | common::BoxToFrustum (const BOX &Box, const FRUSTUM_RADAR &Frustum) |
| bool | common::BoxInFrustum (const BOX &Box, const FRUSTUM_PLANES &Frustum) |
| Zwraca true, jeśli AABB jest w całości wewnątrz frustuma. | |
| bool | common::SphereToSphere (const VEC3 &Center1, float Radius1, const VEC3 &Center2, float Radius2) |
| Zwraca true jeśli podane dwie sfery kolidują ze sobą. | |
| bool | common::SphereToPlane (const VEC3 &SphereCenter, float SphereRadius, const PLANE &Plane) |
| Zwraca true, jeśli sfera koliduje z płaszczyzną. | |
| int | common::ClassifySphereToPlane (const VEC3 &SphereCenter, float SphereRadius, const PLANE &Plane) |
| Klasyfikuje położenie sfery względem płaszczyzny. | |
| bool | common::SphereToFrustum_Fast (const VEC3 &SphereCenter, float SphereRadius, const FRUSTUM_PLANES &Frustum) |
| Zwraca true, jeśli sfera koliduje z frustumem. | |
| bool | common::SphereToFrustum (const VEC3 &SphereCenter, float SphereRadius, const FRUSTUM_PLANES &FrustumPlanes, const FRUSTUM_POINTS *OptFrustumPoints=NULL) |
| Zwraca true, jeśli sfera koliduje z frustumem. | |
| bool | common::SphereToFrustum (const VEC3 &SphereCenter, float SphereRadius, const FRUSTUM_RADAR &Frustum) |
| Testuje przecięcie sfery z frustumem. | |
| bool | common::SphereInFrustum (const VEC3 &SphereCenter, float SphereRadius, const FRUSTUM_PLANES &Frustum) |
| Zwraca true, jeśli sfera zawiera się w całości wewnątrz frustuma. | |
| bool | common::Intersect2Planes (const PLANE &Plane1, const PLANE &Plane2, VEC3 *LineOrig, VEC3 *LineDir) |
| Wylicza kolizję dwóch płaszczyzn zwracając parametry prostej tworzącej ich przecięcie. | |
| bool | common::Intersect3Planes (const PLANE &P1, const PLANE &P2, const PLANE &P3, VEC3 *OutP) |
| Zwraca punkt przecięcia trzech płaszczyzn lub false, jeśli taki punkt nie istnieje. | |
| bool | common::PlaneToTriangle (const PLANE &Plane, const VEC3 &p0, const VEC3 &p1, const VEC3 &p2) |
| Kolizja płaszczyzny z trójkątem. | |
| int | common::ClassifyPlaneToTriangle (const PLANE &Plane, const VEC3 &p0, const VEC3 &p1, const VEC3 &p2) |
| Klasyfikuje położenie trójkąta względem płaszczyzny. | |
| int | common::ClassifyFrustumToPlane (const FRUSTUM_POINTS &Frustum, const PLANE &Plane) |
| Kolizja płaszczyzny z frustumem (klasyfikacja). | |
| bool | common::IntersectLines (const VEC2 &p1, const VEC2 &p2, const VEC2 &p3, const VEC2 &p4) |
| Zwraca true, jeśli dwa odcinki 2D: p1-p2 i p3-p4 zachodzą na siebie. | |
| bool | common::TriangleToTriangle (const VEC3 &V0, const VEC3 &V1, const VEC3 &V2, const VEC3 &U0, const VEC3 &U1, const VEC3 &U2) |
| Testuje kolizję dwóch trójkątów 3D. | |
| bool | common::TriangleInFrustum (const VEC3 &t1, const VEC3 &t2, const VEC3 &t3, const FRUSTUM_PLANES &Frustum) |
| Testuje, czy trójkąt leży w całości wewnątrz frustuma. | |
| bool | common::TriangleToFrustum (const VEC3 &t1, const VEC3 &t2, const VEC3 &t3, const PLANE *OptTrianglePlane, const FRUSTUM_PLANES &FrustumPlanes, const FRUSTUM_POINTS *OptFrustumPoints) |
| Testuje kolizję trójkąta z frustumem. | |
| bool | common::FrustumToFrustum (const FRUSTUM_PLANES &Frustum1_Planes, const FRUSTUM_POINTS &Frustum1_Points, const FRUSTUM_PLANES &Frustum2_Planes, const FRUSTUM_POINTS &Frustum2_Points) |
| Testuje kolizję między dwoma frustumami. | |
| bool | common::PointInPolygon (const VEC2 &Point, const VEC2 PolygonPoints[], uint PolygonPointCount) |
| Zwraca true, jeśli podany punkt leży wewnątrz podanego wielokąta (2D). | |
| bool | common::RayToPolygon (const VEC3 &RayOrig, const VEC3 &RayDir, const VEC3 PolygonPoints[], uint PolygonPointCount, bool BackfaceCulling, float *OutT) |
| Zwraca true, jeśli promień przecina wielokąt (3D) i wtedy przez OutT zwraca parametr dla promienia. | |
| bool | common::SweptSphereToPlane (const VEC3 &SphereCenter, float SphereRadius, const VEC3 &SphereSweepDir, const PLANE &Plane, float *OutT0, float *OutT1) |
| Liczy kolizję poruszającej się sfery z płaszczyzną. | |
| bool | common::SweptSphereToFrustum (const VEC3 &SphereCenter, float SphereRadius, const VEC3 &SphereSweepDir, const FRUSTUM_PLANES &Frustum) |
| Oblicza kolizję poruszającej się sfery z frustumem. | |
| bool | common::SweptSphereToSphere (const VEC3 &SphereCenter1, float SphereRadius1, const VEC3 &SphereCenter2, float SphereRadius2, const VEC3 &SphereSweepDir1, float *OutT1, float *OutT2) |
| Analityczna kolizja dwóch poruszających się sfer. | |
| bool | common::SweptBoxToBox (const BOX &Box1, const BOX &Box2, const VEC3 &SweepDirBox1, float *OutT) |
| Kolizja poruszającego się AABB z drugim AABB. | |
| void | common::SphereBoundingPoints (VEC3 *OutSphereCenter, float *OutSphereRadius, const VEC3 Points[], size_t PointCount) |
| Znajduje sferę otaczającą podany zbiór punktów. | |
| void | common::BoxBoundingPoints (BOX *box, const VEC3 points[], size_t PointCount) |
| Tworzy najmniejszy boks otaczający podany zbiór punktów. | |
| void | common::BoxBoundingSphere (VEC3 *SphereCenter, float *SphereRadius, const BOX &Box) |
| Oblicza sferę otaczającą box. | |
| void | common::SphereBoundingBox (BOX *Out, const VEC3 &SphereCenter, float SphereRadius) |
| Oblicza box otaczający sferę. | |
| void | common::BoxBoundingSpheres (BOX *OutBox, const VEC3 SpheresCenter[], const float SpheresRadius[], size_t SphereCount) |
| Wylicza AABB otaczający podany zbiór sfer. | |
| void | common::RandomPointInUnitSphere (VEC3 *Out, RandomGenerator &Rand) |
| Losuje punkt wewnątrz kuli o środku w (0,0,0) i promieniu 1. Rozkład równomierny. | |
| void | common::RandomPointInUnitSphere (VEC3 *Out) |
| void | common::RandomPointInUnitCircle (VEC2 *Out, RandomGenerator &Rand) |
| Losuje punkt wewnątrz koła o środku w (0,0) i promieniu 1. Rozkład równomierny. | |
| void | common::RandomPointInUnitCircle (VEC2 *Out) |
Zmienne | |
| const VEC2 | common::VEC2_ZERO |
| const VEC2 | common::VEC2_ONE |
| const VEC2 | common::VEC2_POSITIVE_X |
| const VEC2 | common::VEC2_POSITIVE_Y |
| const VEC2 | common::VEC2_NEGATIVE_X |
| const VEC2 | common::VEC2_NEGATIVE_Y |
| const VEC3 | common::VEC3_ZERO |
| const VEC3 | common::VEC3_ONE |
| const VEC3 | common::VEC3_POSITIVE_X |
| const VEC3 | common::VEC3_POSITIVE_Y |
| const VEC3 | common::VEC3_POSITIVE_Z |
| const VEC3 | common::VEC3_NEGATIVE_X |
| const VEC3 | common::VEC3_NEGATIVE_Y |
| const VEC3 | common::VEC3_NEGATIVE_Z |
| const VEC4 | common::VEC4_ZERO |
| const VEC4 | common::VEC4_ONE |
| const VEC4 | common::VEC4_POSITIVE_X |
| const VEC4 | common::VEC4_POSITIVE_Y |
| const VEC4 | common::VEC4_POSITIVE_Z |
| const VEC4 | common::VEC4_POSITIVE_W |
| const VEC4 | common::VEC4_NEGATIVE_X |
| const VEC4 | common::VEC4_NEGATIVE_Y |
| const VEC4 | common::VEC4_NEGATIVE_Z |
| const VEC4 | common::VEC4_NEGATIVE_W |
| const RECTI | common::RECTI_ZERO |
| const RECTF | common::RECTF_ZERO |
| const COLOR | common::COLOR_TRANSPARENT_ |
| const COLOR | common::COLOR_BLACK |
| const COLOR | common::COLOR_GRAY |
| const COLOR | common::COLOR_SILVER |
| const COLOR | common::COLOR_WHITE |
| const COLOR | common::COLOR_FUCHSIA |
| const COLOR | common::COLOR_RED |
| const COLOR | common::COLOR_ORANGE |
| const COLOR | common::COLOR_YELLOW |
| const COLOR | common::COLOR_LIME |
| const COLOR | common::COLOR_AQUA |
| const COLOR | common::COLOR_BLUE |
| const COLOR | common::COLOR_PURPLE |
| const COLOR | common::COLOR_MAROON |
| const COLOR | common::COLOR_OLIVE |
| const COLOR | common::COLOR_GREEN |
| const COLOR | common::COLOR_TEAL |
| const COLORF | common::COLORF_TRANSPARENT_ |
| const COLORF | common::COLORF_BLACK |
| const COLORF | common::COLORF_GRAY |
| const COLORF | common::COLORF_SILVER |
| const COLORF | common::COLORF_WHITE |
| const COLORF | common::COLORF_FUCHSIA |
| const COLORF | common::COLORF_RED |
| const COLORF | common::COLORF_ORANGE |
| const COLORF | common::COLORF_YELLOW |
| const COLORF | common::COLORF_LIME |
| const COLORF | common::COLORF_AQUA |
| const COLORF | common::COLORF_BLUE |
| const COLORF | common::COLORF_PURPLE |
| const COLORF | common::COLORF_MAROON |
| const COLORF | common::COLORF_OLIVE |
| const COLORF | common::COLORF_GREEN |
| const COLORF | common::COLORF_TEAL |
| const PLANE | common::PLANE_ZERO |
| const PLANE | common::PLANE_POSITIVE_X |
| Płaszczyzna pionowa, równoległa do Y i Z, wskazująca na prawo na X. | |
| const PLANE | common::PLANE_POSITIVE_Y |
| Płaszczyzna pozioma, równoległa do X i Z, wskazująca do góry na Y. | |
| const PLANE | common::PLANE_POSITIVE_Z |
| Płaszczyzna pionowa, równoległa do X i Y, wskazująca w głąb na Z. | |
| const PLANE | common::PLANE_NEGATIVE_X |
| Płaszczyzna pionowa, równoległa do Y i Z, wskazująca na lewo na X. | |
| const PLANE | common::PLANE_NEGATIVE_Y |
| Płaszczyzna pozioma, równoległa do X i Z, wskazująca w dół na Y. | |
| const PLANE | common::PLANE_NEGATIVE_Z |
| Płaszczyzna pionowa, równoległa do X i Y, wskazująca do gracza na Z. | |
| const LINE2D | common::LINE2D_ZERO |
| const LINE2D | common::LINE2D_POSITIVE_X |
| const LINE2D | common::LINE2D_NEGATIVE_X |
| const LINE2D | common::LINE2D_POSITIVE_Y |
| const LINE2D | common::LINE2D_NEGATIVE_Y |
| const MATRIX | common::MATRIX_ZERO |
| const MATRIX | common::MATRIX_IDENTITY |
| const QUATERNION | common::QUATERNION_ZERO |
| const QUATERNION | common::QUATERNION_IDENTITY |
| const float | common::POISSON_DISC_1D [] |
| const uint4 | common::POISSON_DISC_1D_COUNT = 100 |
| const VEC2 | common::POISSON_DISC_2D [] |
| const uint4 | common::POISSON_DISC_2D_COUNT = 100 |
| const VEC3 | common::POISSON_DISC_3D [] |
| const uint4 | common::POISSON_DISC_3D_COUNT = 100 |
Część biblioteki CommonLib
1.5.5