Partage
  • Partager sur Facebook
  • Partager sur Twitter

Début moteur2D problème...

Pour gestion transparence.

castorus
8 juillet 2007 à 1:24:57

Bien le bonjour à toutes et tous.
Je suis actuellement sur la création d'un petit moteur 2D générique exploitant openGL et SDL ainsi que la bibliothèque SDL_Image.

Ce moteur a pour but de faciliter le développement de jeux bidimentionels.

Pour le moment, j'en suis juste à la gestion des graphismes, mais malheureusement, j'ai un problème.

le principe est simple pour la gestion du graphisme, vous avez 4 classes principales.

-Screen
-Object
-Tile
-Sprite

Screen est une classe gérant la fenêtre SDL.
Object est une classe regroupant tout les objets graphiques à afficher dans la fenetre via openGL.
Tile est une classe fille de Object et permet de gérer efficacement les Tiles.
Sprite est une classe fille de Object et permet de gérer efficacement les Sprites.

La classe Object contient une liste chainée statique qui permet d'accèder à toutes les instances de la classe Object qui ont étées crées.

Grâce à cette liste chainée, la classe Screen qui est ami de la classe Object, et réciproquement.
Une méthode de la classe Screen permet d'afficher toutes les instances de la classe Object crées (donc les tiles, sprites.)

Par contre, la ou j'ai un soucis, je n'arrive pas à pousser openGL à gerer la transparence, en premier lieu je voulais rendre transparent le font de certaines textures, à la manière de SDL_SetColorKey()

Voici le code, en espérant que vous pourrez m'aider...

Moteur2D.cpp
#include "Moteur2D.h"




#ifndef MOTEUR2D_CPP
#define MOTEUR2D_CPP
SDL_Surface * flipSurface(SDL_Surface * surface)
{
    int current_line,pitch;
    SDL_Surface * fliped_surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                   surface->w,surface->h,
                                   surface->format->BitsPerPixel,
                                   surface->format->Rmask,
                                   surface->format->Gmask,
                                   surface->format->Bmask,
                                   surface->format->Amask);



    SDL_LockSurface(surface);
    SDL_LockSurface(fliped_surface);

    pitch = surface->pitch;
    for (current_line = 0; current_line < surface->h; current_line ++)
    {
        memcpy(&((unsigned char* )fliped_surface->pixels)[current_line*pitch],
               &((unsigned char* )surface->pixels)[(surface->h - 1  -
                                                    current_line)*pitch],
               pitch);
    }

    SDL_UnlockSurface(fliped_surface);
    SDL_UnlockSurface(surface);
    return fliped_surface;
}










Object* Object::liste = NULL;
unsigned int Object::Nbre_Object = 0;
Object* Screen::ptr = NULL;




Object::Object(unsigned int PosX,unsigned int PosY,unsigned int Pos2X,unsigned int Pos2Y)
{
this->PosX = PosX;
this->PosY = PosY;
this->Pos2X = Pos2X;
this->Pos2Y = Pos2Y;
this->suivant = NULL;

Object* pointor = NULL;
Object* pointor2 = NULL;

if(Object::liste==NULL)
{
Object::liste = this;
pointor = Object::liste;
Object::liste->suivant = NULL;
Object::liste->precedent = NULL;
}
else
{
pointor = Object::liste;
pointor2 = pointor;

  while(pointor->suivant != NULL)
  pointor = pointor->suivant;
 
  while((pointor2->suivant != pointor)&&(pointor2 != pointor))
  pointor2 = pointor2->suivant;
 
  if(pointor2->suivant == pointor)
  pointor->precedent = pointor2;
  else
  pointor->precedent = NULL;
 
pointor->suivant = this;
this->suivant = NULL;
}


Object::Nbre_Object++;
Screen::ptr = Object::liste;
}



unsigned int Object::GetNumberOfObjects()
{
return Object::Nbre_Object;
}


unsigned int Object::GetObjectType()
{
return Type;
}


