Pokaż wiadomości

Ta sekcja pozwala Ci zobaczyć wszystkie wiadomości wysłane przez tego użytkownika. Zwróć uwagę, że możesz widzieć tylko wiadomości wysłane w działach do których masz aktualnie dostęp.


Wiadomości - limonki

Strony: [1] 2 3 4 5
1
OpenGL / Odp: [OpenGL] FBO sypie się na hardware z OGL 2.x
« dnia: Czerwiec 17, 2013, 02:37:32 »
Nikt nic nie wie czemu tak się dzieje?

Teoretycznie poradziłem sobie z problemem dając wszędzie GL_RGBA16F jak format tekstury. Jednakże dziwi mnie to, że OGL 2.1 łyka tekstury podpięte do RT tylko i wyłącznie wszystkie takiego samego formatu (przy czym na dodatek wali się testowanie głębi, które na 3.3 działa jak należy), kiedy OGL 3.3 może mieć wszystkie innego formatu...

No nic. Ważne, że działa.

2
OpenGL / [OpenGL] FBO sypie się na hardware z OGL 2.x
« dnia: Czerwiec 15, 2013, 12:04:05 »
Witam!

Ostatnio pisałem dużoooooo pod OGL 3.3. Niestety dostałem takie zadanie, które wymusiło na mnie jak największą kompatybilność ze sprzętem przy w miarę życiowej technologii i grafice. Zanim zacząłem korzystać z OGL 3.3 pisałem pod 2.1, więc przepisanie shaderów i zabezpieczenie paru opcji to była chwila moment. Skompilowana aplikacja pod OGL 3.3 uruchamia się normalnie bez jakichkolwiek problemów. Niestety na OGL 2.1 wszystko umiera prawie do takiego stopnia, że trzeba restartować. Po podejrzeniu loga zobaczyłem, że niby FBO odpowiedzialne za deferreda ma niekompletne formaty tekstur (GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT). Sprawdzałem to kilkakrotnie i żadnego błędu nie widzę. Zaznaczę, że jeżeli dam generalnie jakikolwiek inny formacik od GL_RGBA to na OGL 2.1 się sypie, mimo że i tekstura i renderbuffer ma taki sam format.

Kod jest standardowy (na 2.1 się sypie, a 3.3 normalnie się włącza i wszystko hula):

int Deferred::Initialize( parametry )
{
        // ... width, height itp.

glGenFramebuffers(1, &FBO);
glGenRenderbuffers(1, &colorRT);
glGenRenderbuffers(1, &positionRT);
glGenRenderbuffers(1, &normalsRT);
glGenRenderbuffers(1, &depthBuffer);

glBindFramebuffer(GL_FRAMEBUFFER, FBO);

glBindRenderbuffer(GL_RENDERBUFFER, colorRT);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorRT);

glBindRenderbuffer(GL_RENDERBUFFER, positionRT);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA32F, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_RENDERBUFFER, positionRT);

glBindRenderbuffer(GL_RENDERBUFFER, normalsRT);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA16F, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_RENDERBUFFER, normalsRT);

glBindRenderbuffer(GL_RENDERBUFFER, depthBuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, width, height);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthBuffer);

glGenTextures(1, &colorTexture);
glBindTexture(GL_TEXTURE_2D, colorTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, colorTexture, 0);

glGenTextures(1, &positionTexture);
glBindTexture(GL_TEXTURE_2D, positionTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_RGBA, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, positionTexture, 0);

glGenTextures(1, &normalsTexture);
glBindTexture(GL_TEXTURE_2D, normalsTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, width, height, 0, GL_RGBA, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, normalsTexture, 0);

glGenTextures(1, &depthTexture);
glBindTexture(GL_TEXTURE_2D, depthTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, width, height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depthTexture, 0);

// Sprawdzamy status FBO itp.

glBindFramebuffer(GL_FRAMEBUFFER, 0);
}

Nie rozumie czemu mi to nie chce działać.

PS. Sprawdzana karta była kiedyś kartą pod którą pisałem, a mam binarki z deferredem, które na niej na 100% działały. Sęk w tym, że i one teraz nie chcą działać. Wina sterów? Czy może wersji GL?

3
OpenGL / Odp: OpenGL 3.0+ - kilka pytań
« dnia: Marzec 12, 2013, 17:59:53 »
Nie wiem, co masz na myśli. Procedura jest prosta: kopiujesz geometrię na pamięć karty graficznej, ustawiasz shader, opcje i rysujesz. Dokładnie tak samo dla jednego kwadratu, co dla tysiąca.

