JLI Spieleprogrammierung Foren-Übersicht JLI Spieleprogrammierung

 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen 
 medals.php?sid=a014a55794aad498dcf37d80d4c651b8Medaillen   RegistrierenRegistrieren   ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

RGB-Farbwert einses Pixels
Gehe zu Seite 1, 2  Weiter
 
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Entwicklung
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 14.04.2003, 20:32    Titel: RGB-Farbwert einses Pixels Antworten mit Zitat

Wie bekommt man den RBG-Farbwert eines Pixels heraus???
Im Buch ist zwar eine Funktion beschrieben, mit der man den Farbwert herauskriegen kann, aber dann hat man nachher ne COLORREF-Variable.
Meine Frage is, wie man den jetzt in R, G und B zerlegt.
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Dietmar Ferstl
Mini JLI'ler



Anmeldedatum: 19.07.2002
Beiträge: 47
Wohnort: Regensburg/Bayern
Medaillen: Keine

BeitragVerfasst am: 16.04.2003, 07:02    Titel: Antworten mit Zitat

Hallo,

du musst wissen, in welchem Format (z.B. 555, 565 etc.) dein Pixel vorliegt, und dann die einzelnen Farbwerte herausmaskieren und auf jeweils 888 (RGB) hochshiften.

D.F.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Mr.X
Junior JLI'ler



Anmeldedatum: 15.04.2003
Beiträge: 88

Medaillen: Keine

BeitragVerfasst am: 16.04.2003, 07:39    Titel: Antworten mit Zitat

Hi

Wenn Du wirklich nur aus einer COLORREF-Variable die Farbanteile haben willst, dann shifte entsprechend der COLORREF-Farbanteile 0x00bbggrr Dir die einzelnen Bytes heraus:
Code:


COLORREF     Farbe;
BYTE         Blau;
BYTE         Gruen;
BYTE         Rot;

Farbe  = 0x00ffcc99;       //irgendein 32-Bit-Farbwert (COLORREF)

Blau    =  (BYTE)(Farbe >> 16);
Gruen   =  (BYTE)(Farbe >> 8);
Rot     =  (BYTE)Farbe;




mfG
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 16.04.2003, 18:05    Titel: Antworten mit Zitat

Idea Einfach umgekehrt, wie in der Farbeerrechnenfunktion im Buch?!
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 17.04.2003, 11:01    Titel: Antworten mit Zitat

Also irgendwie klappt das mit dem Umrechnen nich: Sad
Erstens werden die Farben falsch berechnet und zweitens wird das Surface irgendwie kleiner. Wenn ich alle Pixel eines Surfaces von x*y Pixeln in RGB umwandle, diese dann später wieder in COLORREF umwandle und in das Surface kopiere, ist alles viel kleiner dargestellt(Das Sprite wird ständig gezeichnet.)
Code:
int RGB_COLORREF(int r, int g, int b, LPDIRECTDRAWSURFACE7 lpDDSurface)
{
   int ShiftRed   = 0;
   int ShiftGreen = 0;
   int ShiftBlue  = 0;
   int PosRed     = 0;
   int PosGreen   = 0;
   int PosBlue    = 0;

    // Pixelformat bestimmen
    DDPIXELFORMAT ddpf;
    ddpf.dwSize = sizeof(ddpf);
    lpDDSurface->GetPixelFormat(&ddpf);

    // Werte für Rot bestimmen      
    while(0 == (ddpf.dwRBitMask & 1))   
    {      
       ddpf.dwRBitMask >>= 1;
       PosRed++;   
    }   
    ShiftRed = (ddpf.dwRBitMask == 31) ? 3 : 2;   

    // Werte für Grün bestimmen   
    while(0 == (ddpf.dwGBitMask & 1))   
    {      
       ddpf.dwGBitMask >>= 1;      
       PosGreen++;   
    }   
    ShiftGreen = (ddpf.dwGBitMask == 31) ? 3 : 2;   

    // Maske für blau beginnt immer bei 0
    PosBlue = 0;
    ShiftBlue = (ddpf.dwBBitMask == 31) ? 3 : 2;
    switch(Farbtiefe)
    {
        case 32:
        case 24:
                return ((r<<16) + (g<<8) + b);
        break;
           
        case 16:
           return ((( (r) >> ShiftRed)   << PosRed)   +
                   (( (g) >> ShiftGreen) << PosGreen) +    
                 (( (b) >> ShiftBlue)  << PosBlue));
         
        default:
                return 0;
    }
}