Object::~Object()
{
this->precedent->suivant = this->suivant;
this->suivant->precedent = this->precedent;
Object::Nbre_Object--;
}




Screen::Screen(unsigned int width,unsigned int height,unsigned char BitsPerPixel,bool FullScreen)
{
this->width = width;
this->height = height;
this->BitsPerPixel = BitsPerPixel;
this->BytesPerPixel = (this->BitsPerPixel)/8;
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);

if(FullScreen)
this->Screen_Surface = SDL_SetVideoMode(this->width,this->height,this->BitsPerPixel,SDL_OPENGL | SDL_HWSURFACE | SDL_FULLSCREEN);
else
this->Screen_Surface = SDL_SetVideoMode(this->width,this->height,this->BitsPerPixel,SDL_OPENGL | SDL_HWSURFACE);

glEnable(GL_TEXTURE_2D);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
glClearColor(0.0,0.0,0.0,0.0);

glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0,width,0,height);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
this->x_cam = 0;
this->y_cam = 0;
gluLookAt(this->x_cam,this->y_cam,0.1,this->x_cam,this->y_cam,0,0,1,0);
}



void Screen::TranslateCameraPosition(unsigned int x,unsigned int y)
{
this->x_cam+=x;
this->y_cam+=y;
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(this->x_cam,this->y_cam,0.1,this->x_cam,this->y_cam,0,0,1,0);
}


void Screen::SetCameraPosition(unsigned int x,unsigned int y)
{
this->x_cam = x;
this->y_cam = y;
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(this->x_cam,this->y_cam,0.1,this->x_cam,this->y_cam,0,0,1,0);
}

unsigned int Screen::GetWidth()
{
return this->width;
}

unsigned int Screen::GetHeight()
{
return this->height;
}

unsigned int Screen::GetFlag()
{
return this->Flag;
}

unsigned int Screen::GetBytesPerPixel()
{
return this->BytesPerPixel;
}

unsigned int Screen::GetBitsPerPixel()
{
return this->BitsPerPixel;
}

SDL_Surface* Screen::GetScreenSurface()
{
return this->Screen_Surface;
}


void Screen::DrawObjects()
{
Object* ptr2 = Screen::ptr;
glClear(GL_COLOR_BUFFER_BIT);
   while(ptr2 != NULL)
   {
     if(ptr2->Type == OBJECT_TYPE_TILE)
     ptr2->Draw();
   ptr2 = ptr2->suivant;
   }
ptr2 = Screen::ptr;
   while(ptr2 != NULL)
   {
     if(ptr2->Type == OBJECT_TYPE_SPRITE)
     ptr2->Draw();
   ptr2 = ptr2->suivant;
   }
   
SDL_GL_SwapBuffers();
}



Screen::~Screen()
{
Object* ptr2 = Screen::ptr;

   while(ptr2 != NULL)
   {
     if(ptr2->suivant != NULL)
         {
     ptr2 = ptr2->suivant;
     delete ptr2->precedent;
         }
         else
         {
         delete ptr2;
         ptr2 = NULL;
         }
   }
 

SDL_Quit();
}




unsigned long Tile::Number_Tiles = 0;

Tile::Tile(Texture& tex,unsigned int PosX,unsigned int PosY,unsigned int Pos2X,unsigned int Pos2Y,unsigned int Flag):Object(PosX,PosY,Pos2X,Pos2Y)
{
this->Type = OBJECT_TYPE_TILE;
this->tex = &tex;
this->Flag = Flag;
Tile::Number_Tiles++;
}

unsigned int Tile::GetPositionX()
{
return this->PosX;
}

unsigned int Tile::GetPositionY()
{
return this->PosY;
}

void Tile::OnCollisionWithObject(Object& obj)
{
}

