Warsztat.GD

Programowanie => Projektowanie kodu => Wątek zaczęty przez: Q w Luty 17, 2014, 00:39:26

Tytuł: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 17, 2014, 00:39:26
Witam.
Jakiś czas temu miałem do czynienia z biblioteką threejs. Teraz gdy zacząłem bawić się opengl postanowiłem upodobnić mój kod do tej biblioteki. Niestety trudno jest mi wpisać funkcję w obiekty.
Np. obecnie nie wiem jak poradzić sobie z funkcja Display() która wywoływana jest w  glutDisplayFunc( Display ).
Bo chciałbym by mogła się posługiwać metodami i właściwościami głównego obiektu w którym jest zawarta.
Głownie chce opanować tą chmarę funkcji, wprowadzić ład. I sprawić by łatwo pisało się aplikacje tego typu początkującym.
Ale pomijając aspekt techniczny czy warto się w to bawić, czy to wykonalne oraz czy ktoś podejmował już takie wysiłki?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: JasonVoorhees w Luty 17, 2014, 10:15:30
Nie jeden przed Tobą robił takie rzeczy ;) Jakiś famework, nakładki opakowujące funkcje OpenGL'owe.

Tutaj jest poruszony problem, który napotkałeś: http://stackoverflow.com/questions/3589422/using-opengl-glutdisplayfunc-within-class

Swoją drogą nie widzę sensu opierać swojego frameworka o glut. SDL do OpenGL byłby lepszym wyborem. Tam nie ma funkcji glutDisplayFunc :)

Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 17, 2014, 11:21:54
Cytuj
Swoją drogą nie widzę sensu opierać swojego frameworka o glut. SDL do OpenGL byłby lepszym wyborem. Tam nie ma funkcji glutDisplayFunc :)
Ja bym nie radził opierać frameworka OpenGL o cokolwiek niezwiązanego z OpenGL. W ten sposób możesz framework łatwiej reusować w przyszłości.

Ja w swoim frameworku mam klasę Device, która ma parę metod do wołania "z zewnatrz" jak:
- Init - do wywołania za każdym razem jak mamy nowy kontekst OpenGL,
- ContextLost - do wywołania jak chcemy posprzątać (nie trzeba jeżeli za chwilę wołamy Init),
- BeginFrame - start ramki,
- EndFrame - koniec ramki

Powyższe pozwoliło bez większych problemów wpiąć ten framework w przykładowe aplikacje na Androidzie, BlackBerry, a nawet we framework kolegi przy wspólnym projekcie.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 17, 2014, 11:32:21
Pomijając różne opinie, podejścia oto jeden ze sposobów na opakowanie takiego delegata. Szczegóły są do dopięcia przez ciebie.
class GraphicsDevice
{
virtual void OnDraw()
{
}
...
glutDisplayFunc([]() { OnDraw(); });
...
};
Mój "GraphicsDevice" ma blisko do D3D GraphicsDevice.

Jest esencją SRP... robi wszystko... tworzy, przypisuje deklaracje, bufory wierzchołków, shadery i steruje ustawieniami. oczywiście z pomocą masy klas pomocniczych, chociażby VertexBuffer, VertexDeclaration, VertexElement, VertexShader, PixelShader.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Dab w Luty 17, 2014, 11:39:45
glutDisplayFunc([this] { OnDraw(); });

Od kiedy glutDisplayFunc przyjmuje jako parametr std::function? Lambda może zostać zrzutowana na gołą funkcję tylko jeżeli nie przechwytuje żadnych obiektów z kontekstu.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 17, 2014, 11:44:01
Dlatego "szczegóły" zostawiłem dla Q.

A kod poprawiłem na zagadkę zanim odpisałeś.

EDIT: "self" czy "that" można (lub nie można zależy jak masz poukładane)wyciągnąć tą samą drogą jaką wyciągasz z uchwytu do okna. W tym scenariuszu mając metodę typu GetWindowFromHandle
należy ją tu wywołać, zrzutować na GLWindow czy coś w ten deseń i wywołać OnDraw na GraphicsDevice.
Alternatywa to po prostu static member trzymający this (ale to tylko pozwoli ci trzymać jedno okno).
Altrnatywa 2 to static map z this;
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Dab w Luty 17, 2014, 13:47:07
Spoko, to pewnie miał być tylko poglądowy kod, ale...

Cytuj
A kod poprawiłem na zagadkę zanim odpisałeś.

...jest jeszcze gorzej, bo this nie jest niejawnie przechwytywane przy tworzeniu lambdy (a nawet gdyby było, to: patrz uwaga z poprzedniego posta).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 17, 2014, 13:52:01
Wiem przecież!?! :D

Dlatego dopisałem to wszystko też chwilę temu w poprzednim poście.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 17, 2014, 14:28:19
Cytuj
Ja bym nie radził opierać frameworka OpenGL o cokolwiek niezwiązanego z OpenGL
Na razie operam sie na glut -cie bo wiele tutoriali opiera sie na nim. A jako że jestem świerzy w temacie wole mieć gdzie spojrzeć po podpowiedź. Frameworker może udostepniać kilka bibliotek w tym glut-a, sdl czy wlasną. Oczywiście to kilkakrotnie wiecej pisania ale daje też wiecej możliwości.

Na glut -cie (nie wiem czy tak to sie odmienia) nie bedzie mi działało w androidzie?

Dzięki za ten kod, wypróbuje go jak bede w domu (za 2 dni)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: JasonVoorhees w Luty 17, 2014, 15:03:51
Ogólnie jak celujesz w androida, to lepiej byłoby skorzystać z Javy + np. LibGDX - http://www.gamedev.pl/txt/wstep-do-libgdx
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 17, 2014, 15:13:27
Ogólnie jak celujesz w androida, to lepiej byłoby skorzystać z Javy + np. LibGDX - http://www.gamedev.pl/txt/wstep-do-libgdx
Taak... a potem weź to zportuj na iOS. ;)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: JasonVoorhees w Luty 17, 2014, 15:38:17
To niech weźmie inną bibliotekę, która wspiera wszystkie/większość platform docelowych :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 17, 2014, 16:17:35
Ja bym nie radził opierać frameworka OpenGL o cokolwiek niezwiązanego z OpenGL. W ten sposób możesz framework łatwiej reusować w przyszłości.

Ja w swoim frameworku mam klasę Device, która ma parę metod do wołania "z zewnatrz" jak:
- Init - do wywołania za każdym razem jak mamy nowy kontekst OpenGL,
- ContextLost - do wywołania jak chcemy posprzątać (nie trzeba jeżeli za chwilę wołamy Init),
- BeginFrame - start ramki,
- EndFrame - koniec ramki

Powyższe pozwoliło bez większych problemów wpiąć ten framework w przykładowe aplikacje na Androidzie, BlackBerry, a nawet we framework kolegi przy wspólnym projekcie.
Zacznijmy od tego, że SDL 2 czy GLFW z definicji są związane z GL. SDL 2 chodzi na GL, GLFW to pomocnicza libka dedykowana do GL.

Super, skoro już to naklepałeś, to możesz podzielić się tym frameworkiem, zamiast dawać dobre rady "nie używaj gotowych rozwiązań, napisz sam".

Obsługa kontekstu OpenGL na różnych platformach to PITA, zwłaszcza, jeśli chcesz to opakować w przenośny interfejs i nie wiesz, jak się za to zabrać (a jeśli nie korzystałeś z takiego interfejsu (jakim są SDL 2 czy GLFW), to nie wiesz, jak powinien wyglądać).

Ponadto odnoszę wrażenie, że OP chce pisać w GL, a nie pisać pomocniczą libke do GL, zanim cokolwiek zrobi.

SDL 2 jest multiplatformowe. GLFW też. Obsługują najważniejsze platformy OOTB. I są Open Source - jak OP będzie potrzebował odpalić swoją grę na innej platformie, to wystarczy, że dorobi backend do SDL/GLFW dla niej. I będzie musiał naklepać tylko to, co potrzebuje dla danej platformy, a nie cały framework od zera.

Rozumiem, że masz syndrom NIH, ale proszę, nie zarażaj tym innych.



Co do GLUT - AFAIK jest przestarzałe. Tutorial możesz zmienić, albo po prostu zastąpić wywołania GLUT tymi z GLFW lub SDL 2.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 17, 2014, 16:59:51
Cytuj
Super, skoro już to naklepałeś, to możesz podzielić się tym frameworkiem, zamiast dawać dobre rady "nie używaj gotowych rozwiązań, napisz sam".
Autor wątku pytał się o opakowywanie, więc zakładam, że chce coś takiego napisać samemu.


Co do podzielenia się, to brak jakiejkolwiek dokumentacji d mojego frameworka raczej nie jest zachęcającą rzeczą. :)

Cytuj
Ponadto odnoszę wrażenie, że OP chce pisać w GL, a nie pisać pomocniczą libke do GL, zanim cokolwiek zrobi.
W takim przypadku nie pytał by, jak GL owinąć.

Cytuj
Rozumiem, że masz syndrom NIH, ale proszę, nie zarażaj tym innych.
Nie tyle NIH, co trudności ze znalezieniem czegoś, co by mi odpowiadało. A przeglądałem tego sporo.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 17, 2014, 19:57:04
Od kiedy glutDisplayFunc przyjmuje jako parametr std::function? Lambda może zostać zrzutowana na gołą funkcję tylko jeżeli nie przechwytuje żadnych obiektów z kontekstu.
Tak przy okazji, to typ lambdy jest implementation defined. Przyjmowanie jest przez parametr szablonowy może być bardziej wydajne, niż przez std::function.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 18, 2014, 11:22:31
Cytuj
Co do podzielenia się, to brak jakiejkolwiek dokumentacji d mojego frameworka raczej nie jest zachęcającą rzeczą. :)
Mówisz tu o jakiejś stronce czy braku komentarzy, opisów w kodzie itp?

Wyczytałem (gdzieś na angielskiej stronie) że można zaradzić mojemu problemowi z funkcją Display() dając jej modyfikator static. Z tego co pamietam z javy to faktycznie rozwiazywało to podobne problemy ale było mało eleganckie.
A przynajmniej mnie sie to takie wydawało.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 18, 2014, 11:24:21
Cytuj
Mówisz tu o jakiejś stronce czy braku komentarzy, opisów w kodzie itp?
O generalnym braku jednego i drugiego. :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 18, 2014, 14:46:37
To trochę tak, jakbyś się przyznawał do nieczytelnych nazw metod, klas bo przecież to wystarczy(pomijam jakieś mocno wyspecjalizowane klasy). :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 18, 2014, 14:55:52
No mnie też się tak wydawało, bo przeciez jesli masz dobrze napisany kod w nagłowkach to IDE sam podpowie.
A i po nazwach metod mozna się zorientować co robi.
Ale pewnie chodziło o to że bez jakiegoś wiekszego opisu, tutoriala trudno jest tym kogoś zainteresować.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 18, 2014, 14:57:20
To trochę tak, jakbyś się przyznawał do nieczytelnych nazw metod, klas bo przecież to wystarczy(pomijam jakieś mocno wyspecjalizowane klasy). :)
To akurat jest w porządku, ale nie wszystko jest przecież od razu oczywiste po przeczytaniu samych nagłówków. Ot, chociażby które definicje flag bitowych idą do których funkcji. A to tylko jeden z przykładów.
Tytuł: Re: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xion w Luty 18, 2014, 15:16:38
Zamiast tłumaczyć się obszernie, jak to twój framework jest zagadkowy i nieudokumentowany, mógłbyś część tego czasu  przeznaczyć na napisanie jakiegoś kawałka dokumentacji :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 18, 2014, 15:37:57
Ot, chociażby które definicje flag bitowych idą do których funkcji.
A nie dało się tego zrobić na enumach? Nie chciało się(czytaj: za dużo walenia się z rzutowaniem, albo dodawaniem operatorów), czy jakieś inne przciwwskazania?

PS. Oczywiście domyślam się że to taki przykład z głowy...
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 18, 2014, 16:06:22
Cytuj
A nie dało się tego zrobić na enumach? Nie chciało się(czytaj: za dużo walenia się z rzutowaniem, albo dodawaniem operatorów), czy jakieś inne przciwwskazania?
W sumie jest to jakiś pomysł, chociaż z drugiej strony wolał bym nie polegać aż tak na optymalizacjach kompilatora.

Cytuj
Zamiast tłumaczyć się obszernie, jak to twój framework jest zagadkowy i nieudokumentowany, mógłbyś część tego czasu  przeznaczyć na napisanie jakiegoś kawałka dokumentacji :)
Podobnie jak większość tutejszej społeczności mogła by pisać gry zamiast rozmawiać tutaj o ich pisaniu. Takie życie. :)

Zresztą, Xion, już pisałeś na compotach na tym frameworku więc sam powiedz czy warto. :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 19, 2014, 01:00:13
W sumie jest to jakiś pomysł, chociaż z drugiej strony wolał bym nie polegać aż tak na optymalizacjach kompilatora.
AFAIK enumy i inty kompilują się do dokładnie tego samego, więc gdzie tu miejsce na [nie]optymalizację?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 19, 2014, 01:25:33
AFAIK enumy i inty kompilują się do dokładnie tego samego, więc gdzie tu miejsce na [nie]optymalizację?
W operatorze | dla tych enumów.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 19, 2014, 03:05:54
W operatorze | dla tych enumów.
Co z nim? Czemu miałby kompilować się do czegokolwiek innego, niż operator | dla intów?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 19, 2014, 11:12:33
Co z nim? Czemu miałby kompilować się do czegokolwiek innego, niż operator | dla intów?
Na przykład dlatego, że jest to metoda, a nie wbudowany operator? W tym momencie polegamy np. na inliningu*, a przy okazji utrudniamy debugowanie przez "Step Into".

*) Czytałem swego czasu, jak takie poleganie okazało się u kogoś pułapką w przypadku STL, bo przekroczony został limit zagnieżdżeń inliningu.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 19, 2014, 12:11:59
Ja tam nie daje operatorów. W nazwie enuma Flags i niech sobie sam rzutuje i dodaje.

Oprócz wszystkich powyższych pomysłów... gdy mamy mało tych flag to można się pokusić o dodanie części wspólnych. X = 1, Y = 2, XY = 3;
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 19, 2014, 12:13:49
Ja tam nie daje operatorów. W nazwie enuma Flags i niech sobie sam rzutuje i dodaje.
I w efekcie funkcje/metody docelowe przyjmują inta zamiast enuma, o którym to zmniejszeniu czytelności właśnie tu mówimy. :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 19, 2014, 12:28:43
Na przykład dlatego, że jest to metoda
Nope nope nope. Enum nie jest klasą. Enum jest takim nieco bardziej type-safe intem.

Nawet enum class z C++ nie są żadnymi klasami, tylko mają podniesione type safety jeszcze bardziej (i pozwalają wybrać, na jakim wbudowanym typie inta mają bazować). Nie wiem, czy mają operatory arytmetyczne (zwykłe enumy mają).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 19, 2014, 12:55:42
I w efekcie funkcje/metody docelowe przyjmują inta zamiast enuma, o którym to zmniejszeniu czytelności właśnie tu mówimy. :)
Możemy jeszcze makro strzelić które schowa rzutowanko. ;)

Nope nope nope. Enum nie jest klasą. Enum jest takim nieco bardziej type-safe intem.
KK pisał o przeładowaniu operatorów.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 19, 2014, 13:22:20
Możemy jeszcze makro strzelić które schowa rzutowanko. ;)
I będzie wyglądało identycznie jak owo rzutowanie. Co to by miało uprościć?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 19, 2014, 13:27:52
Kolejna alternatywa bez makr i bez inlineowania... za to ze stałymi i bez typesafety,
typedef int DedoFlags;

struct DedoFlag
{
static const int Flaga1 = 1;
static const int Flaga2 = 2;
static const int Flaga3 = 3;
};

DedoFlags Function(DedoFlags flags)
{
return flags;
}

int _tmain(int argc, _TCHAR* argv[])
{
auto flags = Function(DedoFlag::Flaga1 | DedoFlag::Flaga2);

return 0;
}
Przepraszam za wielokrotne edycje... ;)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 19, 2014, 14:31:06
KK pisał o przeładowaniu operatorów.
W kontekście enumów. Tylko, że enumy mają wbudowane operatory.

KK - Srsly, użyj normalnych enumów. To nie Java, one nie mają overheadu.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: quaikohc w Luty 19, 2014, 15:01:51
W kontekście enumów. Tylko, że enumy mają wbudowane operatory.

Co ty z tymi operatorami do enumow? Jakie niby maja operatory? Ciagle nie rozumiesz: nie mozesz napisac tak:

enum Flags
{
  Flaga1 = 1,
  Flaga2 = 2,
  Flaga3 = 4
};

  Flags a = Flags::Flaga2;
  Flags b = Flags::Flaga3;
  Flags c = a | b; // blad
 Flags c = a + b; // blad
  Flags c = Flaga2 |Flaga3; // blad

Nawet  deklarujac enum tak:
enum class Flags : unsigned int{}
ciagle nie mozesz uzyc powyzszego kodu..
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 19, 2014, 16:14:59
Ok, winikiem operacji bitowych i arytmetycznych na enum Flags jest <jakiś typ intowy>, a nie Flags - to wszystko wyjaśnia.

Co do enum class - nie "nawet", a "tym bardziej". Enum classy powstały właśnie po to, aby NIE były implicite castowalne DO inta, jak enumy z C.
Oczywiście żadne nie są implicite castowalne Z inta.