Jeśli to Ci wygląda na zbyt skomplikowane, to może nie potrzebujesz suchego API do grafiki, tylko jakiś framework lub silnik?

Nie chodzi mi tutaj o skomplikowanie tylko o to czy nie jest to trochę overkillem w stosunku do jednego kwadratu? Ale skoro odchodzimy od fixed pipeline to odchodzimy na dobre :) W wypadku prostego debugu np. deferreda zrobię tak jak @noizex pisał - prosta klasa dla prymitywów i nie mam więcej wątpliwości.

Jeśli chodzi o macierze - to zapoznam się z biblioteką GLM i spróbuję sobie napisać swoją małą bibliotekę dla operacji na macierzach.

Natomiast w przypadku przestarzałych funkcji, gDebugger rzeczywiście ma możliwość zatrzymywania się na takich funkcjach. Po napisaniu biblioteki zajmę się usuwaniem takich funkcji.

Jeszcze raz dzięki wszystkim za odpowiedzi.
Sądzę, że moje wątpliwości zostały rozwiane.

Pozdrawiam,
limonki.

4
OpenGL / OpenGL 3.0+ - kilka pytań
« dnia: Marzec 12, 2013, 17:12:24 »
Witam wszystkich.

Od pewnego czasu myślę nad przesiadką z OGLa 2.x na 3.x. Do tej myśli skłoniły mnie między innymi fakty związane z "czystością" API, nowym, lepszym sposobem renderowania i pełną kontrolą nad tym co wysyłam do shaderów. Zacząłem szukać jakichś poradników, przeglądnąłem tak po łebkach na szybko specyfikacje i nasunęło mi się kilka pytań związanych z "nową" technologią.

1. Wiadomo, że OGL 3.0 był przełomową wersją, która odrzuciła funkcje uznane za przestarzałe np. glVertex3f, glBegin, glColor4f. Przypuśćmy, że jeżeli chciałbym wyrenderować kwadrat na całym ekranie z nałożoną teksturą. Według nowego API, muszę tworzyć (jak w wypadku np. modelu) VBO, shadera, wysłać info do shadera i dopiero rysować. Dla normalnych modeli mających więcej niż 4 wierzchołki rozumiem ale, żeby dla głupiego kwadratu? Czy to nie jest trochę takie robienie czegoś na siłę byle, żeby było zgodne z nowym standardem? Dla rzeczy takich jak kwadrat sposób renderowania powinien być prosty...

2. Macierze, macierze, macierze... No właśnie. Jak to jest z tymi macierzami w OGL 3.0+? Wbudowane macierze i wszystko co z nimi związane uznano za przestarzałe. Mam rozumieć, że sam muszę sobie napisać macierze, stos macierzy itp.? Bo korzystanie z wbudowanych w 3.0+ jest podobno be.

3. Czy da się jakoś zmusić kompilator, GLEW'a lub GLFW, żeby funkcje uznane za przestarzałe wywalało jako "undeclared"? Bo w OGLu 2.1 bardzo się zakorzeniłem a chciałbym się przestawić na nową technologię i zapomnieć o starociu, a tak jakoś nie potrafię i potrzebuję "strażnika", który będzie pomagał mi odzwyczaić się od 2.1.

Dzięki wszystkich za odpowiedzi i pozdrawiam,
limonki.

5
OpenGL / Odp: [OpenGL][GLSL] Deferred shading - normalki
« dnia: Grudzień 01, 2012, 23:17:57 »
Czyli w końcu ta linijka kodu działa dobrze?
normals = normalize(worldRotationInverse * gl_NormalMatrix * gl_Normal);Bo niezbyt ogarniam... Tylko w sumie gdyby działała dobrze światło by się nie chrzaniło.

Już kompletnie nic nie pojmuję. Mam taki mindfuck, że to przechodzi samo siebie.

6
OpenGL / Odp: [OpenGL][GLSL] Deferred shading - normalki
« dnia: Grudzień 01, 2012, 21:05:30 »
Spróbuj tak i zobacz jak będą wyglądały normalki, a potem zamiast worldRotationInverse spróbuj dać gl_NormalMatrix.
normals = normalize(worldRotationInverse * gl_Normal);

Powiem tak: jeżeli nie ma albo worldRotationInverse albo gl_NormalMatrix to w tym momencie normalki zmieniają mi się wraz z ruchem kamery a tak nie powinno być.

7
OpenGL / Odp: [OpenGL][GLSL] Deferred shading - normalki
« dnia: Grudzień 01, 2012, 20:22:05 »
Czyli źle obliczam normalkę, czy źle wprowadzam pozycję do gl_FragData?

Jeśli mógłby ktoś poratować jakimś działającym skrawkiem kodu byłbym wdzięczny.

8
OpenGL / [OpenGL][GLSL] Deferred shading - normalki
« dnia: Grudzień 01, 2012, 16:22:51 »
Witam wszystkich forumowiczów i po raz kolejny zwracam się do Was o pomoc.

Otóż zająłem się zagadnieniem, które zwie się deferred shadingiem. Pierwszy raz się za to zabieram tak więc napotkałem pewien problem. Przy kodowaniu posiłkowałem się tym tutorialem (http://www.codinglabs.net/tutorial_simple_def_rendering.aspx), ponieważ zależy mi na początku na dużej prostocie tego zagadnienia. Diffuse wygląda ok, Position też, natomiast mam wątpliwości co do Normalnych, ponieważ wyglądają one jakoś nienaturalnie i dziwnie (czarne normalki, załączam zdjęcia i demko). Przez to całe światło się sypie.

Deferred shading shader:

Vertex banalny i nie miało co się tam popsuć więc nie wstawiam.

Fragment:

uniform sampler2D tDiffuse;
uniform sampler2D tPosition;
uniform sampler2D tNormals;

uniform vec3 lightPos;

void main()
{
vec4 image = texture2D( tDiffuse, gl_TexCoord[0].xy );
vec4 position = texture2D( tPosition, gl_TexCoord[0].xy );
vec3 normal = texture2D( tNormals, gl_TexCoord[0].xy ).rgb;

vec3 lightDir = lightPos - position.xyz;

lightDir = normalize(lightDir);

float NdotL = max(dot(normal,lightDir),0.0);

gl_FragColor = vec4(NdotL);
}

Shader zapsiu do poszczegółnych FBO:

Vertex:

#version 120

varying vec3 normals;
varying vec4 position;
uniform mat4 WorldMatrix;

void main()
{
mat3 worldRotationInverse = transpose(mat3(WorldMatrix));

    gl_TexCoord[0] = gl_MultiTexCoord0;

normals = normalize(worldRotationInverse * gl_NormalMatrix * gl_Normal);
position = gl_ModelViewMatrix * gl_Vertex;

    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}

Fragment:

#version 120

varying vec4 position;
varying vec3 normals;

uniform sampler2D tex;

void main()
{
vec4 color = texture2D(tex, gl_TexCoord[0].st);

gl_FragData[0] = color;
gl_FragData[1] = vec4(position.xyz,0);
gl_FragData[2] = vec4(normals.xyz,0);
}

uniform mat4 WorldMatrix pobieram i wysyłam następująco w funkcji Render():

glUseProgram(Shaders[2].program);

         for (int i = 0; i < num_lim; i++)
{
glPushMatrix();

                glGetFloatv(GL_MODELVIEW_MATRIX, worldMatrix);
                glUniformMatrix4fv(glGetUniformLocation(Shaders[2].program ,"WorldMatrix"), 1, false, worldMatrix);

//Translacja, rotacja, skalowanie

                // Wybranie tekstury

// Render obiektu

glPopMatrix(); // Przywracamy macierz ze stosu
}

Załóżmy:

lightPos - vec3, pozycja światła
position - vec3, pozycja wierzchołka zapisana jako textura

Jeżeli lightPos.x - position.x > 0 to światło działa ok.
Natomiast jeżeli lightPos.x - position.x < 0 to już nie działa ok.
To samo w wypadku osi z.

Generalnie według tutoriala powinno być ok ale światło działa ewidentnie źle. Nie wiem jak to naprawić, ponieważ jestem zielony w temacie deferred renderingu.

Dzięki za wszystkie rady, poprawki, pomoc.

Pozdrawiam,
limonki.

PS. Pierwsze zdjęcie pokazuje światło, które działa w porządku (lightPos.x = 1000), natomiast drugie zdjęcie pokazuje już niedziałające światło (lightPos.x = -1000).

PS 2. Demko:
Sterowanie kamerą a,w,s,d
Sterowanie światłem f,t,g,h
Link do pobrania: http://hostuje.net/file.php?id=50cf5b634162a60c0854f7f7d8f22157

9
OpenGL / Odp: [GLSL, OpenGL] Wygaszanie cząsteczek
« dnia: Październik 25, 2012, 23:59:42 »
Zrobiłem tak jak myślałem - vertex attributes. Link: http://warsztat.gd/screen/12388/particles_effects

Pozdrawiam,
limonki

10
OpenGL / [GLSL, OpenGL] Wygaszanie cząsteczek
« dnia: Październik 21, 2012, 16:43:47 »
Witam forumowiczów!

Z myślą o optymalizacji renderingu postanowiłem, że przepiszę systemy cząsteczkowe ze zwykłego, starego, nieoptymalnego rysowania na VBO (w końcu "trza" się za to było zabrać). I pojawił się problem z wygaszaniem tegoż systemu. W tej chwili przy glDrawArrays nie jestem w stanie zastosować zwykłego gaszenia glColor'em. Pomyślałem sobie o atrybutach wierzchołków, żeby wysłać dla każdego wierzchołka po jednym atrybucie (opacity), odebrać w VS, wpisać do varying'a i mnożyć teksturę * vec4(1, 1, 1, alpha) w FS. Jednak efekt jest mizerny, powiedziałbym, że nawet jest jego brak.

Skopałem coś w kodzie czy Wy korzystacie z jakichś innych rozwiązań na które nie wpadłem?

Pozdrawiam,
limonki

11
OpenGL / Odp: [GLSL][OpenGL] Zmienna liczba świateł w shaderze
« dnia: Wrzesień 28, 2012, 22:58:06 »
Witam ponownie.

Poczytałem trochę o multipassie i albo źle zrozumiałem idee, albo to będzie chodzić gorzej niż poprzednia wersja mojego oświetlenia (i < gl_MaxLights). Zostańmy przy założeniu ośmiu świateł na scenie.

Jeśli dobrze zrozumiałem to co wyczytałem o tej technice to, żeby wykonać multipass muszę każdy obiekt renderować tyle razy ile mam świateł (czyli jeśli mam 8 świateł to teren renderuje 8 razy, co daje ośmiokrotny spadek wydajności, przy poprzedniej wersji daje to: raz renderowany teren ma liczone wszystkie światła od razu). Po wyrenderowaniu każdego światła zapisuję aktualny stan do tekstury (każde światło ma swoją) przy pomocy FBO i czyszczę bufor koloru sceny. Kiedy już wyrenderuję wszystkie światła dla danego obiektu, łączę wszystko w spójną całość za pomocą blendingu i zapisuję do tekstury trzymającej scenę.

Dobrze myślę? Jeśli tak, to czy nie byłoby lepiej zostać przy poprzedniej wersji oświetlenia skoro multipass da tak drastyczny spadek wydajności?

Jeśli się mylę to naprowadźcie mnie na poprawny tok myślenia :)