void Tile::Draw()
{
     glBindTexture(GL_TEXTURE_2D,this->tex->Tex_ID);
           glBegin(GL_QUADS);
           glTexCoord2d((GLdouble)this->tex->A.x,(GLdouble)this->tex->A.y); glVertex3f((float)this->PosX,(float)this->PosY,0.0f);
           glTexCoord2d((GLdouble)this->tex->B.x,(GLdouble)this->tex->B.y); glVertex3f((float)this->Pos2X,(float)this->PosY,0.0f);
           glTexCoord2d((GLdouble)this->tex->C.x,(GLdouble)this->tex->C.y); glVertex3f((float)this->Pos2X,(float)this->Pos2Y,0.0f);
           glTexCoord2d((GLdouble)this->tex->D.x,(GLdouble)this->tex->D.y); glVertex3f((float)this->PosX,(float)this->Pos2Y,0.0f);
           glEnd();
}

Tile::~Tile()
{
}








unsigned long Sprite::Number_Sprites = 0L;

Sprite::Sprite(Texture& tex,unsigned int PosX,unsigned int PosY,unsigned int Pos2X,unsigned int Pos2Y):Object(PosX,PosY,Pos2X,Pos2Y)
{
this->Type = OBJECT_TYPE_SPRITE;
this->tex     = &tex;
this->PosX    = PosX;
this->PosY    = PosY;
this->Pos2X   = Pos2X;
this->Pos2Y   = Pos2Y;
this->Angle   = 0;
}


void Sprite::Translate(unsigned int IncX,unsigned int IncY)
{
this->PosX+=IncX;
this->PosY+=IncY;
}

void Sprite::Rotate(unsigned int Degree)
{
this->Angle+=Degree;
  if((int)(this->Angle/360)>0)
  this->Angle -= ((int)(this->Angle/360)*360); 
}


Texture& Sprite::GetTexture()
{
Texture& text_ret = *(this->tex);
return text_ret;
}


void Sprite::Draw()
{
     glBindTexture(GL_TEXTURE_2D,this->tex->Tex_ID);
           glBegin(GL_QUADS);
           glTexCoord2d((GLdouble)this->tex->A.x,(GLdouble)this->tex->A.y); glVertex3f((float)this->PosX,(float)this->PosY,0.0f);
           glTexCoord2d((GLdouble)this->tex->B.x,(GLdouble)this->tex->B.y); glVertex3f((float)this->Pos2X,(float)this->PosY,0.0f);
           glTexCoord2d((GLdouble)this->tex->C.x,(GLdouble)this->tex->C.y); glVertex3f((float)this->Pos2X,(float)this->Pos2Y,0.0f);
           glTexCoord2d((GLdouble)this->tex->D.x,(GLdouble)this->tex->D.y); glVertex3f((float)this->PosX,(float)this->Pos2Y,0.0f);
           glEnd();
}

unsigned long Sprite::GetNumberOfSprites()
{
return Number_Sprites;
}



void Sprite::SetTexture(Texture& tex)
{
this->tex = &tex;
}


void Sprite::OnCollisionWithObject(Object& obj)
{
}




void Sprite::operator=(Sprite& sprite)
{
this->Angle = sprite.Angle;
this->tex = sprite.tex;
this->PosX = sprite.PosX;
this->PosY = sprite.PosY;
this->Pos2X = sprite.Pos2X;
this->Pos2Y = sprite.Pos2Y;
}


Sprite::~Sprite()
{
}


unsigned int Texture::NbreTexture = 0;


