Autore Topic: [C] Morphos Opengl  (Letto 3048 volte)

Offline raistlin77it

  • Tech Guru
  • *****
  • Post: 221
  • Karma: +2/-0
    • Mostra profilo
[C] Morphos Opengl
« il: 18 Giugno 2011, 12:43:30 »
Ciao a tutti.
Vi sottopongo un problemino che non riesco a risolvere, sotto MorphOS.

Stò realizzando un "homebrew"  che utilizza le SDL/GL.
Visto che lo programmo su pc per comodità ed ho già una beta funzionante, mi sono deciso a compilarlo anche per MorphOS, giusto per vedere se il tutto funziona anche lì (prima di finire il gioco e poi debuggare 3000000 di righe), ed ho trovato un piccolo problema, non riesco a selezionare correttamente gli oggetti in 3d, cosa che su pc funziona benissimo.

Per selezionare gli oggetti io uso il metodo del color picking, quindi tramite la funzione glReadPixels.

All'inizio pensavo fosse un problema di endianness tra pc e mini, ma anche swappando i vari byte, non riesco a selezionare correttamente gli oggetti.


Per farla breve ho creato un listato apposta che basta compilare su Mos per verificare :

--------------------------------------------------------------
Codice: [Seleziona]
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <GL/gl.h>
#include "SDL/SDL.h"
#include "SDL/SDL_opengl.h"


#define RENDER 1 // No ray-plane intersection (i haven't studied the vectors properly )
#define SELECT 2 // So old-good color selection

#define MORPHOS 1

#define SWITCH_INT(a) { char s_i, *p_i;p_i= (char *)&(a);s_i=p_i[0]; p_i[0]=p_i[3]; p_i[3]=s_i;s_i=p_i[1]; p_i[1]=p_i[2]; p_i[2]=s_i; }

int mode = RENDER;

int FRAMES_PER_SECOND = 50; //The frames per second const
int frame = 0; //Keep track of the current frame
int startTicks = 0;
int currentTicks=0;

int SCREENW=800;
int SCREENH=600;

int EDITORMODE=0;       // old stuff from the editor 0=Add,1=Paint,2=Del,3=load,4=save,5=new,6=texture
int OLDEDITORMODE=0;    //
int GRID=0;             //




int mousex,mousey;

unsigned int nIndex;




void DrawSelection() {

    glDisable(GL_LIGHTING);
    glDisable( GL_TEXTURE_2D );
    nIndex=10000;
   
    glColor3ub ( nIndex % 256, (nIndex>>8) % 256, (nIndex>>16) % 256);
    glBegin(GL_QUADS);
        glVertex3f( -0.5f,  -0.5f,   +0.5f);
        glVertex3f( +0.5f,  -0.5f,   +0.5f);
        glVertex3f( +0.5f,  +0.5f,   +0.5f);
        glVertex3f( -0.5f,  +0.5f,   +0.5f);
    glEnd();

}



void mouseMove (int x, int y) {
   
  static int x_pos = 0;
  static int y_pos = 0;

  x_pos = x;
  y_pos = y;

}

void ProcessPick() {



    unsigned int col;
    GLint viewport[4];

    glGetIntegerv(GL_VIEWPORT,viewport);
   


    glReadPixels( mousex, viewport[3]-mousey, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, &col);
    SWITCH_INT(col);

   
    printf(" color number %un",nIndex);
    printf(" color founded %un",col);

    printf(" color put %u ,%u ,%un",nIndex%256,(nIndex>>8) % 256, (nIndex>>16) % 256);  
    printf(" color get %u ,%u ,%un",col%256,(col>>8) % 256, (col>>16) % 256);  
 
}