Teraz rozumiem, o co chodziło z operatorami - o dziwo przeciążenie (inline lub nie) Flags operator | (Flags, Flags) powoduje segfault na G++ 4.8.2 bez optymalizacji, więc chyba odpada.

#define OR(a, b) (decltype(a)(a | b)) // Raczej niepraktyczne.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: quaikohc w Luty 19, 2014, 16:51:03
Ok, winikiem operacji bitowych i arytmetycznych na enum Flags jest <jakiś typ intowy>, a nie Flags - to wszystko wyjaśnia.

Nie. Again: nie ma operacji bitowych ani arytmetyczncyh na enum Flags. Nie sa zdefiniowane. Nie istnieja.
Twoje makro powinno dzialac dla normalnych enumow, moze nie zainicjowales zmiennych albo cos. Dla claass enumow nie powinno sie skompilowac, bo a i b nie przecastuja sie automatycznie na inty, a (again) nie ma operatora | dla enumow.

W przykladzie z class enum chodzilo o to, ze nawet jezeli oznaczymy typ enuma to i tak to nic zmienia .
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: quaikohc w Luty 19, 2014, 16:52:05
(delete this pls)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 19, 2014, 17:01:24
@quaikohc - Operacje są dla zwykłych enumów, i je miałem na myśli przez enum Flags. Kompilują się jak najbardziej, g++ 4.8.2, -Wextra -Wall -Weffc++ -pedantic -std=c++1
Jakbym chodziło o enum class, to napisałbym - surprise, surprise - enum class Flags. ;)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: quaikohc w Luty 19, 2014, 17:09:05
@quaikohc - Operacje są dla zwykłych enumów, i je miałem na myśli przez enum Flags.

Chyba sie nie dogadamy... Jakie operacje sa dla zwyklych enumow? Podaj przyklad.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 19, 2014, 18:20:23
Kod: (c++) [Zaznacz]
#include <iostream>

using namespace std;

enum Flags
{
        f1 = 1,
        f2 = 2,
        f3 = 4
};

void foo(int f)
{
        cout << (int) f;
}

int main()
{
        foo(f1 + f2);
}
Kod: (bash) [Zaznacz]
% g++ -Wextra -Wall -Weffc++ -pedantic -std=c++11 main.cpp && ./a.out
3
Z bitwise też działa. Tylko, że zwraca jakiś-intowy-typ, a nie typ enuma (w tym wypadku int).

W sumie to nie tyle operatory dla enuma, co implicite cast enum -> int.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: quaikohc w Luty 19, 2014, 19:11:13
W sumie to nie tyle operatory dla enuma, co implicite cast enum -> int.

W koncu...
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xion w Luty 19, 2014, 21:35:31
Cytuj
Zresztą, Xion, już pisałeś na compotach na tym frameworku więc sam powiedz czy warto. :)
Jeśli rysowanie sprite'ów wciąż polega na wielokrotnym użyciu przeciążonego operatora (), w stylu foo()(bar)()(baz) etc., to nie, nie warto ;P
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 19, 2014, 23:24:56
^ No co, fluent chaining. :P
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Luty 20, 2014, 01:23:59
^ No co, fluent chaining. :P
Raczej eksplozja kombinatoryczna możliwych przeciążeń rysowania sprita - różne sposoby zadawania tekstury, layera, koloru, UVek i pozycji/kształtu. :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 20, 2014, 09:08:35
Oddzielny SpriteBuilder budujący immutable by wystarczył. :)
Tytuł: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xion w Luty 20, 2014, 09:52:14
Builder? Czyżbyś właśnie powiedział "Builder"?! Toż to enterprise'owa herezja! Przeproś i wyjdź :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 20, 2014, 22:00:38
Witam ponownie.
Próby okiełznania glut- a nie przyniosły pożądanego efektu. Dziś zapoznałem się z SDL i bardziej mi to przypadło do gustu. Głownie dlatego że łatwiej jest to wpisać w obiekty.
Korzystam z tego kursu http://cpp0x.pl/kursy/Kurs-SDL-C++/22 (http://cpp0x.pl/kursy/Kurs-SDL-C++/22)
Niestety nie ma w nim nic o opengl. Przejrzałem kilka kursów ale średnio mi się one podobają. Znacie jakieś proste kursy, najlepiej po polsku albo angielsku?

Ps. Zarys biblioteki już mam. Musze jeszcze wiele przemyśleć. Postaram się dokumentować ją na bieżąco i gdy osiągnie jakiś przyzwoity poziom udostępnie ją.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 21, 2014, 00:23:21
To, co masz, to tutorial do legacy wersji 1.2. Obecna to 2.0.
Obie mają wsparcie dla GL, natomiast to z wersji 2.0 będzie raczej lepsze, bo 1.2 robiła własny rendering na procku, a wsparcie GL było tylko dodatkiem.
AFAIK 2.0 cały rendering robi przez GL na GPU, więc siłą rzeczy wsparcie będzie raczej lepsze.

Zamiast tutoriali polecam oficjalna dokumentację (bardziej można na niej polegać) + szukanie na necie.
http://www.libsdl.org/
http://wiki.libsdl.org/Introduction

Możesz też się przyjrzeć SFML, ono ma interfejs obiektowy C++, jeśli Ci na nim zależy.

Jeśli nie interesuje Cię rendering wbudowany w te biblioteki, a chcesz tylko kontekst GL, to GLFW.

Przy okazji, rzuć okiem na glLoadGen - rozwiązuje drugą część "GLinit dramy", czyli wczytanie funkcji (pierwsza to utworzenie kontekstu i zarządzanie oknem - to robią SDL, SFML, GLFW).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 21, 2014, 13:35:42
Cytuj
Obecna to 2.0.
No właśnie, zainstalowałem bibliotekę ze strony ale jakoś tak mam wątpliwości że jest to wersja 2.0 bo wcześniej miałem w systemie (linux mint 14) chyba wersje 1.2.
Jak to sprawdzić jaka jest?
Druga sprawa, czy skompilowany program uruchomi się na systemie gdzie nie ma zainstalowanej SDL ?
Kolejna sprawa dotyczy bardziej projektowania kodu.
Chcę by biblioteka była prosta jak przysłowiowa budowa cepa.
Np:
Qgl window(800, 600, "nowe okno"); // główny obiekt

window.addCamera(FirstPerson); // definiowanie kamery
window.addKeybordEvent(); // właczanie obługi zdarzen klawiatury
// itd

window.addObject(SPHERE, 200); // dodawanie kuli

window.start(); // rozpoczęcie programu
No i właśnie chciałbym by można było do takiego modelu przypisać możliwość dodawania objektów i zmieniania pramatrów pracy np kamery, oświetlenia itp w czasie pracy programu. Niestety nie mam pomysłu jak to ładnie i elegancko zrobić. Tak by łatwo było to ogarnąć dla każdego kto pierwszy raz zobaczyłby kod.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 21, 2014, 14:12:31
Tak by łatwo było to ogarnąć dla każdego kto pierwszy raz zobaczyłby kod.
Z czasem zrozumiesz że to nie jest najwłaściwsza droga. ;)

IMO najwłaściwsza droga, to taka w której model aplikacji wylewa się z kodu. ;)

np. w kodzie powyżej masz trochę pomieszane. Kamerę dodajesz do okna zamiast do sceny lub ujęcia, czy z drugiej strony do sterownika kamery.
Masz klasę Qgl która tworzy okno... hmm.
Dodajesz do okna obiekt sfery... tylko że logicznie pojmując... okno + sfera = ?
przykładem takiej logicznej hierarchii będzie - mniej więcej - okno>>viewport>>scena>>meshmodels>>sfera(jako specyficzny prymityw).

Tak samo z tym window start. :)
to nie startuje okno... z resztą co to znaczy? :)
Tylko "pętla komunikatów", "przetwarzacz wiadomości", zdarzeń, Dispatcher. Czy nawet proces, czy aplikacja(nie koniecznie sensu stricte) może wystartować.

1. Kod końcowy zawsze ma być jak najprostszy względem tego co robi.
2. Jestem też fanem metod w stylu InitAllWithDefaults(), czy innych helperów które opakowują model do krótkiego kodu.
Ale pisanie samych helperów bez modelu aplikacji to kodowanie od d... strony. ;)

Mógłbym dalej, ale niech najpierw poleci na mnie grad kamieni. :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 21, 2014, 14:37:47
Cytuj
np. w kodzie powyżej masz trochę pomieszane. Kamerę dodajesz do okna zamiast do sceny lub ujęcia, czy z drugiej strony do sterownika kamery.
Masz sporo racji. Nie wziąłem tego pod uwagę że można by tworzyć scenę i to do niej dodawać pozostałe rzeczy. Choć kod ten nie musi być błędny, można przez przypisanie kamery, obiektów do głównego okna dodawać do głównej sceny która będzie zdefiniowania domyślnie. 
Cytuj
Tak samo z tym window start. :)
to nie startuje okno... z resztą co to znaczy? :)
To start pętli w której będzie przetwarzana scena/sceny, kamery, oświetlenie, zdarzenia klawiatury, myszki.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 21, 2014, 16:17:52
Q: IMHO lepiej popracuj z istniejącymi bibliotekami: SDL 2.0 czy SFML i zobacz, jak tam to jest zrobione.

W SFML są nawet klasy od VBO i shaderów (chociaż struktura wierzchołka jest predefiniowana) - można tym zrobić jakieś 3D, chociaż raczej nie tędy droga - SFML to raczej framework 2.5D.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 21, 2014, 17:32:24
Masz sporo racji. Nie wziąłem tego pod uwagę że można by tworzyć scenę i to do niej dodawać pozostałe rzeczy. Choć kod ten nie musi być błędny, można przez przypisanie kamery, obiektów do głównego okna dodawać do głównej sceny która będzie zdefiniowania domyślnie.
Z jednej strony masz rację... wystarczy że będziesz miał tylko "currentScene/currScene" i póki nie doimplementujesz reszty(obsługi kilku scen) to będzie spoko.
Radzę od razu wyciągać takie klasy w zgodzie z SRP. Lepiej dodać 3 klasy z jedną metodą każda niż upychać do jednej klasy metody które mają się do siebie jak jabłka do samolotów.
Jak chcesz to mieć potem w ramach jednej klasy to wyseparuj potem oddzielną klasę kompozytową. pt. Game która ma metody init, run, onInput, onUpdate, onIdle, onSound, onDraw. i wtedy to ma sens. :)

Cytuj
To start pętli w której będzie przetwarzana scena/sceny, kamery, oświetlenie, zdarzenia klawiatury, myszki.

Domyśliłem się... ;)
Chodziło mi tylko oto że miejsce tej metody jest nie właściwe. WNDPROC w oknie to łamanie SRP.
Ja mam wyseparowane to tak: klasa App ma "windows", oraz "dispatcher". Podpinam się w zdarzenia dispatchera i wywołuje okno stamtąd.

A w mainie mam App app;
app.start();

Jeszcze jest opcja taka by maina wciągnąć do swojej aplikacji i zostawić OnStart unimplemented. I jeszcze kilka innych technik...

Cytuj
Q: IMHO lepiej popracuj z istniejącymi bibliotekami: SDL 2.0 czy SFML i zobacz, jak tam to jest zrobione.
Prawdę Xender rzecze. By samemu to zrobić dobrze(nie ma idealnych rozwiązań) najlepiej zobaczyć i się odnieść do tego jak inni to próbowali rozwiązać, opakować w obiekty.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 22, 2014, 17:18:01
Martwi mnie że na wielu stronach spotkałem się z opinia że SDL jest do tworzenia grafiki 2D.
Tzn nie kieruje sie opiniami innych ale martwi mnie wydajność opengl w SDL.
Co do samej biblioteki to przyjąłem taki model:
Qgl window(800, 600, "nazwa okna"); // definiowanie okna
QglScene scene; // definiowanie sceny, jeszcze nie ustaliłem co będzie w konstruktorze

QglObject3D sphere(SPHERE, 25); // definiowanie obiektu 3d
/* podobnie będzie definiowana kamera, oświetlenie itp */

scene.add(sphere); // dodawanie kuli do sceny
window.add(scene); // dodawanie sceny do okna

window.display();
Nie rozwiązałem jeszcze jak będzie można modyfikować kod wewnątrz pętli rysującej np. jeśli będziemy chcieli  dodać wczytywanie mapy z serwera itp. Myślałem nad przekazywaniem wskaźnika obiektu do osobnego wątka.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 22, 2014, 19:52:12
No i co Ci z ctora Object3D, który przyjmuje enuma na kilka predefiniowanych kształtów?
Możliwość zrobienia sfery czy sześcianu może i być przydatna, ale najpierw pomyśl, jak miałby wyglądać interfejs do modeli z pliku, które są o wiele częstszym przypadkiem w większości gier.

A jak już jesteśmy przy modelach - jeden może mieć wiele meshy, jak to jest w wypadku animacji szkieletowej - model jest jeden, ale każda część ciała ma inną transformację (liczoną hierarchicznie z orientacji kości szkieletu od węzła początkowego do danej kończyny).

SDL 1 nadawało się głownie do 2D, bo robiło rendering na procu. Wersja 2 używa GL.

Jeśli chcesz użyć SDL/SFML na tej samej zasadzie, do GLFW, czyli do kontekstu i okna, to nie będą miały wpływu na wydajność (o ile nie tworzą kontekstu z jakimiś dziwnymi flagami (wątpliwe, powinno być w dokumentacji)).

Jeśli chodzi o wydajność renderingu SDL/SFML, to może być różnie. Jeśli zechcesz używać ich renderingu np. tylko GUI (HUD), to nie powinno być problemu.

Wiadomo, że w SFML renderowanie np. dużej tilemapy po prostokącie na tile może ubijać wydajność - ale od tego SFML ma klasę VertexArray.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 22, 2014, 21:30:44
Cytuj
No i co Ci z ctora Object3D, który przyjmuje enuma na kilka predefiniowanych kształtów?Możliwość zrobienia sfery czy sześcianu może i być przydatna, ale najpierw pomyśl, jak miałby wyglądać interfejs do modeli z pliku, które są o wiele częstszym przypadkiem w większości gier.
Biblioteka jest tworzona dla moich potrzeb, dla mojego projektu. Wyświetlanie figur (sfer, wielokątów itp) odgrywa kluczową w nim rolę. Owszem z czasem chcę dodawać nowe możliwości i na pewno znajda sie też wgrywane obiekty z pliku.
"Nie od razu Rzym zbudowano"
Biblioteka ma powstać jako coś pobocznego co jest efektem pracy nad wiekszą całością. Wiele razy już udawało mi się stworzyć tym sposobem przydatne biblioteki.

Poza tym spotkalem się na tym forum z ciepłym przyjęciem i chciałbym oferować całej spoleczności  forum coś w zamian.
Może cos to komuś pomoże, zaintersuje.
Cytuj
A jak już jesteśmy przy modelach - jeden może mieć wiele meshy,
No właśnie nigdy tego dobrze nie rozumiałem. Mam nadziejej że zrozumiem i sie troszke podszkolę

Cytuj
SFML
Przejrzałem tą bibliotekę i podoba mi się ta petla na końcu. Chyba wykorzystam podobny motyw.
Dzieki temu zrezygnuje z metody start() w której znajduje sie ta petla.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 23, 2014, 02:17:08
Cytuj
Przejrzałem tą bibliotekę i podoba mi się ta petla na końcu. Chyba wykorzystam podobny motyw.
Dzieki temu zrezygnuje z metody start() w której znajduje sie ta petla.

Jeśli mówisz o tym przykładzie
#include <SFML/Window.hpp>

int main()
{
    sf::Window window(sf::VideoMode(800, 600), "My window");

    // run the program as long as the window is open
    while (window.isOpen())
    {
        // check all the window's events that were triggered since the last iteration of the loop
        sf::Event event;
        while (window.pollEvent(event))
        {
            // "close requested" event: we close the window
            if (event.type == sf::Event::Closed)
                window.close();
        }
    }

    return 0;
}
To jest bieda i świadczy o tym, że twórcy nie wiedzieli co z tym zrobić, więc zostawili tak jak było.
Proponuje zapoznać się z dwoma wzorcami: Command Dispatcher oraz Scheduler.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 23, 2014, 04:11:39
Tak, dokładnie o tym przykładzie mówiłem.
Masz na mysli http://pl.m.wikipedia.org/wiki/Polecenie_(wzorzec_projektowy) ?
Jakoś trudno jest mi sobie wyobrazić (pewnie jest to spowodowane późną godziną) jak miało by to pomóc w moim problemie. Mógłbyś dać jakiś przyklad np. jako psełdo kod?

Założylem sobie teraz że biblioteka ma byc tak prosta (w użyciu, bo wiele opcji bedzie domyslnie ustawionych) że wyświetlenie okna, menu oraz przejscie z niego do wyświetlania obiektu 3d ma byc mozliwe po wykonaniu nie wiecej niż 10 linijek kodu.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 23, 2014, 11:41:09
^ "command dispatcher", nie "command".

ArekBal - Nie powiedziałbym że to bieda, a raczej nienarzucanie konkretnego modelu.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 23, 2014, 12:14:58
Xender: Jak sobie to przemyślałem to prawdę rzeczesz.

sig2::signal<void(const MSG& msg, bool& cancelDispatch)> message;
sig2::signal<void(void)> idle;