Code:
void COLORREF_RGB(COLORREF Farbe, LPDIRECTDRAWSURFACE7 lpDDSurface)
{
   int ShiftRed   = 0;
   int ShiftGreen = 0;
   int ShiftBlue  = 0;
   int PosRed     = 0;
   int PosGreen   = 0;
   int PosBlue    = 0;

    // Pixelformat bestimmen
    DDPIXELFORMAT ddpf;
    ddpf.dwSize = sizeof(ddpf);
    lpDDSurface->GetPixelFormat(&ddpf);

    // Werte für Rot bestimmen      
    while(0 == (ddpf.dwRBitMask & 1))   
    {      
       ddpf.dwRBitMask >>= 1;
       PosRed++;   
    }   
    ShiftRed = (ddpf.dwRBitMask == 31) ? 3 : 2;   

    // Werte für Grün bestimmen   
    while(0 == (ddpf.dwGBitMask & 1))   
    {      
       ddpf.dwGBitMask >>= 1;      
       PosGreen++;   
    }   
    ShiftGreen = (ddpf.dwGBitMask == 31) ? 3 : 2;   

    // Maske für blau beginnt immer bei 0
    PosBlue = 0;
    ShiftBlue = (ddpf.dwBBitMask == 31) ? 3 : 2;
    switch(Farbtiefe)
    {
        case 32:
        case 24:
                ROT= (BYTE)(Farbe >> 16);
            GRUEN= (BYTE)(Farbe >> 8);
            BLAU= (BYTE)(Farbe);
            return;
        break;
           
        case 16:
             ROT= (BYTE)((Farbe << ShiftRed) >> PosRed);
            GRUEN= (BYTE)((Farbe << ShiftGreen) >> PosGreen);
            BLAU= (BYTE)((Farbe << ShiftBlue) >> PosBlue);
      break;
   }
}

ROT, GRUEN und BLAU sind globale Variablen
Code:
void SetPixelSurface(int ss, int x, int y, COLORREF Farbe)
{
   DDSURFACEDESC2 SurfaceDesc;
    ZeroMemory(&SurfaceDesc,sizeof(SurfaceDesc));
    SurfaceDesc.dwSize = sizeof(SurfaceDesc);

   //Surface sperren
   DD.DDSpriteSurface[ss]->Lock(NULL,&SurfaceDesc,DDLOCK_WAIT,NULL);

   WORD* wlpSurface=(WORD*)SurfaceDesc.lpSurface;

   //Pitch aus Farbtiefe errechnen
   int Pitch=SurfaceDesc.lPitch;
   if(DD.Farbtiefe==32) Pitch/=4;
   else if(DD.Farbtiefe==24) Pitch/=3;
   else Pitch/=2;

   //Pixel mit Farbe überschreiben
   wlpSurface[y*Pitch+x]=Farbe;

   //Surface freigeben
   DD.DDSpriteSurface[ss]->Unlock(NULL);
}

ss ist der Index für das SpriteSurface

Seht ihr den Fehler???
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Christian Rousselle
Site Admin


Alter: 48
Anmeldedatum: 19.07.2002
Beiträge: 1630

Medaillen: Keine

BeitragVerfasst am: 17.04.2003, 11:41    Titel: Antworten mit Zitat