int main(int argc, char *argv[]) {  

   
    SDL_Surface *screen;    


    int done;
   
    SDL_Event event;
    Uint8* keystates;

    // Slightly different SDL initialization
    if ( SDL_Init(SDL_INIT_VIDEO| SDL_INIT_AUDIO) != 0 ) {
        printf("Unable to initialize SDL: %sn", SDL_GetError());
        return 1;
    }

    SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new*

    screen = SDL_SetVideoMode( SCREENW, SCREENH, 32, SDL_OPENGL /*| SDL_FULLSCREEN*/); // *changed*
    if ( !screen ) {
printf("Unable to set video mode: %sn", SDL_GetError());
return 1;
}


    glViewport( 0, 0, SCREENW, SCREENH );
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(60.0, 1.0 * SCREENW/SCREENH, 0.1, 400.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

   
    glEnable (GL_DEPTH_TEST);

    glEnable (GL_COLOR_MATERIAL);




    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);


    gluLookAt(0,0,18,0.0,0.0,0.0,0.0,1.0,0.0);

    done=0;


    glClearColor( 0, 0, 0, 0);    

   

    while(!done){
   
       
       
    startTicks=SDL_GetTicks();
 

    // Clear the screen before drawing
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);



        while(SDL_PollEvent(&event)) {
       
                     
            switch (event.type) {
 
                case SDL_MOUSEMOTION:
            mouseMove (event.button.x, event.button.y);
             mousex=event.button.x;
                  mousey=event.button.y;
                break;
                     
                case SDL_KEYDOWN:
             if (event.key.keysym.sym == SDLK_ESCAPE) done=1;
                break;
           
                case SDL_MOUSEBUTTONDOWN :
                    if (SDL_GetMouseState (NULL,NULL) & SDL_BUTTON_LMASK) {
                        mousex=event.button.x;
                        mousey=event.button.y;
                        mode = SELECT;
                }                
                break;
       
                default:
                break;
      }
        }
       

        if (mode == SELECT) DrawSelection(); else DrawSelection();

    if (mode == SELECT) {
    ProcessPick();
    mode = RENDER;
    } else     SDL_GL_SwapBuffers();
   



               
    if( currentTicks < 1000 / FRAMES_PER_SECOND  ) SDL_Delay( ( 1000 / FRAMES_PER_SECOND ) - currentTicks );
   
    }
   
    SDL_Quit();
   
return 0;
}
------------------------------------------------

succede che per ogni componente R,G,B, che ottengo su morphos, manca sempre un'unità al valore trovato ad esempio se metto R=232,G=3,B=0, ottengo R=231,B=2,G=0; e quindi ho una selezione sbagliata.
Ho postato il listato anche su mzone, ma per ora nessuno mi ha detto nulla.
Non è che ci potete buttare un'occhio e vedere dove c'è l'errore?
Ripeto su pc tolta la funzione di swap dei byte funziona a meraviglia.
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline TheKaneB

  • Human Debugger
  • *****
  • Post: 5292
  • Karma: +20/-23
    • Mostra profilo
    • http://www.antoniobarba.org
Re: [C] Morphos Opengl
« Risposta #1 il: 18 Giugno 2011, 14:35:59 »
Non l'ho debuggato perchè non ne ho il tempo, ma dando un'occhiata veloce al codice ed alla tua descrizione posso sicuramente notare un difetto di approccio da non trascurare.

In sostanza vuoi effettuare il picking di un oggetto usando il colore che questo mostrerà in fase di rendering (in viewport space), mentre tu conosci solo il colore "originale" (cioè nell'object space).

vedo che hai usato questa orribile tecnica http://www.codeguru.com/Cpp/G-M/opengl/ ... .php/c5579
in giro esistono altre guide ancora più oscene, che sfruttano il GL_SELECT. Beh, lasciamo stare... :-)