int start()
  {
    MSG msg = { 0 }; 
   
    m_running = true;

    while(m_running)
    {       
      if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != NULL)
      {
        if(msg.message == WM_QUIT)
          m_running = false;
        else
        {
          bool cancelDispatch = false;
          message(msg, cancelDispatch);
          if(cancelDispatch == false)
          {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
          }
        }       
      }
      else
      {   
        idle();         
        //WaitMessage(); //it is siet with 60 fps and IOCP, fuck u intel... gonna try with sleep(0), it should be easier than generating timer events with system clock (16.666666666667 ms tickkk).
      } // If the message is WM_QUIT, exit the while loop     
    }
    return msg.message;
  }
Ten kod jest mocno związany z winapi(struktura MSG), i boost::signals2, ale tak samo można oprzeć o SFMLa i rxcpp. No w każdym razie oto chodzi. Wszystkie wiadomości lecą przez message bus/pump(czyli tak jak to w winapi, SFML), a ty się rejestrujesz pod zdarzenie z handlerem. Można tez powystawiać inne zdarzenia... Opcji jest wiele potem.

Jak zaczniesz na tej pętli to końca świata nie będzie, ale wcześniej czy później wypadałoby to opakować.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 23, 2014, 15:36:56
^ Nie wiem, jak z obsługą WM_QUIT.

Jeśli (już nie pamiętam na pewno) WinAPI ma 2 rodzaje wiadomości - jedna to "user prosi o zamknięcie okna" (którą można zignorować lub pozwolić zamknąć zwracając z procedury obsługi okna odpowiednią wartość), a WM_QUIT to ta druga, która pojawia się, po zgodzeniu się programu za zamknięcie, to wszystko ok - ta pierwsza zostanie obsłużona jak wszystkie inne.

Natomiast w niektórych framerowkach (chyba większości tu omawianych) jest tylko jedna wiadomość - prośba o zamknięcie okna. W tym momencie natychmiastowa zgoda z pętli głównej nie jest najlepszym pomysłem - nie będzie nawet okazji zapytać usera "czy chcesz zapisać". Więc ta wiadomość powinna raczej pójść do normalnego dispatchu, jak wszystkie inne.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Rolek w Luty 23, 2014, 16:57:46
@up
Kiedy user kliknie X, okno dostaje wiadomość WM_CLOSE, która informuje, że user kliknął X; wartość zwracana nie ma znaczenia i jak program nic nie zrobi w odpowiedzi na tą wiadomość to nic się nie stanie; program może przesłać wiadomość do DefWindowProc, która wykona domyślną operację, dla WM_CLOSE jest to zniszczenie okna.
Kiedy okno jest niszczone, dostaje wiadomość WM_DESTROY, tu też wartość zwracana nie ma znaczenia, a DefWindowProc nic nie robi; okno bezodwołalnie zostaje usunięte po powrocie z procedury obsługi wiadomości.
Nic samo nie wysyła WM_QUIT; WM_QUIT jest wysyłane, kiedy program uzna, że powinien się zakończyć, często jest to podczas niszczenia głównego okna (przy czym to zależy od programu, czy któreś okno uważa za główne).
WM_QUIT jest jedną z tzw. wiadomości wątkowych, tzn. nie jest kierowana do konkretnego okna, a do wątku, a jej intencją jest zakończenie programu.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 23, 2014, 19:32:21
Rolek dobrze gada. Masz WM_CLOSE które od tego jest. A WM_DESTROY od sprzątania jest.
Stąd też pewien logiczny błąd w wielu frameworkach. Gdzie zamknięcie jednego okna zamyka program. W praktyce zamknięcie wszystkich okien albo okna głównego(zależy jak leży) powinno dopiero skutkować WM_QUIT na wątku z GUI.
WM_QUIT też wcale nie oznacza zamknięcia programu, a tylko zakończenie Message Pump/loop. W kontekście kilku wątków(i kilku message pump) lub okna modalnego nazwa WM_QUIT staje się jeszcze bardziej niefrasobliwa. :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 23, 2014, 23:10:56
W SDL2/SDL2_ttf.h jest chyba jakiś bug który uniemożliwia wgranie fontów. Walczę już z tym od rana i chyba poległem. Co ciekawe w 1.2 działało bez zarzutu.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Raptor w Luty 23, 2014, 23:15:59
Wszystkim biblioteka poprawnie działa poza Tobą. Tak, to musi być bug ;p
Może lepiej opisz problem i wstaw problematyczny fragment kodu? :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 23, 2014, 23:23:24
No właśnie nie wszystkim bo na necie jest masa ludzi na to narzekających.
Problem występuje tu:
font = TTF_OpenFont(font_path, size);
if (!font)
{
printf("TTF_OpenFont: %s\n", TTF_GetError());
TTF_Quit();
SDL_Quit();
exit(1);
}
Dostaje komunikat:
Cytuj
TTF_OpenFont: Couldn't load font file
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Raptor w Luty 23, 2014, 23:29:05
Po czymś takim można tylko obstawiać w ciemno:
-zła ścieżka
-zły plik (chociaż z tym się jeszcze nie spotkałem)
-brak wywołania wcześniej funkcji TTF_Init()
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 23, 2014, 23:33:12
Cytuj
-zła ścieżka
Wypróbowałem niemal wszystkie kombinacje.
Cytuj
-zły plik (chociaż z tym się jeszcze nie spotkałem)
Wypróbowałem na 2 różnych.
Cytuj
-brak wywołania wcześniej funkcji TTF_Init()
kod:
if (TTF_Init() != 0)
{
  printf("TTF_Init() Failed: ");
  SDL_Quit();
  exit(1);
}
TTF_Font * font;
font = TTF_OpenFont(font_path, size);
if (!font)
{
printf("TTF_OpenFont: %s\n", TTF_GetError());
TTF_Quit();
SDL_Quit();
exit(1);
}
// Write text to surface
SDL_Color text_color = {255, 255, 255};
SDL_Surface * t = TTF_RenderText_Solid(font, text, text_color);
SDL_Texture * texture = SDL_CreateTextureFromSurface(ren, t);
textArray.push_back(texture);
Jak widać funkcja jest wywoływana.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 24, 2014, 11:16:54
Wypróbowałem niemal wszystkie kombinacje.
Masz wiedzieć, jak ścieżka ma wyglądać, a nie próbować kombinacji.

W każdym razie prawdopodobnie to będzie chciało ścieżkę względem CWD (current working directory) lub absolutną. Nie spodziewałbym się, aby nazwa czcionki systemowej działała.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 24, 2014, 11:44:58
Właśnie doszedłem do tego co nie grało. Kosztowało mnie to sporo nerwów.
Kompilowałem z opcją -lSDL_ttf a powinno być -lSDL2_ttf.
Dopiero jak pogrzebałem w bibliotekach to mnie olśniło.
Ktoś kiedyś powiedział że: "Upór to mądrość głupców"

1 dzień stracony. Też tak macie że potraficie utknąć na czymś tak banalnym?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 27, 2014, 00:37:43
http://www.youtube.com/watch?v=pZtRpHXd5Sk&list=UUp2ZeC5yC_UX5LaiJWjbrmw&feature=share
To efekt działania kodu:
Qgl GameWindow(800, 600,"test 1");
GameWindow.debug_fps = true;

Scene scena1;

Geometry geom(HEXAHEDRON, 0.5, 0.25, 0.5);

Color color(25, 24, 123); // to na razie nie działa
MaterialType typ = SOLID;
Material mater(&typ, &color);

Mesh mesh(&geom, &mater);

scena1.addMesh(&mesh);

GameWindow.setScene(&scena1);
GameWindow.Start();

Chce wprowadzić podział na sceny 2D i 3D. 2D nie używały by opengl i służyły do robienia menu, ekranów powitalnych itp.

Co o tym sądzicie?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Rolek w Luty 27, 2014, 02:08:18
2D nie używały by opengl i służyły do robienia menu, ekranów powitalnych itp.
http://xion.org.pl/productions/texts/coding/game-programming/gfx2d/ (http://xion.org.pl/productions/texts/coding/game-programming/gfx2d/) (co prawda w artykule jest Direct3D, ale chodzi o ogólną ideę)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Luty 27, 2014, 09:59:15
2D nie używały by opengl i służyły do robienia menu, ekranów powitalnych itp.
Bez sensu. Jak już bierzesz GL, to nada się i do tego.

http://xion.org.pl/productions/texts/coding/game-programming/gfx2d/ (http://xion.org.pl/productions/texts/coding/game-programming/gfx2d/) (co prawda w artykule jest Direct3D, ale chodzi o ogólną ideę)
Albo sięgnąć po gotową libkę, która to robi, czyli SFML albo SDL2, które od początku przewijają się przez ten wątek. ;)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Luty 27, 2014, 20:18:34
Albo zaimplementować SpriteBatch/DXSprite
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Luty 28, 2014, 23:10:52
Cytuj
Bez sensu. Jak już bierzesz GL, to nada się i do tego
Masz rację, zwłaszcza że tu jest to ładnie opisane: http://www.gamedev.pl/forum/interfejs-gry-w-opengl

Walcze teraz z kamerą, planuje dodać następujace kamery: FPP, TPP i Orbitujacą (ale nie wiem jaki ma skrót)
Raz dodana kamera będzie już obsługiwała podstawowe dla siebie klawisze klawiatury (WSAD) oraz myszy. Bo zazywczaj każdy i tak z tym walczy. U mnie to bedzie jedna linijka :)

Zauważyłem że zużycie procesora mocno spadło po właczeniu przechwytywania myszy i klawiatury w SDL.
Obawiam się spadku wydajności. Na razie nie mam wyświatlanej liczby FPS-ów wiec tylko to zgaduje.

Na dniach założe stronę dla swojego projektu to i ten frameworker doczeka się jakiejś podstrony.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Frondeus w Luty 28, 2014, 23:54:00
Olej FPSy jeśli nie są mniejsze niż ~40-60 klatek (zależy od preferencji).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 01, 2014, 03:43:36
 ~60 FPS-ów mnie nie satysfakcjonuje. Tyle mialem w webgl-u. Nie po to siegałem po c++ by zadawalać się tak mała ilością. Wiem że prędzej czy później ta liczba spadnie, ale na samym wstępie (bez żadnych skomplikowanych obiektów) chciałbym cieszyć się przynajmniej 1000 FPS-ów.

Chciałbym zmienić:
Mesh mesh(geometry *, material *);
na
Object object(mesh *, material *);
Wydaje mi sie że geometry w znaczeniu jest podobne do mesh. Poza tym do objectu można by dopinać też inne rzeczy np fizykę i lepiej to brzmi. A i wyglada bardziej logicznie,  w dodatku objectem może być też np element 2d i do jego stworzenia wystarczy przeciążenie funkcji.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 01, 2014, 10:54:12
A Vsync?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 02, 2014, 15:07:08
Dziwna sprawa, nie mogę ustawić:
SDL_GL_SetAttribute( SDL_GL_ACCELERATED_VISUAL, 0 );Pojawia mi się błąd:
Cytuj
Invalid arguments '
Candidates are:
int SDL_GL_SetAttribute(enum {SDL_video.h:7493}, int)

--- dop ---

rozwiązaniem jest
SDL_GL_SetAttribute((SDL_GLattr) SDL_GL_ACCELERATED_VISUAL, 1 );
Tylko nie wiem czy to powinno być przed stworzeniem okna czy po.

--- dop ---
sorry pomyłka, trzeba ustawić:
SDL_GL_SetAttribute((SDL_GLattr)SDL_GL_DOUBLEBUFFER, 0);by wyłączyć Vsync
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 02, 2014, 21:00:39
A po co go wyłączać? On jest nie bez powodu - eliminuje szarpanie.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Marzec 03, 2014, 01:32:06
Wyłączać go po to by zsynchronizować rendering z vsynciem. Dziurawy vsync (z powtarzającymi się klatkami) gorszy niż jego brak.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 03, 2014, 18:02:26
^ Vsync ma synchronizację w samej nazwie. Z założenia czeka na odrysowanie monitora po wyrenderowaniu klatki. Oczekiwanie odbywa się w funkcji, która rysuje gotową klatkę (zamienia bufory - np. glfwSwapBuffers).

Jak masz "dziurawy" vsync, to chyba masz coś bardzo źle z pętlą główną albo stackiem driverów.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xion w Marzec 03, 2014, 18:51:25
Inna sprawa, że to oczekiwanie to strata cennego czasu, który mógłby być przeznaczony na coś bardziej produktywnego. Przy włączonym VSyncu, jedyny sposób żeby go nie marnować to użycie wielu wątków.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Marzec 03, 2014, 20:05:36
Cytuj
masz coś bardzo źle z pętlą główną
Prędzej z czymś z poza tej pętli np. streamowaniem z płyty, netu. Aktualizacjami cache i wiele różnych rzeczy.

Innymi słowa... klatka klatce nie równa.

Cytuj
Przy włączonym VSyncu, jedyny sposób żeby go nie marnować to użycie wielu wątków.
No jest jeszcze możliwość ograniczania strat, czyli opóźnianie "synchronizacji" do ostatniej chwili i wykorzystanie wątku na coś innego w między czasie.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 03, 2014, 20:21:09
Cytuj
Przy włączonym VSyncu, jedyny sposób żeby go nie marnować to użycie wielu wątków.
To nie jest w praktyce takie proste, jak się wydaje.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 03, 2014, 23:50:40
A co z AFAIK popularnym w gamedevie modelem puli wątków wykonujących różne zadania w zależności od potrzeb + jednym do renderingu?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 04, 2014, 00:02:47
A co z AFAIK popularnym w gamedevie modelem puli wątków wykonujących różne zadania w zależności od potrzeb + jednym do renderingu?
Na razie jeszcze jestem w fazie eksperymentów, ale na Windows i BlackBerry PlayBook problemem okazuje się ich przełączanie, które wpływa na mocne wahania delty z klatkę na klatkę. W efekcie mam 40-50 FPS o płynności 5-10. Właśnie nadal z tym walczę na wszelakie sposoby i powiem, że nie jest łatwo. Być może zrezygnuję ostatecznie z wątków na rzecz włókien.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 04, 2014, 00:26:21
^ Nie da się ustawić wątku per rdzeń? (Explicite, nie "utworzyć tyle wątków, ile rdzeni i liczyć, że OS zrozumie aluzję".)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 04, 2014, 00:40:31
^ Nie da się ustawić wątku per rdzeń? (Explicite, nie "utworzyć tyle wątków, ile rdzeni i liczyć, że OS zrozumie aluzję".)
Tego jeszcze nie próbowałem.

Nie zmienia to jednak sytuacji na jedordzeniowych fonach.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 04, 2014, 20:37:37
^ Wtedy można użyć jednego wątku z przewidywalnymi efektami. Coroutines/włókna też są opcją.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 04, 2014, 21:48:36
Cytuj
Coroutines/włókna też są opcją.
Jak się okazuje, nie taką prostą. W praniu wyszło, że ani BlackBerry, ani Android nie supportują włókien. Chociaż zawsze pozostaje wydzierganie tego samemu w asmie.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Marzec 05, 2014, 01:51:34
Obadałeś boost::coroutines.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 05, 2014, 02:41:11
Obadałeś boost::coroutines.
Nie. Za duży moloch do kompilacji.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 05, 2014, 11:15:45
^ Nie ma potrzeby kompilować całego Boosta, jest z nim dostarczone narzędzie do wyciągania pojedynczych libek z depsami.


^^ Wygląda na dość skomplikowane, nie wiadomo też od razu, jaki ma narzut i na czym się kompiluje. Wymaga większego researchu, żeby zobaczyć, czy w ogóle się nada.

@Krzysiek K. - A czy normalne wątki, z których działa zawsze tylko jeden, a reszta czeka (synchronizacja), dałoby radę? Scenariusz byłby np. taki:
1. Pod koniec pętli renderingu zapuścić pracę na drugim wątku.
2. Od razu potem czekać na vsync.
3. Czekać na drugi wątek (albo przesłać mu wiadomość, żeby się zablokował i czekał na następny sygnał do działania - jeśli robi coś w pętli, to też się nada).

Wszystko oczywiście dla jednordzeniowców. Profit miałby być taki, że drugi wątek działa, gdy rendering czeka na vsync, ale wątki się nie wywłaszczają*, bo tylko jeden chodzi na raz.

* Wiem, jest możliwość, że wątek 2. wywłaszczy wątek 1. po zleceniu mu pracy, ale przed bibliotecznym czekaniem na vsync. To mógłby być mały albo duży problem... Nie powinien to być race condition, który spowoduje niepoprawne wyniki, ale mógłby zruinować (lub nie) wydajność.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 05, 2014, 13:36:03
Cytuj
Wygląda na dość skomplikowane, nie wiadomo też od razu, jaki ma narzut i na czym się kompiluje. Wymaga większego researchu, żeby zobaczyć, czy w ogóle się nada.
No właśnie główne pytanie jest, czego to używa pod spodem. Standard POSIX definiuje do takich rzeczy nagłówek <ucontext.h> (chociaż jest deprecated), ale BlackBerry (a właściwie QNX) ma w tym nagłówku zakomentowane wszystkie funkcje, a Android NDK r8b tego nagłówka nie ma w ogóle.