Texture::Texture(char* filename)
{
this->Surface = IMG_Load(filename);

   if(this->Surface == NULL)
   {
   this->Tex_ID = 0;
   return;
   }

this->A.x = 0.0f;
this->A.y = 1.0f;
this->B.x = 1.0f;
this->B.y = 1.0f;
this->C.x = 1.0f;
this->C.y = 0.0f;
this->D.x = 0.0f;
this->D.y = 0.0f;
   
Uint32 rmask,gmask,bmask,amask;

   #if SDL_BYTEORDER == SDL_BIG_ENDIAN
   rmask = 0xff000000;
   gmask = 0x00ff0000;
   bmask = 0x0000ff00;
   amask = 0x000000ff;
   #else
   rmask = 0x000000ff;
   gmask = 0x0000ff00;
   bmask = 0x00ff0000;
   amask = 0xff000000;     
   #endif


   
    SDL_PixelFormat format = *(this->Surface->format);
    format.BitsPerPixel = 32;
    format.BytesPerPixel = 4;
    format.Rmask = rmask;
    format.Gmask = gmask;
    format.Bmask = bmask;
    format.Amask = amask;

SDL_Surface* surface_non_retournee = SDL_ConvertSurface(this->Surface,&format,SDL_SWSURFACE);  


SDL_Surface* retournee = flipSurface(surface_non_retournee);

glGenTextures(1,&(this->Tex_ID));
glBindTexture(GL_TEXTURE_2D,this->Tex_ID);

        glTexImage2D(GL_TEXTURE_2D, 0, 4, retournee->w,
                     retournee->h, 0, GL_RGBA,GL_UNSIGNED_BYTE,
                     retournee->pixels);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);

int totalBytes = retournee->w*retournee->h*4;
int i;
unsigned char* change = (unsigned char*)retournee->pixels;

     for(i=3;i<totalBytes;i+=4)
         {
         change[i]=255;
         }

Texture::NbreTexture++;
}


void Texture::SetColorKey(unsigned char Red,unsigned char Green,unsigned char Blue)
{
int totalBytes = (this->Surface->w*this->Surface->h)*4;
int i;
unsigned char* convert = (unsigned char*)this->Surface->pixels;;

     #if SDL_BYTEORDER == SDL_BIG_ENDIAN
     for(i=3;i<totalBytes;i+=4)
         {
             if((convert[i-1]==Blue)&&(convert[i-2]==Green)&&(convert[i-3]==Red))
                 convert[i]=0;
         }
         #else
     for(i=3;i<totalBytes;i+=4)
         {
             if((convert[i-1]==Red)&&(convert[i-2]==Green)&&(convert[i-3]==Blue))
                 convert[i]=0;
         }      
         #endif 
}



void Texture::SetRect(unsigned int x,unsigned int y,unsigned int x2,unsigned int y2)
{
this->A.x = (float)((float)(x)/(float)(this->Surface->w));
this->A.y = (float)((float)(y)/(float)(this->Surface->h));
this->B.x = (float)((float)(x2)/(float)(this->Surface->w));
this->B.y = this->A.y;
this->C.x = this->B.x;
this->C.y = (float)((float)(y2)/(float)(this->Surface->h));
this->D.x = this->A.x;
this->D.y = this->C.y;
}


void Texture::operator=(Texture& tex)
{
if(this->Surface)
SDL_FreeSurface(this->Surface);

Uint32 rmask,gmask,bmask,amask;

#if SDL_BYTEORDER == SDL_BIG_ENDIAN

    rmask = 0xff000000;
    gmask = 0x00ff0000;
    bmask = 0x0000ff00;
    amask = 0x000000ff;
#else

    rmask = 0x000000ff;
    gmask = 0x0000ff00;
    bmask = 0x00ff0000;
    amask = 0xff000000;
#endif


this->Surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
                                     tex.Surface->w,tex.Surface->h,
                                     tex.Surface->format->BitsPerPixel,rmask, gmask, bmask, amask);
                                                                        
memcpy(this->Surface,tex.Surface,(tex.Surface->w*tex.Surface->h));
}





Texture::~Texture()
{
SDL_FreeSurface(this->Surface);
Texture::NbreTexture--;
}
#endif

 


Moteur2D.h :
/*
Moteur bidimentionel générique rédigé en C++ exploitant OpenGL et SDL.
Auteur : €@$†¤Rµ$
*/

#include <math.h>

#ifndef GL_CLAMP_TO_EDGE
#define GL_CLAMP_TO_EDGE 0x812F
#endif