E' chiaro come il sole che la tecnica può funzionare solo se tutta la trafila utilizza un numero di bit sufficiente a non perdere informazioni per strada. In particolare, non è detto che internamente i colori siano sempre RGB24, ma possono anche scendere a RGB16 o RGB15 in base a vari meccanismi interni. Anche se tutta la trafila fosse comunque perfettamente calibrata come numero di bit per canale, potresti sempre avere a che fare con dei calcoli che introducono errori ed approssimazioni (in questo caso introduce un bias verso il nero).

Piuttosto che stare ad impazzire dietro alle conversioni di colore del driver GL di MorphOS (che magari potrebbe cambiare da versione a versione), devi implementare il picking in modo corretto. Come si fa? Con la proiezione inversa dallo schermo verso il World Space.

- Prendi un pixel sulla viewport
- lo moltiplichi per l'inversa della matrice di proiezione sul near plane e sul far clipping plane (trovandoti così 2 punti perpendicolari allo schermo)
- prendi il vettore che unisce questi due punti ed effettua un test ray-box intersection per ciascun oggetto della scena (proiettando ogni volta il vettore di interezione per l'inversa della modelview di ogni oggetto)
- prendi tutti gli oggetti così intersecati e ordinali in base alla distanza dal near plane
[ passaggi opzionali se vuoi fare il picking con precisione al poligono ]
- partendo dall'oggetto più vicino, moltiplica il vettore di prima per l'inversa della matrice di modelview di quell'oggetto, e ti ritrovi nell'object space.
- effettua un test Ray-Triangle su ciascun triangolo (aiutati con un quadtree o, meglio ancora, con un modello scheletale se i tuoi modelli sono troppo carichi di poligoni)
- se becchi almeno un triangolo hai trovato l'oggetto corretto.


link utili (presi più o meno a casaccio da Google)
http://www.mt-wudan.com/wu_tut.php?t=gl_mouseray
http://www.euclideanspace.com/threed/re ... /index.htm
http://www.euclideanspace.com/maths/alg ... /index.htm
http://eigenclass.blogspot.com/2008/10/ ... ngbox.html

Enjoy!
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline raistlin77it

  • Tech Guru
  • *****
  • Post: 221
  • Karma: +2/-0
    • Mostra profilo
Re: [C] Morphos Opengl
« Risposta #2 il: 18 Giugno 2011, 14:55:17 »
Citazione da: "TheKaneB"
Non l'ho debuggato perchè non ne ho il tempo, ma dando un'occhiata veloce al codice ed alla tua descrizione posso sicuramente notare un difetto di approccio da non trascurare.

In sostanza vuoi effettuare il picking di un oggetto usando il colore che questo mostrerà in fase di rendering (in viewport space), mentre tu conosci solo il colore "originale" (cioè nell'object space).

certo, però se fai le cose fatte bene il colore originale lo conservi :D

Citazione da: "TheKaneB"
vedo che hai usato questa orribile tecnica http://www.codeguru.com/Cpp/G-M/opengl/ ... .php/c5579
in giro esistono altre guide ancora più oscene, che sfruttano il GL_SELECT. Beh, lasciamo stare... :-)
non ho usato lo stack di nomi perchè con le nuove opengl è deprecato , questo metodo funziona sempre e mi permette di non studiare le matrici (io programmo per hobby nelle ore di "sonno")

Citazione da: "TheKaneB"
E' chiaro come il sole che la tecnica può funzionare solo se tutta la trafila utilizza un numero di bit sufficiente a non perdere informazioni per strada. In particolare, non è detto che internamente i colori siano sempre RGB24, ma possono anche scendere a RGB16 o RGB15 in base a vari meccanismi interni. Anche se tutta la trafila fosse comunque perfettamente calibrata come numero di bit per canale, potresti sempre avere a che fare con dei calcoli che introducono errori ed approssimazioni (in questo caso introduce un bias verso il nero).
ecco a questo non ci avevo pensato, mi sa che i driver per essere performanti  usano qualche truchetto sporco :(

Citazione da: "TheKaneB"
Piuttosto che stare ad impazzire dietro alle conversioni di colore del driver GL di MorphOS (che magari potrebbe cambiare da versione a versione), devi implementare il picking in modo corretto. Come si fa? Con la proiezione inversa dallo schermo verso il World Space.

- Prendi un pixel sulla viewport
- lo moltiplichi per l'inversa della matrice di proiezione sul near plane e sul far clipping plane (trovandoti così 2 punti perpendicolari allo schermo)
- prendi il vettore che unisce questi due punti ed effettua un test ray-box intersection per ciascun oggetto della scena (proiettando ogni volta il vettore di interezione per l'inversa della modelview di ogni oggetto)
- prendi tutti gli oggetti così intersecati e ordinali in base alla distanza dal near plane
[ passaggi opzionali se vuoi fare il picking con precisione al poligono ]
- partendo dall'oggetto più vicino, moltiplica il vettore di prima per l'inversa della matrice di modelview di quell'oggetto, e ti ritrovi nell'object space.
- effettua un test Ray-Triangle su ciascun triangolo (aiutati con un quadtree o, meglio ancora, con un modello scheletale se i tuoi modelli sono troppo carichi di poligoni)
- se becchi almeno un triangolo hai trovato l'oggetto corretto.
certo disegnando 2 volte la scena ho  il doppio di lavoro, ma sono al massimo 8000 tris al frame
Citazione da: "TheKaneB"
link utili (presi più o meno a casaccio da Google)
http://www.mt-wudan.com/wu_tut.php?t=gl_mouseray
http://www.euclideanspace.com/threed/re ... /index.htm
http://www.euclideanspace.com/maths/alg ... /index.htm
http://eigenclass.blogspot.com/2008/10/ ... ngbox.html

Enjoy!
Eh lo so, però non ho proprio voglia di studiarmi i vettori e le matrici, poi insomma, ho 5000 linee di "sudatissimo" codice, non voglio riscrivero :( :(

UFF :( :(
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline TheKaneB

  • Human Debugger
  • *****
  • Post: 5292
  • Karma: +20/-23
    • Mostra profilo
    • http://www.antoniobarba.org
Re: [C] Morphos Opengl
« Risposta #3 il: 18 Giugno 2011, 15:08:25 »
eh ti capisco ma questa è la minestra, o la mangi o ti butti dalla finestra  :lol:

Fare grafica 3D senza conoscere la geometria analitica è possibile solo se ti affidi a dei sistemi estremamente semplificati e automatizzati, del tipo "clicca un pupino e trascinalo nel posto giusto".
Anche usando un engine già pronto (UDK, Ogre, Irrlicht, ecc...) avrai SEMPRE bisogno di almeno un pochino di geometria, altrimenti ogni volta che vedi una matrice sarai costretto a copia-incollare codice a casaccio preso da internet senza comprenderne il significato, e così ad libitum finchè non trovi per caso un codice che funziona (cosa estremamente improbabile, perchè la matematica si fa con le formule ed i teoremi, non copiando gli esercizi :-) ).

Comunque, questa è l'unica tecnica seria ed efficiente. Tutte le altre sono perfettamente inutili, perchè quello che risparmi in geometria lo perdi in capelli.

Ad esempio, se vuoi modificare il tuo codice per funzionare nonostante il bias cromatico, dovresti crearti i vettori RGB del colore target e di quello "pickato" dalla viewport, fare la differenza e sommare i quadrati delle componenti R,G,B del vettore differenza. Ottieni la cosiddetta "distanza quadrata" tra i due vettori (è quasi come la distanza, ma risparmi una radice quadrata). Se la distanza quadrata è minore o uguale ad una certa soglia, allora i due vettori sono abbastanza vicini tra loro (i due colori sono quasi uguali).

Puoi usare questo accrocchio per rendere funzionante il tuo codice, ma non dire in giro che sono stato io a consigliartelo, ho una reputazione di game developer da difendere  :lol:
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline Z80Fan

  • Administrator
  • Guru
  • *****
  • Post: 1669
  • Karma: +13/-2
    • Mostra profilo
    • http://z80fan.altervista.org
Re: [C] Morphos Opengl
« Risposta #4 il: 18 Giugno 2011, 15:31:00 »
Aspetta, forse c'è una soluzione più semplice, in base al tipo di lavoro che deve fare:
ad esempio, sto scrivendo una specie di clone di Minecraft, e dato che il mondo è formato da cubi regolari, partendo dalla posizione del giocatore e dalla direzione in cui guarda, posso (con qualche algoritmo di rasterizzazione) trovare facilmente tutti i cubi presenti sulla linea dello sguardo.

Bisognerebbe conoscere più in dettaglio lo scopo del programma, per trovare eventuali semplificazioni.
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline TheKaneB

  • Human Debugger
  • *****
  • Post: 5292
  • Karma: +20/-23
    • Mostra profilo
    • http://www.antoniobarba.org
Re: [C] Morphos Opengl
« Risposta #5 il: 18 Giugno 2011, 16:01:30 »
Citazione da: "Z80Fan"
Aspetta, forse c'è una soluzione più semplice, in base al tipo di lavoro che deve fare:
ad esempio, sto scrivendo una specie di clone di Minecraft, e dato che il mondo è formato da cubi regolari, partendo dalla posizione del giocatore e dalla direzione in cui guarda, posso (con qualche algoritmo di rasterizzazione) trovare facilmente tutti i cubi presenti sulla linea dello sguardo.

Bisognerebbe conoscere più in dettaglio lo scopo del programma, per trovare eventuali semplificazioni.

EDIT: avevo scritto una boiata perchè non avevo capito subito il tuo esempio... comunque, ecco la mia risposta corretta:

Nel tuo caso il picking è fatto all'interno del World Space, e il gioco segue una geometria semplice basata su una matrice bidimensionale. Nel tuo caso quindi si rimane a livello di Model.
Qui si parla invece di prendere una scena 3D assolutamente generica e trovare quell'oggetto che sta sotto il pixel desiderato. In questo caso bisogna risalire al model partendo dalla view. Sono problemi del tutto differenti. ;)
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline raistlin77it

  • Tech Guru
  • *****
  • Post: 221
  • Karma: +2/-0
    • Mostra profilo
Re: [C] Morphos Opengl
« Risposta #6 il: 18 Giugno 2011, 16:50:17 »
Citazione da: "Z80Fan"
Bisognerebbe conoscere più in dettaglio lo scopo del programma, per trovare eventuali semplificazioni.

il gioco in questione è un clone di picross 3d
col mio "newbe method" comunque ho già creato un editor di puzzle ed una beta del giochillo.  :D  :D
Mi piacerebbe riuscire a farlo funzionare su mos, visto che lo rilascerei free proprio lì.
http://http://imageshack.us/photo/my-images/189/voxelpuzzle.png/

/newbe mode on
ora vedo se con qualche "workaround" tipo aggiungere un uno ai componenti r,g,b,>0 si risolve senza perdeere ulteriori capelli :P  :P
/newbe mode off
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline TheKaneB

  • Human Debugger
  • *****
  • Post: 5292
  • Karma: +20/-23
    • Mostra profilo
    • http://www.antoniobarba.org
Re: [C] Morphos Opengl
« Risposta #7 il: 18 Giugno 2011, 18:39:26 »
al limite usa il metodo della distanza quadrata nello spazio RGB, come ho spiegato prima...
butto giù un pezzo di codice senza testarlo, giusto per farti capire il metodo...
Codice: [Seleziona]
class RgbVector //
{
public:
RgbVector(int r, int g, int b);

int lenght2() const; // lunghezza quadrata
RgbVector operator-(const RgbVector& a, const RgbVector& b); // operatore per la differenza

int mR, mG, mB; // i 3 canali, pubblici per semplicita'
}

RgbVector::RgbVector(int r, int g, int b)
{
mR = r;
mG = g;
mB = b;
}

int RgbVector::length2() const
{
return mR*mR + mG*mG + mB*mB;
}

RgbVector RgbVector::operator-(const RgbVector& a, const RgbVector& b)
{
return RgbVector(a.mR - b.mR, a.mG - b.mG, a.mB - b.mB);
}

Applicandolo al tuo codice diventerebbe così più o meno:
Codice: [Seleziona]
// Esempio, usando le variabili prese dal tuo codice
RgbVector coloreRiferimento(nIndex%256,(nIndex>>8) % 256, (nIndex>>16) % 256);
RgbVector colorePixel(col%256, (col>>8) % 256, (col>>16) % 256)

RgbVector differenza = coloreRiferimento - colorePixel;
int tolleranza = 12; // sarebbe (2*2)+(2*2)+(2*2) quindi max 2 livelli di differenza per canale
if (differenza.length2() <= tolleranza)
{
// Ok, il colore e' simile abbastanza
}
else
{
// Non ci siamo, il colore e' completamente diverso
}

Un paio di note importanti:
1. Ho usato il C++ nel mio esempio e dovresti farlo anche tu, se non vuoi perdere il doppio del tempo e fare il triplo della fatica
2. NON DEVI ASSOLUTAMENTE accroccare il codice mettendo +1 manualmente. Se, per caso, nella prossima versione di MOS dovessero aggiustare il problema a livello di OpenGL, il tuo programma non funzionerebbe più. Invece implementa questo metodo che è cross platform e tiene in considerazione un certo livello di tolleranza nel confronto tra i colori (tolleranza espressa come distanza massima nello spazio colore RGB).

Ciao!
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline divina

  • Synthetic Voodoo
  • *****
  • Post: 2051
  • Karma: +1/-7
    • Mostra profilo
Re: [C] Morphos Opengl
« Risposta #8 il: 18 Giugno 2011, 21:23:33 »
thread molto interessante :)
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »
MorphOS 3.9-PowerMac G5 && PowerMac G4 FW800 && PowerBook G4 && Pegasos2 G4 //AmigaOS4.x //IcAROS x86 //- A4k 060- MacIntel/powerpc - x86/x64/powerpc servers -

Offline Z80Fan

  • Administrator
  • Guru
  • *****
  • Post: 1669
  • Karma: +13/-2
    • Mostra profilo
    • http://z80fan.altervista.org
Re: [C] Morphos Opengl
« Risposta #9 il: 19 Giugno 2011, 00:11:16 »
Citazione da: "TheKaneB"
EDIT: avevo scritto una boiata perchè non avevo capito subito il tuo esempio... comunque, ecco la mia risposta corretta:
Tranquillo, anche io scrivendo questa risposta stavo per sparare una cazzata assoluta :lol:
Citazione
Nel tuo caso il picking è fatto all'interno del World Space, e il gioco segue una geometria semplice basata su una matrice bidimensionale. Nel tuo caso quindi si rimane a livello di Model.
Qui si parla invece di prendere una scena 3D assolutamente generica e trovare quell'oggetto che sta sotto il pixel desiderato. In questo caso bisogna risalire al model partendo dalla view. Sono problemi del tutto differenti. ;)
Si, ora che ho riflettuto bene la differenza è sostanziale...

Non mi viene in mente altro, mi sa che le uniche soluzioni sono quelle. :(
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline raistlin77it

  • Tech Guru
  • *****
  • Post: 221
  • Karma: +2/-0
    • Mostra profilo
Re: [C] Morphos Opengl
« Risposta #10 il: 19 Giugno 2011, 14:51:40 »
vi ringrazio dell'aiuto, vedrò di sistemare un po' il mio programma allora.

cmq c'è qualcosa che non mi quadra lo stesso,possibile che ci sia un bug così grossolano nelle tinygl ? stamane ho fatto un'altro test con un programmino che cicla tutti i valori di r,g,b e mi manca sempre un'unità al conteggio esatto.
Solo che  se ho ad esempio 220,0,0 al posto di 221,0,0 è una cosa, ma se ho 1,1,30 ottengo 0,0,30 quindi si incasina tutto :P :P
Oggi provo a spulciare i sorgenti di blender che usa comunque la funzione glReadPixels e verò un po' :D
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline raistlin77it

  • Tech Guru
  • *****
  • Post: 221
  • Karma: +2/-0
    • Mostra profilo
Re: [C] Morphos Opengl
« Risposta #11 il: 20 Giugno 2011, 16:00:53 »
smadonnando un po' mi sono accorto che tramite le varie
        glGetIntegerv(GL_RED_BITS, &rr);
   glGetIntegerv(GL_GREEN_BITS, &gg);
   glGetIntegerv(GL_BLUE_BITS, &bb);

anche aprendo uno schermo a 24 bit ottengo sempre un buffer di 16 bit e + precisamente R da 5,G da 6 e B da 5

per quello probabilmente non ho i valori rgb corretti, perchè usa una risoluzione di colore a caxxo :D :D
verdò se riesco a trovare qualcuno stanotte in chat e se si può aggirare il problema o forzare almeno 24 bit veri
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline TheKaneB

  • Human Debugger
  • *****
  • Post: 5292
  • Karma: +20/-23
    • Mostra profilo
    • http://www.antoniobarba.org
Re: [C] Morphos Opengl
« Risposta #12 il: 20 Giugno 2011, 16:07:02 »
non ti intestardire su quello... implementa invece la classe RgbVector che ti ho abbozzato e usa la distanza tra due vettori RGB come metro di paragone per stabilire se due colori sono simili abbastanza, fidati ;-)
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline raistlin77it

  • Tech Guru
  • *****
  • Post: 221
  • Karma: +2/-0
    • Mostra profilo
Re: [C] Morphos Opengl
« Risposta #13 il: 20 Giugno 2011, 17:27:19 »
fatto , implementato la classe rgb ma in c, perchè solo quello so (da autodidatta per giunta)

per ora funziona bene con la tua soluzione. Ora devo riadattare tutti i calcoli dei poligoni,perchè il numero del colore che trovavo mi indicava il poligono scelto :P
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Offline raistlin77it

  • Tech Guru
  • *****
  • Post: 221
  • Karma: +2/-0
    • Mostra profilo
Re: [C] Morphos Opengl
« Risposta #14 il: 25 Giugno 2011, 12:51:18 »
Aggiornamento : da quello che mi ha deto youmguy su mzone, pare che ci sia un bug nella funzione glColor3ub()

Dice che è meglio usare la glColor3f() , a mè cmq non va lo stesso :P

Aspetto di avere risposta anche da kiero che ho trovato 3 giorni fa su irc.

Nel frattempo ho sistemato il mio codice con le aggiunte di thekaneb, ma non è purtroppo pratica come soluzione, visto che devo "campionare" i  colori ogni click ed anche con una tolleranza di 3 ovvero 1 per canale, ( e facendo poi la conversione in numero intero) mi rimangono fuori un sacco di numeri.

Sono giunto quindi alla conclusione di farmi una lista di colori da utilizzare e schiaffarla in un'array.

quando trovo il colore giusto, leggo l'indice dell'array e sono apposto :P

Se sistemano le opengl, basta cambiare un flag da riga di comando , ed utilizzo la soluzione classica senza array.

Per ora funziona tutto a dovere, se trovo ancora problemi aprirò un thread aposta con le differenze/bug tra le opengl classiche e quelle MorphOS.
« Ultima modifica: 01 Gennaio 1970, 02:00:00 da Guest »

Tags: