Składnie kilku obrazow w GPU i policzenie średniej z tekstury

Ktoś może mi podpowiedzieć jak składać obrazy na GPU ( może być OpenGL albo DirectX)

Rysuje 3 prostokąty za pomocą tekstury
Dla uproszenia:

• tekstura ma 256x256 (rozmiar nie jest w sumie istotny)
• tekstura jest jednobarwna (dla uproszenia aby łatwiej było mi policzyć docelowy kolor docelowa mam tam zwykły obraz w odcieniach szarości )
  233,233,233 prostokąt1
  180,180,180 prostokąt2
  100,100,100 prostokąt3

Kształt prostokąta nie ma znaczenia !

Rysuje je jak na załączniku 002.png (kolejne prostokąty przysłaniają ten pod spodem )
**Kolejność prostokąt1 , prostokąt2 , prostokąt3 **

A chciałbym aby finalny obraz był średnia wszystkich trzech jak na rysunku 003.png

Czyli pojawiają sie nowe kolory które są średnia pierwotnych
206 (srednia 233 i 180)
166 (srednia 233 i 100)
140 (srednia 180 i 100)
171 (średnia 233 , 180 i 100 )

Nie mam zielonego pojęcia jaka technika to uzyskać.

Aby policzyć każdym piksel to w dymam miejscu musze znać sumę koloru oraz muszę wiedzieć ile warstw jest w tym miejscu.
Jakiś zator

No ale wiesz jakie będą prostokąty w danym miejscu, i wiesz jakie będą miały kolory. Więc co jest w tym trudnego teraz? Jeśli chcesz to liczyć na GPU to zbuduj sobie macierz dla każdego prostokąta o wymiarach ekranu i kolorach prostokąta w odpowiednich miejscach, od teraz to tylko dodawanie i dzielenie skalarne.

Chyba u mnie za mała wiedza w tematyce rysowania za pomocą GPU bo wiem jak narysować "coś" za pomocą tekstury ale nie wiem jak połączyć kilka obiektów
Bo mam wierzchołki z pozycja i mapowaniem tekstury dla trzech prostokątów
Ale nie wiem co dalej (nie uzyskałem progu wejścia).
**Myślę nad tym co napisałeś **

Zakładając, że masz kartezjański układ współrzędnych i prostokąty przechowujesz w postaci (P1, P2) gdzie P1 to lewy górny wierzchołek, a P2 to prawy dolny i oba są strukturami z polami x i y oznaczającymi odpowiednie współrzędne, to sprawdzenie, czy punkt leży wewnątrz danego prostokąta wygląda tak:

fn within_rectangle(rect: Rectangle, Point(x, y): Point) -> bool {
  (x < rect.p1.x && x > rect.p2.x) && (y < rect.p1.y && y > rect.p2.y)
}

Z tego masz proste obliczenia na kolor piksela. Zakładając, że masz funkcję przyjmującą współrzędne i listę prostokątów (gdzie struktura Rectangle ma pole color):

fn pixel_color(p: Point, rects: &[Rectangle]) -> Color {
  let mut color = Color::black();
  let mut count = 0;

  for rect in rects {
    if within_rectangle(p, rect) {
      color += rect.color;
      count += 1;
    }
  }

  color / count
}

Użyłem tutaj Rust-like syntax, ale chyba dasz radę zrozumieć ogólną zasadę. Teraz możesz to zapisać np. jako pixel shader.

Jeśli tekstura byłaby niejednolita to zasada jest identyczna tylko zamiast rect.color pobierasz kolor piksela dla danego prostokąta w pozycji x - rect.p1.x i y - rect.p1.y.