#include <SDL/SDL.h>
#include <SDL/SDL_image.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <cstring>
#include <cstdlib>

#define OBJECT_TYPE_TILE 0
#define OBJECT_TYPE_SPRITE 1


typedef struct
{
float x,y;
}Point;



SDL_Surface * flipSurface(SDL_Surface * surface);


class Object
{
protected:
friend class Screen;
unsigned int PosX,PosY,Pos2X,Pos2Y;
static Object* liste;
static unsigned int Nbre_Object;
unsigned int Type;
Object *suivant,*precedent;
public:
Object(unsigned int PosX,unsigned int PosY,unsigned int Pos2X,unsigned int Pos2Y);
static unsigned int GetNumberOfObjects();
unsigned int GetObjectType();
virtual void Draw() = 0;
virtual void OnCollisionWithObject(Object& obj)=0;
virtual ~Object();
};


class Screen
{
protected:
friend class Object;
unsigned int width,height,Flag;
unsigned char BytesPerPixel,BitsPerPixel;
unsigned int x_cam,y_cam;
SDL_Surface* Screen_Surface;
static Object* ptr;
public:
Screen(unsigned int width,unsigned int height,unsigned char BitsPerPixel,bool FullScreen=0);
void TranslateCameraPosition(unsigned int x,unsigned int y);
void SetCameraPosition(unsigned int x,unsigned int y);
unsigned int GetWidth();
unsigned int GetHeight();
unsigned int GetFlag();
unsigned int GetBytesPerPixel();
unsigned int GetBitsPerPixel();
SDL_Surface* GetScreenSurface();
virtual void DrawObjects();
~Screen();
};


class Texture
{
protected:
friend class Sprite;
friend class Tile;
SDL_Surface* Surface;
GLuint Tex_ID;
Point A,B,C,D;
static unsigned int NbreTexture;
public:
Texture(char* filename);
void SetColorKey(unsigned char Red,unsigned char Green,unsigned char Blue);
void SetRect(unsigned int x,unsigned int y,unsigned int x2,unsigned int y2);
void operator=(Texture& tex);
~Texture();
};



class Tile : public Object
{
protected:
Texture* tex;
static unsigned long Number_Tiles;
unsigned int Flag;
public:
Tile(Texture& tex,unsigned int PosX,unsigned int PosY,unsigned int Pos2X,unsigned int Pos2Y,unsigned int Flag = 0);
unsigned int GetPositionX();
unsigned int GetPositionY();
virtual void OnCollisionWithObject(Object& obj);
void Draw();
~Tile();
};



class Sprite : public Object
{
protected:
static unsigned long Number_Sprites;
double Angle;
Texture* tex;
public:
Sprite(Texture& tex,unsigned int PosX,unsigned int PosY,unsigned int Pos2X,unsigned int Pos2Y);
void Translate(unsigned int IncX,unsigned int IncY);
void Rotate(unsigned int Degree);
Texture& GetTexture();
void SetTexture(Texture& tex);
static unsigned long GetNumberOfSprites();
void Draw();
void OnCollisionWithObject(Object& obj);
void operator=(Sprite& sprite);
~Sprite();
};

 



testmoteur.cpp
#include <Moteur2D.cpp>



int main(int argc,char** argv)
{
Screen Ecran(800,600,32);

Texture Tex1("background.bmp");
Texture Tex2("sprite.bmp");
Tex2.SetColorKey(0,255,0);

Tile fond(Tex1,0,600,800,0);
Sprite testsprite(Tex2,0,600,60,600-60);

SDL_Event event;
bool continuer = true;

   while(continuer)
   {
   SDL_PollEvent(&event);
      switch(event.type)
      {
      case SDL_QUIT:
      continuer = false;
      break;
      }
   Ecran.DrawObjects();
   }
   
return 0;
}
 


