Herramientas de usuario

Herramientas del sitio


rf_primitive

RF_Primitive

La clase RF_Primitive es la clase que contiene funciones de pintado.

Miembros públicos

Funciones

static void drawCircle(SDL_Surface* surf, Vector2<int> p, int r, Uint32 color)

Función que pinta una circunferencia.

static void drawFCircle(SDL_Surface* surf, Vector2<int> p, int r, Uint32 color)

Función que pinta un círculo lleno.

static void drawLine(SDL_Surface* surf, Vector2<int> p0, Vector2<int> p1, Uint32 color)

Función que pinta una línea.

static Uint32 getPixel(SDL_Surface* surface, int x, int y)

Función que recoge el color del píxel solicitado.

static SDL_Surface* loadPNG_Surface(string file)

Retorna un puntero a una superficie que contiene la imagen del fichero indicado.

static SDL_Texture* loadPNG(string file, RF_Window* ventana)

Retorna un puntero a una textura que contiene la imagen del fichero indicado.

static void putPixel(SDL_Surface* surface, int x, int y, Uint32 pixel)

Pinta un píxel del color indicado en la superficie indicada en la posición indicada.

Implementación

class RF_Primitive
{
    public:
        static void drawLine(SDL_Surface* surf, Vector2<int> p0, Vector2<int> p1, Uint32 color)
        {
            int dX = p1.x - p0.x;
            int dY = p1.y - p0.y;
 
            float pasos = abs(dX);
            if(abs(dY) >= abs(dX))
            {
                pasos = abs(dY);
            }
 
            Vector2<float> inc = Vector2<float>(dX/pasos, dY/pasos);
            Vector2<float> pF = Vector2<float>((float)p0.x,(float)p0.y);
            for(int i = 0; i < pasos; i++)
            {
                RF_Primitive::putPixel(surf,(int)pF.x,(int)pF.y,color);
                pF.x += inc.x;
                pF.y += inc.y;
            }
        }
 
 
        static void drawFCircle(SDL_Surface* surf, Vector2<int> p, int r, Uint32 color)
        {
            for(float i = 0; i <= r; i+=0.1)
            {
                float j2 = r*r-i*i;
                float j = sqrt(j2);
 
                drawLine(surf,Vector2<int>(p.x-round(i),p.y-round(j)), Vector2<int>(p.x+round(i),p.y-round(j)),color);
                drawLine(surf,Vector2<int>(p.x-round(i),p.y+round(j)), Vector2<int>(p.x+round(i),p.y+round(j)),color);
            }
        }
 
        static void drawCircle(SDL_Surface* surf, Vector2<int> p, int r, Uint32 color)
        {
            for(float i = 0; i <= r; i+=0.1)
            {
                float j2 = r*r-i*i;
                float j = sqrt(j2);
 
                putPixel(surf,p.x+round(i),p.y+round(j),color);
                putPixel(surf,p.x-round(i),p.y+round(j),color);
 
                putPixel(surf,p.x+round(i),p.y-round(j),color);
                putPixel(surf,p.x-round(i),p.y-round(j),color);
            }
        }
 
        static Uint32 getPixel(SDL_Surface* surface, int x, int y)
        {
            int bpp = surface->format->BytesPerPixel;
            /* Here p is the address to the pixel we want to retrieve */
            Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
 
            switch(bpp)
            {
                case 1:
                    return *p;
                    break;
 
                case 2:
                    return *(Uint16 *)p;
                    break;
 
                case 3:
                    if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                    {
                        return p[0] | p[1] << 8 | p[2] << 16;
                    }
                    else
                    {
                        return p[0] << 16 | p[1] << 8 | p[2];
                    }
                    break;
 
                case 4:
                    return p[0] << 16 | p[1] << 8 | p[2];//return *(Uint32 *)p;
                    break;
 
                default:
                    return 0;
            }
        }
 
        static void putPixel(SDL_Surface* surface, int x, int y, Uint32 pixel)
        {
            if(0 > x || 0 > y || surface->w <= x || surface->h <= y){return;}
 
            int bpp = surface->format->BytesPerPixel;
            Uint8 *p = (Uint8 *)surface->pixels + y * surface->pitch + x * bpp;
 
            switch(bpp)
            {
                case 1:
                    *p = pixel;
                    break;
 
                case 2:
                    *(Uint16 *)p = pixel;
                    break;
 
                case 3:
                    if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                    {
                        p[0] = (pixel >> 16) & 0xff;
                        p[1] = (pixel >> 8) & 0xff;
                        p[2] = pixel & 0xff;
                    }
                    else
                    {
                        p[0] = pixel & 0xff;
                        p[1] = (pixel >> 8) & 0xff;
                        p[2] = (pixel >> 16) & 0xff;
                    }
                    break;
 
                case 4:
                    *(Uint32 *)p = pixel;
                    break;
            }
        }
 
      static SDL_Surface* loadPNG_Surface(string file)
      {
        return IMG_Load(file.c_str());
      }
      static SDL_Texture* loadPNG(string file, RF_Window* ventana)
      {
        return IMG_LoadTexture(ventana->renderer,file.c_str());
      }
};
Categorías: Clases
rf_primitive.txt · Última modificación: 2018/01/19 02:32 por Yawin