Du musst nicht nur unterscheiden, welche Farbtiefe es ist, sondern auch in Abhängigkeit davon einen BYTE*, WORD* oder DWORD* (hier ist auch wichtig, ob es 24 oder 32 Bit ist.

Christian
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 17.04.2003, 11:43    Titel: Antworten mit Zitat

Und wie unterscheidet man 32 und 24 Bit bei der Berechnung?
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 17.04.2003, 20:06    Titel: Antworten mit Zitat

Das Problem hat sich z.T gelöst. In 32-Bit Auflösung funktioniert es jetzt.
Ich habe vorhin etwas unaufmerksam gelesen Embarassed und bin durch probieren doch noch auf:
Code:
ROT= (BYTE)(Farbe);
GRUEN= (BYTE)(Farbe >> 8);
BLAU= (BYTE)(Farbe >> 16);

gekommen.
Aber postet doch bitte eine Antwort, falls ihr wisst, wie diese Berechnungen in der 16- und 24-Bit Auflösung gehen.
thx
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 12.05.2003, 11:49    Titel: Antworten mit Zitat

Bis jetzt ging es eigentlich ganz gut. Aber jetzt habe ich das Proggie in ein Windowsfenster gepackt und nun kann die 32-Bit-Farbtiefe nicht mehr eingestellt werden(warum auch immer Question ). Jetzt hab ich wieder das Problem, dass irgendwie nur das halbe Surface abgefragt wird.
Wisst ihr durch welchen Wert ich Pitch teilen muss??
Also im Buch stand was davon, dass bei 24-Bit eine WORD-Variable genommen werden muss und Pitch durch 2(?) geteilt werden muss.
Aber ich hab kA, wie die Werte bei den anderen Farbtiefen aussehen.
Außerdem stellt sich mir die Frage, ob das auch reibungslos funzt, wenn ich RGB-Werte bei z.B. 24-Bit-Farbtiefe in eine Datei speicher und dann in einer 16-Bit-Farbtiefe wieder auslese.
Bitte helft mir; es ist wichtig!!!
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 13.05.2003, 20:27    Titel: Antworten mit Zitat

Ich glaube, das hängt mit der Funktion zusammen, die einen Pixelfarbwert aus dem Surface ermittelt. Wenn ich dort die Werte, durch die Pitch geteilt wird, verändere, dann sieht man immer verschiedene Teile. Mal sieht man nur die obere Hälfte, mal sieht man nur die linke Hälfte und manchmal auch nur ein viertel des ganzen Bildes.
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Ciceri
Super JLI'ler


Alter: 37
Anmeldedatum: 26.08.2002
Beiträge: 418
Wohnort: Wischhafen/in der nähe Hamburgs
Medaillen: Keine

BeitragVerfasst am: 14.05.2003, 12:42    Titel: Antworten mit Zitat

@The Lord of Programming: 4mal hintereinander posten. was fällt mir da ein...spam
ist so unübersichtlicher
_________________
www.z-software.de
Spieleentwicklung-Pur
Besuchen Sie uns.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 14.05.2003, 13:08    Titel: Antworten mit Zitat

Ohh sry Embarassed
Aber dein Post hilft auch nicht gerade der Übersichtlichkeit Wink
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Ciceri
Super JLI'ler


Alter: 37
Anmeldedatum: 26.08.2002
Beiträge: 418
Wohnort: Wischhafen/in der nähe Hamburgs
Medaillen: Keine

BeitragVerfasst am: 14.05.2003, 18:17    Titel: Antworten mit Zitat

The Lord of Programming hat Folgendes geschrieben:
Ohh sry Embarassed
Aber dein Post hilft auch nicht gerade der Übersichtlichkeit Wink

ich weiß Wink
_________________
www.z-software.de
Spieleentwicklung-Pur
Besuchen Sie uns.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 14.05.2003, 20:21    Titel: Antworten mit Zitat

So, ich poste jetzt mal den relevanten Quellcode(ich glaube, in dem liegt der Fehler)
Code:
void LockSurface(int ss)
{
    ZeroMemory(&surfaceofGrafic,sizeof(surfaceofGrafic));
    surfaceofGrafic.dwSize = sizeof(surfaceofGrafic);
    DD.DDSpriteSurface[ss]->Lock(NULL,&surfaceofGrafic,DDLOCK_WAIT,NULL);
}

void UnlockSurface(int ss)
{
   DD.DDSpriteSurface[ss]->Unlock(NULL);
}

COLORREF GetPixelSurface(int ss, int x, int y)
{
   COLORREF farbe;

   LockSurface(ss);
   int Pitch=surfaceofGrafic.lPitch;

   if(DD.Farbtiefe==32)
   {
      DWORD* wlpSurface=(DWORD*)surfaceofGrafic.lpSurface;

      //Pitch aus Farbtiefe errechnen
      
      Pitch/=4;
      //Pixel mit Farbe überschreiben
      farbe=(COLORREF)wlpSurface[y*Pitch+x];
   }
   else if(DD.Farbtiefe==24)
   {
      WORD* wlpSurface=(WORD*)surfaceofGrafic.lpSurface;

      //Pitch aus Farbtiefe errechnen
      Pitch/=2;
      //Pixel mit Farbe überschreiben
      farbe=(COLORREF)wlpSurface[y*Pitch+x];
   }
   else if(DD.Farbtiefe==16)
   {
      BYTE* wlpSurface=(BYTE*)surfaceofGrafic.lpSurface;

      //Pitch aus Farbtiefe errechnen
      Pitch/=1;
      //Pixel mit Farbe überschreiben
      farbe=(COLORREF)wlpSurface[y*Pitch+x];
   }
   UnlockSurface(ss);

   return farbe;
}

void SetPixelSurface(int ss, int x, int y, COLORREF Farbe)
{
   LockSurface(ss);
   int Pitch=surfaceofGrafic.lPitch;

   if(DD.Farbtiefe==32)
   {
      DWORD* wlpSurface=(DWORD*)surfaceofGrafic.lpSurface;

      //Pitch aus Farbtiefe errechnen
      Pitch/=4;
      //Pixel mit Farbe überschreiben
      wlpSurface[y*Pitch+x]=Farbe;
   }
   else if(DD.Farbtiefe==24)
   {
      WORD* wlpSurface=(WORD*)surfaceofGrafic.lpSurface;

      //Pitch aus Farbtiefe errechnen
      Pitch/=2;
      //Pixel mit Farbe überschreiben
      wlpSurface[y*Pitch+x]=Farbe;
   }
   else if(DD.Farbtiefe==16)
   {
      BYTE* wlpSurface=(BYTE*)surfaceofGrafic.lpSurface;

      //Pitch aus Farbtiefe errechnen
      Pitch/=1;
      //Pixel mit Farbe überschreiben
      wlpSurface[y*Pitch+x]=Farbe;
   }
   UnlockSurface(ss);
}

Findet ihr hier irgendeinen Fehler???
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Jörg
JLI MVP
JLI MVP



Anmeldedatum: 19.07.2002
Beiträge: 182
Wohnort: Siegen/NRW
Medaillen: Keine

BeitragVerfasst am: 14.05.2003, 21:31    Titel: Antworten mit Zitat

Also ganz spontan würde ich sagen, du musst bei 24bit durch 3 teilen und bei 16bit durch 2 (weil 24bit=3byte und 16bit=2byte). Bei 24bit würde ich das dann so machen (ich nehme hier BYTE, weil ich keine Lust habe, mir eine drei Byte große Struktur anzulegen):
Code:
   else if(DD.Farbtiefe==24)
   {
      BYTE* wlpSurface=(BYTE*)surfaceofGrafic.lpSurface;

      //Pitch aus Farbtiefe errechnen
      //Pitch/=3; <-- auskommentiert
      //Pixel mit Farbe überschreiben
      farbe=(COLORREF)wlpSurface[y*Pitch+x*3]; // <-- hier x mal drei
   }

Bei 16bit kannst du dann WORD nehmen, oder wie hier BYTE mit 2 multiplizieren.

Noch ein Grund, warum es nicht funktioniert, könnte sein, dass in COLORREF die Farben so angelegt sind: 0x00bbggrr, also nicht in der Reihenfolge RGB.
Außerdem müsstest du bei 16bit dann noch ein bischen hin und her shiften, da dort die Farbwerte ja jeweils weniger als ein Byte zur verfügung haben, aber kuck dir das am besten mal im Buch an (ab S.302).
_________________
www.messiahzone.de.vu
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Entwicklung Alle Zeiten sind GMT
Gehe zu Seite 1, 2  Weiter
Seite 1 von 2

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de

Impressum