En l'occurence la methode SetColorKey de la classe Texture devrait permettre de rendre un fond transparent en modifiant le canal alpha de la texture, de plus j'ai activé le blending avec glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);


Cette activation se fait directement dans le constructeur de l'objet Screen.

Donc sur ce, merci de votre aide.
  • Partager sur Facebook
  • Partager sur Twitter
T4g1
  • Langage C++
8 juillet 2007 à 9:23:51

D'abord avec un post comme ca y'a personne qui va avoir envie de t'aider ( sauf un fou ^^ ).

D'aprés ce que j'ai compris, le probléme c'est que tu aimerais faire une image transparente et l'afficher avec OpenGL ?

Pourquoi n'utilise tu pas SDL tout seul ?! OpenGL c'est pour la 3D !

Simplifie toi la vie ...
  • Partager sur Facebook
  • Partager sur Twitter
Yno
8 juillet 2007 à 10:05:41

Salut,

Beurk, c'est caca de mélanger SDL et OpenGL pour l'affichage. Fais soit l'un soit l'autre, mais dans tous les cas évites les mélanges douteux (SetColorKey & Blending OpenGL...).
Crées simplement une texture au format .png, et rends-la transparente dans ton logiciel d'édition d'image. Ensuite, en activant simplement le blending OpenGL la transparence de tes textures apparaîtra tout de suite sans que tu n'ai rien d'autre à faire.

Citation : castorus

glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);


Fais gaffe avec ce mode de blending, il requiert de dessiner tes polygones dans l'ordre du plus éloigné au plus proche (suppose que tu veuille faire de la 3D Iso, ou une GUI...).
  • Partager sur Facebook
  • Partager sur Twitter
castorus
8 juillet 2007 à 16:26:18

Citation : Yno

Salut,

Beurk, c'est caca de mélanger SDL et OpenGL pour l'affichage. Fais soit l'un soit l'autre, mais dans tous les cas évites les mélanges douteux (SetColorKey & Blending OpenGL...).


Justement, c'est ce que je fais, j'utilise uniquement OpenGL pour l'affichage. Merci de lire les posts avant de répondre.

Citation : T4g1

Pourquoi n'utilise tu pas SDL tout seul ?! OpenGL c'est pour la 3D !

Simplifie toi la vie ...



Et oui merci pour cette replique de noob, "openGL c'est pour la 3d" heeuu openGL est une librairie graphique, faites aussi bien pour la gestion du 2d que du 3d....
"Simplifie toi la vie..." C'est ce que je fais, openGL permet des gestion graphiques bien plus poussées et rapides que SDL. Donc merci de ton conseil super utile hein mais ma question c'était pas de savoir ce que t'en pense, mais comment faire pour rendre transparent un fond, ce serait cool de répondre aux questions posées et pas de partir en HS à chaque fois.

  • Partager sur Facebook
  • Partager sur Twitter
ironzorg
8 juillet 2007 à 16:35:29

Citation : castorus

je n'arrive pas à pousser openGL à gerer la transparence



Utilise SDL alors :-°
  • Partager sur Facebook
  • Partager sur Twitter
castorus
8 juillet 2007 à 21:40:04

Va te cacher ironzorg au lieu de parler pour rien dire serieux c'est quoi ici.
  • Partager sur Facebook
  • Partager sur Twitter
le grand schtroumpf
8 juillet 2007 à 22:15:40

Tu es sûr a 100% de la fiabilité de ta méthode SetColorKey??

Si tu n'as jamais vérifié qu'elle mettait bien les pixels de la couleur choisit a 0, fais-le d'abord.

Sinon, regarde dans la documentation d'openGL, sur les fonction que tu utilise pour créer la texture, et aussi sur le blending.
  • Partager sur Facebook
  • Partager sur Twitter
sangohan42
9 juillet 2007 à 15:12:54

Franchement Castorus tu dépasse les bornes et même si j'ai peut etre pas ton niveau je suis obligé de réagir .