Cytuj
@Krzysiek K. - A czy normalne wątki, z których działa zawsze tylko jeden, a reszta czeka (synchronizacja), dałoby radę? Scenariusz byłby np. taki:
1. Pod koniec pętli renderingu zapuścić pracę na drugim wątku.
2. Od razu potem czekać na vsync.
3. Czekać na drugi wątek (albo przesłać mu wiadomość, żeby się zablokował i czekał na następny sygnał do działania - jeśli robi coś w pętli, to też się nada).
Jest duży problem z punktem 3. Czekanie na drugi wątek odpada, bo drugi wątek w moim przypadku to typowy worker, który zawsze ma robotę (chyba że kamera stoi w miejscu przez jakieś 5-10 sekund). Żeby przesłać mu wiadomość, najpierw wątek renderujący musiał by się sam obudzić, a nie mamy gwarancji że to nastąpi bezpośrednio po vsync. No i wątek pracujący musiał by ten sygnał do spauzowania odebrać i sam to zrobić - pthreads nie przewiduje możliwości pauzy czy zatrzymania wątku przez inny wątek.

Cytuj
Wszystko oczywiście dla jednordzeniowców. Profit miałby być taki, że drugi wątek działa, gdy rendering czeka na vsync, ale wątki się nie wywłaszczają*, bo tylko jeden chodzi na raz.
Nie ma możliwości, żeby się nie wywłaszczały, bo worker musi być wywłaszczony po powrocie z vsync byśmy w ogóle zauważyli, że vsync powrócił.

Cytuj
Nie powinien to być race condition, który spowoduje niepoprawne wyniki, ale mógłby zruinować (lub nie) wydajność.
Race condition u mnie nie jest problemem, bo wszystko jest podwójnie/potrójnie buforowane (oczywiście swapowane są tylko wskaźniki do struktur). Worker i rendering pracują niezależnie na osobnych strukturach, a gdy worker coś zbuduje nowego, wysyła to do renderingu który od następnej klatki zaczyna tego używać.

Co do wydajności - proste podejście w ogólności powoduje masakrę. Sama wydajność nie jest problemem, bo FPS się praktycznie nie zmienia, ale problemem jest rozłożenie roboty. Przez parę klatek pracuje worker, potem rendering wygeneruje parę klatek w bardzo szybkich odstępach, i tak w kółko. Całość mocno utrudnia liczenie delty i w efekcie 40-50 FPS wygląda jak 5-10.

Póki co problem udało mi się znacznie zmniejszyć włączając vsync, dodając glFinish na początku klatki, uśredniając deltę z kilku ostatnich klatek i wstawiając usleep(250) na koniec renderingu i w paru miejscach workera. Próbowałem się też bawić priorytetami, ale póki co są u mnie one niemożliwe do wykorzystania - kod najeżony jest spinlockami i całość wiesza się po maksymalnie kilku sekundach działania. :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Marzec 05, 2014, 15:09:22
Nie rozumiem gdzie jest błąd.

Może od drugiej strony...

Dla mnie proste podejście to renderowanie do buforów kilku klatek na raz, każda klatka z odpowiednią deltą + latency na inputach obejmujące te kilka klatek.

Podstawowy problem IMHO to synchronizacja w sterowniku w miejscach które nie są wcale oczywiste. Po prostu niektóre operacje będą blokować się na różnych wątkach... trzeba wybadać które.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 05, 2014, 15:21:20
Cytuj
Dla mnie proste podejście to renderowanie do buforów kilku klatek na raz, każda klatka z odpowiednią deltą + latency na inputach obejmujące te kilka klatek.
Jedyne akcelerowane API graficzne które znam i które efektywnie wspiera wielowątkowość to DirectX 10/11, czego na Androic/BlackBerry/iOS raczej nie uświadczysz. OpenGL ES działa ściśle jednowątkowo, więc na raz więcej niż jednej klatki renderować się nie da. A jak już tą jedną będziesz miał, to czemu nie wyświetlić jej od razu. Co nie zmienia faktu wątpliwego sensu takiego podejścia na 1- czy 2-rdzeniowych urządzeniach.

Cytuj
Podstawowy problem IMHO to synchronizacja w sterowniku w miejscach które nie są wcale oczywiste.
Wręcz przeciwnie - jest to całkowicie oczywiste:
- DirectX 9 z flagą MULTITHREADED - sekcja krytyczna na całym API DirectX,
- DirectX 10/11 - deferred contexty są niezależne od siebie i od kontekstu głównego, brak synchronizacji przy normalnych operacjach,
- OpenGL (każdy) - wszystkie wywołania API mogą pochodzić tylko z jednego wątku, do którego kontekst OpenGL jest przypięty
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Marzec 05, 2014, 16:43:58
Komunikacja między wątkami trwa relatywnie długo dla jednej klatki(zanim jeden nada, drugi odbierze i znowu nada).

W ogóle pisanie aplikacji wielowątkowej na platformę 1-rdzeniową mija się z celem. Czasami zmusza do tego API(które np. nie pozwala wykonywać pewnych operacji na części)ale samo założenie jest błędne.
coroutines to chyba najlepsza ucieczka od takiej pułapki logicznej.

Ta sekcja krytyczna w DX9 to kij w oko. Nazywanie tego MULTITHREADED jest sporą przesadą. THREADSAFE byłoby lepszym określeniem.

Co do dx 10/11 to te nienormalne operacje są istotne.

Co do OGL to nie wiesz na ile i które operacje zablokują renderowanie na innych wątkach na jakich urządzeniach.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 05, 2014, 17:49:24
Znacie jakiś prosty kod na kamerę fps?
Bo już mi ręce odpadają, pracuje nad kodem:
#include "Camera.hpp"

QGL_Camera::QGL_Camera(QGLCameraType typ) {
Typ = typ;

camX=0.0;       //
camY=0.0; //
camZ=0.0;       //current position of the camera

camRotY=0.0;       //camera rotation in Y axis
camRotX=0.0;     //camera rotation in X axis

work = true;

movevel = 0.0015;
mousevel = 0.15;


state = SDL_GetKeyboardState(NULL);     //which key is pressed?

SDL_ShowCursor(SDL_DISABLE);

glShadeModel(GL_SMOOTH);
glClearDepth(3.0f);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

gluPerspective(800,1024,1,100);

}

void QGL_Camera::UpdateCamera(SDL_Window *mainWindow, int width, int height)      //move and mouse sensitivity, and is the mouse inside the window?
{
        if(true)  //if the mouse is in the screen
        {
int MidX=width/2;   //middle of the screen
int MidY=height/2;

//we don't show the cursor
if(work)
{
SDL_GetMouseState(&tmpx,&tmpy); //get the current position of the cursor
SDL_ShowCursor(SDL_DISABLE);

camRotX += mousevel*(MidX-tmpx);   //get the rotation, for example, if the mouse current position is 315, than 5*0.2, this is for Y
camRotY += mousevel*(MidY-tmpy); //this is for X

if(camRotX > 360) camRotX = 0;
if(camRotX < 0)camRotX = 360;

if(camRotY > 360) camRotY = 0;
if(camRotY < 0)camRotY = 360;

SDL_WarpMouseInWindow(mainWindow, MidX, MidY);//move back the cursor to the center of the screen

if(state[SDL_SCANCODE_W])
{
moveCamera(forward);
}
else if(state[SDL_SCANCODE_S])
{
moveCamera(back);
}

if(state[SDL_SCANCODE_A])       //move left
camZ++;
else if(state[SDL_SCANCODE_D])  //move right
camZ--;
if(state[SDL_SCANCODE_ESCAPE] || state[SDL_SCANCODE_Q])
work = false;
}
else
{
SDL_ShowCursor(SDL_ENABLE);
}

if(SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(1))
work = true;
        }
        moveCameraUp();

        glRotatef(camRotX,1,0,0);       //rotate the camera (more precisly move everything in the opposit direction)
        glRotatef(camRotY,0,1,0);
        glRotatef(camRotX,0,0,1);

        glTranslatef(camX,0,camZ);
}


void QGL_Camera::moveCamera(directiton dir)
{

        if(dir == 0){
        camX+=sin(camRotX*M_PI)*movevel;    //calculate the new coorinate, if you don't understand, draw a right triangle with the datas, you have
        camZ+=cos(camRotX*M_PI)*movevel;    //and try to calculate the new coorinate with trigonometric functions, that should help
        }
        else
        {
        printf("s");
        camX=sin(camRotX/180*M_PI)*movevel;    //calculate the new coorinate, if you don't understand, draw a right triangle with the datas, you have
camZ=cos(camRotX/180*M_PI)*movevel;
        }

}
void QGL_Camera::moveCameraUp()
{
        //the the same, only this time we calculate the y coorinate
        float rad=(camRotY+movevel)*M_PI/180.0;
        camY+=sin(rad)*movevel;

}
I bez przerwy coś nie gra ;/
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ackg w Marzec 05, 2014, 18:02:23
Gdybaństwo:
ThreadSafeBool workerStartCondition;

int main() {
while (notExit) {
poolEvents();
render();
workerStartCondition = false;
workerThread.computeNextFrame();
workerStartCondition = true;
swapBuffers();
workerThread.join();
}

/* ... */
}

void WorkerThread::computeNextFrame() {
while (!workerStartCondition) {
yield();
}

/* ... */
}

Jeśli "yield()" puści główny wątek do "workerStartCondition = true;", to może jest szansa, że "swapBuffers()" też się załapie? Mam tutaj na myśli sytuację z jednym rdzeniem.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Marzec 05, 2014, 18:16:31
Najprostszy kod dla kamery fpp to chyba macierzami YawPitchRoll.
Wygooglaj jak we frameworku którego używasz taką macierz najprościej utworzyć. Albo wygooglay neta i DIY.

a potem to banał:
//mniej więcej
yprMx= yawPitchRoll(yaw:mouseX, pitch:mouseY, roll:0);
camDir = vec3.Front() * yprMx;
camLookAt = camPos + camDir;
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 05, 2014, 18:28:20
To zależy, jaka kamera. Do FPS sprawdzą się kąty Eulera (wspomniane yaw, pitch, roll). Do np. symulatora lotu się to nie nada, bo ten model ma gimbal lock - ale za to kamera na kwaternionach będzie dobra.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 05, 2014, 19:16:48
Aha.  Mam też problem z perspektywą.  W ogóle jej nie ma.
Szukałem troszkę w necie i chyba musze przekształcać macierzowo  czy coś takiego.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Marzec 05, 2014, 19:54:51
Generujesz macierz na podstawie parametrów... czyli robisz to samo co wszystkie funkcje api matematycznych, albo sam znajdujesz api matematyczne.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 05, 2014, 20:07:52
glm
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 05, 2014, 21:33:55
Cytuj
Komunikacja między wątkami trwa relatywnie długo dla jednej klatki(zanim jeden nada, drugi odbierze i znowu nada).
Zależy jak tą komunikację zrobisz. W moim przypadku są to głównie operacje atomowe. Poza tym wątki pracują niezależnie - wątek roboczy skupia się na generowaniu szczegółów świata w miarę przesuwania kamery, więc natychmiastowy efekt nie jest konieczny.

Cytuj
Co do dx 10/11 to te nienormalne operacje są istotne.
Wyjaśnij proszę, co w tym jest nienormalnego? Czyżby to, że po raz pierwszy pojawiło się graficzne API, które zauważa fakt, że proces może mieć wiele wątków?

Cytuj
Co do OGL to nie wiesz na ile i które operacje zablokują renderowanie na innych wątkach na jakich urządzeniach.
Wiem tyle, że kontekst OpenGL nie może być dzielony ani używany przez różne wątki. Możesz mieć kilka kontekstów OpenGL, ale poza praktycznie osobną instancją drivera idzie za tym też osobny kontekst GPU. A context switch samego GPU jest jeszcze bardziej kosztowny od context switcha CPU. To się po prostu nie opłaci.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Marzec 05, 2014, 22:54:32
Wyjaśnij proszę, co w tym jest nienormalnego?
Nic... po prostu napisałeś wcześniej że synchronizacja przy normalnych operacjach nie powinna wystąpić.

No z tego co ja wiem to mamy tylko wglShareList oraz GL_PIXEL_UNPACK_BUFFER jako pewniaki.
A reszta w rękach drivera, który może ale raczej nie skorzysta z kilku kontekstów.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 05, 2014, 23:39:10
Cytuj
Nic... po prostu napisałeś wcześniej że synchronizacja przy normalnych operacjach nie powinna wystąpić.
No to w takim razie operacje w DX 11 (nie DX10 - tam tego jeszcze nie było) nadal są pod tym względem "normalne". Immediate i deferred context różnią się jedynie tym, że immediate idzie od razu do command buffera GPU, a deferred do buforów pomocniczych. I są to bardzo osobne konteksty - nie ma tutaj synchronizacji, bo działają na osobnych strukturach.

Cytuj
No z tego co ja wiem to mamy tylko wglShareList oraz GL_PIXEL_UNPACK_BUFFER jako pewniaki.
Z których listy są reliktem przeszłości, a pixel buffery wymagają odczytania bufora GPU->CPU (co zwykle jest złym pomysłem).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 06, 2014, 16:21:48
http://www.youtube.com/watch?v=ub0qvuzcK-I&feature=youtu.be

Kamera już jest.
Nie wiem jak zrobić by nie wyświetlało tego co jest niewidoczne. Dzięki temu to co z tyłu nie nakładało by się na obraz.
To co widać na filmiku to około 20 linijek kodu.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Karol w Marzec 06, 2014, 17:38:28
Nie wiem jak zrobić by nie wyświetlało tego co jest niewidoczne. Dzięki temu to co z tyłu nie nakładało by się na obraz.
Włączyć test głębi?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: flexi w Marzec 06, 2014, 17:40:20
Włączyć test głębi?

Jak by nie wiedzial jak: glEnable(GL_DEPTH_TEST);
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 06, 2014, 19:50:36
Dzięki, działa.
Opłaca się włączać: glEnable(GL_DEPTH_CLAMP); ?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 06, 2014, 21:29:36
^ https://www.opengl.org/wiki/Clipping_FAQ#When_I_move_the_viewpoint_close_to_an_object.2C_it_starts_to_disappear._How_can_I_disable_OpenGL.27s_zNear_clipping_plane.3F
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 11, 2014, 15:46:09
Znalazłem coś takiego:
void BuildList( void )
{
    glNewList( CYLINDER, GL_COMPILE );
    glBegin( GL_TRIANGLE_STRIP );
    for( int i=0; i<=360; i++ )
    {
        glNormal3f( 3*sinf(DEG2RAD(i)), 0, 3*cosf(DEG2RAD(i)) );
        glVertex3f( 3*sinf(DEG2RAD(i)), 5, 3*cosf(DEG2RAD(i)) );
        glNormal3f( 3*sinf(DEG2RAD(i)), 0, 3*cosf(DEG2RAD(i)) );
        glVertex3f( 3*sinf(DEG2RAD(i)), -5, 3*cosf(DEG2RAD(i)) );
    };
    glEnd();
    glEndList();
};

Obecnie używam własnych funkcji na wyświetlanie obiektów. Czy to przyspieszy wyświetlanie?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: flexi w Marzec 11, 2014, 19:16:34
Znalazłem coś takiego:
void BuildList( void )
{
    glNewList( CYLINDER, GL_COMPILE );
    glBegin( GL_TRIANGLE_STRIP );
    for( int i=0; i<=360; i++ )
    {
        glNormal3f( 3*sinf(DEG2RAD(i)), 0, 3*cosf(DEG2RAD(i)) );
        glVertex3f( 3*sinf(DEG2RAD(i)), 5, 3*cosf(DEG2RAD(i)) );
        glNormal3f( 3*sinf(DEG2RAD(i)), 0, 3*cosf(DEG2RAD(i)) );
        glVertex3f( 3*sinf(DEG2RAD(i)), -5, 3*cosf(DEG2RAD(i)) );
    };
    glEnd();
    glEndList();
};

Obecnie używam własnych funkcji na wyświetlanie obiektów. Czy to przyspieszy wyświetlanie?

Z tego co wiem listy sa stare, nie sa zle (bo ponoc w jakis testach widzialem dosc szybkie to jest) ale teraz jest uzywane VAO,VBO :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 12, 2014, 14:17:14
Cytuj
VAO,VBO
Dzięki przyda się to.

W bibliotece Threejs był taki mechanizm że normalnie można było umieścić około 1600 obiektów i program zwalniał ale gdy sie je połączyło mergeMesh można było ich upchnąć nawet 200 000. Niestety nie można było nimi manipulować. Chyba było to oparte na VBO.

Obecnie walczę ze światłem. Dodaje się je tak samo do sceny jak obiekty:

QGL_Color color_light(1.0, 1.0, 1.0);
QGL_Light light(DIRECTIONAL, &color_light);

scena1.add(&light);

Niestety mam mały problem. Rozumiem że są 3 rodzaje świateł, otaczające, kierunkowe i punktowe.
Niestety nie za bardzo rozumiem jak to się przedstawia w kodzie.
Np. do zdefiniowania światła otaczającego używam tego (przynajmniej u mnie wygląda to jak otaczające):
// Światło otaczające
ambient[0] = Color.R;
ambient[1] = Color.G;
ambient[2] = Color.B;
ambient[3] = 0.3;

// Światło rozproszone
diffuse[0] = Color.R;
diffuse[1] = Color.G;
diffuse[2] = Color.B;
diffuse[3] = 0.3;

position[0] = 1.0;
position[1] = 50.0;
position[2] = 1.0;
position[3] = 0;

float SpotDirection1[] = {0.0f, 0.0f, -1.0f};

glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, SpotDirection1);

Mam już stronę i zaczynam pisać dokumentację do tej biblioteki. Jak urodzi się z tego coś interesującego pierwsi dostaniecie linka :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: flexi w Marzec 12, 2014, 16:23:02
Dzięki przyda się to.

W bibliotece Threejs był taki mechanizm że normalnie można było umieścić około 1600 obiektów i program zwalniał ale gdy sie je połączyło mergeMesh można było ich upchnąć nawet 200 000. Niestety nie można było nimi manipulować. Chyba było to oparte na VBO.

Obecnie walczę ze światłem. Dodaje się je tak samo do sceny jak obiekty:

QGL_Color color_light(1.0, 1.0, 1.0);
QGL_Light light(DIRECTIONAL, &color_light);

scena1.add(&light);

Niestety mam mały problem. Rozumiem że są 3 rodzaje świateł, otaczające, kierunkowe i punktowe.
Niestety nie za bardzo rozumiem jak to się przedstawia w kodzie.
Np. do zdefiniowania światła otaczającego używam tego (przynajmniej u mnie wygląda to jak otaczające):
// Światło otaczające
ambient[0] = Color.R;
ambient[1] = Color.G;
ambient[2] = Color.B;
ambient[3] = 0.3;

// Światło rozproszone
diffuse[0] = Color.R;
diffuse[1] = Color.G;
diffuse[2] = Color.B;
diffuse[3] = 0.3;

position[0] = 1.0;
position[1] = 50.0;
position[2] = 1.0;
position[3] = 0;

float SpotDirection1[] = {0.0f, 0.0f, -1.0f};

glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, SpotDirection1);

Mam już stronę i zaczynam pisać dokumentację do tej biblioteki. Jak urodzi się z tego coś interesującego pierwsi dostaniecie linka :)

Czlowieku uzywaj nowego OpenGL'a ;D (3.2+) a nie uzywasz jakies antyczne glLightfv ;D
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 12, 2014, 17:53:18
Cytuj
jakies antyczne glLightfv
Aha  a co jest teraz na topie bym wiedział czego szukać?
Korzystam z tutoriali zawartych w sieci, cześć jest już mocno przestarzała.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: flexi w Marzec 12, 2014, 18:17:01
Aha  a co jest teraz na topie bym wiedział czego szukać?
Korzystam z tutoriali zawartych w sieci, cześć jest już mocno przestarzała.

Uzywaj shader'y do swiatel :)

btw tu tutorial dotyczy nowego opengl: http://ogldev.atspace.co.uk/
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Rokuzo w Marzec 12, 2014, 22:44:33
A ja polecam http://www.opengl-tutorial.org/ oraz http://open.gl/ :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: BraXi w Marzec 13, 2014, 23:22:15
Również ta stronka: http://www.opengl-tutorial.org/
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Marzec 14, 2014, 14:12:20
A coś po polsku, coś dla zupełnego laika?
Wcześniej używałem wysokopoziomowych bibliotek i wszystko zaczynało i kończyło się od ustalenia pozycji i intensywności światła.

Rozumiem że działa to tak że przemnażamy kolor jakiegoś wierzchołka przez intensywność światła oraz jego punkt padania a dzielimy przez dystans. (mniej więcej).

Nie rozumiem typów danych typu float3 i vec3. Rozumiem że to coś w stylu:
typedef float float3[3];lub
typedef struct
{
    float x;
    float y;
    float z;
}float3;

Jednak czasami widzę że te typy są od siebie odejmowane, dodawane itp a mi niestety kompilator tego nie łyka.

Jak w tym wszystkim wygląda sprawa cieni?
Rozumiem że mechanizm przemnażania cieni jest podobny do świateł.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: flexi w Marzec 14, 2014, 15:26:50
A coś po polsku, coś dla zupełnego laika?
Wcześniej używałem wysokopoziomowych bibliotek i wszystko zaczynało i kończyło się od ustalenia pozycji i intensywności światła.

Rozumiem że działa to tak że przemnażamy kolor jakiegoś wierzchołka przez intensywność światła oraz jego punkt padania a dzielimy przez dystans. (mniej więcej).

Nie rozumiem typów danych typu float3 i vec3. Rozumiem że to coś w stylu:
typedef float float3[3];lub
typedef struct
{
    float x;
    float y;
    float z;
}float3;

Jednak czasami widzę że te typy są od siebie odejmowane, dodawane itp a mi niestety kompilator tego nie łyka.

Jak w tym wszystkim wygląda sprawa cieni?
Rozumiem że mechanizm przemnażania cieni jest podobny do świateł.

Czas nauczyc sie angielskiego.

Btw. Shadery sie kompiluje przez OpenGL :) glGenShader,glGenProgram itp :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 14, 2014, 19:34:11
Cytuj
A coś po polsku, coś dla zupełnego laika?
Hmmm... może kurs angielskiego? ;)

Serio, chcesz coś umieć, wcześniej czy później będziesz musiał przerzucić się na angielskie materiały.

Cytuj
Nie rozumiem typów danych typu float3 i vec3. Rozumiem że to coś w stylu:
Jednak czasami widzę że te typy są od siebie odejmowane, dodawane itp a mi niestety kompilator tego nie łyka.
Zależy jaki kompilator. Kompilator HLSL czy GLSL (odpowiednio) to Ci łyknie. Kompilator C++ już nie, chyba że użyjesz jakiejś biblioteki do tego (np. GLM).

Cytuj
Jak w tym wszystkim wygląda sprawa cieni?
Rozumiem że mechanizm przemnażania cieni jest podobny do świateł.
Podobny, z tym wyjątkiem, że różni się wszystkim. Przede wszystkim, zrobienie porządnych i wydajnych cieni jest dużo trudniejsze od porządnych i wydajnych świateł.

Cytuj
Btw. Shadery sie kompiluje przez OpenGL :) glGenShader,glGenProgram itp :)
Te funkcje nic nie kompilują. One tylko generują indeksy do bindowania.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Marzec 15, 2014, 11:35:23
Nie rozumiem typów danych typu float3 i vec3. Rozumiem że to coś w stylu:
typedef float float3[3];lub
typedef struct
{
    float x;
    float y;
    float z;
}float3;

Jednak czasami widzę że te typy są od siebie odejmowane, dodawane itp a mi niestety kompilator tego nie łyka.

W C++ klas z odpowiednimi operatorami dostarcza biblioteka GLM. Oprócz wektorów i macierzy są tam kwaterniony i inne przydatne rzeczy.

W GLSL (język shaderów) są to typy wbudowane. GLSL jest kompilowany przez sterownik grafiki (każdy producent ma własny kompilator, co bywa przyczyną problemów). Ogólnie w podlinkowanych tu tutorialach do GL >=3.2 będą opisane shadery. Wiki OpenGL jest pomocna.

Po polsku jest książka "OpenGL Księga Eksperta wydanie 5" (orig. "OpenGL Superbible 5") (nie wcześniejsze).

Do cieni używa się "shadow mapping", używało się też "shadow volume" (nie wiem, jak teraz).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Krzysiek K. w Marzec 15, 2014, 12:54:33
Cytuj
Do cieni używa się "shadow mapping", używało się też "shadow volume" (nie wiem, jak teraz).
Warto również wymienić lightmapy (i różne ich warianty), których używało się zawsze (a dokładniej od czasu Quake 1).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 12, 2014, 00:23:20
Dalej męczę obiekty w opengl.
Zastanawiam się jak zorganizować faces.
Wiem że powinno mieć mesh czyli 3 wierzchołki opisujące geometrie.
3 kolory na wierzchołek i dane opisujące texturę.
Czyli mniej więcej coś takiego:

Psełdokod
mesh(vec3, vec3, vec3);
colors(vec4, vec4, vec4);
text(vec2, vec2, vec2);

Czy dobrze to rozplanowałem?
Pytam się bo chce by było to napisane jak najbardziej według standardów przyjętych w grafice 3d.

W dodatku nie wiem gdzie trzymać dane opisujące texture na wierzchołkach.
Zamierzam budować obiekt tak:
psełdokod
obiekt(geometria, materiał);i teraz nie wiem czy to powinno być w geometrii czy w materiale?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Czerwiec 12, 2014, 10:18:10
Cytuj
Wiem że powinno mieć mesh czyli 3 wierzchołki opisujące geometrie.
:)
Co?

Meshe to w praktyce zbiory vertex buforów wraz z deklaracjami + "typem" rysowania(triangle, triangle strip, quad itd.) i ew. offsety, size do submeshy.

Efekty tzw. materiały i tekstury to już model.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 13, 2014, 00:33:39
Coś mi się pomyliło z tym mesh, myślałem że to geometria trójkąta. Zmyliła mnie wikipedia.
Dopiero to: http://threejs.org/docs/#Reference/Objects/Mesh
Mnie wyprowadzilo z błędu, czyli rozumiem że podstawową jednostką jest face na który składa się wierzchołek, color, i opis textury (jej ułożenie)?
Geometria zawiera face-y natomiast w materiale ma być textura (obraz), dane o oświetleniu, jak ma na nie reagować, cienie itp.
Dobrze to rozumiem?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 13, 2014, 01:42:21
Podstawową jednostką jest vertex - pojedynczy wierzchołek. Dokładniej to vertex jest zbiorem wszystkich danych dla shaderów związanych z tym wierzchołkiem - pozycja, texcoordy, kolor, generalnie to cokolwiek byś chciał. Przy czym pojedynczy vertex może być (i zwykle jest) użyty do budowy wielu trójkątów, jednak do tego wszystkie dane wierzchołka muszą być identyczne dla wszystkich trójkątów - tzn. jak masz np. łączenie tekstur, to będziesz miał po dwa vertexy w tych samych miejscach (bo texcoordy są różne).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 13, 2014, 08:28:53
czuli ma to wyglądać mniej więcej tak:
psełdokkod
vertices(position, colors, texcode);

vertices.position(vec3, vec3, vec3);
vertices.colors(vec4, vec4, vec4);
vertices.colors(vec2, vec2, vec2);

Wzoruje się na threejs (bo kiedyś używałem tej biblioteki).
tam to wygląda tak:
var geometry = new THREE.Geometry();

geometry.vertices.push( new THREE.Vector3( -10,  10, 0 ) );
geometry.vertices.push( new THREE.Vector3( -10, -10, 0 ) );
geometry.vertices.push( new THREE.Vector3(  10, -10, 0 ) );

geometry.faces.push( new THREE.Face3( 0, 1, 2 ) );

geometry.computeBoundingSphere();
nie rozumie tylko co to jest:
geometry.faces.push( new THREE.Face3( 0, 1, 2 ) );W dokumentacji jest że jest to tablica wierzchołków, tylko po co ma trójwymiarową współrzędną?
Czy może są to indeksy vertices?
Poza tym w threejs, dane o kolorze są w innej właściwości, poza vertices które zdają się przechowywać tylko dane o położeniu wierzchołka. Jak to wygląda w innych bibliotekach?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Czerwiec 13, 2014, 09:46:55
Cytuj
Czy może są to indeksy vertices?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 13, 2014, 10:17:30
Poza tym w threejs, dane o kolorze są w innej właściwości, poza vertices które zdają się przechowywać tylko dane o położeniu wierzchołka. Jak to wygląda w innych bibliotekach?
Dane vertexa można upakować na dwa sposoby:
Obie te kombinacje są w OpenGL dozwolone, wystarczy odpowiednio użyć funkcji glVertexAttribPointer(). threejs zdaje sie uzywac tego pierwszego (chociaz wysokopoziomowy interfejs nie musi odpowiadac niskopoziomowej implementacji). Apple w oficjalnej dokumentacji do iOS poleca ten drugi ze wzgledu na wydajnosc.

Z tego co rozumiem to threejs-owe "faces" to w OGL-u bedzie Element Array Buffer - bufor indeksow. Z tym ze wyglada na to, ze threejs wymusza trojkaty (stad zawsze podajesz 3 indeksy), a w OGL mozesz uzyc innych opcji - punkt, linia, triangle strip, triangle fan i co tam jeszcze jest.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Czerwiec 13, 2014, 12:22:44
Obie te kombinacje są w OpenGL dozwolone, wystarczy odpowiednio użyć funkcji glVertexAttribPointer(). threejs zdaje sie uzywac tego pierwszego (chociaz wysokopoziomowy interfejs nie musi odpowiadac niskopoziomowej implementacji). Apple w oficjalnej dokumentacji do iOS poleca ten drugi ze wzgledu na wydajnosc.
Brnąc dalej w ten temat - https://forum.warsztat.gd/index.php?topic=26435
(AoS - Array of Structures, czyli pełne wierzchołki jeden za drugim).
(SoA - Structure of Arrays, czyli osobne tablice (podział na "typ" jak to określił Xirdus, chociaż bardziej bym to nazwał podziałem na składowe, bo typy w GLSL to vec4, vec2 itp.)).

Z czego chyba najbardziej przydatny może być link do https://www.opengl.org/wiki/Vertex_Specification_Best_Practices
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 14, 2014, 09:27:38
Zdecydowałem się na podział geometrii na faces:

Geometry geo;

// tworzenie trójkata
Faces f1(position, color, texpos, normal);
Faces f2(position, color, texpos, normal);
Faces f3(position, color, texpos, normal);

// dodawanie do geometrii
geo.add(f1);
geo.add(f2);
geo.add(f3);
/* albo
geo.add(f1,f2,f3);

*/
// wyczytywanie pozycji pierwszego wierzchołka:
vec3 pos = geo.faces[0].position;


Co o tym sadzicie?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: koirat w Czerwiec 14, 2014, 12:54:05
Konstruktor tych Faces to mi bardziej wygląda na Vertex.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 14, 2014, 14:18:38
Cytuj
wygląda na Vertex:
...

// tworzenie trójkata
Vertex f1(position, color, texpos, normal);
Vertex f2(position, color, texpos, normal);
Vertex f3(position, color, texpos, normal);

Face face(f1, f2, f3);

geo.add(face);
...

Lepiej?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 14, 2014, 14:43:01
Pytanie co chcesz osiągnąć. Bo taki interfejs jak zaprezentowałeś wydaje mi się tak samo toporny, jak nie jeszcze gorszy od gołego OGL-a. Biblioteki wrapuje się po to, by uprościć interfejs i przenieść bibliotekę na wyższy poziom abstrakcji - tutaj nie widzę ani pierwszego ani drugiego.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 14, 2014, 15:19:52
No dzięki temu do raz już zdefiniowanej geometrii będzie można łatwo dostać się do odpowiednich danych i je modyfikować:

geo. face[1].vertex[2].color = vec4(0.3, 0.2, 05. 1.0);
Chyba że znacie prostszy sposób.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: remz w Czerwiec 14, 2014, 15:42:59
Jeśli ma to tak wyglądać, to Face raczej nie powinien zawierać wierzchołków, tylko indeksy do ich tablicy.

geo.vertices[face[0].v1].color = ...
Tu jest to dość prosto wytłumaczone:
http://msdn.microsoft.com/en-us/library/windows/desktop/bb147325(v=vs.85).aspx (http://msdn.microsoft.com/en-us/library/windows/desktop/bb147325(v=vs.85).aspx)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Rokuzo w Czerwiec 14, 2014, 15:49:47
Nie chcę nic mówić ale to wszystko możesz sobie o kant d*** rozbić, generalnie nie wiem czy ktoś już tego nie pisał, ale takie myślenie nad wprowadzeniem abstrakcji nad jakiekolwiek API, bibliotekę itd. bez dokładnej znajomości owej rzeczy to strzał w stopę.

Nie raz coś takiego próbowałem sobie wprowadzić, jakiś biedny framework czy coś ale powiem jedno, chociaż dużego doświadczenia generalnie nie mam. Daj sobie spokój, bo widzę, że nie masz zielonego pojęcia co robisz i do czego Ci się to przyda. Pisz w gołym OGL, z czasem, czy to za pierwszą grą, czy kolejną sam zobaczysz, które elementy można sobie "schować" i jak to zrobić, albo które się powtarzają, a które trzeba mieć na tacy. Właściwie to bezwiednie i tak w końcu wyjdzie Tobie coś na wzór właśnie takiego frameworka.

Jak dalej chcesz filozofować i wolisz pisać bezsensowne właściwie rzeczy to bierz źródełka jakiegoś silnika i możesz sobie pomyśleć, jak oni to zrobili.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 14, 2014, 16:16:05
Cytuj
geo.vertices[face[0].v1].color = ...
wydaje mi się że zapis:
Cytuj
geo. face[1].vertex[2].color = ...
jest bardziej czytelny, poza tym można łatwo i przejrzyście modyfikować właściwości wszystkich wierzchołków dla face:
geo. face[1].color(jakis_kolor);
Cytuj
Nie raz coś takiego próbowałem sobie wprowadzić, jakiś biedny framework czy coś ale powiem jedno, chociaż dużego doświadczenia generalnie nie mam. Daj sobie spokój, bo widzę, że nie masz zielonego pojęcia co robisz i do czego Ci się to przyda. Pisz w gołym OGL, z czasem, czy to za pierwszą grą, czy kolejną sam zobaczysz, które elementy można sobie "schować" i jak to zrobić, albo które się powtarzają, a które trzeba mieć na tacy. Właściwie to bezwiednie i tak w końcu wyjdzie Tobie coś na wzór właśnie takiego frameworka.

Jak dalej chcesz filozofować i wolisz pisać bezsensowne właściwie rzeczy to bierz źródełka jakiegoś silnika i możesz sobie pomyśleć, jak oni to zrobili.
Po pierwsze to że tobie sie nie udało nie znaczy że i mi sie nie powiedzie.
Ja wole obiektowość bo zaczynałem od JS -> Java -> C++ dlatego męczy mnie goły opengl i wprowadza jakieś takie uczucie chaosu.
Po 2 to że ktoś napisał silnik nie znaczy że zrobił to dobrze, nie raz brałem kod który potem musiałem przerabiać bo był kiepsko napisany. Dlatego wole wszystko dobrze przemysleć. 
Po 3 ja już sie wzoruje na threejs Bo mi sie ta biblioteka podobała, ale chciałbym dodać większa konsekwencje tak jak w javie gdzie wszystko jest klasą.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 14, 2014, 18:12:35
wydaje mi się że zapis:
(...)
jest bardziej czytelny, poza tym można łatwo i przejrzyście modyfikować właściwości wszystkich wierzchołków dla face
Problem w tym, że po dodaniu vertexa do geometrii zazwyczaj NIE będziesz już go modyfikował.

Po 2 to że ktoś napisał silnik nie znaczy że zrobił to dobrze, nie raz brałem kod który potem musiałem przerabiać bo był kiepsko napisany. Dlatego wole wszystko dobrze przemysleć.
A skąd pewność że ty, dopiero raczkujący w OGL, zrobisz to lepiej niż oni?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xion w Czerwiec 14, 2014, 18:27:13
Cytuj
Po pierwsze to że tobie sie nie udało nie znaczy że i mi sie nie powiedzie.
Cytuj
Ja wole obiektowość (...) dlatego męczy mnie goły opengl i wprowadza jakieś takie uczucie chaosu.
Cytuj
Po 2 to że ktoś napisał silnik nie znaczy że zrobił to dobrze, nie raz brałem kod który potem musiałem przerabiać bo był kiepsko napisany. Dlatego wole wszystko dobrze przemysleć.
Gratulacje, w tym jednym poście zdołałeś zawrzeć chyba wszystkie błędne przekonania, które charakteryzują domorosłych silnikologów na Warsztacie, klepiących fafnasty endżyn kolejną już dekadę, i nigdy niekończących żadnych gier :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 14, 2014, 18:48:16
Cytuj
Problem w tym, że po dodaniu vertexa do geometrii zazwyczaj NIE będziesz już go modyfikował.
No tu się nie zgodzę, w threejs brałem standardową geometrie cuba i modyfikowałem ją do swoich potrzeb.
Więc możliwość łatwego i czytelnego modyfikowania bardzo mi się przyda. I zapewne nie tylko mi.
Cytuj
A skąd pewność że ty, dopiero raczkujący w OGL, zrobisz to lepiej niż oni?
Bo jestem geniuszem :D
A na serio to ostatnio ściągnąłem jakiś program z tutorialu na jakieś podstronie wikipedii, nie dość że się nie chciał skompilować to naszpikowany był błędami. Skoro coś z tak zaufanego źródła było napisane ot tak sobie to co z innymi rzeczami.
W dodatku biblioteka nad która pracuje to niejako efekt uboczny innego projektu który ma z niej korzystać więc w moim interesie jest by działało to szybko i sprawnie.
Cytuj
Gratulacje, w tym jednym poście zdołałeś zawrzeć chyba wszystkie błędne przekonania, które charakteryzują domorosłych silnikologów na Warsztacie, klepiących fafnasty endżyn kolejną już dekadę, i nigdy niekończących żadnych gier :)
Widzisz, ja już miałem napisany silnik ale postanowiłem przepisać go na c++
Tutaj masz wersje 1.5 https://www.youtube.com/watch?v=oXkiGrfIi_Y
Udało mi się go podciagnąć do wersji 9.* więc był bardzo zaawansowany, niestety bazował na JS, nie chciałem się zastanawiać czy dało by rade coś więcej z niego wyciągnąć i od razu skoczyłem do c++.
Może nie umiem za wielu rzeczy ale wszystkie te braki nadrabiam uporem i determinacją i jestem skłonny się  z Tobą założyć że do końca tego roku będziesz mógł już sobie pograć w moją gre.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 14, 2014, 21:24:16
No tu się nie zgodzę, w threejs brałem standardową geometrie cuba i modyfikowałem ją do swoich potrzeb.
Dla testów czy do gry? Jeśli do gry, to czy modyfikowałeś tego cube'a po wstępnym przygotowaniu sceny?

jakiś program z tutorialu na jakieś podstronie wikipedii
coś z tak zaufanego źródła
-.-
Miałem na myśli nie jakieś demka z tutoriali, tylko SFML, Ogre, Irrlicht czy inne "prawdziwożyciowe" rzeczy.

W dodatku biblioteka nad która pracuje to niejako efekt uboczny innego projektu który ma z niej korzystać więc w moim interesie jest by działało to szybko i sprawnie.
Bardzo dobre podejście - pisać bibliotekę razem z grą. Z tym że lepiej nie uogólniać - nie rób tej biblioteki jako osobnego tworu, tylko niech tworzy z grą spójną całość, i celem twoim niech nie będzie pisanie biblioteki, tylko pisanie gry - w sensie nie dodawaj do biblioteki żadnych elementów których w grze nie używasz. Potem jak skończysz możesz się zastanowić nad przerobieniem na osobną binarkę.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Rokuzo w Czerwiec 15, 2014, 01:00:56
Już dawno temu widziałem demko z AO w WebGL, który renderował 2x tyle klocków przy około 60 fpsach :) (tak three.js, jeżeli go tutaj użyłeś to jest to jakiś fail) No ale bez specyfikacji Twojego komputera, wersji przeglądarki itp. itd. wiele się tutaj wypowiadać nie będę.

Co do wiki to daj lepiej linka do tego kawałka kodu :) No i czekam na Twoją wypasioną grę.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: lethern w Czerwiec 15, 2014, 06:32:03
Cytuj
Ja wole obiektowość bo zaczynałem od JS -> Java -> C++

javascript? A co ma obiektowość do javascript? Podobnie Java, widziałem tysiące linijek kodu STRUKTURALNEGO napisanego w Javie. C++ tu też niczego nie zmienia...
Kod obiektowy to nie znaczy kod z dużą ilością słówek "class", już pomijając fakt, że pisanie obiektowo nie zawsze jest najlepsze (co już było wyżej przez pewne osoby wspomniane).

Co do
Cytuj
jestem geniuszem
to się zgodzę, ale geniuszem zua ;)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 15, 2014, 08:31:05
Cytuj
Jeśli do gry, to czy modyfikowałeś tego cube'a po wstępnym przygotowaniu sceny?
Tak. Ze zmodyfikowanych cubów tworzyłem geometrie chunku i dołanczałem ją do sceny, w wersji 1.5 działalo to topornie, po wersji 8.* wyglądało to imponująco :) Szkoda że nie chciało mi sie nagrywać filmików :(
Cytuj
Już dawno temu widziałem demko z AO w WebGL, który renderował 2x tyle klocków przy około 60 fpsach :)
Na filmiku jest wersja 1.5, doszedłem do wersji 9.6 więc wyobraź obie postęp jakiego dokonałem.
Cytuj
(tak three.js, jeżeli go tutaj użyłeś to jest to jakiś fail)
Tak użyłem, dlaczego fail?
Tutaj masz maksymalny widok jaki dało mi sie wygenerować, poza ta granice miałem poniżej 25 fps
https://scontent-b-fra.xx.fbcdn.net/hphotos-xpa1/t1.0-9/1381938_389034134532549_1682444610_n.jpg
Nie wygląda imponująco ale widok odpowiada około 120%-140% standardowego w minecrafcie.
Cytuj
No ale bez specyfikacji Twojego komputera, wersji przeglądarki itp. itd. wiele się tutaj wypowiadać nie będę.
To było robione na 6-cio letnim komputerze, procesor intel pentium core 2 duo, karta jakaś nvidia z 512 mb (nic specjalnego)
Cytuj
Co do wiki to daj lepiej linka do tego kawałka kodu :)
Nie zachowałem strony, ja trzymam wszystko na kartach i nie zapisuje do zakładek. jak zamknę karte to po jakimś czasie trudno jest mi znaleźć to w histori ale obiecuje że jak się znów na niego natkne to dam ci linka
Cytuj
Cytuj
javascript? A co ma obiektowość do javascript? Podobnie Java, widziałem tysiące linijek kodu STRUKTURALNEGO napisanego w Javie
Może i widziałeś, a ja pisałem w tych językach. Samo używanie drzewa DOM jest zorientowane obiektowo, powiedz jak można pisać w JS nie posługując się DOM, no chyba że używasz czegoś z rodzaju nodejs, ale i tam wszystko kreci sie wokół obiektów. Co do javy to wszem można pisać strukturalnie ale nikt tego nie robi.
Cytuj
No i czekam na Twoją wypasioną grę.
hmm pewnie nie będzie wypasiona i pewnie nikt w nia nie bedzie grał poza mną bo zazwyczaj moje projekty przechodzą bez większego echa.
Robie to po to by sie czegoś nauczyć, zrozumieć jak to działa.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 15, 2014, 13:12:40
Może i widziałeś, a ja pisałem w tych językach. Samo używanie drzewa DOM jest zorientowane obiektowo, powiedz jak można pisać w JS nie posługując się DOM, no chyba że używasz czegoś z rodzaju nodejs, ale i tam wszystko kreci sie wokół obiektów. Co do javy to wszem można pisać strukturalnie ale nikt tego nie robi.
Same obiekty to nie jest jeszcze obiektowość. Chodzi jeszcze o enkapsulację, polimorfizm i brak stanu globalnego. Popraw mnie jeśli się mylę, ale DOM to chyba jeden wielki stan globalny?

Co do programowania strukturalnego, to chciałbym żeby ludzie z niego częściej korzystali, bo obecnie nie występuje niemal nigdy. Najpopularniejszym paradygmatem jest niestety programowanie bezmyślne - na zasadzie "no przecież działa".
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: lethern w Czerwiec 15, 2014, 15:34:24
"W javie nikt nie pisze strukturalnie"
@Q
jeżeli dla Ciebie różnica między programowaniem strukturalnym a obiektowym polega na tym, w pseudokodzie:
Object obj = new Object();
obj.setX(50);
obj.setY(20);
obj.setLasers(true);
obj.setParent(owner);
scene.add(obj);
Struct st = malloc(..);
st.x= 50;
st.y= 20;
st.lasers= true;
st.parent= owner;
add_to_scene(scene, obj);
No to sorry... i c no difference
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 15, 2014, 17:26:02
@lethern: ani jeden ani drugi przykład nie pokazuje programowania strukturalnego.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 15, 2014, 18:35:39
To zaczyna przypominać dyskusje czy lepiej jest pisać obiektowo czy strukturalnie.
lethern różnica między strukturą a obiektem jest taka że obiekt może mieć metody i w ogóle może więcej niż jakakolwiek struktura. Osobiście nie używam struktur(tylko sporadycznie) bo nie wiem czy czasami w danej strukturze nie będę potrzebował metody która coś tam będzie robić.
Cytuj
Same obiekty to nie jest jeszcze obiektowość.
Wychodze z założenia że jak coś ma pióra, chodzi i gdacze to jest to kura.
Co do hermetyzacji to można zastosować w JS funkcje anonimowe i przestrzenie nazw.
JS jest prosty jak budowa cepa :)

Z tego co się orientuje to w javie opengl ma obiektową naturę. (z tego co podejrzałem w kodzie, nigdy nie pisałem openg w javie i mogę się mylić) Więc jak ktoś będzie chciał pobawić się opengl w javie to i tak otrze sie o obiekty i tego nie przeskoczy.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: koirat w Czerwiec 15, 2014, 18:46:31
http://pl.wikipedia.org/wiki/Programowanie_strukturalne
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xion w Czerwiec 15, 2014, 19:31:06
@lethern: ani jeden ani drugi przykład nie pokazuje programowania strukturalnego.
Yep. Wbrew podobieństwu nazewniczemu, programowanie strukturalne ma niewiele wspólnego ze struct-urami. Już lepiej byłoby mówić o programowaniu imperatywnym, bo wtedy przynajmniej łatwo byłoby zauważyć, że każdy programujący w C++/Javie/JS/C#/Pythonie/Ruby/Perlu/etc. pisze "strukturalnie".
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xender w Czerwiec 15, 2014, 19:47:21
Już lepiej byłoby mówić o programowaniu imperatywnym, bo wtedy przynajmniej łatwo byłoby zauważyć, że każdy programujący w C++/Javie/JS/C#/Pythonie/Ruby/Perlu/etc. pisze "strukturalnie".
Przez te cudzysłowy już nie idzie Cię zrozumieć w tym zdaniu...
Programowanie strukturalne ze structami nie ma nic wspólnego (jest ortogonalnym konceptem).
Jest natomiast dobudowaniem na bazie programowania imperatywnego ograniczeń skonstruowanych tak, żeby kiepscy programiści mogli pisać "czytelny" kod (dobrze umieszczone goto, którego programowanie strukturalne zakazuje w całości, potrafi być czytelniejsze niż dodatkowe warunki w pętlach. Wczesny return tym bardziej).

Więc generalnie racze mało kto pisze w tych językach strukturalnie.

A struct'ów ani obiektów w nich w sumie też używać nie trzeba, można jechać z luźnymi zmiennymi (przynajmniej do pewnego poziomu skomplikowania programu). Więc jeśli te cudzysłowy miały wskazywać na niepoprawne znaczenie to też nie rozumiem...
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Czerwiec 15, 2014, 21:22:21
Cytuj
bo wtedy przynajmniej łatwo byłoby zauważyć, że każdy programujący w C++/Javie/JS/C#/Pythonie/Ruby/Perlu/etc. pisze "strukturalnie".
Nie każdy i nie wszystko.

Załamuje mnie gdy ludzie poniżej 20 lat są adwokatami programowania strukturalnego, a Fortrana na oczy nie widzieli. Ja mam 30 lat, a się nie odważę...

Wracając do tematu i utopii
pt. Face Object.
Daruj sobie Q. Obiektowość obiektowością, ale po ch.. ci  taki face...
Cytuj
Vertex f1(position, color, texpos, normal);
...
Face face(f1, f2, f3);
geo.add(face);
Nawet w blenderze "face"y mogły być trójkątem lub quadem(co zresztą komplikowało sporo)...

Wierzchołki w buforze są zazwyczaj DZIELONE tzn. zawsze gdy budujesz poligon(wielobok) czy dowolną bryłę zawsze się starasz dzielić wierzchołki zamiast je dublować, potem jakbyś sie przyjrzał na kompletny lepszy model to... Rozłożenie wierzchołków w takim meshu jest naprawdę z d... np. a) przy triangle strip z konieczności się dubluje wierzchołki ale oszczędność wraca gdzieś indziej, b) gdy potrzeba dodatkowej normalnej dla jednego z trójkątów przylegających do wierzchołka to znowu się robi sieczka... powodzenia w dodawaniu faceów w podany przez ciebie sposób. :)

 Nie jest głupie wybieranie trójkątów, czy innych faceów z mesha, przyszłego bufora. To jest często potrzebne(np. triangle picking).  Ale przy dodawaniu nie będzie to wyglądać tak różowo jak w twojej utopii.
W praktyce dodasz wierzchołki, ew. indeksy, wskażesz metodę rysowania i voila mesh gotowy. jak jakiś program będzie chciał być mądrzejszy(a to niekoniecznie się przykłada na lepsze rozwiązanie) to ci wypluje kilka takich części gdzie każda się inaczej rysuje.

Spróbuj dodać okrąg twoją metodą... będzie to baaardzo nieefektywne dodanie. :)

Z resztą użyjmy dodawanie okręgu jako przykładu...
Taki okrąg można przechować na kilka sposobów... z tych ważniejszych: najbardziej generyczny to będzie bufor wierzchołków + bufor indeksów(wtedy możemy przechowywać nie tylko okręgi w naszym buforze... ale mamy dzielenie wierzchołków... i bufor indeksów). Najbardziej optymalny to Triangle Fan(ale rysowanie tym czegoś innego niż wachlarze, czy okręgi to koszmar).

Proponuje tą obiektowość upchać gdzieś indziej(ja tak robię). I np. miej metody importujące całe meshe, buduj meshe(te generyczne ;P) z figur geometrycznych.

Reasumując...
Będzisz chciał mieć metodę pobierającą konkretny trójkąt czy iterującą po trójkątach mesha/submesha... ale te trójkąty nie przekładają się na ilość wierzchołków w meshu/submeshu...

No... chyba nie pozostawiłem żadnych wątpliwości
THE END
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 16, 2014, 01:58:30
Ja dam Ci inny przykład, załóżmy że mamy kilka domów na ulicy, każdy przylega do siebie ścianą.
Nie jest potrzebne wyświetlanie przylegających ścian. W moim modelu łatwo jest pozbyć się jakiegoś face-a bez ingerencje w reszte geometrii, wystarczy:
geo.deleteFace(121);  // 121 to index jakiegoś face-a
Co wiecej łatwo jest sprawdzić które face do siebie przylegają(bo beda miały wspólne wierzchołki).