Pozdrawiam,
limonki.

12
OpenGL / Odp: [GLSL][OpenGL] Zmienna liczba świateł w shaderze
« dnia: Wrzesień 28, 2012, 12:54:33 »
Cytat: olo16
Strzał na ślepo: #version?

Próbowałem maksymalnej na mojej wersji OGL'a. Nic nie pomogło.

Cytat: olo16
Byłoby miło mieć jakiś bardziej szczegółowy komunikat błędu - próbowałeś jakichś debugowych opcji/rozszerzeń?

Hmmmm...Nie. Szczerze to nawet nie wiedziałem, że coś takiego jest. Jakiś program do tego służy? Wybaczcie moją niewiedzę, z shaderami bawię się już trochę czasu ale wciąż uważam się za początkującego w tej kwestii.

Cytat: Avaj
Pętle for ze zmienną liczbą kroków wymagają Shader Model 3.0 z tego co pamiętam.

To tłumaczy wszystko. Niestety - SM 2.0.

Cytat: Avaj
Po trzecie, możesz zrobić multipass, ustaw blending na addytywny i rysuj jedno światło w każdym passie.

OK. Ogarnę multipass rendering i jakoś do tego dojdę jak to zrobić.

Dziękuję wszystkim za odpowiedzi ;)

Pozdrawiam,
limonki.