Ton comportement est désagréable au possible lorsque quiconque te répond et que cela ne te plaît pas. Met ton comportement négatif de coté quand tu rentres sur ce site(non je ne fais le modérateur ^^) et ca ira beaucoup mieux.



  • Partager sur Facebook
  • Partager sur Twitter
Fvirtman
  • Langage C++
9 juillet 2007 à 15:28:17

Au lieu d'utiliser GL_BLEND (qui est davantage fait pour bosser sur la transparance, et qui peut poser probleme avec le Z-buffer dans certains cas), essaie d'utiliser GL_ALPHA_TEST : qui lui sera bien plus rapide, et sera du "tout ou rien" : soit il affiche le pixel, soit non : ideal pour simuler en 32 bits une colorkey.
  • Partager sur Facebook
  • Partager sur Twitter

Recueil de code C et C++  http://fvirtman.free.fr/recueil/index.html

castorus
9 juillet 2007 à 22:50:34

Okay, merci beaucoup pour cette piste Fvirtman, je vais suivre ton conseil.
  • Partager sur Facebook
  • Partager sur Twitter
T4g1
  • Langage C++
10 juillet 2007 à 14:09:33

Citation : Castorus

Et oui merci pour cette replique de noob, "openGL c'est pour la 3d" heeuu openGL est une librairie graphique, faites aussi bien pour la gestion du 2d que du 3d....
"Simplifie toi la vie..." C'est ce que je fais, openGL permet des gestion graphiques bien plus poussées et rapides que SDL. Donc merci de ton conseil super utile hein mais ma question c'était pas de savoir ce que t'en pense, mais comment faire pour rendre transparent un fond, ce serait cool de répondre aux questions posées et pas de partir en HS à chaque fois.



Ben si t'est plus malin que tout le monde t'avais qu'a te debrouiller seul.

Connard
  • Partager sur Facebook
  • Partager sur Twitter
castorus
10 juillet 2007 à 14:33:16

Seul non, sans toi oui parce que sur le coup je suis peut être un connard mais toi tu postes pour rien donc tu sors ->[] :p ...
(Et puis de toute façon que ce soit avec ton aide ou sans c'est du pareil au même hein vu comment tu parles pour dire des anneries du genre "OpenGL c'est que pour le 3d !" aucun poste constructif de ta part hormis pour m'insulter...)

Enfin bon.
Donc, j'ai résolut mon problème, mais il semblerait que sous windows vista (Je suis sous xp home j'ai testé l'affichage sous windows vista aujourd'hui même) l'affichage des textures ait un soucis, je me retrouve avec un écran blanc lorsque les textures sont actives, quelqu'un pourrait me dire si cela vient concrêtement de Vista ou alors d'un bout de code à adapter pour cette plateforme?

(Parce que c'est éttonant sur les plateformes Xp aucun soucis.)
Merci de votre aide future.
  • Partager sur Facebook
  • Partager sur Twitter
Nanoc
  • Langage C++
10 juillet 2007 à 14:44:38

Je crois que vu comme tu poses la question et comme tu réponds, ça donne vraiment pas envie de répondre.
  • Partager sur Facebook
  • Partager sur Twitter
Co-auteur du cours de C++. ||| Posez vos questions sur le forum ||| Me contacter.
castorus
10 juillet 2007 à 14:48:31

Sûr si c'est pour balancer un troll du genre openGL est uniquement pour la 3D, normal que je réponde de façon impulsive étant donné que cela distribue une image faussée de cette API graphique.
Après c'est aux gens de juger si leur dires sont fondés ou non.
  • Partager sur Facebook
  • Partager sur Twitter
Anonyme
10 juillet 2007 à 15:09:17

Vous êtes priés de rester calmes, castorus évite d'envoyer chier quand on te répond, si la réponse est pas centrée, explique en quoi, et T4g1, t'es prié de ne jamais en venir aux insultes.

Vous vous prenez 5% tous les deux.
  • Partager sur Facebook
  • Partager sur Twitter