Owszem ilość wierzchołków jest duża ale zyskujemy bardzo prostą w modyfikacji geometrie.
W podanym przeze mnie wyżej modelu pozbycie sie niewidocznych ścian nie tylko zmniejszy ilość wierzchołków ale także nie trzeba bedzie tego oteksturowywać, czyli mniej obliczeń dla shadera fragmentów i bufora głębokości.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 16, 2014, 02:14:44
Jeśli niczego nie spartoliłeś to fragment shader i tak by się nie odpalił. Takie randomowe usuwanie face'ów ma jedną poważną wadę - bufory OGL-a muszą być ciągłymi blokami pamięci, a modyfikacja gdzieś w środku wymaga przesunięcia wszystkich dalszych elementów - operacja dość kosztowna. Oczywiście można zrobić swap z ostatnim elementem i pop_back, ale uniemożliwia to stosowanie triangle stripów.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 16, 2014, 02:18:41
Cytuj
ma jedną poważną wadę - bufory OGL-a muszą być ciągłymi blokami pamięci, a modyfikacja gdzieś w środku wymaga przesunięcia wszystkich dalszych elementów
Miałem na myśli modyfikacje geometri przed dodaniem jej do obiektu a tego do sceny, czyli przed wysłaniem jej do bufora.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: lethern w Czerwiec 16, 2014, 03:28:13
@Xion @Xirdus @Xender Hmm, nikt nie użył w dyskusji zwrotu "programowanie proceduralne", a dopiero teraz zauważyłem że to chyba tak się właściwie nazywa (chyba). Co do komentarzy to ... trudno mi się odnieść, z racji mojej pomyłki w nazwie na starcie ;)
[edit] Na wszelki wypadek dopiszę: chodziło mi o styl pisania C, czy linux (mi się to wprost  kojarzy z określeniem "programowanie strukturalne", sorry)
@Q
Cytuj
lethern różnica między strukturą a obiektem jest taka że obiekt może mieć metody i w ogóle może więcej niż jakakolwiek struktura.
Q, ok, w teorii obiekty są bytami gdzie dane i metody są ściśle powiązane, ale napisałeś to tak jakby struktura nie mogła miec metod.. Tym bardziej dziwi to zdanie, kiedy struktura i klasa naprawdę niewiele się różnią. Nie bede dogryzał, po prostu napiszę że nie rozumiem o co kaman
struct ze_obiektowosc{
   virtual void ze_wirtualna();
};
struct X : public ze_obiektowosc
{
int ze_ja_nie_moge();
};
Cytuj
Więc jak ktoś będzie chciał pobawić się opengl w javie to i tak otrze sie o obiekty i tego nie przeskoczy.
Biorąc pod uwagę powyższe, nadal nie widzę różnicy żeby cały opengl był napisany w strukturach a w classach (obiektach). Obiektowość leży daleko głębiej niż upiep*enie wszystkiego w klasę i udawanie niewiniątka (witam programistów java)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 16, 2014, 04:07:48
Cytuj
Obiektowość leży daleko głębiej niż upiep*enie wszystkiego w klasę i udawanie niewiniątka (witam programistów java)
To zabrzmiało tak jakby trzeba było wyznawać całą filozofie obiektowości by korzystać z obiektów.
struct ze_obiektowosc{
   virtual void ze_wirtualna();
};
struct X : public ze_obiektowosc
{
        int ze_ja_nie_moge();
};
Przyznam się że nie wiedziałem że tak można, struktury znam dość słabo.
Cytuj
ale napisałeś to tak jakby struktura nie mogła miec metod
Bo nie wiedziałem że mogą. Jeszcze 5 miesiecy temu nie umiałem c++(właściwie to chciałem się uczyć języka D, ale nikt w nim nie pisze). Przeleciałem przez kilka tutoriali ale nie zagłębiałem się w struktury, bo i po co skoro są klasy.   
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 16, 2014, 08:42:27
W C++ słowa class i struct są równoznaczne, różnią się tylko domyślnym specyfikatorem dostępu. Jednak koncepcyjnie struktura i klasa to dwie różne rzeczy służące do czego innego - "poprawna" klasa nie powinna mieć żadnych pól publicznych i wszystko powinno się odbywać za pomocą metod, natomiast "poprawna" struktura powinna mieć wszystkie pola publiczne i żadnych metod. Przy czym para metod get/set powoduje upublicznienie pola klasy - nie jest to dobry design.

Miałem na myśli modyfikacje geometri przed dodaniem jej do obiektu a tego do sceny, czyli przed wysłaniem jej do bufora.
Czyli to o czym mówiłem na początku - po inicjalizacji nie zmieniasz geometrii obiektu, ergo nie potrzeba ci interfejsu do edycja face'ów (tylko dobrej fabryki która od razy zrobi wszystko co trzeba).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xion w Czerwiec 16, 2014, 11:29:56
Cytuj
Tym bardziej dziwi to zdanie, kiedy struktura i klasa naprawdę niewiele się różnią.
Tylko w C++. W innych językach, gdzie oba te pojęcia występują (np. C#, D, Swift), różnice są znaczne. Najważniejsza jest taka, że struktury są value types, a klasy reference types.

Cytuj
(witam programistów java)
No tak, gdy programiści Javy korzystają ze wszystkich obiektowych patternów to źle, bo za dużo abstrakcji i SingletonFactoryProxyProviderów. A gdy nie korzystają, traktując klasy raczej jak moduły z logiką i stanem, to jest to "upiep*nie wszystkiego w klasę i udawanie niewiniątka" -_-
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 18, 2014, 11:02:44
Walczę teraz z obiektami czyli z mesh. Rozumiem że przyjeta praktyka jest jeden VAO na obiekt.
Chciałbym by VAO było tablicą tak jak VBO.   
Nie rozumiem tylko dlaczego kompilator nie chce puścić mi tego:

GLuint vao[100]; // tablica VAO mieszczaca 100 objektów
glGenVertexArrays(100, &vao);
Jak Wy rozwiązujecie ten problem bo w końcu macie chyba wiecej VAO niż jeden w programie?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 18, 2014, 11:15:50
glGenVertexArrays(100, vao);
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Rokuzo w Czerwiec 18, 2014, 14:08:16
Nie chce Tobie tego puścić, bo nie znasz podstaw języka C i zapewne C++.
Dziwi mnie, że się wypowiadasz jeszcze do tego na temat obiektów itd.
Już więcej do tego tematu wole nie zaglądać, bo mnie chyba krew zaleje :D
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Czerwiec 18, 2014, 16:23:01
Cytuj
Rozumiem że przyjeta praktyka jest jeden VAO na obiekt
Ja mam dzielone(shared) vao - w innej nomenklaturze zwane vertex deklaracjami.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 19, 2014, 08:22:48
glGenVertexArrays(100, vao);Myślałem że ta funkcja przyjmuje jako 2 argument tylko referencje.
Po zmianie faktycznie wszystko działa, dziękuje.
Tak sobie myślę czy 18000 VAO to nie przegięcie?
Bo z moich wyliczeń to tyle bym potrzebował. webgl ciął się przy około 1600 VAO.
Cytuj
Nie chce Tobie tego puścić, bo nie znasz podstaw języka C i zapewne C++.
Dziwi mnie, że się wypowiadasz jeszcze do tego na temat obiektów itd.
No tak, zapomniałem że Ty urodziłeś się z całą wiedzą i nie musiałeś się niczego uczyć.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 19, 2014, 09:08:58
Przyjmuje wskaźnik nie referencję.
18k buforów? Tak to przesada, co ty chcesz w nich trzymać?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 19, 2014, 09:46:39
Cytuj
co ty chcesz w nich trzymać?
Wyliczyłem że będe potrzebował mniej więcej tyle obiektów.
Przy ilu zauważę spadek wydajności? Webgl dostawał zadyszki przy ~1500 ale kompilowany powinien być przynajmniej 2-4 razy szybszy. czyli około 6k ale to tylko moje domysły.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 19, 2014, 10:08:07
o_O? A wiesz ze możesz wyrenderować jeden obiekt kilka razy?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 19, 2014, 10:20:26
glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, 3);Wiem.
Ale potrzebuje umieścić te obiekty w odpowiednich miejscach, musiałbym wysłać w uniformie dane o lokalizacji.
A z tego co czytałem tablice wysłane jako uniformy mają ograniczenie do 256. a nawet jeśli nie to wysłanie np 250k (bo tyle bym musiał wysłać jakbym na tym oparł swój silnik) danych o lokalizacji na jeden VAO jest chyba dość ekstremalnym posunięciem.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 19, 2014, 10:55:20
Możesz wrzucić do VBO pozycje i ustawić divisor na 1, wtedy będziesz mieć pozycję per instancja.
Ale co Ty chcesz w ogóle osiągnąć? Bo to mnie najbardziej ciekawi.
 
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 19, 2014, 12:23:23
Cytuj
Możesz wrzucić do VBO pozycje i ustawić divisor na 1, wtedy będziesz mieć pozycję per instancja.
Chodzi Ci o to: http://ogldev.atspace.co.uk/www/tutorial33/tutorial33.html ?
Cytuj
Ale co Ty chcesz w ogóle osiągnąć? Bo to mnie najbardziej ciekawi.
:D
Chce móc wyświetlać jak najwięcej powtarzających się obiektów.
 Wcześniej nie wiedziałem że istnieje możliwość przeskakiwania po buforze per instancja.
Wyczytałem że za pomocą glDrawArraysInstanced można wyświetlić nawet 4 mln. obiektów. 
To w zasadzie rozwiązywało by mój problem, tylko teraz muszę wymyślić jak to ubrać w obiektowy kod.
tak by łatwo było z całego tego dobrodziejstwa korzystać.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: flexi w Czerwiec 19, 2014, 15:05:09
Chodzi Ci o to: http://ogldev.atspace.co.uk/www/tutorial33/tutorial33.html ?:D
Chce móc wyświetlać jak najwięcej powtarzających się obiektów.
 Wcześniej nie wiedziałem że istnieje możliwość przeskakiwania po buforze per instancja.
Wyczytałem że za pomocą glDrawArraysInstanced można wyświetlić nawet 4 mln. obiektów. 
To w zasadzie rozwiązywało by mój problem, tylko teraz muszę wymyślić jak to ubrać w obiektowy kod.
tak by łatwo było z całego tego dobrodziejstwa korzystać.

Najpierw zrozum o co chodzi z obiektowoscia :)
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 19, 2014, 17:07:48
Ale paskudny layout.

Na poważnie, to jak wyobrażasz sobie tą obiektowość i jej użycie? Jak ma Ci ułatwić pracę?
Bo jak dla mnie to ty się do tego zabierasz od d... strony. Obiektowość powinna być tak jakby "naturalna", jeśli musisz na siłę upychać to w obiekty to nie tak.

A poza tym to działa ci coś? Najpierw wyświetl te 4kk obiektów jak bóg przykazał, a dopiero potem zacznij kombinowanie.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: lethern w Czerwiec 19, 2014, 22:19:35
to jest "thinking in java"
it can't be helped
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Czerwiec 22, 2014, 18:15:44
30 100 vao to juz przegięcie, a ty piszesz o 18 k... widocznie ich nie rozumiesz... poczytaj o nich jeszcze raz.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 23, 2014, 02:31:09
Cytuj
Na poważnie, to jak wyobrażasz sobie tą obiektowość i jej użycie? Jak ma Ci ułatwić pracę?
No już nie raz pokazywałem kod i jak ma to wyglądać.
Nie mi ma ułatwić prace tylko ludziom którzy zabiorą sie za projekt razem ze mną.
Cytuj
Bo jak dla mnie to ty się do tego zabierasz od d... strony. Obiektowość powinna być tak jakby "naturalna", jeśli musisz na siłę upychać to w obiekty to nie tak.
Jeśli wszystko będzie przemyślane to dlaczego nie?
Mój ostatni projekt w javie był pisany strukturalnie, ale po pewnym czasie trudno sie go debugowało.
Zajeło mi 3 tygodnie przepisanie tego na obiektowy kod.
Chce tego uniknąć w tym projekcie, dlatego wole od razu zacząć projekt od właściwej strony.
Cytuj
A poza tym to działa ci coś?
Na razie nie, do końca miesiąca siedzę w pracy ;/ Ale od lipca mam urlop (cały miesiąc) i zamierzam przeznaczyć go na mój projekt. Obecnie przebudowuje kod tak by coś sie już wyświetlało. Ale i tak 90% zajmuje mi planowanie jak to uprościć do maximum.
Cytuj
to jest "thinking in java"
No niestety, java mi sie podobała, obiektowość traktuje jako posegregowane w drzewa funkcje.
Dzięki temu łatwo było mi znaleźć coś w programie napisanym w javie nawet jak nie wiedziałem co i jak.
Cytuj
100 vao to juz przegięcie, a ty piszesz o 18 k... widocznie ich nie rozumiesz
webgl wyświetlał mi 1600 VAO i całkiem nieźle sobie radził.

Obecnie mam problem jak zrobić by instancja obiektu odpowiedzialnego za shadery była dostępna w innych obiektach tak by móc używać jej metod i właściwości, ale bez przekazywania jej w postaci argumentu np w konstruktorze.
chce np móc użyć metode wysyłającą macierz widoku do shadera wierzchołków w metodzie kamery:

psełdokod:
Shader shader("plik");
...
clasa camera::update()
{
   matrixCamera = ... // tworzenie marixa :p
   shader.send(matrixCamera);
}
 
Ogólnie to nie mam pomysłu jak zarzadzać shaderem w różnych obiektach.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 23, 2014, 02:58:20
Niemniej duża ilość małych buforów jest zbędnym obciążeniem GPU, oprócz zarządzania tym dochodzi jeszcze koszt przełączenia bufora. glDrawRangeElements i jedyne co musisz trzymać to indeks początkowy i końcowy modelu, prościej?

Dla ludzi którzy będą z tobą pracować, jeśli będą znali ogla, nauka kolejnego api może byc irytująca.

KISS*
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 23, 2014, 03:08:22
obiektowość traktuje jako posegregowane w drzewa funkcje.
To nie jest obiektowość. Obiekt jest to byt jakiejś klasy, posiadający jakieś zachowania. Klasa te zachowania definiuje. Dziedziczenie pozwala mieć dwa obiekty tej samej klasy, ale o różnych zachowaniach. Korzystanie z wyżej wymienionych cech to obiektowość. "Drzewiastość funkcji" to właśnie programowanie strukturalne - przeczytaj sobie Wikipedię.

BTW. Nie myli ci się VAO z VBO?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 23, 2014, 03:23:49
Myślałem że tylko ja nie śpię :)
Cytuj
glDrawRangeElements i jedyne co musisz trzymać to indeks początkowy i końcowy modelu, prościej?
Niby prościej. A co z teksturą? nie trzeba jej przełączyć przy przełączaniu VAO?
Cytuj
BTW. Nie myli ci się VAO z VBO?
Nie, ale o tej godzinie nie wiem czy moje zdania sa logiczne i w moim rozumowaniu może wkraść się błąd.
Cytuj
To nie jest obiektowość. Obiekt jest to byt jakiejś klasy, posiadający jakieś zachowania. Klasa te zachowania definiuje. Dziedziczenie pozwala mieć dwa obiekty tej samej klasy, ale o różnych zachowaniach. Korzystanie z wyżej wymienionych cech to obiektowość. "Drzewiastość funkcji" to właśnie programowanie strukturalne - przeczytaj sobie Wikipedię.
Sorry źle się wyraziłem, nie miałem na mysli że to traktuje dosłownie, tylko że podoba mi sie ten aspekt obiektowości.
Wiem na czym polega obiektowość.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 23, 2014, 09:55:19
Vao grupuje informacje o kilku vbo, także mówiąc o vao mówimy o vbo.

A co z teksturą? nie trzeba jej przełączyć przy przełączaniu VAO?
No trzeba, ale mówiliśmy o geometrii.
Cytuj
psełdokod:
Shader shader("plik");
...
clasa camera::update()
{
   matrixCamera = ... // tworzenie marixa :p
   shader.send(matrixCamera);
}
 

Ogólnie to nie mam pomysłu jak zarządzać shaderem w różnych obiektach.

Zrób singleton/globala a najlepiej nie rób tego. A, skąd shader ma wiedzieć że ustawiłeś mu macierz kamery, a nie czegoś innego? Po co kamera ma cokolwiek wiedzieć o shaderze, niech będzie samodzielnym bytem i udostępnia odpowiednie informacje.