13
OpenGL / [GLSL][OpenGL] Zmienna liczba świateł w shaderze
« dnia: Wrzesień 27, 2012, 23:50:35 »
Witam wszystkich.

Zająłem się przepisywaniem oświetlenia w moim silniku 3D na bardziej dynamiczne. Napisałem shader, który obsługiwał jedno światełko. Postanowiłem, że dodam obsługę wszystkich 8 świateł. I tu pojawia się problem nie do przeskoczenia. Wysyłam za pomocą uniforma ilość włączonych świateł. Jednak po dodaniu warunku i < lightsNum shadery nie chcą się zlinkować. Wartość jest na pewno dobrze wysyłana, bo sprawdziłem to kilkakrotnie. Jeśli ustawię ręcznie liczbę świateł to wszystko wykonuje się poprawnie. Nie wiem gdzie skopałem kod (a może nie skopałem?). Outputu linkowania prawie żadnego. Jedynie tylko to:

Fragment shader(s) linked,  vertex shader(s) failed to link.
Vertex Shader:

uniform int lightsNum;

varying vec4 finalcolor;

void main()
{
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_TexCoord[1] = gl_MultiTexCoord1;
gl_TexCoord[2] = gl_MultiTexCoord2;
gl_TexCoord[3] = gl_MultiTexCoord3;

vec4 diffuse, ambient, color;
vec3 normal, lightDir, halfVector, ecPos, aux;
float dist, NdotL, NdotHV, att;

normal = normalize(gl_NormalMatrix * gl_Normal);
ecPos = vec3(gl_ModelViewMatrix * gl_Vertex);

color = vec4(0.0);

for(int i = 0; i < lightsNum; i++)
{
aux = gl_LightSource[i].position.xyz - ecPos;
lightDir = normalize(aux);
dist = length(aux);

diffuse = gl_FrontMaterial.diffuse * gl_LightSource[i].diffuse;
ambient = gl_FrontMaterial.ambient * gl_LightSource[i].ambient;

NdotL = max(dot(normal, lightDir), 0.0);
if (NdotL > 0.0)
{
att = 1.0 / (gl_LightSource[i].constantAttenuation +
gl_LightSource[i].linearAttenuation * dist +
gl_LightSource[i].quadraticAttenuation * dist * dist);
color += att * (diffuse * NdotL + ambient);
}
}

finalcolor = color;

gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}

Wysyłanie uniforma:

int lightsNum = glGetUniformLocation(Shaders[0].program, "lightsNum");
glUniform1i(lightsNum, lights_num);

Ewentualnie zostaje jeszcze gl_MaxLights ale to za bardzo muli na mojej grafie, a nie chcę, żeby przy jednym świetle muliło jak przy ośmiu.

A najśmieszniejsze z tego wszystkiego jest to, że już nawet próbowałem kopiować samą pętle z shadera w silniku 2D, w którym takie "cuda" (jak ilość świateł wysyłana za pomocą uniforma) działają bez problemu.

Jeśli coś pominąłem co przyda się przy diagnozie to napiszcie.

Liczę na wielką mądrość warsztatu i czekam na odpowiedź, bo ja już wysiadam. :)

Pozdrawiam,
limonki.

14
Cytuj
Zresztą 100 świateł w forward renderingu i tak nie będziesz robił.

Max Uniform Vertex Components    1024
Powiem tak: czysta ciekawość odnośnie tego czy jest możliwość podniesienia tego limitu, ale wygląda na to, że jest ustalany odgórnie przez sterownik OpenGL.

Cytuj
@OP: Skoro możesz indeksować tylko 1 uniforma, to może po prostu połączysz wszystkie atrybuty światła w 1 uniforma, robiąc strukturę?

To też nie jest zły pomysł. Przyznam szczerze, że nigdy nie bawiłem się w struktury w shaderach. Widziałem zaledwie parę przykładów w których zastosowano takie rozwiązanie :). Zawsze jakoś wolałem wszystko rozbijać na kilka uniformów. Poszukam w necie jak się za takie coś zabrać, bo to zawsze jakieś dodatkowe doświadczenie :)

15
Ok, poczytam sobie trochę w wolnej chwili :), chociaż podejrzewam, że tę technikę wykorzystam dopiero w silniku 3D, który aktualnie przeżywa ciężki okres braku chęci do kodzenia.

Dziękuje wszystkim za pomoc ;).

Strony: [1] 2 3 4 5