Co chcę ci powiedzieć to że opakowując ogla w obiekty będziesz miał 2x więcej debugowania. A nawet więcej bo z tego co widzę to się dopiero uczysz więc nawet nie wiesz czego nie wiesz.
Zauważ ze chcę tu oddzielić opakowywanie ogla w obiekty od opakowywania pozostałych rzeczy w obiekty. Pierwsze jest bez sensu, drugie ma sens, ale tu potrzeba doświadczenia w pisaniu silników i ich organizacji.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 24, 2014, 09:18:21
Cytuj
No trzeba, ale mówiliśmy o geometrii.
Ale chyba trzeba ja zmienić gdy wyświetlamy inny element geometrii?
glDrawRangeElements(GL_TRIANGLES, 0, 2, 3, GL_UNSIGNED_SHORT, (const GLvoid*) pindices);
// tu zmiana textury
glDrawRangeElements(GL_TRIANGLES, 3, 5, 3, GL_UNSIGNED_SHORT, (const GLvoid*) pindices+3);
Czy można za pomoca glDrawElementsInstanced wyświetlić tak jak w  glDrawRangeElements obiekty z jakiegoś przedziału bufora, bo zdaje się że nie? (niestety jestem znów w pracy i możliwosci szukania w necie mam mocno ograniczone)
Poza tym mam pytanie odnośnie textur.
Czy raz wysłaną texturę za pomoca uniformu moge zmieniać za pomoca bind, czy też za każdym razem muszę ja znów wysyłać jako uniform? Z tego co sie orientuje to program shadera działa jako klient-serwer wiec istnieje chyba możliwośc że wyrysuje mi geometrie zanim zaktualizowana zostanie textura w uniformie?
Cytuj
A, skąd shader ma wiedzieć że ustawiłeś mu macierz kamery, a nie czegoś innego?
No bede musiał zrobic odpowiednie metody do aktualizacji odpowiednich uniformów.
Cytuj
A nawet więcej bo z tego co widzę to się dopiero uczysz więc nawet nie wiesz czego nie wiesz.
Gdy zaczynałem ten temat nie wiedziałem prawie nic. Był tylko pomysł, teraz mam juz całkiem sporo kodu i wiedzy jak to urzeczywistnić.
Cytuj
Pierwsze jest bez sensu, drugie ma sens, ale tu potrzeba doświadczenia w pisaniu silników i ich organizacji.
To przypomina żądanie pracodawcy by osoba zaraz po studiach miała doświadczenie. Chyba na czymś to doswiadczenie trzeba zdobyć?
Na razie zdobywam informacje co mozna a co nie, jak coś się robi. Od lipca mam urlop i dopiero wtedy zamierzam na powaznie do tego usiąść.
Cytuj
Zauważ ze chcę tu oddzielić opakowywanie ogla w obiekty od opakowywania pozostałych rzeczy w obiekty. Pierwsze jest bez sensu,
Obiektowość + opengl to chyba jakies tabu? Przynajmniej takie odnosze wrażenie po waszych reakcjach na tem pomysł.
Pownienem napisać w temacie że to wątek w którym można spotkać rewolucyjne i śmiałe idee.
Nie raz bralem się za cos gdy inni mówili: "Nie znasz sie na tym", "to głupie", "nie uda Ci się" itp.
Ja jednak zawsze udowadniałem że mam rację, może opengl + obiekty to głupi pomysł ale chyba można sprawdzić jak to będzie wyglądało? 
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: albireo w Czerwiec 24, 2014, 09:46:01
Czy można za pomoca glDrawElementsInstanced wyświetlić tak jak w  glDrawRangeElements obiekty z jakiegoś przedziału bufora, bo zdaje się że nie? (niestety jestem znów w pracy i możliwosci szukania w necie mam mocno ograniczone)
Oczywiście, że można, jeśli użyłbyś glDrawElements zamiast glDrawRangeElements (pomijając drugi i trzeci argument), to uzyskasz taki sam wynik (użycie glDrawRangeElements zamiast glDrawElements ma sens tylko jeśli nie korzystasz z VBO).
Poza tym mam pytanie odnośnie textur.
Czy raz wysłaną texturę za pomoca uniformu moge zmieniać za pomoca bind, czy też za każdym razem muszę ja znów wysyłać jako uniform? Z tego co sie orientuje to program shadera działa jako klient-serwer wiec istnieje chyba możliwośc że wyrysuje mi geometrie zanim zaktualizowana zostanie textura w uniformie?
Nie istnieje taka możliwość (pomijając bugi w driverze), jeśli najpierw ustawisz teksturę a później wywołasz rysowanie, to zostanie to narysowane ustawioną teksturą.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Xirdus w Czerwiec 24, 2014, 11:15:02
Wprawdzie doświadczenia z OGL mam mizernie mało, niecaly miesiac, ale parę rzeczy z tego wątku mi nie pasuje.

Vao grupuje informacje o kilku vbo, także mówiąc o vao mówimy o vbo.
A nie jest przypadkiem tak, że VAO przechowuje informacje jak używać zbindowanego VBO, przy czym mozemy w dowolnej chwili (pomiedzy drawcallami) zmienic VBO dla danego VAO, i VAO dla danego VBO?

Czy raz wysłaną texturę za pomoca uniformu moge zmieniać za pomoca bind, czy też za każdym razem muszę ja znów wysyłać jako uniform?
Uniformem jest chyba texture unit, a nie sama tekstura?

użycie glDrawRangeElements zamiast glDrawElements ma sens tylko jeśli nie korzystasz z VBO
Moglbys rozwinac? Z tego co wyczytalem, i jedno i drugie korzysta z VBO.

Nie istnieje taka możliwość (pomijając bugi w driverze), jeśli najpierw ustawisz teksturę a później wywołasz rysowanie, to zostanie to narysowane ustawioną teksturą.
Koledze Q chodzilo chyba o zmiane miedzy drawcallami. AFAIK podbindowanie tekstury pod ten sam texture unit powinno dac natychmiastowy efekt bez zadnych dodatkowych zabaw?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 24, 2014, 11:38:46
A nie jest przypadkiem tak, że VAO przechowuje informacje jak używać zbindowanego VBO, przy czym mozemy w dowolnej chwili (pomiedzy drawcallami) zmienic VBO dla danego VAO, i VAO dla danego VBO?

Yhm, do Vao można podpiąć kilka vbo, po prostu zamiast wołać vbo, ustawiać wszystkie atrybuty, divisory, to robimy to raz dla vao, i potem wołamy tylko vao. Nie widzę przeszkód by można było zmieniać podpięte vbo, aczkolwiek nie próbowałem.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: albireo w Czerwiec 24, 2014, 11:44:49
Moglbys rozwinac? Z tego co wyczytalem, i jedno i drugie korzysta z VBO.
Dodatkowe parametry glDrawRangeElements, to zakres użytych  indeksów, więc ma to znaczenie w zasadzie tylko w sytuacji kiedy dane wierzchołków przesyła się z pamięci systemu do pamięci karty, czyli gdy korzysta się z vertex array (nie mylić z VAO) lub z VBO często modyfikowanych (GL_STREAM_DRAW), ale w tej drugiej sytuacji i tak normalnie korzysta się ze wszystkich danych z bufora, więc nie ma to w zasadzie znaczenia. Może to też mieć znaczenie kiedy dane potrzebne do narysowania sceny nie mieszczą się w pamięci karty graficznej, ale wtedy i tak wydajność leci.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: ArekBal w Czerwiec 24, 2014, 12:03:21
Wprawdzie doświadczenia z OGL mam mizernie mało, niecaly miesiac, ale parę rzeczy z tego wątku mi nie pasuje.
A nie jest przypadkiem tak, że VAO przechowuje informacje jak używać zbindowanego VBO, przy czym możemy w dowolnej chwili (pomiędzy drawcallami) zmienić VBO dla danego VAO, i VAO dla danego VBO?

Tak jest... stąd absurdalnym pomysłem jest potrzeba 16k vao

W dokumentacji jest zasugerowane niechcący że VBO są składnikami VAO. Ale należy to rozumieć w ten sposób że bufory do rysowania wymagają tych deklaracji.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 29, 2014, 10:17:22
Co do trzymania całej geometrii w jednym vao to ma to taka wadę że gdy próbujemy renderować dwa obiekty przy pomocy funkcji glDrawElementsInstanced jeden po drugim to gl_InstanceID ulega resetowi.
// wypisujemy 5 elementów
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_INT,(GLvoid*)0, 5);
// wypisujemy kolejne 5 elementów
// gl_InstanceID znów jest ustawione na 0
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_INT,(GLvoid*)0, 5);
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 29, 2014, 11:30:05
Byłoby bardzo niewygodne gdyby nie ulegało, mam wrażenie że czegoś o instancingu nie zrozumiałeś.

Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 29, 2014, 12:27:37
No tak ale to eliminuje jeden VAO do wyświetlania całej geometrii. trzeba utworzyć ich co najmniej kilka.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 29, 2014, 13:05:15
Nie, widzę że nie czytałeś dokumentacji: http://www.opengl.org/sdk/docs/man3/ (http://www.opengl.org/sdk/docs/man3/).
I teraz tak,
void glDrawElementsInstanced(GLenum mode,  GLsizei count,  GLenum type,  const void * indices,  GLsizei primcount);cont: ilość indeksów modelu
indices: wskaźnik na pierwszy indeks, można liczyć jako pierwszy indeks*sizeof(type)
primcount: ilość instancji

Dla geometrii o takiej samej budowie wierzchołka wystarczy jedno VAO.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Czerwiec 29, 2014, 14:55:35
Nie rozumiesz o co mi chodzi, mam jakiś obiekt np trójkąt. Ustawiam mu teksture i wklejam ileś razy, potem zmieniam texture i znów wypisuje go iles razy, jeśli gl_InstanceID po każdym razie mi sie ustawi na 0 to przesłane macierze do bufora który odpowiada za pozycje staja sie bezwartościowe. Ponieważ trójkąt A i B beda rysowane w tych samych miejscach.
I nie ma znaczenia gdzie ustawie index, lub ile ma mieć indexów.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Czerwiec 29, 2014, 15:09:54
A co pisałem ci wcześniej o trzymaniu pozycji w VBO? I ewentualnym aktualizowaniu wedle potrzeby.
Z tego co widzę teraz robisz tak że wysyłasz w uniformie pozycje wszystkich obiektów, rysujesz kilka z nich, zmieniasz texturę, rysujesz(nie wklejasz) resztę, da?
Od biedy możesz wysłać jakiś offset  do ~ID.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: albireo w Czerwiec 29, 2014, 15:57:45
Przypuszczam, że właśnie trzyma pozycje w VBO (glVertexAttribDivisor), i wtedy właśnie jest problem, bo za każdym kolejnym wywołaniem rysuje te same obiekty, ale jeśli potrzebna jest zmiana tekstur, to można skorzystać z tablicy tekstur (array texture) i załatwić wszystko jednym wywołaniem draw*instanced dodając dodatkowy atrybut z numerem tekstury (ewentualnie obliczając go na podstawie gl_InstanceID jeśli się da, np w sytuacji gdy każdą teksturą rysowanych jest tyle samo obiektów).
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Lipiec 03, 2014, 18:28:51
Cytuj
Przypuszczam, że właśnie trzyma pozycje w VBO (glVertexAttribDivisor), i wtedy właśnie jest problem, bo za każdym kolejnym wywołaniem rysuje te same obiekty
Dobrze przypuszczasz :)
Wpadłem na taki pomysł:
// wypisujemy 5 elementów
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_INT,(GLvoid*)0, 5);
// wypisujemy kolejne 5 elementów
// gl_InstanceID znów jest ustawione na 0
// ale zmieniamy bufor z pozycjami na inny i obchodzimy problem z  gl_InstanceID
/*
 tu podmiana bufora
*/
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_INT,(GLvoid*)0, 5);

Niestety pojawiły się problemy. Po pierwsze można podmienić dane w samym buforze za pomocą glBufferSubData ale wąże sie to z przesłaniem danych do bufora co jest chyba dość kosztowne czasowo, w dodatku kod:
glBindBuffer(GL_ARRAY_BUFFER, vbo[3]);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(Position2), Position2);
glBindBuffer( GL_ARRAY_BUFFER, 0 );
nic mi nie robi.
Po drugie fajnie było by podmienić jeden bufor na inny już istniejący. Niestety wykracza to poza zakres mojej wiedzy.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Lipiec 03, 2014, 19:23:18
kuźwa, nie możesz przesłać w uniformie jakiegoś offsetu go gl_InstanceID, ha? Myśl kreatywnie.
I sizeof(Position2) pomnóż przez rozmiar Position2, bo tu ma być podany rozmiar w bajtach całego fragmentu pamięci który wysyłasz.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Lipiec 03, 2014, 20:18:04
Cytuj
kuźwa, nie możesz przesłać w uniformie jakiegoś offsetu go gl_InstanceID, ha?
Nie czaje
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: albireo w Lipiec 03, 2014, 20:44:52
kuźwa, nie możesz przesłać w uniformie jakiegoś offsetu go gl_InstanceID, ha? Myśl kreatywnie.
Przesłanie offsetu nic nie da, bo i tak nie zostanie on uwzględniony w atrybutach z ustawionym glVertexAttribDivisor różnym od zera, jakby sam sobie te dane pobierał (np z tekstury) to by można tego użyć.

Zamiast podstawiania nowego bufora (lub nowych danych w buforze), możesz przestawić początek danych za pomocą glVertexAttribPointer, w ostatnim argumencie dajesz offset do początku danych w bajtach, tyle że wtedy traci się część sensu używania VAO.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Lipiec 03, 2014, 21:02:53
Q pisze iż zeruje mu się gl_InstanceID, znaczy że go do czegoś używa. Podałem mu więc sposób na zachowanie tej wartości pomiędzy kolejnymi callami.

Najlepiej byłoby chyba aktualizować bufor, przy małej ilości danych i aktualizacji nie powinno być to obciążeniem. Jak mu będzie sprawiało to problem to zapewne będzie miał wystarczającego skilla by sobie z tym poradzić.

A i zawsze może zrezygnować z VAO i pracować na zwykłych VBO, na początek myślę że byłoby mu prościej. 
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Lipiec 04, 2014, 09:28:37
Rozwiązałem problem.
1. tworze 2 bufory przechowujące pozycje np poz1 i poz2.(dla każdego obiektu)
2. podpinam do wiazania w shaderze odpowiedzialnego za pozycje bufor poz1 i wyrysowuje jakiś obiekt z bufora geometrii
3. podpinam analogicznie do tego samego wiazania bufor poz2 i wyrysowuje inny obiekt z tego samego bufora geometrii.

Problem z gl_InstanceID rozwiązany, wszystko wygląda mniej wiecej tak:
glBindBuffer(GL_ARRAY_BUFFER, vbo[3]);
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, 0, 0);
glBindTexture( GL_TEXTURE_2D, tex1 );
glDrawElementsInstanced(GL_TRIANGLES, 6, GL_UNSIGNED_INT,(GLvoid*)0, 2);

glBindBuffer(GL_ARRAY_BUFFER, vbo[4]);
glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, 0, 0);
glBindTexture( GL_TEXTURE_2D, tex2 );
glDrawElementsInstanced(GL_TRIANGLES, 3, GL_UNSIGNED_INT,(GLvoid *)(3*sizeof(GLuint)), 2);
Wydaje mi sie że powinno działać to szybciej niż napełnianie bufora nowymi danymi.

A teraz to co tygryski lubią najbardziej, zamiana tego na obiekty :P
Tak sobie myślałem że dobrze będzie wprowadzić podział na różne obiekty, np:
Object obiekt1(geo, mat); // jakiś obiekt
scene.add(obiekt1); // dodanie
...
// tu zmiana pozycji obiektu1
...
scene.add(obiekt1); // dodanie nowego obiektu na innej pozycji

// ====== Tutaj nowy typ obiektu =======

Clone clonet1(geo, mat); // jakiś obiekt
scene.add(clone); // dodanie
...
// tu zmiana pozycji clone1
...
scene.add(clone1); // sklonowanie clona na innej pozycji
// bedą też 2 obbiekty jak w 1 przykładzie ale bedzie to ten sam obiekt tylko wyświetlany w 2 pozycjach

Co o tym myślicie?
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Lipiec 04, 2014, 10:10:52
Czekaj, w buforze przechowujesz pozycję tylko jednego/kilku obiektów? 
Co do przykładu to jakoś dziwnie nie wygląda, ale jest zbyt ubogi żeby coś o tym powiedzieć.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Lipiec 04, 2014, 10:23:05
Cytuj
Czekaj, w buforze przechowujesz pozycję tylko jednego/kilku obiektów? 
tak, 1 bufor z pozycjami na obiekt.
Cytuj
Co do przykładu to jakoś dziwnie nie wygląda, ale jest zbyt ubogi żeby coś o tym powiedzieć.
No to tylko koncept.
Chodziło mi o rozdzielenie pojedynczych obiektów od takich które będa występować w dużej ilości.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Lipiec 04, 2014, 10:35:54
No więc w takim wypadku dużo prościej przesłać pozycję/macierz transformacji w uniformie. Przechowywanie pozycji w buforze ma sens dla wielu takich samych obiektów, np. 1k krzaczków trawy.
Jak masz po kilka obiektów, możesz rysować w pętli.
Wybacz że wprowadziłem cię w błąd ale chyba się wtedy źle zrozumieliśmy.
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: Q w Lipiec 04, 2014, 11:43:44
Cytuj
No więc w takim wypadku dużo prościej przesłać pozycję/macierz transformacji w uniformie. Przechowywanie pozycji w buforze ma sens dla wielu takich samych obiektów, np. 1k krzaczków trawy.
To prawda, w dodatku łatwiej jest zmienić potem wartość takiej pozycji ale ma to wady.
Z tego co mi wiadomo (gdzieś wyczytałem i nie wiem czy to prawda) to uniformy mają ograniczenia wielkości. Więc w końcu napotkamy na ograniczenia, a ja tego nie lubie.
Poza tym jak już gdzieś pisałem wcześniej biblioteka nad którą pracuje ma służyć do mojego projektu, a w nim chce wyświetlać ponad 4kk obiektów (nie wiem czy to osiągnę ale cel przyznacie że ambitny).
Wiec tak czy siak muszę się na jakieś rozwiązanie zdecydować.
Cytuj
Wybacz że wprowadziłem cię w błąd ale chyba się wtedy źle zrozumieliśmy.
Nic sie nie stało, dzięki Tobie poczytałem sobie troszkę o offsetach. 
Tytuł: Odp: [c++] Opengl opakowany w obiekty, czy warto?
Wiadomość wysłana przez: DezerteR w Lipiec 04, 2014, 11:58:07
Wiesz, wszystko zależy od tego co chcesz wyświetlać, co innego wyświetlać trawę, a co innego czołg z kilkudziesięcioma kośćmi i kilkoma teksturami. 

Uniformy mają jakieś tam ograniczenie, ale jest coś takiego jak Unifom Buffer Object.