Updated SDL 1.3 to the latest hg-5868:33245988e8a2 , video resize is not supported yet
This commit is contained in:
pelya
1221
project/jni/sdl-1.3/src/render/SDL_render.c
Normal file
1221
project/jni/sdl-1.3/src/render/SDL_render.c
Normal file
File diff suppressed because it is too large
Load Diff
151
project/jni/sdl-1.3/src/render/SDL_sysrender.h
Normal file
151
project/jni/sdl-1.3/src/render/SDL_sysrender.h
Normal file
@@ -0,0 +1,151 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#ifndef _SDL_sysrender_h
|
||||
#define _SDL_sysrender_h
|
||||
|
||||
#include "SDL_render.h"
|
||||
#include "SDL_events.h"
|
||||
#include "SDL_yuv_sw_c.h"
|
||||
|
||||
/* The SDL 2D rendering system */
|
||||
|
||||
typedef struct SDL_RenderDriver SDL_RenderDriver;
|
||||
|
||||
/* Define the SDL texture structure */
|
||||
struct SDL_Texture
|
||||
{
|
||||
const void *magic;
|
||||
Uint32 format; /**< The pixel format of the texture */
|
||||
int access; /**< SDL_TextureAccess */
|
||||
int w; /**< The width of the texture */
|
||||
int h; /**< The height of the texture */
|
||||
int modMode; /**< The texture modulation mode */
|
||||
SDL_BlendMode blendMode; /**< The texture blend mode */
|
||||
Uint8 r, g, b, a; /**< Texture modulation values */
|
||||
|
||||
SDL_Renderer *renderer;
|
||||
|
||||
/* Support for formats not supported directly by the renderer */
|
||||
SDL_Texture *native;
|
||||
SDL_SW_YUVTexture *yuv;
|
||||
void *pixels;
|
||||
int pitch;
|
||||
SDL_Rect locked_rect;
|
||||
|
||||
void *driverdata; /**< Driver specific texture representation */
|
||||
|
||||
SDL_Texture *prev;
|
||||
SDL_Texture *next;
|
||||
};
|
||||
|
||||
/* Define the SDL renderer structure */
|
||||
struct SDL_Renderer
|
||||
{
|
||||
const void *magic;
|
||||
|
||||
void (*WindowEvent) (SDL_Renderer * renderer, const SDL_WindowEvent *event);
|
||||
int (*CreateTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
int (*SetTextureColorMod) (SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
int (*SetTextureAlphaMod) (SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
int (*SetTextureBlendMode) (SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
int (*UpdateTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels,
|
||||
int pitch);
|
||||
int (*LockTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, void **pixels, int *pitch);
|
||||
void (*UnlockTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
int (*UpdateViewport) (SDL_Renderer * renderer);
|
||||
int (*RenderClear) (SDL_Renderer * renderer);
|
||||
int (*RenderDrawPoints) (SDL_Renderer * renderer, const SDL_Point * points,
|
||||
int count);
|
||||
int (*RenderDrawLines) (SDL_Renderer * renderer, const SDL_Point * points,
|
||||
int count);
|
||||
int (*RenderFillRects) (SDL_Renderer * renderer, const SDL_Rect * rects,
|
||||
int count);
|
||||
int (*RenderCopy) (SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
|
||||
int (*RenderReadPixels) (SDL_Renderer * renderer, const SDL_Rect * rect,
|
||||
Uint32 format, void * pixels, int pitch);
|
||||
void (*RenderPresent) (SDL_Renderer * renderer);
|
||||
void (*DestroyTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
|
||||
void (*DestroyRenderer) (SDL_Renderer * renderer);
|
||||
|
||||
/* The current renderer info */
|
||||
SDL_RendererInfo info;
|
||||
|
||||
/* The window associated with the renderer */
|
||||
SDL_Window *window;
|
||||
SDL_bool minimized;
|
||||
|
||||
/* The drawable area within the window */
|
||||
SDL_Rect viewport;
|
||||
|
||||
/* The list of textures */
|
||||
SDL_Texture *textures;
|
||||
|
||||
Uint8 r, g, b, a; /**< Color for drawing operations values */
|
||||
SDL_BlendMode blendMode; /**< The drawing blend mode */
|
||||
|
||||
void *driverdata;
|
||||
};
|
||||
|
||||
/* Define the SDL render driver structure */
|
||||
struct SDL_RenderDriver
|
||||
{
|
||||
SDL_Renderer *(*CreateRenderer) (SDL_Window * window, Uint32 flags);
|
||||
|
||||
/* Info about the renderer capabilities */
|
||||
SDL_RendererInfo info;
|
||||
};
|
||||
|
||||
#if !SDL_RENDER_DISABLED
|
||||
|
||||
#if SDL_VIDEO_RENDER_D3D
|
||||
extern SDL_RenderDriver D3D_RenderDriver;
|
||||
#endif
|
||||
#if SDL_VIDEO_RENDER_OGL
|
||||
extern SDL_RenderDriver GL_RenderDriver;
|
||||
#endif
|
||||
#if SDL_VIDEO_RENDER_OGL_ES2
|
||||
extern SDL_RenderDriver GLES2_RenderDriver;
|
||||
#endif
|
||||
#if SDL_VIDEO_RENDER_OGL_ES
|
||||
extern SDL_RenderDriver GLES_RenderDriver;
|
||||
#endif
|
||||
#if SDL_VIDEO_RENDER_DIRECTFB
|
||||
extern SDL_RenderDriver DirectFB_RenderDriver;
|
||||
#endif
|
||||
#if SDL_VIDEO_RENDER_NDS
|
||||
extern SDL_RenderDriver NDS_RenderDriver;
|
||||
#endif
|
||||
extern SDL_RenderDriver SW_RenderDriver;
|
||||
|
||||
#endif /* !SDL_RENDER_DISABLED */
|
||||
|
||||
#endif /* _SDL_sysrender_h */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
431
project/jni/sdl-1.3/src/render/SDL_yuv_mmx.c
Normal file
431
project/jni/sdl-1.3/src/render/SDL_yuv_mmx.c
Normal file
@@ -0,0 +1,431 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if (__GNUC__ > 2) && defined(__i386__) && __OPTIMIZE__ && SDL_ASSEMBLY_ROUTINES
|
||||
|
||||
#include "SDL_stdinc.h"
|
||||
|
||||
#include "mmx.h"
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
|
||||
static mmx_t MMX_0080w = { .ud = {0x00800080, 0x00800080} };
|
||||
static mmx_t MMX_00FFw = { .ud = {0x00ff00ff, 0x00ff00ff} };
|
||||
static mmx_t MMX_FF00w = { .ud = {0xff00ff00, 0xff00ff00} };
|
||||
|
||||
static mmx_t MMX_Ycoeff = { .uw = {0x004a, 0x004a, 0x004a, 0x004a} };
|
||||
|
||||
static mmx_t MMX_UbluRGB = { .uw = {0x0072, 0x0072, 0x0072, 0x0072} };
|
||||
static mmx_t MMX_VredRGB = { .uw = {0x0059, 0x0059, 0x0059, 0x0059} };
|
||||
static mmx_t MMX_UgrnRGB = { .uw = {0xffea, 0xffea, 0xffea, 0xffea} };
|
||||
static mmx_t MMX_VgrnRGB = { .uw = {0xffd2, 0xffd2, 0xffd2, 0xffd2} };
|
||||
|
||||
static mmx_t MMX_Ublu5x5 = { .uw = {0x0081, 0x0081, 0x0081, 0x0081} };
|
||||
static mmx_t MMX_Vred5x5 = { .uw = {0x0066, 0x0066, 0x0066, 0x0066} };
|
||||
static mmx_t MMX_Ugrn565 = { .uw = {0xffe8, 0xffe8, 0xffe8, 0xffe8} };
|
||||
static mmx_t MMX_Vgrn565 = { .uw = {0xffcd, 0xffcd, 0xffcd, 0xffcd} };
|
||||
|
||||
static mmx_t MMX_red565 = { .uw = {0xf800, 0xf800, 0xf800, 0xf800} };
|
||||
static mmx_t MMX_grn565 = { .uw = {0x07e0, 0x07e0, 0x07e0, 0x07e0} };
|
||||
|
||||
/**
|
||||
This MMX assembler is my first assembler/MMX program ever.
|
||||
Thus it maybe buggy.
|
||||
Send patches to:
|
||||
mvogt@rhrk.uni-kl.de
|
||||
|
||||
After it worked fine I have "obfuscated" the code a bit to have
|
||||
more parallism in the MMX units. This means I moved
|
||||
initilisation around and delayed other instruction.
|
||||
Performance measurement did not show that this brought any advantage
|
||||
but in theory it _should_ be faster this way.
|
||||
|
||||
The overall performanve gain to the C based dither was 30%-40%.
|
||||
The MMX routine calculates 256bit=8RGB values in each cycle
|
||||
(4 for row1 & 4 for row2)
|
||||
|
||||
The red/green/blue.. coefficents are taken from the mpeg_play
|
||||
player. They look nice, but I dont know if you can have
|
||||
better values, to avoid integer rounding errors.
|
||||
|
||||
|
||||
IMPORTANT:
|
||||
==========
|
||||
|
||||
It is a requirement that the cr/cb/lum are 8 byte aligned and
|
||||
the out are 16byte aligned or you will/may get segfaults
|
||||
|
||||
*/
|
||||
|
||||
void ColorRGBDitherYV12MMX1X( int *colortab, Uint32 *rgb_2_pix,
|
||||
unsigned char *lum, unsigned char *cr,
|
||||
unsigned char *cb, unsigned char *out,
|
||||
int rows, int cols, int mod )
|
||||
{
|
||||
Uint32 *row1;
|
||||
Uint32 *row2;
|
||||
|
||||
unsigned char* y = lum +cols*rows; // Pointer to the end
|
||||
int x = 0;
|
||||
row1 = (Uint32 *)out; // 32 bit target
|
||||
row2 = (Uint32 *)out+cols+mod; // start of second row
|
||||
mod = (mod+cols+mod)*4; // increment for row1 in byte
|
||||
|
||||
__asm__ __volatile__ (
|
||||
// tap dance to workaround the inability to use %%ebx at will...
|
||||
// move one thing to the stack...
|
||||
"pushl $0\n" // save a slot on the stack.
|
||||
"pushl %%ebx\n" // save %%ebx.
|
||||
"movl %0, %%ebx\n" // put the thing in ebx.
|
||||
"movl %%ebx,4(%%esp)\n" // put the thing in the stack slot.
|
||||
"popl %%ebx\n" // get back %%ebx (the PIC register).
|
||||
|
||||
".align 8\n"
|
||||
"1:\n"
|
||||
|
||||
// create Cr (result in mm1)
|
||||
"pushl %%ebx\n"
|
||||
"movl 4(%%esp),%%ebx\n"
|
||||
"movd (%%ebx),%%mm1\n" // 0 0 0 0 v3 v2 v1 v0
|
||||
"popl %%ebx\n"
|
||||
"pxor %%mm7,%%mm7\n" // 00 00 00 00 00 00 00 00
|
||||
"movd (%2), %%mm2\n" // 0 0 0 0 l3 l2 l1 l0
|
||||
"punpcklbw %%mm7,%%mm1\n" // 0 v3 0 v2 00 v1 00 v0
|
||||
"punpckldq %%mm1,%%mm1\n" // 00 v1 00 v0 00 v1 00 v0
|
||||
"psubw %9,%%mm1\n" // mm1-128:r1 r1 r0 r0 r1 r1 r0 r0
|
||||
|
||||
// create Cr_g (result in mm0)
|
||||
"movq %%mm1,%%mm0\n" // r1 r1 r0 r0 r1 r1 r0 r0
|
||||
"pmullw %10,%%mm0\n" // red*-46dec=0.7136*64
|
||||
"pmullw %11,%%mm1\n" // red*89dec=1.4013*64
|
||||
"psraw $6, %%mm0\n" // red=red/64
|
||||
"psraw $6, %%mm1\n" // red=red/64
|
||||
|
||||
// create L1 L2 (result in mm2,mm4)
|
||||
// L2=lum+cols
|
||||
"movq (%2,%4),%%mm3\n" // 0 0 0 0 L3 L2 L1 L0
|
||||
"punpckldq %%mm3,%%mm2\n" // L3 L2 L1 L0 l3 l2 l1 l0
|
||||
"movq %%mm2,%%mm4\n" // L3 L2 L1 L0 l3 l2 l1 l0
|
||||
"pand %12,%%mm2\n" // L3 0 L1 0 l3 0 l1 0
|
||||
"pand %13,%%mm4\n" // 0 L2 0 L0 0 l2 0 l0
|
||||
"psrlw $8,%%mm2\n" // 0 L3 0 L1 0 l3 0 l1
|
||||
|
||||
// create R (result in mm6)
|
||||
"movq %%mm2,%%mm5\n" // 0 L3 0 L1 0 l3 0 l1
|
||||
"movq %%mm4,%%mm6\n" // 0 L2 0 L0 0 l2 0 l0
|
||||
"paddsw %%mm1, %%mm5\n" // lum1+red:x R3 x R1 x r3 x r1
|
||||
"paddsw %%mm1, %%mm6\n" // lum1+red:x R2 x R0 x r2 x r0
|
||||
"packuswb %%mm5,%%mm5\n" // R3 R1 r3 r1 R3 R1 r3 r1
|
||||
"packuswb %%mm6,%%mm6\n" // R2 R0 r2 r0 R2 R0 r2 r0
|
||||
"pxor %%mm7,%%mm7\n" // 00 00 00 00 00 00 00 00
|
||||
"punpcklbw %%mm5,%%mm6\n" // R3 R2 R1 R0 r3 r2 r1 r0
|
||||
|
||||
// create Cb (result in mm1)
|
||||
"movd (%1), %%mm1\n" // 0 0 0 0 u3 u2 u1 u0
|
||||
"punpcklbw %%mm7,%%mm1\n" // 0 u3 0 u2 00 u1 00 u0
|
||||
"punpckldq %%mm1,%%mm1\n" // 00 u1 00 u0 00 u1 00 u0
|
||||
"psubw %9,%%mm1\n" // mm1-128:u1 u1 u0 u0 u1 u1 u0 u0
|
||||
|
||||
// create Cb_g (result in mm5)
|
||||
"movq %%mm1,%%mm5\n" // u1 u1 u0 u0 u1 u1 u0 u0
|
||||
"pmullw %14,%%mm5\n" // blue*-109dec=1.7129*64
|
||||
"pmullw %15,%%mm1\n" // blue*114dec=1.78125*64
|
||||
"psraw $6, %%mm5\n" // blue=red/64
|
||||
"psraw $6, %%mm1\n" // blue=blue/64
|
||||
|
||||
// create G (result in mm7)
|
||||
"movq %%mm2,%%mm3\n" // 0 L3 0 L1 0 l3 0 l1
|
||||
"movq %%mm4,%%mm7\n" // 0 L2 0 L0 0 l2 0 l1
|
||||
"paddsw %%mm5, %%mm3\n" // lum1+Cb_g:x G3t x G1t x g3t x g1t
|
||||
"paddsw %%mm5, %%mm7\n" // lum1+Cb_g:x G2t x G0t x g2t x g0t
|
||||
"paddsw %%mm0, %%mm3\n" // lum1+Cr_g:x G3 x G1 x g3 x g1
|
||||
"paddsw %%mm0, %%mm7\n" // lum1+blue:x G2 x G0 x g2 x g0
|
||||
"packuswb %%mm3,%%mm3\n" // G3 G1 g3 g1 G3 G1 g3 g1
|
||||
"packuswb %%mm7,%%mm7\n" // G2 G0 g2 g0 G2 G0 g2 g0
|
||||
"punpcklbw %%mm3,%%mm7\n" // G3 G2 G1 G0 g3 g2 g1 g0
|
||||
|
||||
// create B (result in mm5)
|
||||
"movq %%mm2,%%mm3\n" // 0 L3 0 L1 0 l3 0 l1
|
||||
"movq %%mm4,%%mm5\n" // 0 L2 0 L0 0 l2 0 l1
|
||||
"paddsw %%mm1, %%mm3\n" // lum1+blue:x B3 x B1 x b3 x b1
|
||||
"paddsw %%mm1, %%mm5\n" // lum1+blue:x B2 x B0 x b2 x b0
|
||||
"packuswb %%mm3,%%mm3\n" // B3 B1 b3 b1 B3 B1 b3 b1
|
||||
"packuswb %%mm5,%%mm5\n" // B2 B0 b2 b0 B2 B0 b2 b0
|
||||
"punpcklbw %%mm3,%%mm5\n" // B3 B2 B1 B0 b3 b2 b1 b0
|
||||
|
||||
// fill destination row1 (needed are mm6=Rr,mm7=Gg,mm5=Bb)
|
||||
|
||||
"pxor %%mm2,%%mm2\n" // 0 0 0 0 0 0 0 0
|
||||
"pxor %%mm4,%%mm4\n" // 0 0 0 0 0 0 0 0
|
||||
"movq %%mm6,%%mm1\n" // R3 R2 R1 R0 r3 r2 r1 r0
|
||||
"movq %%mm5,%%mm3\n" // B3 B2 B1 B0 b3 b2 b1 b0
|
||||
|
||||
// process lower lum
|
||||
"punpcklbw %%mm4,%%mm1\n" // 0 r3 0 r2 0 r1 0 r0
|
||||
"punpcklbw %%mm4,%%mm3\n" // 0 b3 0 b2 0 b1 0 b0
|
||||
"movq %%mm1,%%mm2\n" // 0 r3 0 r2 0 r1 0 r0
|
||||
"movq %%mm3,%%mm0\n" // 0 b3 0 b2 0 b1 0 b0
|
||||
"punpcklwd %%mm1,%%mm3\n" // 0 r1 0 b1 0 r0 0 b0
|
||||
"punpckhwd %%mm2,%%mm0\n" // 0 r3 0 b3 0 r2 0 b2
|
||||
|
||||
"pxor %%mm2,%%mm2\n" // 0 0 0 0 0 0 0 0
|
||||
"movq %%mm7,%%mm1\n" // G3 G2 G1 G0 g3 g2 g1 g0
|
||||
"punpcklbw %%mm1,%%mm2\n" // g3 0 g2 0 g1 0 g0 0
|
||||
"punpcklwd %%mm4,%%mm2\n" // 0 0 g1 0 0 0 g0 0
|
||||
"por %%mm3, %%mm2\n" // 0 r1 g1 b1 0 r0 g0 b0
|
||||
"movq %%mm2,(%3)\n" // wrote out ! row1
|
||||
|
||||
"pxor %%mm2,%%mm2\n" // 0 0 0 0 0 0 0 0
|
||||
"punpcklbw %%mm1,%%mm4\n" // g3 0 g2 0 g1 0 g0 0
|
||||
"punpckhwd %%mm2,%%mm4\n" // 0 0 g3 0 0 0 g2 0
|
||||
"por %%mm0, %%mm4\n" // 0 r3 g3 b3 0 r2 g2 b2
|
||||
"movq %%mm4,8(%3)\n" // wrote out ! row1
|
||||
|
||||
// fill destination row2 (needed are mm6=Rr,mm7=Gg,mm5=Bb)
|
||||
// this can be done "destructive"
|
||||
"pxor %%mm2,%%mm2\n" // 0 0 0 0 0 0 0 0
|
||||
"punpckhbw %%mm2,%%mm6\n" // 0 R3 0 R2 0 R1 0 R0
|
||||
"punpckhbw %%mm1,%%mm5\n" // G3 B3 G2 B2 G1 B1 G0 B0
|
||||
"movq %%mm5,%%mm1\n" // G3 B3 G2 B2 G1 B1 G0 B0
|
||||
"punpcklwd %%mm6,%%mm1\n" // 0 R1 G1 B1 0 R0 G0 B0
|
||||
"movq %%mm1,(%5)\n" // wrote out ! row2
|
||||
"punpckhwd %%mm6,%%mm5\n" // 0 R3 G3 B3 0 R2 G2 B2
|
||||
"movq %%mm5,8(%5)\n" // wrote out ! row2
|
||||
|
||||
"addl $4,%2\n" // lum+4
|
||||
"leal 16(%3),%3\n" // row1+16
|
||||
"leal 16(%5),%5\n" // row2+16
|
||||
"addl $2,(%%esp)\n" // cr+2
|
||||
"addl $2,%1\n" // cb+2
|
||||
|
||||
"addl $4,%6\n" // x+4
|
||||
"cmpl %4,%6\n"
|
||||
|
||||
"jl 1b\n"
|
||||
"addl %4,%2\n" // lum += cols
|
||||
"addl %8,%3\n" // row1+= mod
|
||||
"addl %8,%5\n" // row2+= mod
|
||||
"movl $0,%6\n" // x=0
|
||||
"cmpl %7,%2\n"
|
||||
"jl 1b\n"
|
||||
|
||||
"addl $4,%%esp\n" // get rid of the stack slot we reserved.
|
||||
"emms\n" // reset MMX registers.
|
||||
:
|
||||
: "m" (cr), "r"(cb),"r"(lum),
|
||||
"r"(row1),"r"(cols),"r"(row2),"m"(x),"m"(y),"m"(mod),
|
||||
"m"(MMX_0080w),"m"(MMX_VgrnRGB),"m"(MMX_VredRGB),
|
||||
"m"(MMX_FF00w),"m"(MMX_00FFw),"m"(MMX_UgrnRGB),
|
||||
"m"(MMX_UbluRGB)
|
||||
);
|
||||
}
|
||||
|
||||
void Color565DitherYV12MMX1X( int *colortab, Uint32 *rgb_2_pix,
|
||||
unsigned char *lum, unsigned char *cr,
|
||||
unsigned char *cb, unsigned char *out,
|
||||
int rows, int cols, int mod )
|
||||
{
|
||||
Uint16 *row1;
|
||||
Uint16 *row2;
|
||||
|
||||
unsigned char* y = lum +cols*rows; /* Pointer to the end */
|
||||
int x = 0;
|
||||
row1 = (Uint16 *)out; /* 16 bit target */
|
||||
row2 = (Uint16 *)out+cols+mod; /* start of second row */
|
||||
mod = (mod+cols+mod)*2; /* increment for row1 in byte */
|
||||
|
||||
__asm__ __volatile__(
|
||||
// tap dance to workaround the inability to use %%ebx at will...
|
||||
// move one thing to the stack...
|
||||
"pushl $0\n" // save a slot on the stack.
|
||||
"pushl %%ebx\n" // save %%ebx.
|
||||
"movl %0, %%ebx\n" // put the thing in ebx.
|
||||
"movl %%ebx, 4(%%esp)\n" // put the thing in the stack slot.
|
||||
"popl %%ebx\n" // get back %%ebx (the PIC register).
|
||||
|
||||
".align 8\n"
|
||||
"1:\n"
|
||||
|
||||
"movd (%1), %%mm0\n" // 4 Cb 0 0 0 0 u3 u2 u1 u0
|
||||
"pxor %%mm7, %%mm7\n"
|
||||
"pushl %%ebx\n"
|
||||
"movl 4(%%esp), %%ebx\n"
|
||||
"movd (%%ebx), %%mm1\n" // 4 Cr 0 0 0 0 v3 v2 v1 v0
|
||||
"popl %%ebx\n"
|
||||
|
||||
"punpcklbw %%mm7, %%mm0\n" // 4 W cb 0 u3 0 u2 0 u1 0 u0
|
||||
"punpcklbw %%mm7, %%mm1\n" // 4 W cr 0 v3 0 v2 0 v1 0 v0
|
||||
"psubw %9, %%mm0\n"
|
||||
"psubw %9, %%mm1\n"
|
||||
"movq %%mm0, %%mm2\n" // Cb 0 u3 0 u2 0 u1 0 u0
|
||||
"movq %%mm1, %%mm3\n" // Cr
|
||||
"pmullw %10, %%mm2\n" // Cb2green 0 R3 0 R2 0 R1 0 R0
|
||||
"movq (%2), %%mm6\n" // L1 l7 L6 L5 L4 L3 L2 L1 L0
|
||||
"pmullw %11, %%mm0\n" // Cb2blue
|
||||
"pand %12, %%mm6\n" // L1 00 L6 00 L4 00 L2 00 L0
|
||||
"pmullw %13, %%mm3\n" // Cr2green
|
||||
"movq (%2), %%mm7\n" // L2
|
||||
"pmullw %14, %%mm1\n" // Cr2red
|
||||
"psrlw $8, %%mm7\n" // L2 00 L7 00 L5 00 L3 00 L1
|
||||
"pmullw %15, %%mm6\n" // lum1
|
||||
"paddw %%mm3, %%mm2\n" // Cb2green + Cr2green == green
|
||||
"pmullw %15, %%mm7\n" // lum2
|
||||
|
||||
"movq %%mm6, %%mm4\n" // lum1
|
||||
"paddw %%mm0, %%mm6\n" // lum1 +blue 00 B6 00 B4 00 B2 00 B0
|
||||
"movq %%mm4, %%mm5\n" // lum1
|
||||
"paddw %%mm1, %%mm4\n" // lum1 +red 00 R6 00 R4 00 R2 00 R0
|
||||
"paddw %%mm2, %%mm5\n" // lum1 +green 00 G6 00 G4 00 G2 00 G0
|
||||
"psraw $6, %%mm4\n" // R1 0 .. 64
|
||||
"movq %%mm7, %%mm3\n" // lum2 00 L7 00 L5 00 L3 00 L1
|
||||
"psraw $6, %%mm5\n" // G1 - .. +
|
||||
"paddw %%mm0, %%mm7\n" // Lum2 +blue 00 B7 00 B5 00 B3 00 B1
|
||||
"psraw $6, %%mm6\n" // B1 0 .. 64
|
||||
"packuswb %%mm4, %%mm4\n" // R1 R1
|
||||
"packuswb %%mm5, %%mm5\n" // G1 G1
|
||||
"packuswb %%mm6, %%mm6\n" // B1 B1
|
||||
"punpcklbw %%mm4, %%mm4\n"
|
||||
"punpcklbw %%mm5, %%mm5\n"
|
||||
|
||||
"pand %16, %%mm4\n"
|
||||
"psllw $3, %%mm5\n" // GREEN 1
|
||||
"punpcklbw %%mm6, %%mm6\n"
|
||||
"pand %17, %%mm5\n"
|
||||
"pand %16, %%mm6\n"
|
||||
"por %%mm5, %%mm4\n" //
|
||||
"psrlw $11, %%mm6\n" // BLUE 1
|
||||
"movq %%mm3, %%mm5\n" // lum2
|
||||
"paddw %%mm1, %%mm3\n" // lum2 +red 00 R7 00 R5 00 R3 00 R1
|
||||
"paddw %%mm2, %%mm5\n" // lum2 +green 00 G7 00 G5 00 G3 00 G1
|
||||
"psraw $6, %%mm3\n" // R2
|
||||
"por %%mm6, %%mm4\n" // MM4
|
||||
"psraw $6, %%mm5\n" // G2
|
||||
"movq (%2, %4), %%mm6\n" // L3 load lum2
|
||||
"psraw $6, %%mm7\n"
|
||||
"packuswb %%mm3, %%mm3\n"
|
||||
"packuswb %%mm5, %%mm5\n"
|
||||
"packuswb %%mm7, %%mm7\n"
|
||||
"pand %12, %%mm6\n" // L3
|
||||
"punpcklbw %%mm3, %%mm3\n"
|
||||
"punpcklbw %%mm5, %%mm5\n"
|
||||
"pmullw %15, %%mm6\n" // lum3
|
||||
"punpcklbw %%mm7, %%mm7\n"
|
||||
"psllw $3, %%mm5\n" // GREEN 2
|
||||
"pand %16, %%mm7\n"
|
||||
"pand %16, %%mm3\n"
|
||||
"psrlw $11, %%mm7\n" // BLUE 2
|
||||
"pand %17, %%mm5\n"
|
||||
"por %%mm7, %%mm3\n"
|
||||
"movq (%2,%4), %%mm7\n" // L4 load lum2
|
||||
"por %%mm5, %%mm3\n" //
|
||||
"psrlw $8, %%mm7\n" // L4
|
||||
"movq %%mm4, %%mm5\n"
|
||||
"punpcklwd %%mm3, %%mm4\n"
|
||||
"pmullw %15, %%mm7\n" // lum4
|
||||
"punpckhwd %%mm3, %%mm5\n"
|
||||
|
||||
"movq %%mm4, (%3)\n" // write row1
|
||||
"movq %%mm5, 8(%3)\n" // write row1
|
||||
|
||||
"movq %%mm6, %%mm4\n" // Lum3
|
||||
"paddw %%mm0, %%mm6\n" // Lum3 +blue
|
||||
|
||||
"movq %%mm4, %%mm5\n" // Lum3
|
||||
"paddw %%mm1, %%mm4\n" // Lum3 +red
|
||||
"paddw %%mm2, %%mm5\n" // Lum3 +green
|
||||
"psraw $6, %%mm4\n"
|
||||
"movq %%mm7, %%mm3\n" // Lum4
|
||||
"psraw $6, %%mm5\n"
|
||||
"paddw %%mm0, %%mm7\n" // Lum4 +blue
|
||||
"psraw $6, %%mm6\n" // Lum3 +blue
|
||||
"movq %%mm3, %%mm0\n" // Lum4
|
||||
"packuswb %%mm4, %%mm4\n"
|
||||
"paddw %%mm1, %%mm3\n" // Lum4 +red
|
||||
"packuswb %%mm5, %%mm5\n"
|
||||
"paddw %%mm2, %%mm0\n" // Lum4 +green
|
||||
"packuswb %%mm6, %%mm6\n"
|
||||
"punpcklbw %%mm4, %%mm4\n"
|
||||
"punpcklbw %%mm5, %%mm5\n"
|
||||
"punpcklbw %%mm6, %%mm6\n"
|
||||
"psllw $3, %%mm5\n" // GREEN 3
|
||||
"pand %16, %%mm4\n"
|
||||
"psraw $6, %%mm3\n" // psr 6
|
||||
"psraw $6, %%mm0\n"
|
||||
"pand %16, %%mm6\n" // BLUE
|
||||
"pand %17, %%mm5\n"
|
||||
"psrlw $11, %%mm6\n" // BLUE 3
|
||||
"por %%mm5, %%mm4\n"
|
||||
"psraw $6, %%mm7\n"
|
||||
"por %%mm6, %%mm4\n"
|
||||
"packuswb %%mm3, %%mm3\n"
|
||||
"packuswb %%mm0, %%mm0\n"
|
||||
"packuswb %%mm7, %%mm7\n"
|
||||
"punpcklbw %%mm3, %%mm3\n"
|
||||
"punpcklbw %%mm0, %%mm0\n"
|
||||
"punpcklbw %%mm7, %%mm7\n"
|
||||
"pand %16, %%mm3\n"
|
||||
"pand %16, %%mm7\n" // BLUE
|
||||
"psllw $3, %%mm0\n" // GREEN 4
|
||||
"psrlw $11, %%mm7\n"
|
||||
"pand %17, %%mm0\n"
|
||||
"por %%mm7, %%mm3\n"
|
||||
"por %%mm0, %%mm3\n"
|
||||
|
||||
"movq %%mm4, %%mm5\n"
|
||||
|
||||
"punpcklwd %%mm3, %%mm4\n"
|
||||
"punpckhwd %%mm3, %%mm5\n"
|
||||
|
||||
"movq %%mm4, (%5)\n"
|
||||
"movq %%mm5, 8(%5)\n"
|
||||
|
||||
"addl $8, %6\n"
|
||||
"addl $8, %2\n"
|
||||
"addl $4, (%%esp)\n"
|
||||
"addl $4, %1\n"
|
||||
"cmpl %4, %6\n"
|
||||
"leal 16(%3), %3\n"
|
||||
"leal 16(%5),%5\n" // row2+16
|
||||
|
||||
"jl 1b\n"
|
||||
"addl %4, %2\n" // lum += cols
|
||||
"addl %8, %3\n" // row1+= mod
|
||||
"addl %8, %5\n" // row2+= mod
|
||||
"movl $0, %6\n" // x=0
|
||||
"cmpl %7, %2\n"
|
||||
"jl 1b\n"
|
||||
"addl $4, %%esp\n" // get rid of the stack slot we reserved.
|
||||
"emms\n"
|
||||
:
|
||||
: "m" (cr), "r"(cb),"r"(lum),
|
||||
"r"(row1),"r"(cols),"r"(row2),"m"(x),"m"(y),"m"(mod),
|
||||
"m"(MMX_0080w),"m"(MMX_Ugrn565),"m"(MMX_Ublu5x5),
|
||||
"m"(MMX_00FFw),"m"(MMX_Vgrn565),"m"(MMX_Vred5x5),
|
||||
"m"(MMX_Ycoeff),"m"(MMX_red565),"m"(MMX_grn565)
|
||||
);
|
||||
}
|
||||
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#endif /* GCC3 i386 inline assembly */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
1322
project/jni/sdl-1.3/src/render/SDL_yuv_sw.c
Normal file
1322
project/jni/sdl-1.3/src/render/SDL_yuv_sw.c
Normal file
File diff suppressed because it is too large
Load Diff
68
project/jni/sdl-1.3/src/render/SDL_yuv_sw_c.h
Normal file
68
project/jni/sdl-1.3/src/render/SDL_yuv_sw_c.h
Normal file
@@ -0,0 +1,68 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#include "SDL_video.h"
|
||||
|
||||
/* This is the software implementation of the YUV texture support */
|
||||
|
||||
struct SDL_SW_YUVTexture
|
||||
{
|
||||
Uint32 format;
|
||||
Uint32 target_format;
|
||||
int w, h;
|
||||
Uint8 *pixels;
|
||||
int *colortab;
|
||||
Uint32 *rgb_2_pix;
|
||||
void (*Display1X) (int *colortab, Uint32 * rgb_2_pix,
|
||||
unsigned char *lum, unsigned char *cr,
|
||||
unsigned char *cb, unsigned char *out,
|
||||
int rows, int cols, int mod);
|
||||
void (*Display2X) (int *colortab, Uint32 * rgb_2_pix,
|
||||
unsigned char *lum, unsigned char *cr,
|
||||
unsigned char *cb, unsigned char *out,
|
||||
int rows, int cols, int mod);
|
||||
|
||||
/* These are just so we don't have to allocate them separately */
|
||||
Uint16 pitches[3];
|
||||
Uint8 *planes[3];
|
||||
|
||||
/* This is a temporary surface in case we have to stretch copy */
|
||||
SDL_Surface *stretch;
|
||||
SDL_Surface *display;
|
||||
};
|
||||
|
||||
typedef struct SDL_SW_YUVTexture SDL_SW_YUVTexture;
|
||||
|
||||
SDL_SW_YUVTexture *SDL_SW_CreateYUVTexture(Uint32 format, int w, int h);
|
||||
int SDL_SW_QueryYUVTexturePixels(SDL_SW_YUVTexture * swdata, void **pixels,
|
||||
int *pitch);
|
||||
int SDL_SW_UpdateYUVTexture(SDL_SW_YUVTexture * swdata, const SDL_Rect * rect,
|
||||
const void *pixels, int pitch);
|
||||
int SDL_SW_LockYUVTexture(SDL_SW_YUVTexture * swdata, const SDL_Rect * rect,
|
||||
void **pixels, int *pitch);
|
||||
void SDL_SW_UnlockYUVTexture(SDL_SW_YUVTexture * swdata);
|
||||
int SDL_SW_CopyYUVToRGB(SDL_SW_YUVTexture * swdata, const SDL_Rect * srcrect,
|
||||
Uint32 target_format, int w, int h, void *pixels,
|
||||
int pitch);
|
||||
void SDL_SW_DestroyYUVTexture(SDL_SW_YUVTexture * swdata);
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
1204
project/jni/sdl-1.3/src/render/direct3d/SDL_render_d3d.c
Normal file
1204
project/jni/sdl-1.3/src/render/direct3d/SDL_render_d3d.c
Normal file
File diff suppressed because it is too large
Load Diff
642
project/jni/sdl-1.3/src/render/mmx.h
Normal file
642
project/jni/sdl-1.3/src/render/mmx.h
Normal file
@@ -0,0 +1,642 @@
|
||||
/* mmx.h
|
||||
|
||||
MultiMedia eXtensions GCC interface library for IA32.
|
||||
|
||||
To use this library, simply include this header file
|
||||
and compile with GCC. You MUST have inlining enabled
|
||||
in order for mmx_ok() to work; this can be done by
|
||||
simply using -O on the GCC command line.
|
||||
|
||||
Compiling with -DMMX_TRACE will cause detailed trace
|
||||
output to be sent to stderr for each mmx operation.
|
||||
This adds lots of code, and obviously slows execution to
|
||||
a crawl, but can be very useful for debugging.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY
|
||||
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT
|
||||
LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
AND FITNESS FOR ANY PARTICULAR PURPOSE.
|
||||
|
||||
1997-99 by H. Dietz and R. Fisher
|
||||
|
||||
Notes:
|
||||
It appears that the latest gas has the pand problem fixed, therefore
|
||||
I'll undefine BROKEN_PAND by default.
|
||||
*/
|
||||
|
||||
#ifndef _MMX_H
|
||||
#define _MMX_H
|
||||
|
||||
|
||||
/* Warning: at this writing, the version of GAS packaged
|
||||
with most Linux distributions does not handle the
|
||||
parallel AND operation mnemonic correctly. If the
|
||||
symbol BROKEN_PAND is defined, a slower alternative
|
||||
coding will be used. If execution of mmxtest results
|
||||
in an illegal instruction fault, define this symbol.
|
||||
*/
|
||||
#undef BROKEN_PAND
|
||||
|
||||
|
||||
/* The type of an value that fits in an MMX register
|
||||
(note that long long constant values MUST be suffixed
|
||||
by LL and unsigned long long values by ULL, lest
|
||||
they be truncated by the compiler)
|
||||
*/
|
||||
typedef union
|
||||
{
|
||||
long long q; /* Quadword (64-bit) value */
|
||||
unsigned long long uq; /* Unsigned Quadword */
|
||||
int d[2]; /* 2 Doubleword (32-bit) values */
|
||||
unsigned int ud[2]; /* 2 Unsigned Doubleword */
|
||||
short w[4]; /* 4 Word (16-bit) values */
|
||||
unsigned short uw[4]; /* 4 Unsigned Word */
|
||||
char b[8]; /* 8 Byte (8-bit) values */
|
||||
unsigned char ub[8]; /* 8 Unsigned Byte */
|
||||
float s[2]; /* Single-precision (32-bit) value */
|
||||
} __attribute__ ((aligned(8))) mmx_t; /* On an 8-byte (64-bit) boundary */
|
||||
|
||||
|
||||
#if 0
|
||||
/* Function to test if multimedia instructions are supported...
|
||||
*/
|
||||
inline extern int
|
||||
mm_support(void)
|
||||
{
|
||||
/* Returns 1 if MMX instructions are supported,
|
||||
3 if Cyrix MMX and Extended MMX instructions are supported
|
||||
5 if AMD MMX and 3DNow! instructions are supported
|
||||
0 if hardware does not support any of these
|
||||
*/
|
||||
register int rval = 0;
|
||||
|
||||
__asm__ __volatile__(
|
||||
/* See if CPUID instruction is supported ... */
|
||||
/* ... Get copies of EFLAGS into eax and ecx */
|
||||
"pushf\n\t"
|
||||
"popl %%eax\n\t" "movl %%eax, %%ecx\n\t"
|
||||
/* ... Toggle the ID bit in one copy and store */
|
||||
/* to the EFLAGS reg */
|
||||
"xorl $0x200000, %%eax\n\t"
|
||||
"push %%eax\n\t" "popf\n\t"
|
||||
/* ... Get the (hopefully modified) EFLAGS */
|
||||
"pushf\n\t" "popl %%eax\n\t"
|
||||
/* ... Compare and test result */
|
||||
"xorl %%eax, %%ecx\n\t" "testl $0x200000, %%ecx\n\t" "jz NotSupported1\n\t" /* CPUID not supported */
|
||||
/* Get standard CPUID information, and
|
||||
go to a specific vendor section */
|
||||
"movl $0, %%eax\n\t" "cpuid\n\t"
|
||||
/* Check for Intel */
|
||||
"cmpl $0x756e6547, %%ebx\n\t"
|
||||
"jne TryAMD\n\t"
|
||||
"cmpl $0x49656e69, %%edx\n\t"
|
||||
"jne TryAMD\n\t"
|
||||
"cmpl $0x6c65746e, %%ecx\n"
|
||||
"jne TryAMD\n\t" "jmp Intel\n\t"
|
||||
/* Check for AMD */
|
||||
"\nTryAMD:\n\t"
|
||||
"cmpl $0x68747541, %%ebx\n\t"
|
||||
"jne TryCyrix\n\t"
|
||||
"cmpl $0x69746e65, %%edx\n\t"
|
||||
"jne TryCyrix\n\t"
|
||||
"cmpl $0x444d4163, %%ecx\n"
|
||||
"jne TryCyrix\n\t" "jmp AMD\n\t"
|
||||
/* Check for Cyrix */
|
||||
"\nTryCyrix:\n\t"
|
||||
"cmpl $0x69727943, %%ebx\n\t"
|
||||
"jne NotSupported2\n\t"
|
||||
"cmpl $0x736e4978, %%edx\n\t"
|
||||
"jne NotSupported3\n\t"
|
||||
"cmpl $0x64616574, %%ecx\n\t"
|
||||
"jne NotSupported4\n\t"
|
||||
/* Drop through to Cyrix... */
|
||||
/* Cyrix Section */
|
||||
/* See if extended CPUID level 80000001 is supported */
|
||||
/* The value of CPUID/80000001 for the 6x86MX is undefined
|
||||
according to the Cyrix CPU Detection Guide (Preliminary
|
||||
Rev. 1.01 table 1), so we'll check the value of eax for
|
||||
CPUID/0 to see if standard CPUID level 2 is supported.
|
||||
According to the table, the only CPU which supports level
|
||||
2 is also the only one which supports extended CPUID levels.
|
||||
*/
|
||||
"cmpl $0x2, %%eax\n\t" "jne MMXtest\n\t" /* Use standard CPUID instead */
|
||||
/* Extended CPUID supported (in theory), so get extended
|
||||
features */
|
||||
"movl $0x80000001, %%eax\n\t" "cpuid\n\t" "testl $0x00800000, %%eax\n\t" /* Test for MMX */
|
||||
"jz NotSupported5\n\t" /* MMX not supported */
|
||||
"testl $0x01000000, %%eax\n\t" /* Test for Ext'd MMX */
|
||||
"jnz EMMXSupported\n\t" "movl $1, %0:\n\n\t" /* MMX Supported */
|
||||
"jmp Return\n\n" "EMMXSupported:\n\t" "movl $3, %0:\n\n\t" /* EMMX and MMX Supported */
|
||||
"jmp Return\n\t"
|
||||
/* AMD Section */
|
||||
"AMD:\n\t"
|
||||
/* See if extended CPUID is supported */
|
||||
"movl $0x80000000, %%eax\n\t" "cpuid\n\t" "cmpl $0x80000000, %%eax\n\t" "jl MMXtest\n\t" /* Use standard CPUID instead */
|
||||
/* Extended CPUID supported, so get extended features */
|
||||
"movl $0x80000001, %%eax\n\t" "cpuid\n\t" "testl $0x00800000, %%edx\n\t" /* Test for MMX */
|
||||
"jz NotSupported6\n\t" /* MMX not supported */
|
||||
"testl $0x80000000, %%edx\n\t" /* Test for 3DNow! */
|
||||
"jnz ThreeDNowSupported\n\t" "movl $1, %0:\n\n\t" /* MMX Supported */
|
||||
"jmp Return\n\n" "ThreeDNowSupported:\n\t" "movl $5, %0:\n\n\t" /* 3DNow! and MMX Supported */
|
||||
"jmp Return\n\t"
|
||||
/* Intel Section */
|
||||
"Intel:\n\t"
|
||||
/* Check for MMX */
|
||||
"MMXtest:\n\t" "movl $1, %%eax\n\t" "cpuid\n\t" "testl $0x00800000, %%edx\n\t" /* Test for MMX */
|
||||
"jz NotSupported7\n\t" /* MMX Not supported */
|
||||
"movl $1, %0:\n\n\t" /* MMX Supported */
|
||||
"jmp Return\n\t"
|
||||
/* Nothing supported */
|
||||
"\nNotSupported1:\n\t" "#movl $101, %0:\n\n\t" "\nNotSupported2:\n\t" "#movl $102, %0:\n\n\t" "\nNotSupported3:\n\t" "#movl $103, %0:\n\n\t" "\nNotSupported4:\n\t" "#movl $104, %0:\n\n\t" "\nNotSupported5:\n\t" "#movl $105, %0:\n\n\t" "\nNotSupported6:\n\t" "#movl $106, %0:\n\n\t" "\nNotSupported7:\n\t" "#movl $107, %0:\n\n\t" "movl $0, %0:\n\n\t" "Return:\n\t":"=a"(rval): /* no input */
|
||||
:"eax", "ebx", "ecx", "edx");
|
||||
|
||||
/* Return */
|
||||
return (rval);
|
||||
}
|
||||
|
||||
/* Function to test if mmx instructions are supported...
|
||||
*/
|
||||
inline extern int
|
||||
mmx_ok(void)
|
||||
{
|
||||
/* Returns 1 if MMX instructions are supported, 0 otherwise */
|
||||
return (mm_support() & 0x1);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Helper functions for the instruction macros that follow...
|
||||
(note that memory-to-register, m2r, instructions are nearly
|
||||
as efficient as register-to-register, r2r, instructions;
|
||||
however, memory-to-memory instructions are really simulated
|
||||
as a convenience, and are only 1/3 as efficient)
|
||||
*/
|
||||
#ifdef MMX_TRACE
|
||||
|
||||
/* Include the stuff for printing a trace to stderr...
|
||||
*/
|
||||
|
||||
#define mmx_i2r(op, imm, reg) \
|
||||
{ \
|
||||
mmx_t mmx_trace; \
|
||||
mmx_trace.uq = (imm); \
|
||||
printf(#op "_i2r(" #imm "=0x%08x%08x, ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
__asm__ __volatile__ ("movq %%" #reg ", %0" \
|
||||
: "=X" (mmx_trace) \
|
||||
: /* nothing */ ); \
|
||||
printf(#reg "=0x%08x%08x) => ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
__asm__ __volatile__ (#op " %0, %%" #reg \
|
||||
: /* nothing */ \
|
||||
: "X" (imm)); \
|
||||
__asm__ __volatile__ ("movq %%" #reg ", %0" \
|
||||
: "=X" (mmx_trace) \
|
||||
: /* nothing */ ); \
|
||||
printf(#reg "=0x%08x%08x\n", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
}
|
||||
|
||||
#define mmx_m2r(op, mem, reg) \
|
||||
{ \
|
||||
mmx_t mmx_trace; \
|
||||
mmx_trace = (mem); \
|
||||
printf(#op "_m2r(" #mem "=0x%08x%08x, ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
__asm__ __volatile__ ("movq %%" #reg ", %0" \
|
||||
: "=X" (mmx_trace) \
|
||||
: /* nothing */ ); \
|
||||
printf(#reg "=0x%08x%08x) => ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
__asm__ __volatile__ (#op " %0, %%" #reg \
|
||||
: /* nothing */ \
|
||||
: "X" (mem)); \
|
||||
__asm__ __volatile__ ("movq %%" #reg ", %0" \
|
||||
: "=X" (mmx_trace) \
|
||||
: /* nothing */ ); \
|
||||
printf(#reg "=0x%08x%08x\n", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
}
|
||||
|
||||
#define mmx_r2m(op, reg, mem) \
|
||||
{ \
|
||||
mmx_t mmx_trace; \
|
||||
__asm__ __volatile__ ("movq %%" #reg ", %0" \
|
||||
: "=X" (mmx_trace) \
|
||||
: /* nothing */ ); \
|
||||
printf(#op "_r2m(" #reg "=0x%08x%08x, ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
mmx_trace = (mem); \
|
||||
printf(#mem "=0x%08x%08x) => ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
__asm__ __volatile__ (#op " %%" #reg ", %0" \
|
||||
: "=X" (mem) \
|
||||
: /* nothing */ ); \
|
||||
mmx_trace = (mem); \
|
||||
printf(#mem "=0x%08x%08x\n", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
}
|
||||
|
||||
#define mmx_r2r(op, regs, regd) \
|
||||
{ \
|
||||
mmx_t mmx_trace; \
|
||||
__asm__ __volatile__ ("movq %%" #regs ", %0" \
|
||||
: "=X" (mmx_trace) \
|
||||
: /* nothing */ ); \
|
||||
printf(#op "_r2r(" #regs "=0x%08x%08x, ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
__asm__ __volatile__ ("movq %%" #regd ", %0" \
|
||||
: "=X" (mmx_trace) \
|
||||
: /* nothing */ ); \
|
||||
printf(#regd "=0x%08x%08x) => ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
__asm__ __volatile__ (#op " %" #regs ", %" #regd); \
|
||||
__asm__ __volatile__ ("movq %%" #regd ", %0" \
|
||||
: "=X" (mmx_trace) \
|
||||
: /* nothing */ ); \
|
||||
printf(#regd "=0x%08x%08x\n", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
}
|
||||
|
||||
#define mmx_m2m(op, mems, memd) \
|
||||
{ \
|
||||
mmx_t mmx_trace; \
|
||||
mmx_trace = (mems); \
|
||||
printf(#op "_m2m(" #mems "=0x%08x%08x, ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
mmx_trace = (memd); \
|
||||
printf(#memd "=0x%08x%08x) => ", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
__asm__ __volatile__ ("movq %0, %%mm0\n\t" \
|
||||
#op " %1, %%mm0\n\t" \
|
||||
"movq %%mm0, %0" \
|
||||
: "=X" (memd) \
|
||||
: "X" (mems)); \
|
||||
mmx_trace = (memd); \
|
||||
printf(#memd "=0x%08x%08x\n", \
|
||||
mmx_trace.d[1], mmx_trace.d[0]); \
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
/* These macros are a lot simpler without the tracing...
|
||||
*/
|
||||
|
||||
#define mmx_i2r(op, imm, reg) \
|
||||
__asm__ __volatile__ (#op " %0, %%" #reg \
|
||||
: /* nothing */ \
|
||||
: "X" (imm) )
|
||||
|
||||
#define mmx_m2r(op, mem, reg) \
|
||||
__asm__ __volatile__ (#op " %0, %%" #reg \
|
||||
: /* nothing */ \
|
||||
: "m" (mem))
|
||||
|
||||
#define mmx_r2m(op, reg, mem) \
|
||||
__asm__ __volatile__ (#op " %%" #reg ", %0" \
|
||||
: "=m" (mem) \
|
||||
: /* nothing */ )
|
||||
|
||||
#define mmx_r2r(op, regs, regd) \
|
||||
__asm__ __volatile__ (#op " %" #regs ", %" #regd)
|
||||
|
||||
#define mmx_m2m(op, mems, memd) \
|
||||
__asm__ __volatile__ ("movq %0, %%mm0\n\t" \
|
||||
#op " %1, %%mm0\n\t" \
|
||||
"movq %%mm0, %0" \
|
||||
: "=X" (memd) \
|
||||
: "X" (mems))
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/* 1x64 MOVe Quadword
|
||||
(this is both a load and a store...
|
||||
in fact, it is the only way to store)
|
||||
*/
|
||||
#define movq_m2r(var, reg) mmx_m2r(movq, var, reg)
|
||||
#define movq_r2m(reg, var) mmx_r2m(movq, reg, var)
|
||||
#define movq_r2r(regs, regd) mmx_r2r(movq, regs, regd)
|
||||
#define movq(vars, vard) \
|
||||
__asm__ __volatile__ ("movq %1, %%mm0\n\t" \
|
||||
"movq %%mm0, %0" \
|
||||
: "=X" (vard) \
|
||||
: "X" (vars))
|
||||
|
||||
|
||||
/* 1x32 MOVe Doubleword
|
||||
(like movq, this is both load and store...
|
||||
but is most useful for moving things between
|
||||
mmx registers and ordinary registers)
|
||||
*/
|
||||
#define movd_m2r(var, reg) mmx_m2r(movd, var, reg)
|
||||
#define movd_r2m(reg, var) mmx_r2m(movd, reg, var)
|
||||
#define movd_r2r(regs, regd) mmx_r2r(movd, regs, regd)
|
||||
#define movd(vars, vard) \
|
||||
__asm__ __volatile__ ("movd %1, %%mm0\n\t" \
|
||||
"movd %%mm0, %0" \
|
||||
: "=X" (vard) \
|
||||
: "X" (vars))
|
||||
|
||||
|
||||
/* 2x32, 4x16, and 8x8 Parallel ADDs
|
||||
*/
|
||||
#define paddd_m2r(var, reg) mmx_m2r(paddd, var, reg)
|
||||
#define paddd_r2r(regs, regd) mmx_r2r(paddd, regs, regd)
|
||||
#define paddd(vars, vard) mmx_m2m(paddd, vars, vard)
|
||||
|
||||
#define paddw_m2r(var, reg) mmx_m2r(paddw, var, reg)
|
||||
#define paddw_r2r(regs, regd) mmx_r2r(paddw, regs, regd)
|
||||
#define paddw(vars, vard) mmx_m2m(paddw, vars, vard)
|
||||
|
||||
#define paddb_m2r(var, reg) mmx_m2r(paddb, var, reg)
|
||||
#define paddb_r2r(regs, regd) mmx_r2r(paddb, regs, regd)
|
||||
#define paddb(vars, vard) mmx_m2m(paddb, vars, vard)
|
||||
|
||||
|
||||
/* 4x16 and 8x8 Parallel ADDs using Saturation arithmetic
|
||||
*/
|
||||
#define paddsw_m2r(var, reg) mmx_m2r(paddsw, var, reg)
|
||||
#define paddsw_r2r(regs, regd) mmx_r2r(paddsw, regs, regd)
|
||||
#define paddsw(vars, vard) mmx_m2m(paddsw, vars, vard)
|
||||
|
||||
#define paddsb_m2r(var, reg) mmx_m2r(paddsb, var, reg)
|
||||
#define paddsb_r2r(regs, regd) mmx_r2r(paddsb, regs, regd)
|
||||
#define paddsb(vars, vard) mmx_m2m(paddsb, vars, vard)
|
||||
|
||||
|
||||
/* 4x16 and 8x8 Parallel ADDs using Unsigned Saturation arithmetic
|
||||
*/
|
||||
#define paddusw_m2r(var, reg) mmx_m2r(paddusw, var, reg)
|
||||
#define paddusw_r2r(regs, regd) mmx_r2r(paddusw, regs, regd)
|
||||
#define paddusw(vars, vard) mmx_m2m(paddusw, vars, vard)
|
||||
|
||||
#define paddusb_m2r(var, reg) mmx_m2r(paddusb, var, reg)
|
||||
#define paddusb_r2r(regs, regd) mmx_r2r(paddusb, regs, regd)
|
||||
#define paddusb(vars, vard) mmx_m2m(paddusb, vars, vard)
|
||||
|
||||
|
||||
/* 2x32, 4x16, and 8x8 Parallel SUBs
|
||||
*/
|
||||
#define psubd_m2r(var, reg) mmx_m2r(psubd, var, reg)
|
||||
#define psubd_r2r(regs, regd) mmx_r2r(psubd, regs, regd)
|
||||
#define psubd(vars, vard) mmx_m2m(psubd, vars, vard)
|
||||
|
||||
#define psubw_m2r(var, reg) mmx_m2r(psubw, var, reg)
|
||||
#define psubw_r2r(regs, regd) mmx_r2r(psubw, regs, regd)
|
||||
#define psubw(vars, vard) mmx_m2m(psubw, vars, vard)
|
||||
|
||||
#define psubb_m2r(var, reg) mmx_m2r(psubb, var, reg)
|
||||
#define psubb_r2r(regs, regd) mmx_r2r(psubb, regs, regd)
|
||||
#define psubb(vars, vard) mmx_m2m(psubb, vars, vard)
|
||||
|
||||
|
||||
/* 4x16 and 8x8 Parallel SUBs using Saturation arithmetic
|
||||
*/
|
||||
#define psubsw_m2r(var, reg) mmx_m2r(psubsw, var, reg)
|
||||
#define psubsw_r2r(regs, regd) mmx_r2r(psubsw, regs, regd)
|
||||
#define psubsw(vars, vard) mmx_m2m(psubsw, vars, vard)
|
||||
|
||||
#define psubsb_m2r(var, reg) mmx_m2r(psubsb, var, reg)
|
||||
#define psubsb_r2r(regs, regd) mmx_r2r(psubsb, regs, regd)
|
||||
#define psubsb(vars, vard) mmx_m2m(psubsb, vars, vard)
|
||||
|
||||
|
||||
/* 4x16 and 8x8 Parallel SUBs using Unsigned Saturation arithmetic
|
||||
*/
|
||||
#define psubusw_m2r(var, reg) mmx_m2r(psubusw, var, reg)
|
||||
#define psubusw_r2r(regs, regd) mmx_r2r(psubusw, regs, regd)
|
||||
#define psubusw(vars, vard) mmx_m2m(psubusw, vars, vard)
|
||||
|
||||
#define psubusb_m2r(var, reg) mmx_m2r(psubusb, var, reg)
|
||||
#define psubusb_r2r(regs, regd) mmx_r2r(psubusb, regs, regd)
|
||||
#define psubusb(vars, vard) mmx_m2m(psubusb, vars, vard)
|
||||
|
||||
|
||||
/* 4x16 Parallel MULs giving Low 4x16 portions of results
|
||||
*/
|
||||
#define pmullw_m2r(var, reg) mmx_m2r(pmullw, var, reg)
|
||||
#define pmullw_r2r(regs, regd) mmx_r2r(pmullw, regs, regd)
|
||||
#define pmullw(vars, vard) mmx_m2m(pmullw, vars, vard)
|
||||
|
||||
|
||||
/* 4x16 Parallel MULs giving High 4x16 portions of results
|
||||
*/
|
||||
#define pmulhw_m2r(var, reg) mmx_m2r(pmulhw, var, reg)
|
||||
#define pmulhw_r2r(regs, regd) mmx_r2r(pmulhw, regs, regd)
|
||||
#define pmulhw(vars, vard) mmx_m2m(pmulhw, vars, vard)
|
||||
|
||||
|
||||
/* 4x16->2x32 Parallel Mul-ADD
|
||||
(muls like pmullw, then adds adjacent 16-bit fields
|
||||
in the multiply result to make the final 2x32 result)
|
||||
*/
|
||||
#define pmaddwd_m2r(var, reg) mmx_m2r(pmaddwd, var, reg)
|
||||
#define pmaddwd_r2r(regs, regd) mmx_r2r(pmaddwd, regs, regd)
|
||||
#define pmaddwd(vars, vard) mmx_m2m(pmaddwd, vars, vard)
|
||||
|
||||
|
||||
/* 1x64 bitwise AND
|
||||
*/
|
||||
#ifdef BROKEN_PAND
|
||||
#define pand_m2r(var, reg) \
|
||||
{ \
|
||||
mmx_m2r(pandn, (mmx_t) -1LL, reg); \
|
||||
mmx_m2r(pandn, var, reg); \
|
||||
}
|
||||
#define pand_r2r(regs, regd) \
|
||||
{ \
|
||||
mmx_m2r(pandn, (mmx_t) -1LL, regd); \
|
||||
mmx_r2r(pandn, regs, regd) \
|
||||
}
|
||||
#define pand(vars, vard) \
|
||||
{ \
|
||||
movq_m2r(vard, mm0); \
|
||||
mmx_m2r(pandn, (mmx_t) -1LL, mm0); \
|
||||
mmx_m2r(pandn, vars, mm0); \
|
||||
movq_r2m(mm0, vard); \
|
||||
}
|
||||
#else
|
||||
#define pand_m2r(var, reg) mmx_m2r(pand, var, reg)
|
||||
#define pand_r2r(regs, regd) mmx_r2r(pand, regs, regd)
|
||||
#define pand(vars, vard) mmx_m2m(pand, vars, vard)
|
||||
#endif
|
||||
|
||||
|
||||
/* 1x64 bitwise AND with Not the destination
|
||||
*/
|
||||
#define pandn_m2r(var, reg) mmx_m2r(pandn, var, reg)
|
||||
#define pandn_r2r(regs, regd) mmx_r2r(pandn, regs, regd)
|
||||
#define pandn(vars, vard) mmx_m2m(pandn, vars, vard)
|
||||
|
||||
|
||||
/* 1x64 bitwise OR
|
||||
*/
|
||||
#define por_m2r(var, reg) mmx_m2r(por, var, reg)
|
||||
#define por_r2r(regs, regd) mmx_r2r(por, regs, regd)
|
||||
#define por(vars, vard) mmx_m2m(por, vars, vard)
|
||||
|
||||
|
||||
/* 1x64 bitwise eXclusive OR
|
||||
*/
|
||||
#define pxor_m2r(var, reg) mmx_m2r(pxor, var, reg)
|
||||
#define pxor_r2r(regs, regd) mmx_r2r(pxor, regs, regd)
|
||||
#define pxor(vars, vard) mmx_m2m(pxor, vars, vard)
|
||||
|
||||
|
||||
/* 2x32, 4x16, and 8x8 Parallel CoMPare for EQuality
|
||||
(resulting fields are either 0 or -1)
|
||||
*/
|
||||
#define pcmpeqd_m2r(var, reg) mmx_m2r(pcmpeqd, var, reg)
|
||||
#define pcmpeqd_r2r(regs, regd) mmx_r2r(pcmpeqd, regs, regd)
|
||||
#define pcmpeqd(vars, vard) mmx_m2m(pcmpeqd, vars, vard)
|
||||
|
||||
#define pcmpeqw_m2r(var, reg) mmx_m2r(pcmpeqw, var, reg)
|
||||
#define pcmpeqw_r2r(regs, regd) mmx_r2r(pcmpeqw, regs, regd)
|
||||
#define pcmpeqw(vars, vard) mmx_m2m(pcmpeqw, vars, vard)
|
||||
|
||||
#define pcmpeqb_m2r(var, reg) mmx_m2r(pcmpeqb, var, reg)
|
||||
#define pcmpeqb_r2r(regs, regd) mmx_r2r(pcmpeqb, regs, regd)
|
||||
#define pcmpeqb(vars, vard) mmx_m2m(pcmpeqb, vars, vard)
|
||||
|
||||
|
||||
/* 2x32, 4x16, and 8x8 Parallel CoMPare for Greater Than
|
||||
(resulting fields are either 0 or -1)
|
||||
*/
|
||||
#define pcmpgtd_m2r(var, reg) mmx_m2r(pcmpgtd, var, reg)
|
||||
#define pcmpgtd_r2r(regs, regd) mmx_r2r(pcmpgtd, regs, regd)
|
||||
#define pcmpgtd(vars, vard) mmx_m2m(pcmpgtd, vars, vard)
|
||||
|
||||
#define pcmpgtw_m2r(var, reg) mmx_m2r(pcmpgtw, var, reg)
|
||||
#define pcmpgtw_r2r(regs, regd) mmx_r2r(pcmpgtw, regs, regd)
|
||||
#define pcmpgtw(vars, vard) mmx_m2m(pcmpgtw, vars, vard)
|
||||
|
||||
#define pcmpgtb_m2r(var, reg) mmx_m2r(pcmpgtb, var, reg)
|
||||
#define pcmpgtb_r2r(regs, regd) mmx_r2r(pcmpgtb, regs, regd)
|
||||
#define pcmpgtb(vars, vard) mmx_m2m(pcmpgtb, vars, vard)
|
||||
|
||||
|
||||
/* 1x64, 2x32, and 4x16 Parallel Shift Left Logical
|
||||
*/
|
||||
#define psllq_i2r(imm, reg) mmx_i2r(psllq, imm, reg)
|
||||
#define psllq_m2r(var, reg) mmx_m2r(psllq, var, reg)
|
||||
#define psllq_r2r(regs, regd) mmx_r2r(psllq, regs, regd)
|
||||
#define psllq(vars, vard) mmx_m2m(psllq, vars, vard)
|
||||
|
||||
#define pslld_i2r(imm, reg) mmx_i2r(pslld, imm, reg)
|
||||
#define pslld_m2r(var, reg) mmx_m2r(pslld, var, reg)
|
||||
#define pslld_r2r(regs, regd) mmx_r2r(pslld, regs, regd)
|
||||
#define pslld(vars, vard) mmx_m2m(pslld, vars, vard)
|
||||
|
||||
#define psllw_i2r(imm, reg) mmx_i2r(psllw, imm, reg)
|
||||
#define psllw_m2r(var, reg) mmx_m2r(psllw, var, reg)
|
||||
#define psllw_r2r(regs, regd) mmx_r2r(psllw, regs, regd)
|
||||
#define psllw(vars, vard) mmx_m2m(psllw, vars, vard)
|
||||
|
||||
|
||||
/* 1x64, 2x32, and 4x16 Parallel Shift Right Logical
|
||||
*/
|
||||
#define psrlq_i2r(imm, reg) mmx_i2r(psrlq, imm, reg)
|
||||
#define psrlq_m2r(var, reg) mmx_m2r(psrlq, var, reg)
|
||||
#define psrlq_r2r(regs, regd) mmx_r2r(psrlq, regs, regd)
|
||||
#define psrlq(vars, vard) mmx_m2m(psrlq, vars, vard)
|
||||
|
||||
#define psrld_i2r(imm, reg) mmx_i2r(psrld, imm, reg)
|
||||
#define psrld_m2r(var, reg) mmx_m2r(psrld, var, reg)
|
||||
#define psrld_r2r(regs, regd) mmx_r2r(psrld, regs, regd)
|
||||
#define psrld(vars, vard) mmx_m2m(psrld, vars, vard)
|
||||
|
||||
#define psrlw_i2r(imm, reg) mmx_i2r(psrlw, imm, reg)
|
||||
#define psrlw_m2r(var, reg) mmx_m2r(psrlw, var, reg)
|
||||
#define psrlw_r2r(regs, regd) mmx_r2r(psrlw, regs, regd)
|
||||
#define psrlw(vars, vard) mmx_m2m(psrlw, vars, vard)
|
||||
|
||||
|
||||
/* 2x32 and 4x16 Parallel Shift Right Arithmetic
|
||||
*/
|
||||
#define psrad_i2r(imm, reg) mmx_i2r(psrad, imm, reg)
|
||||
#define psrad_m2r(var, reg) mmx_m2r(psrad, var, reg)
|
||||
#define psrad_r2r(regs, regd) mmx_r2r(psrad, regs, regd)
|
||||
#define psrad(vars, vard) mmx_m2m(psrad, vars, vard)
|
||||
|
||||
#define psraw_i2r(imm, reg) mmx_i2r(psraw, imm, reg)
|
||||
#define psraw_m2r(var, reg) mmx_m2r(psraw, var, reg)
|
||||
#define psraw_r2r(regs, regd) mmx_r2r(psraw, regs, regd)
|
||||
#define psraw(vars, vard) mmx_m2m(psraw, vars, vard)
|
||||
|
||||
|
||||
/* 2x32->4x16 and 4x16->8x8 PACK and Signed Saturate
|
||||
(packs source and dest fields into dest in that order)
|
||||
*/
|
||||
#define packssdw_m2r(var, reg) mmx_m2r(packssdw, var, reg)
|
||||
#define packssdw_r2r(regs, regd) mmx_r2r(packssdw, regs, regd)
|
||||
#define packssdw(vars, vard) mmx_m2m(packssdw, vars, vard)
|
||||
|
||||
#define packsswb_m2r(var, reg) mmx_m2r(packsswb, var, reg)
|
||||
#define packsswb_r2r(regs, regd) mmx_r2r(packsswb, regs, regd)
|
||||
#define packsswb(vars, vard) mmx_m2m(packsswb, vars, vard)
|
||||
|
||||
|
||||
/* 4x16->8x8 PACK and Unsigned Saturate
|
||||
(packs source and dest fields into dest in that order)
|
||||
*/
|
||||
#define packuswb_m2r(var, reg) mmx_m2r(packuswb, var, reg)
|
||||
#define packuswb_r2r(regs, regd) mmx_r2r(packuswb, regs, regd)
|
||||
#define packuswb(vars, vard) mmx_m2m(packuswb, vars, vard)
|
||||
|
||||
|
||||
/* 2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK Low
|
||||
(interleaves low half of dest with low half of source
|
||||
as padding in each result field)
|
||||
*/
|
||||
#define punpckldq_m2r(var, reg) mmx_m2r(punpckldq, var, reg)
|
||||
#define punpckldq_r2r(regs, regd) mmx_r2r(punpckldq, regs, regd)
|
||||
#define punpckldq(vars, vard) mmx_m2m(punpckldq, vars, vard)
|
||||
|
||||
#define punpcklwd_m2r(var, reg) mmx_m2r(punpcklwd, var, reg)
|
||||
#define punpcklwd_r2r(regs, regd) mmx_r2r(punpcklwd, regs, regd)
|
||||
#define punpcklwd(vars, vard) mmx_m2m(punpcklwd, vars, vard)
|
||||
|
||||
#define punpcklbw_m2r(var, reg) mmx_m2r(punpcklbw, var, reg)
|
||||
#define punpcklbw_r2r(regs, regd) mmx_r2r(punpcklbw, regs, regd)
|
||||
#define punpcklbw(vars, vard) mmx_m2m(punpcklbw, vars, vard)
|
||||
|
||||
|
||||
/* 2x32->1x64, 4x16->2x32, and 8x8->4x16 UNPaCK High
|
||||
(interleaves high half of dest with high half of source
|
||||
as padding in each result field)
|
||||
*/
|
||||
#define punpckhdq_m2r(var, reg) mmx_m2r(punpckhdq, var, reg)
|
||||
#define punpckhdq_r2r(regs, regd) mmx_r2r(punpckhdq, regs, regd)
|
||||
#define punpckhdq(vars, vard) mmx_m2m(punpckhdq, vars, vard)
|
||||
|
||||
#define punpckhwd_m2r(var, reg) mmx_m2r(punpckhwd, var, reg)
|
||||
#define punpckhwd_r2r(regs, regd) mmx_r2r(punpckhwd, regs, regd)
|
||||
#define punpckhwd(vars, vard) mmx_m2m(punpckhwd, vars, vard)
|
||||
|
||||
#define punpckhbw_m2r(var, reg) mmx_m2r(punpckhbw, var, reg)
|
||||
#define punpckhbw_r2r(regs, regd) mmx_r2r(punpckhbw, regs, regd)
|
||||
#define punpckhbw(vars, vard) mmx_m2m(punpckhbw, vars, vard)
|
||||
|
||||
|
||||
/* Empty MMx State
|
||||
(used to clean-up when going from mmx to float use
|
||||
of the registers that are shared by both; note that
|
||||
there is no float-to-mmx operation needed, because
|
||||
only the float tag word info is corruptible)
|
||||
*/
|
||||
#ifdef MMX_TRACE
|
||||
|
||||
#define emms() \
|
||||
{ \
|
||||
printf("emms()\n"); \
|
||||
__asm__ __volatile__ ("emms"); \
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
#define emms() __asm__ __volatile__ ("emms")
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
361
project/jni/sdl-1.3/src/render/nds/SDL_ndsrender.c
Normal file
361
project/jni/sdl-1.3/src/render/nds/SDL_ndsrender.c
Normal file
@@ -0,0 +1,361 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if SDL_VIDEO_RENDER_NDS
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <nds.h>
|
||||
|
||||
#include <gl2d.h>
|
||||
|
||||
#include "SDL_video.h"
|
||||
#include "../../video/SDL_sysvideo.h"
|
||||
#include "SDL_render.h"
|
||||
#include "../SDL_sysrender.h"
|
||||
#include "SDL_log.h"
|
||||
|
||||
/* SDL NDS renderer implementation */
|
||||
|
||||
extern SDL_RenderDriver NDS_RenderDriver;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
/* Whether current 3D engine is on the main or sub screen. */
|
||||
int is_sub;
|
||||
} NDS_RenderData;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
glImage image[1];
|
||||
} NDS_TextureData;
|
||||
|
||||
|
||||
static int NDS_UpdateViewport(SDL_Renderer *renderer)
|
||||
{
|
||||
/* Nothing to do. */
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
NDS_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
|
||||
{
|
||||
NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
|
||||
NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
|
||||
int dest_y;
|
||||
|
||||
if (data->is_sub) {
|
||||
dest_y = dstrect->y;
|
||||
} else {
|
||||
dest_y = dstrect->y-SCREEN_HEIGHT;
|
||||
}
|
||||
|
||||
if (texture->w == dstrect->w && texture->h == dstrect->h) {
|
||||
/* No scaling */
|
||||
glSprite(dstrect->x, dest_y, GL_FLIP_NONE, txdat->image);
|
||||
} else {
|
||||
/* Convert the scaling proportion into a 20.12 value. */
|
||||
s32 scale_w = divf32(dstrect->w << 12, texture->w << 12);
|
||||
s32 scale_h = divf32(dstrect->h << 12, texture->h << 12);
|
||||
|
||||
glSpriteScaleXY(dstrect->x, dest_y, scale_w, scale_h, GL_FLIP_NONE, txdat->image);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int NDS_CreateTexture(SDL_Renderer *renderer, SDL_Texture *texture)
|
||||
{
|
||||
NDS_TextureData *txdat = NULL;
|
||||
int i;
|
||||
|
||||
SDL_Log("NDS_CreateTexture: NDS_CreateTexture.\n");
|
||||
|
||||
/* Sanity checks. */
|
||||
for (i=0; i<NDS_RenderDriver.info.num_texture_formats; i++) {
|
||||
if (texture->format == NDS_RenderDriver.info.texture_formats[i])
|
||||
break;
|
||||
}
|
||||
if (i == NDS_RenderDriver.info.num_texture_formats) {
|
||||
SDL_SetError("Unsupported texture format (%x)", texture->format);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (texture->w > NDS_RenderDriver.info.max_texture_width) {
|
||||
SDL_SetError("Texture too large (%d)", texture->w);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (texture->h > NDS_RenderDriver.info.max_texture_height) {
|
||||
SDL_SetError("Texture too tall (%d)", texture->h);
|
||||
return -1;
|
||||
}
|
||||
|
||||
texture->driverdata = SDL_calloc(1, sizeof(NDS_TextureData));
|
||||
txdat = (NDS_TextureData *) texture->driverdata;
|
||||
if (!txdat) {
|
||||
SDL_OutOfMemory();
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
NDS_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
NDS_TextureData *txdat = texture->driverdata;
|
||||
|
||||
/* free anything else allocated for texture */
|
||||
SDL_free(txdat);
|
||||
}
|
||||
|
||||
/* size is no more than 512. */
|
||||
static int get_gltexture_size(unsigned int size)
|
||||
{
|
||||
if (size > 256)
|
||||
return TEXTURE_SIZE_512;
|
||||
else if (size > 128)
|
||||
return TEXTURE_SIZE_256;
|
||||
else if (size > 64)
|
||||
return TEXTURE_SIZE_128;
|
||||
else if (size > 32)
|
||||
return TEXTURE_SIZE_64;
|
||||
else if (size > 16)
|
||||
return TEXTURE_SIZE_32;
|
||||
else if (size > 8)
|
||||
return TEXTURE_SIZE_16;
|
||||
else
|
||||
return TEXTURE_SIZE_8;
|
||||
}
|
||||
|
||||
static int NDS_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels, int pitch)
|
||||
{
|
||||
NDS_TextureData *txdat = (NDS_TextureData *) texture->driverdata;
|
||||
|
||||
glLoadTileSet(txdat->image,
|
||||
rect->w, rect->h,
|
||||
rect->w, rect->h,
|
||||
texture->format == SDL_PIXELFORMAT_ABGR1555 ? GL_RGBA : GL_RGB,
|
||||
get_gltexture_size(rect->w),
|
||||
get_gltexture_size(rect->h),
|
||||
TEXGEN_OFF, 0, NULL,
|
||||
pixels);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int NDS_LockTexture(SDL_Renderer *renderer, SDL_Texture *texture,
|
||||
const SDL_Rect *rect, void **pixels, int *pitch)
|
||||
{
|
||||
SDL_Log("enter %s (todo)\n", __func__);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void NDS_UnlockTexture(SDL_Renderer *renderer, SDL_Texture *texture)
|
||||
{
|
||||
SDL_Log("enter %s\n", __func__);
|
||||
/* stub! */
|
||||
}
|
||||
|
||||
static int NDS_RenderClear(SDL_Renderer *renderer)
|
||||
{
|
||||
glClearColor(renderer->r >> 3,
|
||||
renderer->g >> 3,
|
||||
renderer->b >> 3,
|
||||
renderer->a >> 3);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void NDS_RenderPresent(SDL_Renderer * renderer)
|
||||
{
|
||||
NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
|
||||
static int frame =0;
|
||||
|
||||
glEnd2D();
|
||||
|
||||
glFlush(0);
|
||||
|
||||
swiWaitForVBlank();
|
||||
|
||||
/* wait for capture unit to be ready */
|
||||
while(REG_DISPCAPCNT & DCAP_ENABLE);
|
||||
|
||||
/* 3D engine can only work on one screen at a time. */
|
||||
data->is_sub = !data->is_sub;
|
||||
if (data->is_sub) {
|
||||
lcdMainOnBottom();
|
||||
vramSetBankC(VRAM_C_LCD);
|
||||
vramSetBankD(VRAM_D_SUB_SPRITE);
|
||||
REG_DISPCAPCNT = DCAP_BANK(2) | DCAP_ENABLE | DCAP_SIZE(3);
|
||||
} else {
|
||||
lcdMainOnTop();
|
||||
vramSetBankD(VRAM_D_LCD);
|
||||
vramSetBankC(VRAM_C_SUB_BG);
|
||||
REG_DISPCAPCNT = DCAP_BANK(3) | DCAP_ENABLE | DCAP_SIZE(3);
|
||||
}
|
||||
|
||||
glBegin2D();
|
||||
}
|
||||
|
||||
static int NDS_RenderDrawPoints(SDL_Renderer *renderer, const SDL_Point *points,
|
||||
int count)
|
||||
{
|
||||
NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
|
||||
int i;
|
||||
int color = RGB15(renderer->r >> 3,
|
||||
renderer->g >> 3,
|
||||
renderer->b >> 3);
|
||||
|
||||
for (i=0; i < count; i++) {
|
||||
if (data->is_sub) {
|
||||
glPutPixel(points[i].x, points[i].y, color);
|
||||
} else {
|
||||
glPutPixel(points[i].x, points[i].y - SCREEN_HEIGHT, color);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int NDS_RenderDrawLines(SDL_Renderer *renderer, const SDL_Point *points,
|
||||
int count)
|
||||
{
|
||||
NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
|
||||
int i;
|
||||
int color = RGB15(renderer->r >> 3,
|
||||
renderer->g >> 3,
|
||||
renderer->b >> 3);
|
||||
|
||||
for (i=0; i < count-1; i++) {
|
||||
if (data->is_sub) {
|
||||
glLine(points[i].x, points[i].y, points[i+1].x, points[i+1].y, color);
|
||||
} else {
|
||||
glLine(points[i].x, points[i].y - SCREEN_HEIGHT,
|
||||
points[i+1].x, points[i+1].y - SCREEN_HEIGHT, color);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int NDS_RenderFillRects(SDL_Renderer *renderer, const SDL_Rect *rects,
|
||||
int count)
|
||||
{
|
||||
NDS_RenderData *data = (NDS_RenderData *) renderer->driverdata;
|
||||
int i;
|
||||
int color = RGB15(renderer->r >> 3,
|
||||
renderer->g >> 3,
|
||||
renderer->b >> 3);
|
||||
|
||||
for (i=0; i<count; i++) {
|
||||
if (data->is_sub) {
|
||||
glBoxFilled(rects[i].x, rects[i].y,
|
||||
rects[i].x + rects[i].w,
|
||||
rects[i].y + rects[i].h, color);
|
||||
} else {
|
||||
glBoxFilled(rects[i].x, rects[i].y - SCREEN_HEIGHT,
|
||||
rects[i].x + rects[i].w,
|
||||
rects[i].y + rects[i].h - SCREEN_HEIGHT,
|
||||
color);
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static SDL_Renderer *
|
||||
NDS_CreateRenderer(SDL_Window * window, Uint32 flags)
|
||||
{
|
||||
SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);
|
||||
SDL_DisplayMode *displayMode = &display->current_mode;
|
||||
SDL_Renderer *renderer;
|
||||
NDS_RenderData *data;
|
||||
int bpp;
|
||||
Uint32 Rmask, Gmask, Bmask, Amask;
|
||||
|
||||
if (displayMode->format != SDL_PIXELFORMAT_ABGR1555) {
|
||||
SDL_SetError("Unsupported pixel format (%x)", displayMode->format);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (!SDL_PixelFormatEnumToMasks(displayMode->format, &bpp,
|
||||
&Rmask, &Gmask, &Bmask, &Amask)) {
|
||||
SDL_SetError("Unknown display format");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
|
||||
if (!renderer) {
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
data = (NDS_RenderData *) SDL_calloc(1, sizeof(*data));
|
||||
if (!data) {
|
||||
SDL_free(renderer);
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
renderer->info = NDS_RenderDriver.info;
|
||||
renderer->info.flags = SDL_RENDERER_ACCELERATED;
|
||||
|
||||
renderer->UpdateViewport = NDS_UpdateViewport;
|
||||
renderer->CreateTexture = NDS_CreateTexture;
|
||||
renderer->DestroyTexture = NDS_DestroyTexture;
|
||||
renderer->RenderCopy = NDS_RenderCopy;
|
||||
renderer->UpdateTexture = NDS_UpdateTexture;
|
||||
renderer->LockTexture = NDS_LockTexture;
|
||||
renderer->UnlockTexture = NDS_UnlockTexture;
|
||||
renderer->RenderClear = NDS_RenderClear;
|
||||
renderer->RenderPresent = NDS_RenderPresent;
|
||||
renderer->RenderDrawPoints = NDS_RenderDrawPoints;
|
||||
renderer->RenderDrawLines = NDS_RenderDrawLines;
|
||||
renderer->RenderFillRects = NDS_RenderFillRects;
|
||||
|
||||
renderer->driverdata = data;
|
||||
|
||||
return renderer;
|
||||
}
|
||||
|
||||
SDL_RenderDriver NDS_RenderDriver = {
|
||||
.CreateRenderer = NDS_CreateRenderer,
|
||||
.info = {
|
||||
.name = "nds",
|
||||
.flags = SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC,
|
||||
.num_texture_formats = 2,
|
||||
.texture_formats = { [0] = SDL_PIXELFORMAT_ABGR1555,
|
||||
[1] = SDL_PIXELFORMAT_BGR555,
|
||||
},
|
||||
.max_texture_width = 512,
|
||||
.max_texture_height = 512,
|
||||
}
|
||||
};
|
||||
|
||||
#endif /* SDL_VIDEO_RENDER_NDS */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
455
project/jni/sdl-1.3/src/render/opengl/SDL_glfuncs.h
Normal file
455
project/jni/sdl-1.3/src/render/opengl/SDL_glfuncs.h
Normal file
@@ -0,0 +1,455 @@
|
||||
/* list of OpenGL functions sorted alphabetically
|
||||
If you need to use a GL function from the SDL video subsystem,
|
||||
change it's entry from SDL_PROC_UNUSED to SDL_PROC and rebuild.
|
||||
*/
|
||||
#define SDL_PROC_UNUSED(ret,func,params)
|
||||
|
||||
SDL_PROC_UNUSED(void, glAccum, (GLenum, GLfloat))
|
||||
SDL_PROC_UNUSED(void, glAlphaFunc, (GLenum, GLclampf))
|
||||
SDL_PROC_UNUSED(GLboolean, glAreTexturesResident,
|
||||
(GLsizei, const GLuint *, GLboolean *))
|
||||
SDL_PROC_UNUSED(void, glArrayElement, (GLint))
|
||||
SDL_PROC(void, glBegin, (GLenum))
|
||||
SDL_PROC(void, glBindTexture, (GLenum, GLuint))
|
||||
SDL_PROC_UNUSED(void, glBitmap,
|
||||
(GLsizei, GLsizei, GLfloat, GLfloat, GLfloat, GLfloat,
|
||||
const GLubyte *))
|
||||
SDL_PROC(void, glBlendFunc, (GLenum, GLenum))
|
||||
SDL_PROC_UNUSED(void, glCallList, (GLuint))
|
||||
SDL_PROC_UNUSED(void, glCallLists, (GLsizei, GLenum, const GLvoid *))
|
||||
SDL_PROC(void, glClear, (GLbitfield))
|
||||
SDL_PROC_UNUSED(void, glClearAccum, (GLfloat, GLfloat, GLfloat, GLfloat))
|
||||
SDL_PROC(void, glClearColor, (GLclampf, GLclampf, GLclampf, GLclampf))
|
||||
SDL_PROC_UNUSED(void, glClearDepth, (GLclampd))
|
||||
SDL_PROC_UNUSED(void, glClearIndex, (GLfloat))
|
||||
SDL_PROC_UNUSED(void, glClearStencil, (GLint))
|
||||
SDL_PROC_UNUSED(void, glClipPlane, (GLenum, const GLdouble *))
|
||||
SDL_PROC_UNUSED(void, glColor3b, (GLbyte, GLbyte, GLbyte))
|
||||
SDL_PROC_UNUSED(void, glColor3bv, (const GLbyte *))
|
||||
SDL_PROC_UNUSED(void, glColor3d, (GLdouble, GLdouble, GLdouble))
|
||||
SDL_PROC_UNUSED(void, glColor3dv, (const GLdouble *))
|
||||
SDL_PROC_UNUSED(void, glColor3f, (GLfloat, GLfloat, GLfloat))
|
||||
SDL_PROC_UNUSED(void, glColor3fv, (const GLfloat *))
|
||||
SDL_PROC_UNUSED(void, glColor3i, (GLint, GLint, GLint))
|
||||
SDL_PROC_UNUSED(void, glColor3iv, (const GLint *))
|
||||
SDL_PROC_UNUSED(void, glColor3s, (GLshort, GLshort, GLshort))
|
||||
SDL_PROC_UNUSED(void, glColor3sv, (const GLshort *))
|
||||
SDL_PROC_UNUSED(void, glColor3ub, (GLubyte, GLubyte, GLubyte))
|
||||
SDL_PROC_UNUSED(void, glColor3ubv, (const GLubyte *))
|
||||
SDL_PROC_UNUSED(void, glColor3ui, (GLuint, GLuint, GLuint))
|
||||
SDL_PROC_UNUSED(void, glColor3uiv, (const GLuint *))
|
||||
SDL_PROC_UNUSED(void, glColor3us, (GLushort, GLushort, GLushort))
|
||||
SDL_PROC_UNUSED(void, glColor3usv, (const GLushort *))
|
||||
SDL_PROC_UNUSED(void, glColor4b, (GLbyte, GLbyte, GLbyte, GLbyte))
|
||||
SDL_PROC_UNUSED(void, glColor4bv, (const GLbyte *))
|
||||
SDL_PROC_UNUSED(void, glColor4d, (GLdouble, GLdouble, GLdouble, GLdouble))
|
||||
SDL_PROC_UNUSED(void, glColor4dv, (const GLdouble *))
|
||||
SDL_PROC(void, glColor4f, (GLfloat, GLfloat, GLfloat, GLfloat))
|
||||
SDL_PROC_UNUSED(void, glColor4fv, (const GLfloat *))
|
||||
SDL_PROC_UNUSED(void, glColor4i, (GLint, GLint, GLint, GLint))
|
||||
SDL_PROC_UNUSED(void, glColor4iv, (const GLint *))
|
||||
SDL_PROC_UNUSED(void, glColor4s, (GLshort, GLshort, GLshort, GLshort))
|
||||
SDL_PROC_UNUSED(void, glColor4sv, (const GLshort *))
|
||||
SDL_PROC_UNUSED(void, glColor4ub,
|
||||
(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha))
|
||||
SDL_PROC_UNUSED(void, glColor4ubv, (const GLubyte * v))
|
||||
SDL_PROC_UNUSED(void, glColor4ui,
|
||||
(GLuint red, GLuint green, GLuint blue, GLuint alpha))
|
||||
SDL_PROC_UNUSED(void, glColor4uiv, (const GLuint * v))
|
||||
SDL_PROC_UNUSED(void, glColor4us,
|
||||
(GLushort red, GLushort green, GLushort blue, GLushort alpha))
|
||||
SDL_PROC_UNUSED(void, glColor4usv, (const GLushort * v))
|
||||
SDL_PROC_UNUSED(void, glColorMask,
|
||||
(GLboolean red, GLboolean green, GLboolean blue,
|
||||
GLboolean alpha))
|
||||
SDL_PROC_UNUSED(void, glColorMaterial, (GLenum face, GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glColorPointer,
|
||||
(GLint size, GLenum type, GLsizei stride,
|
||||
const GLvoid * pointer))
|
||||
SDL_PROC_UNUSED(void, glCopyPixels,
|
||||
(GLint x, GLint y, GLsizei width, GLsizei height,
|
||||
GLenum type))
|
||||
SDL_PROC_UNUSED(void, glCopyTexImage1D,
|
||||
(GLenum target, GLint level, GLenum internalFormat, GLint x,
|
||||
GLint y, GLsizei width, GLint border))
|
||||
SDL_PROC_UNUSED(void, glCopyTexImage2D,
|
||||
(GLenum target, GLint level, GLenum internalFormat, GLint x,
|
||||
GLint y, GLsizei width, GLsizei height, GLint border))
|
||||
SDL_PROC_UNUSED(void, glCopyTexSubImage1D,
|
||||
(GLenum target, GLint level, GLint xoffset, GLint x, GLint y,
|
||||
GLsizei width))
|
||||
SDL_PROC_UNUSED(void, glCopyTexSubImage2D,
|
||||
(GLenum target, GLint level, GLint xoffset, GLint yoffset,
|
||||
GLint x, GLint y, GLsizei width, GLsizei height))
|
||||
SDL_PROC_UNUSED(void, glCullFace, (GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glDeleteLists, (GLuint list, GLsizei range))
|
||||
SDL_PROC(void, glDeleteTextures, (GLsizei n, const GLuint * textures))
|
||||
SDL_PROC_UNUSED(void, glDepthFunc, (GLenum func))
|
||||
SDL_PROC_UNUSED(void, glDepthMask, (GLboolean flag))
|
||||
SDL_PROC_UNUSED(void, glDepthRange, (GLclampd zNear, GLclampd zFar))
|
||||
SDL_PROC(void, glDisable, (GLenum cap))
|
||||
SDL_PROC_UNUSED(void, glDisableClientState, (GLenum array))
|
||||
SDL_PROC_UNUSED(void, glDrawArrays, (GLenum mode, GLint first, GLsizei count))
|
||||
SDL_PROC_UNUSED(void, glDrawBuffer, (GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glDrawElements,
|
||||
(GLenum mode, GLsizei count, GLenum type,
|
||||
const GLvoid * indices))
|
||||
SDL_PROC(void, glDrawPixels,
|
||||
(GLsizei width, GLsizei height, GLenum format, GLenum type,
|
||||
const GLvoid * pixels))
|
||||
SDL_PROC_UNUSED(void, glEdgeFlag, (GLboolean flag))
|
||||
SDL_PROC_UNUSED(void, glEdgeFlagPointer,
|
||||
(GLsizei stride, const GLvoid * pointer))
|
||||
SDL_PROC_UNUSED(void, glEdgeFlagv, (const GLboolean * flag))
|
||||
SDL_PROC(void, glEnable, (GLenum cap))
|
||||
SDL_PROC_UNUSED(void, glEnableClientState, (GLenum array))
|
||||
SDL_PROC(void, glEnd, (void))
|
||||
SDL_PROC_UNUSED(void, glEndList, (void))
|
||||
SDL_PROC_UNUSED(void, glEvalCoord1d, (GLdouble u))
|
||||
SDL_PROC_UNUSED(void, glEvalCoord1dv, (const GLdouble * u))
|
||||
SDL_PROC_UNUSED(void, glEvalCoord1f, (GLfloat u))
|
||||
SDL_PROC_UNUSED(void, glEvalCoord1fv, (const GLfloat * u))
|
||||
SDL_PROC_UNUSED(void, glEvalCoord2d, (GLdouble u, GLdouble v))
|
||||
SDL_PROC_UNUSED(void, glEvalCoord2dv, (const GLdouble * u))
|
||||
SDL_PROC_UNUSED(void, glEvalCoord2f, (GLfloat u, GLfloat v))
|
||||
SDL_PROC_UNUSED(void, glEvalCoord2fv, (const GLfloat * u))
|
||||
SDL_PROC_UNUSED(void, glEvalMesh1, (GLenum mode, GLint i1, GLint i2))
|
||||
SDL_PROC_UNUSED(void, glEvalMesh2,
|
||||
(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2))
|
||||
SDL_PROC_UNUSED(void, glEvalPoint1, (GLint i))
|
||||
SDL_PROC_UNUSED(void, glEvalPoint2, (GLint i, GLint j))
|
||||
SDL_PROC_UNUSED(void, glFeedbackBuffer,
|
||||
(GLsizei size, GLenum type, GLfloat * buffer))
|
||||
SDL_PROC_UNUSED(void, glFinish, (void))
|
||||
SDL_PROC_UNUSED(void, glFlush, (void))
|
||||
SDL_PROC_UNUSED(void, glFogf, (GLenum pname, GLfloat param))
|
||||
SDL_PROC_UNUSED(void, glFogfv, (GLenum pname, const GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glFogi, (GLenum pname, GLint param))
|
||||
SDL_PROC_UNUSED(void, glFogiv, (GLenum pname, const GLint * params))
|
||||
SDL_PROC_UNUSED(void, glFrontFace, (GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glFrustum,
|
||||
(GLdouble left, GLdouble right, GLdouble bottom,
|
||||
GLdouble top, GLdouble zNear, GLdouble zFar))
|
||||
SDL_PROC_UNUSED(GLuint, glGenLists, (GLsizei range))
|
||||
SDL_PROC(void, glGenTextures, (GLsizei n, GLuint * textures))
|
||||
SDL_PROC_UNUSED(void, glGetBooleanv, (GLenum pname, GLboolean * params))
|
||||
SDL_PROC_UNUSED(void, glGetClipPlane, (GLenum plane, GLdouble * equation))
|
||||
SDL_PROC_UNUSED(void, glGetDoublev, (GLenum pname, GLdouble * params))
|
||||
SDL_PROC(GLenum, glGetError, (void))
|
||||
SDL_PROC_UNUSED(void, glGetFloatv, (GLenum pname, GLfloat * params))
|
||||
SDL_PROC(void, glGetIntegerv, (GLenum pname, GLint * params))
|
||||
SDL_PROC_UNUSED(void, glGetLightfv,
|
||||
(GLenum light, GLenum pname, GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glGetLightiv,
|
||||
(GLenum light, GLenum pname, GLint * params))
|
||||
SDL_PROC_UNUSED(void, glGetMapdv, (GLenum target, GLenum query, GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glGetMapfv, (GLenum target, GLenum query, GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glGetMapiv, (GLenum target, GLenum query, GLint * v))
|
||||
SDL_PROC_UNUSED(void, glGetMaterialfv,
|
||||
(GLenum face, GLenum pname, GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glGetMaterialiv,
|
||||
(GLenum face, GLenum pname, GLint * params))
|
||||
SDL_PROC_UNUSED(void, glGetPixelMapfv, (GLenum map, GLfloat * values))
|
||||
SDL_PROC_UNUSED(void, glGetPixelMapuiv, (GLenum map, GLuint * values))
|
||||
SDL_PROC_UNUSED(void, glGetPixelMapusv, (GLenum map, GLushort * values))
|
||||
SDL_PROC_UNUSED(void, glGetPointerv, (GLenum pname, GLvoid * *params))
|
||||
SDL_PROC_UNUSED(void, glGetPolygonStipple, (GLubyte * mask))
|
||||
SDL_PROC(const GLubyte *, glGetString, (GLenum name))
|
||||
SDL_PROC_UNUSED(void, glGetTexEnvfv,
|
||||
(GLenum target, GLenum pname, GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glGetTexEnviv,
|
||||
(GLenum target, GLenum pname, GLint * params))
|
||||
SDL_PROC_UNUSED(void, glGetTexGendv,
|
||||
(GLenum coord, GLenum pname, GLdouble * params))
|
||||
SDL_PROC_UNUSED(void, glGetTexGenfv,
|
||||
(GLenum coord, GLenum pname, GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glGetTexGeniv,
|
||||
(GLenum coord, GLenum pname, GLint * params))
|
||||
SDL_PROC_UNUSED(void, glGetTexImage,
|
||||
(GLenum target, GLint level, GLenum format, GLenum type,
|
||||
GLvoid * pixels))
|
||||
SDL_PROC_UNUSED(void, glGetTexLevelParameterfv,
|
||||
(GLenum target, GLint level, GLenum pname, GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glGetTexLevelParameteriv,
|
||||
(GLenum target, GLint level, GLenum pname, GLint * params))
|
||||
SDL_PROC_UNUSED(void, glGetTexParameterfv,
|
||||
(GLenum target, GLenum pname, GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glGetTexParameteriv,
|
||||
(GLenum target, GLenum pname, GLint * params))
|
||||
SDL_PROC_UNUSED(void, glHint, (GLenum target, GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glIndexMask, (GLuint mask))
|
||||
SDL_PROC_UNUSED(void, glIndexPointer,
|
||||
(GLenum type, GLsizei stride, const GLvoid * pointer))
|
||||
SDL_PROC_UNUSED(void, glIndexd, (GLdouble c))
|
||||
SDL_PROC_UNUSED(void, glIndexdv, (const GLdouble * c))
|
||||
SDL_PROC_UNUSED(void, glIndexf, (GLfloat c))
|
||||
SDL_PROC_UNUSED(void, glIndexfv, (const GLfloat * c))
|
||||
SDL_PROC_UNUSED(void, glIndexi, (GLint c))
|
||||
SDL_PROC_UNUSED(void, glIndexiv, (const GLint * c))
|
||||
SDL_PROC_UNUSED(void, glIndexs, (GLshort c))
|
||||
SDL_PROC_UNUSED(void, glIndexsv, (const GLshort * c))
|
||||
SDL_PROC_UNUSED(void, glIndexub, (GLubyte c))
|
||||
SDL_PROC_UNUSED(void, glIndexubv, (const GLubyte * c))
|
||||
SDL_PROC_UNUSED(void, glInitNames, (void))
|
||||
SDL_PROC_UNUSED(void, glInterleavedArrays,
|
||||
(GLenum format, GLsizei stride, const GLvoid * pointer))
|
||||
SDL_PROC_UNUSED(GLboolean, glIsEnabled, (GLenum cap))
|
||||
SDL_PROC_UNUSED(GLboolean, glIsList, (GLuint list))
|
||||
SDL_PROC_UNUSED(GLboolean, glIsTexture, (GLuint texture))
|
||||
SDL_PROC_UNUSED(void, glLightModelf, (GLenum pname, GLfloat param))
|
||||
SDL_PROC_UNUSED(void, glLightModelfv, (GLenum pname, const GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glLightModeli, (GLenum pname, GLint param))
|
||||
SDL_PROC_UNUSED(void, glLightModeliv, (GLenum pname, const GLint * params))
|
||||
SDL_PROC_UNUSED(void, glLightf, (GLenum light, GLenum pname, GLfloat param))
|
||||
SDL_PROC_UNUSED(void, glLightfv,
|
||||
(GLenum light, GLenum pname, const GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glLighti, (GLenum light, GLenum pname, GLint param))
|
||||
SDL_PROC_UNUSED(void, glLightiv,
|
||||
(GLenum light, GLenum pname, const GLint * params))
|
||||
SDL_PROC_UNUSED(void, glLineStipple, (GLint factor, GLushort pattern))
|
||||
SDL_PROC(void, glLineWidth, (GLfloat width))
|
||||
SDL_PROC_UNUSED(void, glListBase, (GLuint base))
|
||||
SDL_PROC(void, glLoadIdentity, (void))
|
||||
SDL_PROC_UNUSED(void, glLoadMatrixd, (const GLdouble * m))
|
||||
SDL_PROC_UNUSED(void, glLoadMatrixf, (const GLfloat * m))
|
||||
SDL_PROC_UNUSED(void, glLoadName, (GLuint name))
|
||||
SDL_PROC_UNUSED(void, glLogicOp, (GLenum opcode))
|
||||
SDL_PROC_UNUSED(void, glMap1d,
|
||||
(GLenum target, GLdouble u1, GLdouble u2, GLint stride,
|
||||
GLint order, const GLdouble * points))
|
||||
SDL_PROC_UNUSED(void, glMap1f,
|
||||
(GLenum target, GLfloat u1, GLfloat u2, GLint stride,
|
||||
GLint order, const GLfloat * points))
|
||||
SDL_PROC_UNUSED(void, glMap2d,
|
||||
(GLenum target, GLdouble u1, GLdouble u2, GLint ustride,
|
||||
GLint uorder, GLdouble v1, GLdouble v2, GLint vstride,
|
||||
GLint vorder, const GLdouble * points))
|
||||
SDL_PROC_UNUSED(void, glMap2f,
|
||||
(GLenum target, GLfloat u1, GLfloat u2, GLint ustride,
|
||||
GLint uorder, GLfloat v1, GLfloat v2, GLint vstride,
|
||||
GLint vorder, const GLfloat * points))
|
||||
SDL_PROC_UNUSED(void, glMapGrid1d, (GLint un, GLdouble u1, GLdouble u2))
|
||||
SDL_PROC_UNUSED(void, glMapGrid1f, (GLint un, GLfloat u1, GLfloat u2))
|
||||
SDL_PROC_UNUSED(void, glMapGrid2d,
|
||||
(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1,
|
||||
GLdouble v2))
|
||||
SDL_PROC_UNUSED(void, glMapGrid2f,
|
||||
(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1,
|
||||
GLfloat v2))
|
||||
SDL_PROC_UNUSED(void, glMaterialf, (GLenum face, GLenum pname, GLfloat param))
|
||||
SDL_PROC_UNUSED(void, glMaterialfv,
|
||||
(GLenum face, GLenum pname, const GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glMateriali, (GLenum face, GLenum pname, GLint param))
|
||||
SDL_PROC_UNUSED(void, glMaterialiv,
|
||||
(GLenum face, GLenum pname, const GLint * params))
|
||||
SDL_PROC(void, glMatrixMode, (GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glMultMatrixd, (const GLdouble * m))
|
||||
SDL_PROC_UNUSED(void, glMultMatrixf, (const GLfloat * m))
|
||||
SDL_PROC_UNUSED(void, glNewList, (GLuint list, GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glNormal3b, (GLbyte nx, GLbyte ny, GLbyte nz))
|
||||
SDL_PROC_UNUSED(void, glNormal3bv, (const GLbyte * v))
|
||||
SDL_PROC_UNUSED(void, glNormal3d, (GLdouble nx, GLdouble ny, GLdouble nz))
|
||||
SDL_PROC_UNUSED(void, glNormal3dv, (const GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glNormal3f, (GLfloat nx, GLfloat ny, GLfloat nz))
|
||||
SDL_PROC_UNUSED(void, glNormal3fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glNormal3i, (GLint nx, GLint ny, GLint nz))
|
||||
SDL_PROC_UNUSED(void, glNormal3iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glNormal3s, (GLshort nx, GLshort ny, GLshort nz))
|
||||
SDL_PROC_UNUSED(void, glNormal3sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glNormalPointer,
|
||||
(GLenum type, GLsizei stride, const GLvoid * pointer))
|
||||
SDL_PROC(void, glOrtho,
|
||||
(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top,
|
||||
GLdouble zNear, GLdouble zFar))
|
||||
SDL_PROC_UNUSED(void, glPassThrough, (GLfloat token))
|
||||
SDL_PROC_UNUSED(void, glPixelMapfv,
|
||||
(GLenum map, GLsizei mapsize, const GLfloat * values))
|
||||
SDL_PROC_UNUSED(void, glPixelMapuiv,
|
||||
(GLenum map, GLsizei mapsize, const GLuint * values))
|
||||
SDL_PROC_UNUSED(void, glPixelMapusv,
|
||||
(GLenum map, GLsizei mapsize, const GLushort * values))
|
||||
SDL_PROC_UNUSED(void, glPixelStoref, (GLenum pname, GLfloat param))
|
||||
SDL_PROC(void, glPixelStorei, (GLenum pname, GLint param))
|
||||
SDL_PROC_UNUSED(void, glPixelTransferf, (GLenum pname, GLfloat param))
|
||||
SDL_PROC_UNUSED(void, glPixelTransferi, (GLenum pname, GLint param))
|
||||
SDL_PROC_UNUSED(void, glPixelZoom, (GLfloat xfactor, GLfloat yfactor))
|
||||
SDL_PROC(void, glPointSize, (GLfloat size))
|
||||
SDL_PROC_UNUSED(void, glPolygonMode, (GLenum face, GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glPolygonOffset, (GLfloat factor, GLfloat units))
|
||||
SDL_PROC_UNUSED(void, glPolygonStipple, (const GLubyte * mask))
|
||||
SDL_PROC_UNUSED(void, glPopAttrib, (void))
|
||||
SDL_PROC_UNUSED(void, glPopClientAttrib, (void))
|
||||
SDL_PROC_UNUSED(void, glPopMatrix, (void))
|
||||
SDL_PROC_UNUSED(void, glPopName, (void))
|
||||
SDL_PROC_UNUSED(void, glPrioritizeTextures,
|
||||
(GLsizei n, const GLuint * textures,
|
||||
const GLclampf * priorities))
|
||||
SDL_PROC_UNUSED(void, glPushAttrib, (GLbitfield mask))
|
||||
SDL_PROC_UNUSED(void, glPushClientAttrib, (GLbitfield mask))
|
||||
SDL_PROC_UNUSED(void, glPushMatrix, (void))
|
||||
SDL_PROC_UNUSED(void, glPushName, (GLuint name))
|
||||
SDL_PROC_UNUSED(void, glRasterPos2d, (GLdouble x, GLdouble y))
|
||||
SDL_PROC_UNUSED(void, glRasterPos2dv, (const GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos2f, (GLfloat x, GLfloat y))
|
||||
SDL_PROC_UNUSED(void, glRasterPos2fv, (const GLfloat * v))
|
||||
SDL_PROC(void, glRasterPos2i, (GLint x, GLint y))
|
||||
SDL_PROC_UNUSED(void, glRasterPos2iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos2s, (GLshort x, GLshort y))
|
||||
SDL_PROC_UNUSED(void, glRasterPos2sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos3d, (GLdouble x, GLdouble y, GLdouble z))
|
||||
SDL_PROC_UNUSED(void, glRasterPos3dv, (const GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos3f, (GLfloat x, GLfloat y, GLfloat z))
|
||||
SDL_PROC_UNUSED(void, glRasterPos3fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos3i, (GLint x, GLint y, GLint z))
|
||||
SDL_PROC_UNUSED(void, glRasterPos3iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos3s, (GLshort x, GLshort y, GLshort z))
|
||||
SDL_PROC_UNUSED(void, glRasterPos3sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos4d,
|
||||
(GLdouble x, GLdouble y, GLdouble z, GLdouble w))
|
||||
SDL_PROC_UNUSED(void, glRasterPos4dv, (const GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos4f,
|
||||
(GLfloat x, GLfloat y, GLfloat z, GLfloat w))
|
||||
SDL_PROC_UNUSED(void, glRasterPos4fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos4i, (GLint x, GLint y, GLint z, GLint w))
|
||||
SDL_PROC_UNUSED(void, glRasterPos4iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glRasterPos4s,
|
||||
(GLshort x, GLshort y, GLshort z, GLshort w))
|
||||
SDL_PROC_UNUSED(void, glRasterPos4sv, (const GLshort * v))
|
||||
SDL_PROC(void, glReadBuffer, (GLenum mode))
|
||||
SDL_PROC(void, glReadPixels,
|
||||
(GLint x, GLint y, GLsizei width, GLsizei height,
|
||||
GLenum format, GLenum type, GLvoid * pixels))
|
||||
SDL_PROC_UNUSED(void, glRectd,
|
||||
(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2))
|
||||
SDL_PROC_UNUSED(void, glRectdv, (const GLdouble * v1, const GLdouble * v2))
|
||||
SDL_PROC_UNUSED(void, glRectf,
|
||||
(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2))
|
||||
SDL_PROC_UNUSED(void, glRectfv, (const GLfloat * v1, const GLfloat * v2))
|
||||
SDL_PROC(void, glRecti, (GLint x1, GLint y1, GLint x2, GLint y2))
|
||||
SDL_PROC_UNUSED(void, glRectiv, (const GLint * v1, const GLint * v2))
|
||||
SDL_PROC_UNUSED(void, glRects,
|
||||
(GLshort x1, GLshort y1, GLshort x2, GLshort y2))
|
||||
SDL_PROC_UNUSED(void, glRectsv, (const GLshort * v1, const GLshort * v2))
|
||||
SDL_PROC_UNUSED(GLint, glRenderMode, (GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glRotated,
|
||||
(GLdouble angle, GLdouble x, GLdouble y, GLdouble z))
|
||||
SDL_PROC_UNUSED(void, glRotatef,
|
||||
(GLfloat angle, GLfloat x, GLfloat y, GLfloat z))
|
||||
SDL_PROC_UNUSED(void, glScaled, (GLdouble x, GLdouble y, GLdouble z))
|
||||
SDL_PROC_UNUSED(void, glScalef, (GLfloat x, GLfloat y, GLfloat z))
|
||||
SDL_PROC(void, glScissor, (GLint x, GLint y, GLsizei width, GLsizei height))
|
||||
SDL_PROC_UNUSED(void, glSelectBuffer, (GLsizei size, GLuint * buffer))
|
||||
SDL_PROC_UNUSED(void, glShadeModel, (GLenum mode))
|
||||
SDL_PROC_UNUSED(void, glStencilFunc, (GLenum func, GLint ref, GLuint mask))
|
||||
SDL_PROC_UNUSED(void, glStencilMask, (GLuint mask))
|
||||
SDL_PROC_UNUSED(void, glStencilOp, (GLenum fail, GLenum zfail, GLenum zpass))
|
||||
SDL_PROC_UNUSED(void, glTexCoord1d, (GLdouble s))
|
||||
SDL_PROC_UNUSED(void, glTexCoord1dv, (const GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord1f, (GLfloat s))
|
||||
SDL_PROC_UNUSED(void, glTexCoord1fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord1i, (GLint s))
|
||||
SDL_PROC_UNUSED(void, glTexCoord1iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord1s, (GLshort s))
|
||||
SDL_PROC_UNUSED(void, glTexCoord1sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord2d, (GLdouble s, GLdouble t))
|
||||
SDL_PROC_UNUSED(void, glTexCoord2dv, (const GLdouble * v))
|
||||
SDL_PROC(void, glTexCoord2f, (GLfloat s, GLfloat t))
|
||||
SDL_PROC_UNUSED(void, glTexCoord2fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord2i, (GLint s, GLint t))
|
||||
SDL_PROC_UNUSED(void, glTexCoord2iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord2s, (GLshort s, GLshort t))
|
||||
SDL_PROC_UNUSED(void, glTexCoord2sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord3d, (GLdouble s, GLdouble t, GLdouble r))
|
||||
SDL_PROC_UNUSED(void, glTexCoord3dv, (const GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord3f, (GLfloat s, GLfloat t, GLfloat r))
|
||||
SDL_PROC_UNUSED(void, glTexCoord3fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord3i, (GLint s, GLint t, GLint r))
|
||||
SDL_PROC_UNUSED(void, glTexCoord3iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord3s, (GLshort s, GLshort t, GLshort r))
|
||||
SDL_PROC_UNUSED(void, glTexCoord3sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord4d,
|
||||
(GLdouble s, GLdouble t, GLdouble r, GLdouble q))
|
||||
SDL_PROC_UNUSED(void, glTexCoord4dv, (const GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord4f,
|
||||
(GLfloat s, GLfloat t, GLfloat r, GLfloat q))
|
||||
SDL_PROC_UNUSED(void, glTexCoord4fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord4i, (GLint s, GLint t, GLint r, GLint q))
|
||||
SDL_PROC_UNUSED(void, glTexCoord4iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoord4s,
|
||||
(GLshort s, GLshort t, GLshort r, GLshort q))
|
||||
SDL_PROC_UNUSED(void, glTexCoord4sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glTexCoordPointer,
|
||||
(GLint size, GLenum type, GLsizei stride,
|
||||
const GLvoid * pointer))
|
||||
SDL_PROC(void, glTexEnvf, (GLenum target, GLenum pname, GLfloat param))
|
||||
SDL_PROC_UNUSED(void, glTexEnvfv,
|
||||
(GLenum target, GLenum pname, const GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glTexEnvi, (GLenum target, GLenum pname, GLint param))
|
||||
SDL_PROC_UNUSED(void, glTexEnviv,
|
||||
(GLenum target, GLenum pname, const GLint * params))
|
||||
SDL_PROC_UNUSED(void, glTexGend, (GLenum coord, GLenum pname, GLdouble param))
|
||||
SDL_PROC_UNUSED(void, glTexGendv,
|
||||
(GLenum coord, GLenum pname, const GLdouble * params))
|
||||
SDL_PROC_UNUSED(void, glTexGenf, (GLenum coord, GLenum pname, GLfloat param))
|
||||
SDL_PROC_UNUSED(void, glTexGenfv,
|
||||
(GLenum coord, GLenum pname, const GLfloat * params))
|
||||
SDL_PROC_UNUSED(void, glTexGeni, (GLenum coord, GLenum pname, GLint param))
|
||||
SDL_PROC_UNUSED(void, glTexGeniv,
|
||||
(GLenum coord, GLenum pname, const GLint * params))
|
||||
SDL_PROC_UNUSED(void, glTexImage1D,
|
||||
(GLenum target, GLint level, GLint internalformat,
|
||||
GLsizei width, GLint border, GLenum format, GLenum type,
|
||||
const GLvoid * pixels))
|
||||
SDL_PROC(void, glTexImage2D,
|
||||
(GLenum target, GLint level, GLint internalformat, GLsizei width,
|
||||
GLsizei height, GLint border, GLenum format, GLenum type,
|
||||
const GLvoid * pixels))
|
||||
SDL_PROC_UNUSED(void, glTexParameterf,
|
||||
(GLenum target, GLenum pname, GLfloat param))
|
||||
SDL_PROC_UNUSED(void, glTexParameterfv,
|
||||
(GLenum target, GLenum pname, const GLfloat * params))
|
||||
SDL_PROC(void, glTexParameteri, (GLenum target, GLenum pname, GLint param))
|
||||
SDL_PROC_UNUSED(void, glTexParameteriv,
|
||||
(GLenum target, GLenum pname, const GLint * params))
|
||||
SDL_PROC_UNUSED(void, glTexSubImage1D,
|
||||
(GLenum target, GLint level, GLint xoffset, GLsizei width,
|
||||
GLenum format, GLenum type, const GLvoid * pixels))
|
||||
SDL_PROC(void, glTexSubImage2D,
|
||||
(GLenum target, GLint level, GLint xoffset, GLint yoffset,
|
||||
GLsizei width, GLsizei height, GLenum format, GLenum type,
|
||||
const GLvoid * pixels))
|
||||
SDL_PROC_UNUSED(void, glTranslated, (GLdouble x, GLdouble y, GLdouble z))
|
||||
SDL_PROC_UNUSED(void, glTranslatef, (GLfloat x, GLfloat y, GLfloat z))
|
||||
SDL_PROC_UNUSED(void, glVertex2d, (GLdouble x, GLdouble y))
|
||||
SDL_PROC_UNUSED(void, glVertex2dv, (const GLdouble * v))
|
||||
SDL_PROC(void, glVertex2f, (GLfloat x, GLfloat y))
|
||||
SDL_PROC_UNUSED(void, glVertex2fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glVertex2i, (GLint x, GLint y))
|
||||
SDL_PROC_UNUSED(void, glVertex2iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glVertex2s, (GLshort x, GLshort y))
|
||||
SDL_PROC_UNUSED(void, glVertex2sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glVertex3d, (GLdouble x, GLdouble y, GLdouble z))
|
||||
SDL_PROC_UNUSED(void, glVertex3dv, (const GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glVertex3f, (GLfloat x, GLfloat y, GLfloat z))
|
||||
SDL_PROC_UNUSED(void, glVertex3fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glVertex3i, (GLint x, GLint y, GLint z))
|
||||
SDL_PROC_UNUSED(void, glVertex3iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glVertex3s, (GLshort x, GLshort y, GLshort z))
|
||||
SDL_PROC_UNUSED(void, glVertex3sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glVertex4d,
|
||||
(GLdouble x, GLdouble y, GLdouble z, GLdouble w))
|
||||
SDL_PROC_UNUSED(void, glVertex4dv, (const GLdouble * v))
|
||||
SDL_PROC_UNUSED(void, glVertex4f,
|
||||
(GLfloat x, GLfloat y, GLfloat z, GLfloat w))
|
||||
SDL_PROC_UNUSED(void, glVertex4fv, (const GLfloat * v))
|
||||
SDL_PROC_UNUSED(void, glVertex4i, (GLint x, GLint y, GLint z, GLint w))
|
||||
SDL_PROC_UNUSED(void, glVertex4iv, (const GLint * v))
|
||||
SDL_PROC_UNUSED(void, glVertex4s,
|
||||
(GLshort x, GLshort y, GLshort z, GLshort w))
|
||||
SDL_PROC_UNUSED(void, glVertex4sv, (const GLshort * v))
|
||||
SDL_PROC_UNUSED(void, glVertexPointer,
|
||||
(GLint size, GLenum type, GLsizei stride,
|
||||
const GLvoid * pointer))
|
||||
SDL_PROC(void, glViewport, (GLint x, GLint y, GLsizei width, GLsizei height))
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
1026
project/jni/sdl-1.3/src/render/opengl/SDL_render_gl.c
Normal file
1026
project/jni/sdl-1.3/src/render/opengl/SDL_render_gl.c
Normal file
File diff suppressed because it is too large
Load Diff
358
project/jni/sdl-1.3/src/render/opengl/SDL_shaders_gl.c
Normal file
358
project/jni/sdl-1.3/src/render/opengl/SDL_shaders_gl.c
Normal file
@@ -0,0 +1,358 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED
|
||||
|
||||
#include "SDL_stdinc.h"
|
||||
#include "SDL_log.h"
|
||||
#include "SDL_opengl.h"
|
||||
#include "SDL_video.h"
|
||||
#include "SDL_shaders_gl.h"
|
||||
|
||||
/* OpenGL shader implementation */
|
||||
|
||||
/*#define DEBUG_SHADERS*/
|
||||
|
||||
typedef struct
|
||||
{
|
||||
GLhandleARB program;
|
||||
GLhandleARB vert_shader;
|
||||
GLhandleARB frag_shader;
|
||||
} GL_ShaderData;
|
||||
|
||||
struct GL_ShaderContext
|
||||
{
|
||||
GLenum (*glGetError)(void);
|
||||
|
||||
PFNGLATTACHOBJECTARBPROC glAttachObjectARB;
|
||||
PFNGLCOMPILESHADERARBPROC glCompileShaderARB;
|
||||
PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB;
|
||||
PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB;
|
||||
PFNGLDELETEOBJECTARBPROC glDeleteObjectARB;
|
||||
PFNGLGETINFOLOGARBPROC glGetInfoLogARB;
|
||||
PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB;
|
||||
PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB;
|
||||
PFNGLLINKPROGRAMARBPROC glLinkProgramARB;
|
||||
PFNGLSHADERSOURCEARBPROC glShaderSourceARB;
|
||||
PFNGLUNIFORM1IARBPROC glUniform1iARB;
|
||||
PFNGLUNIFORM1FARBPROC glUniform1fARB;
|
||||
PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB;
|
||||
|
||||
SDL_bool GL_ARB_texture_rectangle_supported;
|
||||
|
||||
GL_ShaderData shaders[NUM_SHADERS];
|
||||
};
|
||||
|
||||
/*
|
||||
* NOTE: Always use sampler2D, etc here. We'll #define them to the
|
||||
* texture_rectangle versions if we choose to use that extension.
|
||||
*/
|
||||
static const char *shader_source[NUM_SHADERS][2] =
|
||||
{
|
||||
/* SHADER_NONE */
|
||||
{ NULL, NULL },
|
||||
|
||||
/* SHADER_SOLID */
|
||||
{
|
||||
/* vertex shader */
|
||||
"varying vec4 v_color;\n"
|
||||
"\n"
|
||||
"void main()\n"
|
||||
"{\n"
|
||||
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
|
||||
" v_color = gl_Color;\n"
|
||||
"}",
|
||||
/* fragment shader */
|
||||
"varying vec4 v_color;\n"
|
||||
"\n"
|
||||
"void main()\n"
|
||||
"{\n"
|
||||
" gl_FragColor = v_color;\n"
|
||||
"}"
|
||||
},
|
||||
|
||||
/* SHADER_RGB */
|
||||
{
|
||||
/* vertex shader */
|
||||
"varying vec4 v_color;\n"
|
||||
"varying vec2 v_texCoord;\n"
|
||||
"\n"
|
||||
"void main()\n"
|
||||
"{\n"
|
||||
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
|
||||
" v_color = gl_Color;\n"
|
||||
" v_texCoord = vec2(gl_MultiTexCoord0);\n"
|
||||
"}",
|
||||
/* fragment shader */
|
||||
"varying vec4 v_color;\n"
|
||||
"varying vec2 v_texCoord;\n"
|
||||
"uniform sampler2D tex0;\n"
|
||||
"\n"
|
||||
"void main()\n"
|
||||
"{\n"
|
||||
" gl_FragColor = texture2D(tex0, v_texCoord) * v_color;\n"
|
||||
"}"
|
||||
},
|
||||
|
||||
/* SHADER_YV12 */
|
||||
{
|
||||
/* vertex shader */
|
||||
"varying vec4 v_color;\n"
|
||||
"varying vec2 v_texCoord;\n"
|
||||
"\n"
|
||||
"void main()\n"
|
||||
"{\n"
|
||||
" gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;\n"
|
||||
" v_color = gl_Color;\n"
|
||||
" v_texCoord = vec2(gl_MultiTexCoord0);\n"
|
||||
"}",
|
||||
/* fragment shader */
|
||||
"varying vec4 v_color;\n"
|
||||
"varying vec2 v_texCoord;\n"
|
||||
"uniform sampler2D tex0; // Y \n"
|
||||
"uniform sampler2D tex1; // U \n"
|
||||
"uniform sampler2D tex2; // V \n"
|
||||
"\n"
|
||||
"// YUV offset \n"
|
||||
"const vec3 offset = vec3(-0.0625, -0.5, -0.5);\n"
|
||||
"\n"
|
||||
"// RGB coefficients \n"
|
||||
"const vec3 Rcoeff = vec3(1.164, 0.000, 1.596);\n"
|
||||
"const vec3 Gcoeff = vec3(1.164, -0.391, -0.813);\n"
|
||||
"const vec3 Bcoeff = vec3(1.164, 2.018, 0.000);\n"
|
||||
"\n"
|
||||
"void main()\n"
|
||||
"{\n"
|
||||
" vec2 tcoord;\n"
|
||||
" vec3 yuv, rgb;\n"
|
||||
"\n"
|
||||
" // Get the Y value \n"
|
||||
" tcoord = v_texCoord;\n"
|
||||
" yuv.x = texture2D(tex0, tcoord).r;\n"
|
||||
"\n"
|
||||
" // Get the U and V values \n"
|
||||
" tcoord *= 0.5;\n"
|
||||
" yuv.y = texture2D(tex1, tcoord).r;\n"
|
||||
" yuv.z = texture2D(tex2, tcoord).r;\n"
|
||||
"\n"
|
||||
" // Do the color transform \n"
|
||||
" yuv += offset;\n"
|
||||
" rgb.r = dot(yuv, Rcoeff);\n"
|
||||
" rgb.g = dot(yuv, Gcoeff);\n"
|
||||
" rgb.b = dot(yuv, Bcoeff);\n"
|
||||
"\n"
|
||||
" // That was easy. :) \n"
|
||||
" gl_FragColor = vec4(rgb, 1.0) * v_color;\n"
|
||||
"}"
|
||||
},
|
||||
};
|
||||
|
||||
static SDL_bool
|
||||
CompileShader(GL_ShaderContext *ctx, GLhandleARB shader, const char *defines, const char *source)
|
||||
{
|
||||
GLint status;
|
||||
const char *sources[2];
|
||||
|
||||
sources[0] = defines;
|
||||
sources[1] = source;
|
||||
|
||||
ctx->glShaderSourceARB(shader, SDL_arraysize(sources), sources, NULL);
|
||||
ctx->glCompileShaderARB(shader);
|
||||
ctx->glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &status);
|
||||
if (status == 0) {
|
||||
GLint length;
|
||||
char *info;
|
||||
|
||||
ctx->glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
|
||||
info = SDL_stack_alloc(char, length+1);
|
||||
ctx->glGetInfoLogARB(shader, length, NULL, info);
|
||||
SDL_LogError(SDL_LOG_CATEGORY_RENDER,
|
||||
"Failed to compile shader:\n%s%s\n%s", defines, source, info);
|
||||
#ifdef DEBUG_SHADERS
|
||||
fprintf(stderr,
|
||||
"Failed to compile shader:\n%s%s\n%s", defines, source, info);
|
||||
#endif
|
||||
SDL_stack_free(info);
|
||||
|
||||
return SDL_FALSE;
|
||||
} else {
|
||||
return SDL_TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
static SDL_bool
|
||||
CompileShaderProgram(GL_ShaderContext *ctx, int index, GL_ShaderData *data)
|
||||
{
|
||||
const int num_tmus_bound = 4;
|
||||
const char *vert_defines = "";
|
||||
const char *frag_defines = "";
|
||||
int i;
|
||||
GLint location;
|
||||
|
||||
if (index == SHADER_NONE) {
|
||||
return SDL_TRUE;
|
||||
}
|
||||
|
||||
ctx->glGetError();
|
||||
|
||||
/* Make sure we use the correct sampler type for our texture type */
|
||||
if (ctx->GL_ARB_texture_rectangle_supported) {
|
||||
frag_defines =
|
||||
"#define sampler2D sampler2DRect\n"
|
||||
"#define texture2D texture2DRect\n";
|
||||
}
|
||||
|
||||
/* Create one program object to rule them all */
|
||||
data->program = ctx->glCreateProgramObjectARB();
|
||||
|
||||
/* Create the vertex shader */
|
||||
data->vert_shader = ctx->glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
|
||||
if (!CompileShader(ctx, data->vert_shader, vert_defines, shader_source[index][0])) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
/* Create the fragment shader */
|
||||
data->frag_shader = ctx->glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
|
||||
if (!CompileShader(ctx, data->frag_shader, frag_defines, shader_source[index][1])) {
|
||||
return SDL_FALSE;
|
||||
}
|
||||
|
||||
/* ... and in the darkness bind them */
|
||||
ctx->glAttachObjectARB(data->program, data->vert_shader);
|
||||
ctx->glAttachObjectARB(data->program, data->frag_shader);
|
||||
ctx->glLinkProgramARB(data->program);
|
||||
|
||||
/* Set up some uniform variables */
|
||||
ctx->glUseProgramObjectARB(data->program);
|
||||
for (i = 0; i < num_tmus_bound; ++i) {
|
||||
char tex_name[5];
|
||||
SDL_snprintf(tex_name, SDL_arraysize(tex_name), "tex%d", i);
|
||||
location = ctx->glGetUniformLocationARB(data->program, tex_name);
|
||||
if (location >= 0) {
|
||||
ctx->glUniform1iARB(location, i);
|
||||
}
|
||||
}
|
||||
ctx->glUseProgramObjectARB(0);
|
||||
|
||||
return (ctx->glGetError() == GL_NO_ERROR);
|
||||
}
|
||||
|
||||
static void
|
||||
DestroyShaderProgram(GL_ShaderContext *ctx, GL_ShaderData *data)
|
||||
{
|
||||
ctx->glDeleteObjectARB(data->vert_shader);
|
||||
ctx->glDeleteObjectARB(data->frag_shader);
|
||||
ctx->glDeleteObjectARB(data->program);
|
||||
}
|
||||
|
||||
GL_ShaderContext *
|
||||
GL_CreateShaderContext()
|
||||
{
|
||||
GL_ShaderContext *ctx;
|
||||
SDL_bool shaders_supported;
|
||||
int i;
|
||||
|
||||
ctx = (GL_ShaderContext *)SDL_calloc(1, sizeof(*ctx));
|
||||
if (!ctx) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (SDL_GL_ExtensionSupported("GL_ARB_texture_rectangle")
|
||||
|| SDL_GL_ExtensionSupported("GL_EXT_texture_rectangle")) {
|
||||
ctx->GL_ARB_texture_rectangle_supported = SDL_TRUE;
|
||||
}
|
||||
|
||||
/* Check for shader support */
|
||||
shaders_supported = SDL_FALSE;
|
||||
if (SDL_GL_ExtensionSupported("GL_ARB_shader_objects") &&
|
||||
SDL_GL_ExtensionSupported("GL_ARB_shading_language_100") &&
|
||||
SDL_GL_ExtensionSupported("GL_ARB_vertex_shader") &&
|
||||
SDL_GL_ExtensionSupported("GL_ARB_fragment_shader")) {
|
||||
ctx->glGetError = (GLenum (*)(void)) SDL_GL_GetProcAddress("glGetError");
|
||||
ctx->glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC) SDL_GL_GetProcAddress("glAttachObjectARB");
|
||||
ctx->glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC) SDL_GL_GetProcAddress("glCompileShaderARB");
|
||||
ctx->glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC) SDL_GL_GetProcAddress("glCreateProgramObjectARB");
|
||||
ctx->glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC) SDL_GL_GetProcAddress("glCreateShaderObjectARB");
|
||||
ctx->glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC) SDL_GL_GetProcAddress("glDeleteObjectARB");
|
||||
ctx->glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC) SDL_GL_GetProcAddress("glGetInfoLogARB");
|
||||
ctx->glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC) SDL_GL_GetProcAddress("glGetObjectParameterivARB");
|
||||
ctx->glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC) SDL_GL_GetProcAddress("glGetUniformLocationARB");
|
||||
ctx->glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC) SDL_GL_GetProcAddress("glLinkProgramARB");
|
||||
ctx->glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC) SDL_GL_GetProcAddress("glShaderSourceARB");
|
||||
ctx->glUniform1iARB = (PFNGLUNIFORM1IARBPROC) SDL_GL_GetProcAddress("glUniform1iARB");
|
||||
ctx->glUniform1fARB = (PFNGLUNIFORM1FARBPROC) SDL_GL_GetProcAddress("glUniform1fARB");
|
||||
ctx->glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC) SDL_GL_GetProcAddress("glUseProgramObjectARB");
|
||||
if (ctx->glGetError &&
|
||||
ctx->glAttachObjectARB &&
|
||||
ctx->glCompileShaderARB &&
|
||||
ctx->glCreateProgramObjectARB &&
|
||||
ctx->glCreateShaderObjectARB &&
|
||||
ctx->glDeleteObjectARB &&
|
||||
ctx->glGetInfoLogARB &&
|
||||
ctx->glGetObjectParameterivARB &&
|
||||
ctx->glGetUniformLocationARB &&
|
||||
ctx->glLinkProgramARB &&
|
||||
ctx->glShaderSourceARB &&
|
||||
ctx->glUniform1iARB &&
|
||||
ctx->glUniform1fARB &&
|
||||
ctx->glUseProgramObjectARB) {
|
||||
shaders_supported = SDL_TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
if (!shaders_supported) {
|
||||
SDL_free(ctx);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Compile all the shaders */
|
||||
for (i = 0; i < NUM_SHADERS; ++i) {
|
||||
if (!CompileShaderProgram(ctx, i, &ctx->shaders[i])) {
|
||||
GL_DestroyShaderContext(ctx);
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* We're done! */
|
||||
return ctx;
|
||||
}
|
||||
|
||||
void
|
||||
GL_SelectShader(GL_ShaderContext *ctx, GL_Shader shader)
|
||||
{
|
||||
ctx->glUseProgramObjectARB(ctx->shaders[shader].program);
|
||||
}
|
||||
|
||||
void
|
||||
GL_DestroyShaderContext(GL_ShaderContext *ctx)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < NUM_SHADERS; ++i) {
|
||||
DestroyShaderProgram(ctx, &ctx->shaders[i]);
|
||||
}
|
||||
SDL_free(ctx);
|
||||
}
|
||||
|
||||
#endif /* SDL_VIDEO_RENDER_OGL && !SDL_RENDER_DISABLED */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
39
project/jni/sdl-1.3/src/render/opengl/SDL_shaders_gl.h
Normal file
39
project/jni/sdl-1.3/src/render/opengl/SDL_shaders_gl.h
Normal file
@@ -0,0 +1,39 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
/* OpenGL shader implementation */
|
||||
|
||||
typedef enum {
|
||||
SHADER_NONE,
|
||||
SHADER_SOLID,
|
||||
SHADER_RGB,
|
||||
SHADER_YV12,
|
||||
NUM_SHADERS
|
||||
} GL_Shader;
|
||||
|
||||
typedef struct GL_ShaderContext GL_ShaderContext;
|
||||
|
||||
extern GL_ShaderContext * GL_CreateShaderContext();
|
||||
extern void GL_SelectShader(GL_ShaderContext *ctx, GL_Shader shader);
|
||||
extern void GL_DestroyShaderContext(GL_ShaderContext *ctx);
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
887
project/jni/sdl-1.3/src/render/opengles/SDL_render_gles.c
Normal file
887
project/jni/sdl-1.3/src/render/opengles/SDL_render_gles.c
Normal file
@@ -0,0 +1,887 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if SDL_VIDEO_RENDER_OGL_ES && !SDL_RENDER_DISABLED
|
||||
|
||||
#include "SDL_hints.h"
|
||||
#include "SDL_opengles.h"
|
||||
#include "../SDL_sysrender.h"
|
||||
#include <android/log.h>
|
||||
|
||||
#if defined(SDL_VIDEO_DRIVER_PANDORA)
|
||||
|
||||
/* Empty function stub to get OpenGL ES 1.x support without */
|
||||
/* OpenGL ES extension GL_OES_draw_texture supported */
|
||||
GL_API void GL_APIENTRY
|
||||
glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
#endif /* PANDORA */
|
||||
|
||||
/* OpenGL ES 1.1 renderer implementation, based on the OpenGL renderer */
|
||||
|
||||
static const float inv255f = 1.0f / 255.0f;
|
||||
|
||||
static SDL_Renderer *GLES_CreateRenderer(SDL_Window * window, Uint32 flags);
|
||||
static void GLES_WindowEvent(SDL_Renderer * renderer,
|
||||
const SDL_WindowEvent *event);
|
||||
static int GLES_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
static int GLES_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels,
|
||||
int pitch);
|
||||
static int GLES_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, void **pixels, int *pitch);
|
||||
static void GLES_UnlockTexture(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int GLES_UpdateViewport(SDL_Renderer * renderer);
|
||||
static int GLES_RenderClear(SDL_Renderer * renderer);
|
||||
static int GLES_RenderDrawPoints(SDL_Renderer * renderer,
|
||||
const SDL_Point * points, int count);
|
||||
static int GLES_RenderDrawLines(SDL_Renderer * renderer,
|
||||
const SDL_Point * points, int count);
|
||||
static int GLES_RenderFillRects(SDL_Renderer * renderer,
|
||||
const SDL_Rect * rects, int count);
|
||||
static int GLES_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect,
|
||||
const SDL_Rect * dstrect);
|
||||
static int GLES_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
|
||||
Uint32 pixel_format, void * pixels, int pitch);
|
||||
static void GLES_RenderPresent(SDL_Renderer * renderer);
|
||||
static void GLES_DestroyTexture(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static void GLES_DestroyRenderer(SDL_Renderer * renderer);
|
||||
|
||||
|
||||
SDL_RenderDriver GLES_RenderDriver = {
|
||||
GLES_CreateRenderer,
|
||||
{
|
||||
"opengles",
|
||||
(SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC),
|
||||
5,
|
||||
{SDL_PIXELFORMAT_ABGR8888,SDL_PIXELFORMAT_RGB565,SDL_PIXELFORMAT_RGBA5551,SDL_PIXELFORMAT_RGBA4444,SDL_PIXELFORMAT_RGB24},
|
||||
0,
|
||||
0}
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
SDL_GLContext context;
|
||||
struct {
|
||||
Uint32 color;
|
||||
int blendMode;
|
||||
SDL_bool tex_coords;
|
||||
} current;
|
||||
|
||||
SDL_bool useDrawTexture;
|
||||
SDL_bool GL_OES_draw_texture_supported;
|
||||
} GLES_RenderData;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
GLuint texture;
|
||||
GLenum type;
|
||||
GLfloat texw;
|
||||
GLfloat texh;
|
||||
GLenum format;
|
||||
GLenum formattype;
|
||||
void *pixels;
|
||||
int pitch;
|
||||
} GLES_TextureData;
|
||||
|
||||
static void
|
||||
GLES_SetError(const char *prefix, GLenum result)
|
||||
{
|
||||
const char *error;
|
||||
|
||||
switch (result) {
|
||||
case GL_NO_ERROR:
|
||||
error = "GL_NO_ERROR";
|
||||
break;
|
||||
case GL_INVALID_ENUM:
|
||||
error = "GL_INVALID_ENUM";
|
||||
break;
|
||||
case GL_INVALID_VALUE:
|
||||
error = "GL_INVALID_VALUE";
|
||||
break;
|
||||
case GL_INVALID_OPERATION:
|
||||
error = "GL_INVALID_OPERATION";
|
||||
break;
|
||||
case GL_STACK_OVERFLOW:
|
||||
error = "GL_STACK_OVERFLOW";
|
||||
break;
|
||||
case GL_STACK_UNDERFLOW:
|
||||
error = "GL_STACK_UNDERFLOW";
|
||||
break;
|
||||
case GL_OUT_OF_MEMORY:
|
||||
error = "GL_OUT_OF_MEMORY";
|
||||
break;
|
||||
default:
|
||||
error = "UNKNOWN";
|
||||
break;
|
||||
}
|
||||
SDL_SetError("%s: %s", prefix, error);
|
||||
}
|
||||
|
||||
static SDL_GLContext SDL_CurrentContext = NULL;
|
||||
|
||||
static int
|
||||
GLES_ActivateRenderer(SDL_Renderer * renderer)
|
||||
{
|
||||
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
|
||||
|
||||
if (SDL_CurrentContext != data->context) {
|
||||
if (SDL_GL_MakeCurrent(renderer->window, data->context) < 0) {
|
||||
return -1;
|
||||
}
|
||||
SDL_CurrentContext = data->context;
|
||||
|
||||
GLES_UpdateViewport(renderer);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* This is called if we need to invalidate all of the SDL OpenGL state */
|
||||
extern void
|
||||
GLES_ResetState(SDL_Renderer *renderer)
|
||||
{
|
||||
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
|
||||
|
||||
if (SDL_CurrentContext == data->context) {
|
||||
GLES_UpdateViewport(renderer);
|
||||
} else {
|
||||
GLES_ActivateRenderer(renderer);
|
||||
}
|
||||
|
||||
data->current.color = 0;
|
||||
data->current.blendMode = -1;
|
||||
data->current.tex_coords = SDL_FALSE;
|
||||
|
||||
glDisable(GL_DEPTH_TEST);
|
||||
glDisable(GL_CULL_FACE);
|
||||
|
||||
glMatrixMode(GL_MODELVIEW);
|
||||
glLoadIdentity();
|
||||
|
||||
glEnableClientState(GL_VERTEX_ARRAY);
|
||||
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
}
|
||||
|
||||
SDL_Renderer *
|
||||
GLES_CreateRenderer(SDL_Window * window, Uint32 flags)
|
||||
{
|
||||
SDL_Renderer *renderer;
|
||||
GLES_RenderData *data;
|
||||
GLint value;
|
||||
|
||||
__android_log_print(ANDROID_LOG_INFO, "SDL", "GLES_CreateRenderer(): creating GLES 1.x renderer");
|
||||
|
||||
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
|
||||
if (!renderer) {
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
data = (GLES_RenderData *) SDL_calloc(1, sizeof(*data));
|
||||
if (!data) {
|
||||
GLES_DestroyRenderer(renderer);
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
renderer->WindowEvent = GLES_WindowEvent;
|
||||
renderer->CreateTexture = GLES_CreateTexture;
|
||||
renderer->UpdateTexture = GLES_UpdateTexture;
|
||||
renderer->LockTexture = GLES_LockTexture;
|
||||
renderer->UnlockTexture = GLES_UnlockTexture;
|
||||
renderer->UpdateViewport = GLES_UpdateViewport;
|
||||
renderer->RenderClear = GLES_RenderClear;
|
||||
renderer->RenderDrawPoints = GLES_RenderDrawPoints;
|
||||
renderer->RenderDrawLines = GLES_RenderDrawLines;
|
||||
renderer->RenderFillRects = GLES_RenderFillRects;
|
||||
renderer->RenderCopy = GLES_RenderCopy;
|
||||
renderer->RenderReadPixels = GLES_RenderReadPixels;
|
||||
renderer->RenderPresent = GLES_RenderPresent;
|
||||
renderer->DestroyTexture = GLES_DestroyTexture;
|
||||
renderer->DestroyRenderer = GLES_DestroyRenderer;
|
||||
renderer->info = GLES_RenderDriver.info;
|
||||
renderer->info.flags = SDL_RENDERER_ACCELERATED;
|
||||
renderer->driverdata = data;
|
||||
|
||||
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
|
||||
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 1);
|
||||
|
||||
data->context = SDL_GL_CreateContext(window);
|
||||
if (!data->context) {
|
||||
GLES_DestroyRenderer(renderer);
|
||||
return NULL;
|
||||
}
|
||||
if (SDL_GL_MakeCurrent(window, data->context) < 0) {
|
||||
GLES_DestroyRenderer(renderer);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (flags & SDL_RENDERER_PRESENTVSYNC) {
|
||||
SDL_GL_SetSwapInterval(1);
|
||||
} else {
|
||||
SDL_GL_SetSwapInterval(0);
|
||||
}
|
||||
if (SDL_GL_GetSwapInterval() > 0) {
|
||||
renderer->info.flags |= SDL_RENDERER_PRESENTVSYNC;
|
||||
}
|
||||
|
||||
#if SDL_VIDEO_DRIVER_PANDORA
|
||||
data->GL_OES_draw_texture_supported = SDL_FALSE;
|
||||
data->useDrawTexture = SDL_FALSE;
|
||||
#else
|
||||
if (SDL_GL_ExtensionSupported("GL_OES_draw_texture")) {
|
||||
data->GL_OES_draw_texture_supported = SDL_TRUE;
|
||||
data->useDrawTexture = SDL_TRUE;
|
||||
} else {
|
||||
data->GL_OES_draw_texture_supported = SDL_FALSE;
|
||||
data->useDrawTexture = SDL_FALSE;
|
||||
}
|
||||
#endif
|
||||
|
||||
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
|
||||
renderer->info.max_texture_width = value;
|
||||
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &value);
|
||||
renderer->info.max_texture_height = value;
|
||||
|
||||
/* Set up parameters for rendering */
|
||||
GLES_ResetState(renderer);
|
||||
|
||||
return renderer;
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
|
||||
{
|
||||
__android_log_print(ANDROID_LOG_INFO, "SDL", "GLES_WindowEvent() called");
|
||||
#ifndef ANDROID
|
||||
if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {
|
||||
/* Rebind the context to the window area and update matrices */
|
||||
SDL_CurrentContext = NULL;
|
||||
}
|
||||
#endif
|
||||
if (event->event == SDL_WINDOWEVENT_MINIMIZED) {
|
||||
/* According to Apple documentation, we need to finish drawing NOW! */
|
||||
glFinish();
|
||||
}
|
||||
}
|
||||
|
||||
static __inline__ int
|
||||
power_of_2(int input)
|
||||
{
|
||||
int value = 1;
|
||||
|
||||
while (value < input) {
|
||||
value <<= 1;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
static GLenum
|
||||
GetScaleQuality(void)
|
||||
{
|
||||
const char *hint = SDL_GetHint(SDL_HINT_RENDER_SCALE_QUALITY);
|
||||
|
||||
if (!hint || *hint == '0' || SDL_strcasecmp(hint, "nearest") == 0) {
|
||||
return GL_NEAREST;
|
||||
} else {
|
||||
return GL_LINEAR;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_CreateTextureInternal(SDL_Renderer * renderer, SDL_Texture * texture, GLES_TextureData *data)
|
||||
{
|
||||
GLint internalFormat;
|
||||
GLenum format, type;
|
||||
int texture_w, texture_h;
|
||||
GLenum scaleMode;
|
||||
GLenum result;
|
||||
|
||||
GLES_ActivateRenderer(renderer);
|
||||
|
||||
switch (texture->format) {
|
||||
case SDL_PIXELFORMAT_ABGR8888:
|
||||
internalFormat = GL_RGBA;
|
||||
format = GL_RGBA;
|
||||
type = GL_UNSIGNED_BYTE;
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB565:
|
||||
internalFormat = GL_RGB;
|
||||
format = GL_RGB;
|
||||
type = GL_UNSIGNED_SHORT_5_6_5;
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGBA5551:
|
||||
internalFormat = GL_RGBA;
|
||||
format = GL_RGBA;
|
||||
type = GL_UNSIGNED_SHORT_5_5_5_1;
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGBA4444:
|
||||
internalFormat = GL_RGBA;
|
||||
format = GL_RGBA;
|
||||
type = GL_UNSIGNED_SHORT_4_4_4_4;
|
||||
break;
|
||||
case SDL_PIXELFORMAT_RGB24:
|
||||
internalFormat = GL_RGB;
|
||||
format = GL_RGB;
|
||||
type = GL_UNSIGNED_BYTE;
|
||||
break;
|
||||
default:
|
||||
SDL_SetError("Texture format not supported");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(data == NULL) {
|
||||
data = (GLES_TextureData *) SDL_calloc(1, sizeof(*data));
|
||||
if (!data) {
|
||||
SDL_OutOfMemory();
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
|
||||
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
|
||||
data->pixels = SDL_calloc(1, texture->h * data->pitch);
|
||||
if (!data->pixels) {
|
||||
SDL_OutOfMemory();
|
||||
SDL_free(data);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
texture->driverdata = data;
|
||||
|
||||
glGetError();
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
glGenTextures(1, &data->texture);
|
||||
|
||||
data->type = GL_TEXTURE_2D;
|
||||
/* no NPOV textures allowed in OpenGL ES (yet) */
|
||||
texture_w = power_of_2(texture->w);
|
||||
texture_h = power_of_2(texture->h);
|
||||
data->texw = (GLfloat) texture->w / texture_w;
|
||||
data->texh = (GLfloat) texture->h / texture_h;
|
||||
|
||||
data->format = format;
|
||||
data->formattype = type;
|
||||
scaleMode = GetScaleQuality();
|
||||
glBindTexture(data->type, data->texture);
|
||||
glTexParameteri(data->type, GL_TEXTURE_MIN_FILTER, scaleMode);
|
||||
glTexParameteri(data->type, GL_TEXTURE_MAG_FILTER, scaleMode);
|
||||
glTexParameteri(data->type, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
||||
glTexParameteri(data->type, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
||||
|
||||
glTexImage2D(data->type, 0, internalFormat, texture_w,
|
||||
texture_h, 0, format, type, NULL);
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
|
||||
result = glGetError();
|
||||
if (result != GL_NO_ERROR) {
|
||||
GLES_SetError("glTexImage2D()", result);
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
return GLES_CreateTextureInternal(renderer, texture, NULL);
|
||||
}
|
||||
|
||||
extern int
|
||||
GLES_ReinitTextureAndroid(SDL_Renderer * renderer, SDL_Texture * texture, void * data)
|
||||
{
|
||||
return GLES_CreateTextureInternal(renderer, texture, (GLES_TextureData *)data);
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels, int pitch)
|
||||
{
|
||||
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
|
||||
Uint8 *blob = NULL;
|
||||
Uint8 *src;
|
||||
int srcPitch;
|
||||
int y;
|
||||
|
||||
GLES_ActivateRenderer(renderer);
|
||||
|
||||
/* Bail out if we're supposed to update an empty rectangle */
|
||||
if (rect->w <= 0 || rect->h <= 0)
|
||||
return 0;
|
||||
|
||||
/* Reformat the texture data into a tightly packed array */
|
||||
srcPitch = rect->w * SDL_BYTESPERPIXEL(texture->format);
|
||||
src = (Uint8 *)pixels;
|
||||
if (pitch != srcPitch)
|
||||
{
|
||||
blob = (Uint8 *)SDL_malloc(srcPitch * rect->h);
|
||||
if (!blob)
|
||||
{
|
||||
SDL_OutOfMemory();
|
||||
return -1;
|
||||
}
|
||||
src = blob;
|
||||
for (y = 0; y < rect->h; ++y)
|
||||
{
|
||||
SDL_memcpy(src, pixels, srcPitch);
|
||||
src += srcPitch;
|
||||
pixels = (Uint8 *)pixels + pitch;
|
||||
}
|
||||
src = blob;
|
||||
}
|
||||
|
||||
/* Create a texture subimage with the supplied data */
|
||||
glGetError();
|
||||
glEnable(data->type);
|
||||
glBindTexture(data->type, data->texture);
|
||||
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
|
||||
glTexSubImage2D(data->type,
|
||||
0,
|
||||
rect->x,
|
||||
rect->y,
|
||||
rect->w,
|
||||
rect->h,
|
||||
data->format,
|
||||
data->formattype,
|
||||
src);
|
||||
if (blob) {
|
||||
SDL_free(blob);
|
||||
}
|
||||
|
||||
if (glGetError() != GL_NO_ERROR)
|
||||
{
|
||||
SDL_SetError("Failed to update texture");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, void **pixels, int *pitch)
|
||||
{
|
||||
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
|
||||
|
||||
*pixels =
|
||||
(void *) ((Uint8 *) data->pixels + rect->y * data->pitch +
|
||||
rect->x * SDL_BYTESPERPIXEL(texture->format));
|
||||
*pitch = data->pitch;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
|
||||
SDL_Rect rect;
|
||||
|
||||
/* We do whole texture updates, at least for now */
|
||||
rect.x = 0;
|
||||
rect.y = 0;
|
||||
rect.w = texture->w;
|
||||
rect.h = texture->h;
|
||||
GLES_UpdateTexture(renderer, texture, &rect, data->pixels, data->pitch);
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_UpdateViewport(SDL_Renderer * renderer)
|
||||
{
|
||||
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
|
||||
|
||||
if (SDL_CurrentContext != data->context) {
|
||||
/* We'll update the viewport after we rebind the context */
|
||||
return 0;
|
||||
}
|
||||
|
||||
glViewport(renderer->viewport.x, renderer->viewport.y,
|
||||
renderer->viewport.w, renderer->viewport.h);
|
||||
|
||||
glMatrixMode(GL_PROJECTION);
|
||||
glLoadIdentity();
|
||||
glOrthof((GLfloat) 0,
|
||||
(GLfloat) renderer->viewport.w,
|
||||
(GLfloat) renderer->viewport.h,
|
||||
(GLfloat) 0, 0.0, 1.0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_SetColor(GLES_RenderData * data, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
Uint32 color = ((a << 24) | (r << 16) | (g << 8) | b);
|
||||
|
||||
if (color != data->current.color) {
|
||||
glColor4f((GLfloat) r * inv255f,
|
||||
(GLfloat) g * inv255f,
|
||||
(GLfloat) b * inv255f,
|
||||
(GLfloat) a * inv255f);
|
||||
data->current.color = color;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_SetBlendMode(GLES_RenderData * data, int blendMode)
|
||||
{
|
||||
if (blendMode != data->current.blendMode) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_NONE:
|
||||
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
|
||||
glDisable(GL_BLEND);
|
||||
break;
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
||||
glEnable(GL_BLEND);
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
||||
glEnable(GL_BLEND);
|
||||
glBlendFunc(GL_SRC_ALPHA, GL_ONE);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
|
||||
glEnable(GL_BLEND);
|
||||
glBlendFunc(GL_ZERO, GL_SRC_COLOR);
|
||||
break;
|
||||
}
|
||||
data->current.blendMode = blendMode;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_SetTexCoords(GLES_RenderData * data, SDL_bool enabled)
|
||||
{
|
||||
if (enabled != data->current.tex_coords) {
|
||||
if (enabled) {
|
||||
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
} else {
|
||||
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
||||
}
|
||||
data->current.tex_coords = enabled;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_SetDrawingState(SDL_Renderer * renderer)
|
||||
{
|
||||
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
|
||||
|
||||
GLES_ActivateRenderer(renderer);
|
||||
|
||||
GLES_SetColor(data, (GLfloat) renderer->r,
|
||||
(GLfloat) renderer->g,
|
||||
(GLfloat) renderer->b,
|
||||
(GLfloat) renderer->a);
|
||||
|
||||
GLES_SetBlendMode(data, renderer->blendMode);
|
||||
|
||||
GLES_SetTexCoords(data, SDL_FALSE);
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_RenderClear(SDL_Renderer * renderer)
|
||||
{
|
||||
GLES_ActivateRenderer(renderer);
|
||||
|
||||
glClearColor((GLfloat) renderer->r * inv255f,
|
||||
(GLfloat) renderer->g * inv255f,
|
||||
(GLfloat) renderer->b * inv255f,
|
||||
(GLfloat) renderer->a * inv255f);
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
|
||||
int count)
|
||||
{
|
||||
int i;
|
||||
GLshort *vertices;
|
||||
|
||||
GLES_SetDrawingState(renderer);
|
||||
|
||||
vertices = SDL_stack_alloc(GLshort, count*2);
|
||||
for (i = 0; i < count; ++i) {
|
||||
vertices[2*i+0] = (GLshort)points[i].x;
|
||||
vertices[2*i+1] = (GLshort)points[i].y;
|
||||
}
|
||||
glVertexPointer(2, GL_SHORT, 0, vertices);
|
||||
glDrawArrays(GL_POINTS, 0, count);
|
||||
SDL_stack_free(vertices);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
|
||||
int count)
|
||||
{
|
||||
int i;
|
||||
GLshort *vertices;
|
||||
|
||||
GLES_SetDrawingState(renderer);
|
||||
|
||||
vertices = SDL_stack_alloc(GLshort, count*2);
|
||||
for (i = 0; i < count; ++i) {
|
||||
vertices[2*i+0] = (GLshort)points[i].x;
|
||||
vertices[2*i+1] = (GLshort)points[i].y;
|
||||
}
|
||||
glVertexPointer(2, GL_SHORT, 0, vertices);
|
||||
if (count > 2 &&
|
||||
points[0].x == points[count-1].x && points[0].y == points[count-1].y) {
|
||||
/* GL_LINE_LOOP takes care of the final segment */
|
||||
--count;
|
||||
glDrawArrays(GL_LINE_LOOP, 0, count);
|
||||
} else {
|
||||
glDrawArrays(GL_LINE_STRIP, 0, count);
|
||||
/* We need to close the endpoint of the line */
|
||||
glDrawArrays(GL_POINTS, count-1, 1);
|
||||
}
|
||||
SDL_stack_free(vertices);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect * rects,
|
||||
int count)
|
||||
{
|
||||
int i;
|
||||
|
||||
GLES_SetDrawingState(renderer);
|
||||
|
||||
for (i = 0; i < count; ++i) {
|
||||
const SDL_Rect *rect = &rects[i];
|
||||
GLshort minx = rect->x;
|
||||
GLshort maxx = rect->x + rect->w;
|
||||
GLshort miny = rect->y;
|
||||
GLshort maxy = rect->y + rect->h;
|
||||
GLshort vertices[8];
|
||||
vertices[0] = minx;
|
||||
vertices[1] = miny;
|
||||
vertices[2] = maxx;
|
||||
vertices[3] = miny;
|
||||
vertices[4] = minx;
|
||||
vertices[5] = maxy;
|
||||
vertices[6] = maxx;
|
||||
vertices[7] = maxy;
|
||||
|
||||
glVertexPointer(2, GL_SHORT, 0, vertices);
|
||||
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
|
||||
{
|
||||
|
||||
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
|
||||
GLES_TextureData *texturedata = (GLES_TextureData *) texture->driverdata;
|
||||
int minx, miny, maxx, maxy;
|
||||
GLfloat minu, maxu, minv, maxv;
|
||||
|
||||
GLES_ActivateRenderer(renderer);
|
||||
|
||||
glEnable(GL_TEXTURE_2D);
|
||||
|
||||
glBindTexture(texturedata->type, texturedata->texture);
|
||||
|
||||
if (texture->modMode) {
|
||||
GLES_SetColor(data, texture->r, texture->g, texture->b, texture->a);
|
||||
} else {
|
||||
GLES_SetColor(data, 255, 255, 255, 255);
|
||||
}
|
||||
|
||||
GLES_SetBlendMode(data, texture->blendMode);
|
||||
|
||||
GLES_SetTexCoords(data, SDL_TRUE);
|
||||
|
||||
if (data->GL_OES_draw_texture_supported && data->useDrawTexture) {
|
||||
/* this code is a little funny because the viewport is upside down vs SDL's coordinate system */
|
||||
GLint cropRect[4];
|
||||
int w, h;
|
||||
SDL_Window *window = renderer->window;
|
||||
|
||||
SDL_GetWindowSize(window, &w, &h);
|
||||
cropRect[0] = srcrect->x;
|
||||
cropRect[1] = srcrect->y + srcrect->h;
|
||||
cropRect[2] = srcrect->w;
|
||||
cropRect[3] = -srcrect->h;
|
||||
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_CROP_RECT_OES,
|
||||
cropRect);
|
||||
glDrawTexiOES(renderer->viewport.x + dstrect->x,
|
||||
h - (renderer->viewport.y + dstrect->y) - dstrect->h, 0,
|
||||
dstrect->w, dstrect->h);
|
||||
} else {
|
||||
|
||||
minx = dstrect->x;
|
||||
miny = dstrect->y;
|
||||
maxx = dstrect->x + dstrect->w;
|
||||
maxy = dstrect->y + dstrect->h;
|
||||
|
||||
minu = (GLfloat) srcrect->x / texture->w;
|
||||
minu *= texturedata->texw;
|
||||
maxu = (GLfloat) (srcrect->x + srcrect->w) / texture->w;
|
||||
maxu *= texturedata->texw;
|
||||
minv = (GLfloat) srcrect->y / texture->h;
|
||||
minv *= texturedata->texh;
|
||||
maxv = (GLfloat) (srcrect->y + srcrect->h) / texture->h;
|
||||
maxv *= texturedata->texh;
|
||||
|
||||
GLshort vertices[8];
|
||||
GLfloat texCoords[8];
|
||||
|
||||
vertices[0] = minx;
|
||||
vertices[1] = miny;
|
||||
vertices[2] = maxx;
|
||||
vertices[3] = miny;
|
||||
vertices[4] = minx;
|
||||
vertices[5] = maxy;
|
||||
vertices[6] = maxx;
|
||||
vertices[7] = maxy;
|
||||
|
||||
texCoords[0] = minu;
|
||||
texCoords[1] = minv;
|
||||
texCoords[2] = maxu;
|
||||
texCoords[3] = minv;
|
||||
texCoords[4] = minu;
|
||||
texCoords[5] = maxv;
|
||||
texCoords[6] = maxu;
|
||||
texCoords[7] = maxv;
|
||||
|
||||
glVertexPointer(2, GL_SHORT, 0, vertices);
|
||||
glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
|
||||
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
|
||||
}
|
||||
glDisable(GL_TEXTURE_2D);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
GLES_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
|
||||
Uint32 pixel_format, void * pixels, int pitch)
|
||||
{
|
||||
SDL_Window *window = renderer->window;
|
||||
Uint32 temp_format = SDL_PIXELFORMAT_ABGR8888;
|
||||
void *temp_pixels;
|
||||
int temp_pitch;
|
||||
Uint8 *src, *dst, *tmp;
|
||||
int w, h, length, rows;
|
||||
int status;
|
||||
|
||||
GLES_ActivateRenderer(renderer);
|
||||
|
||||
temp_pitch = rect->w * SDL_BYTESPERPIXEL(temp_format);
|
||||
temp_pixels = SDL_malloc(rect->h * temp_pitch);
|
||||
if (!temp_pixels) {
|
||||
SDL_OutOfMemory();
|
||||
return -1;
|
||||
}
|
||||
|
||||
SDL_GetWindowSize(window, &w, &h);
|
||||
|
||||
glPixelStorei(GL_PACK_ALIGNMENT, 1);
|
||||
|
||||
glReadPixels(rect->x, (h-rect->y)-rect->h, rect->w, rect->h,
|
||||
GL_RGBA, GL_UNSIGNED_BYTE, temp_pixels);
|
||||
|
||||
/* Flip the rows to be top-down */
|
||||
length = rect->w * SDL_BYTESPERPIXEL(temp_format);
|
||||
src = (Uint8*)temp_pixels + (rect->h-1)*temp_pitch;
|
||||
dst = (Uint8*)temp_pixels;
|
||||
tmp = SDL_stack_alloc(Uint8, length);
|
||||
rows = rect->h / 2;
|
||||
while (rows--) {
|
||||
SDL_memcpy(tmp, dst, length);
|
||||
SDL_memcpy(dst, src, length);
|
||||
SDL_memcpy(src, tmp, length);
|
||||
dst += temp_pitch;
|
||||
src -= temp_pitch;
|
||||
}
|
||||
SDL_stack_free(tmp);
|
||||
|
||||
status = SDL_ConvertPixels(rect->w, rect->h,
|
||||
temp_format, temp_pixels, temp_pitch,
|
||||
pixel_format, pixels, pitch);
|
||||
SDL_free(temp_pixels);
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_RenderPresent(SDL_Renderer * renderer)
|
||||
{
|
||||
GLES_ActivateRenderer(renderer);
|
||||
|
||||
SDL_GL_SwapWindow(renderer->window);
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
GLES_TextureData *data = (GLES_TextureData *) texture->driverdata;
|
||||
|
||||
GLES_ActivateRenderer(renderer);
|
||||
|
||||
if (!data) {
|
||||
return;
|
||||
}
|
||||
if (data->texture) {
|
||||
glDeleteTextures(1, &data->texture);
|
||||
}
|
||||
if (data->pixels) {
|
||||
SDL_free(data->pixels);
|
||||
}
|
||||
SDL_free(data);
|
||||
texture->driverdata = NULL;
|
||||
}
|
||||
|
||||
static void
|
||||
GLES_DestroyRenderer(SDL_Renderer * renderer)
|
||||
{
|
||||
GLES_RenderData *data = (GLES_RenderData *) renderer->driverdata;
|
||||
|
||||
if (data) {
|
||||
if (data->context) {
|
||||
SDL_GL_DeleteContext(data->context);
|
||||
}
|
||||
SDL_free(data);
|
||||
}
|
||||
SDL_free(renderer);
|
||||
}
|
||||
|
||||
#endif /* SDL_VIDEO_RENDER_OGL_ES && !SDL_RENDER_DISABLED */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
1262
project/jni/sdl-1.3/src/render/opengles2/SDL_render_gles2.c
Normal file
1262
project/jni/sdl-1.3/src/render/opengles2/SDL_render_gles2.c
Normal file
File diff suppressed because it is too large
Load Diff
541
project/jni/sdl-1.3/src/render/opengles2/SDL_shaders_gles2.c
Normal file
541
project/jni/sdl-1.3/src/render/opengles2/SDL_shaders_gles2.c
Normal file
@@ -0,0 +1,541 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED
|
||||
|
||||
#include "SDL_video.h"
|
||||
#include "SDL_opengles2.h"
|
||||
#include "SDL_shaders_gles2.h"
|
||||
#include "SDL_stdinc.h"
|
||||
|
||||
/*************************************************************************************************
|
||||
* Vertex/fragment shader source *
|
||||
*************************************************************************************************/
|
||||
|
||||
static const Uint8 GLES2_VertexSrc_Default_[] = " \
|
||||
uniform mat4 u_projection; \
|
||||
attribute vec4 a_position; \
|
||||
attribute vec2 a_texCoord; \
|
||||
varying vec2 v_texCoord; \
|
||||
\
|
||||
void main() \
|
||||
{ \
|
||||
v_texCoord = a_texCoord; \
|
||||
gl_Position = u_projection * a_position; \
|
||||
gl_PointSize = 1.0; \
|
||||
} \
|
||||
";
|
||||
|
||||
static const Uint8 GLES2_FragmentSrc_SolidSrc_[] = " \
|
||||
precision mediump float; \
|
||||
uniform vec4 u_color; \
|
||||
\
|
||||
void main() \
|
||||
{ \
|
||||
gl_FragColor = u_color; \
|
||||
} \
|
||||
";
|
||||
|
||||
static const Uint8 GLES2_FragmentSrc_TextureSrc_[] = " \
|
||||
precision mediump float; \
|
||||
uniform sampler2D u_texture; \
|
||||
uniform vec4 u_modulation; \
|
||||
varying vec2 v_texCoord; \
|
||||
\
|
||||
void main() \
|
||||
{ \
|
||||
gl_FragColor = texture2D(u_texture, v_texCoord); \
|
||||
gl_FragColor *= u_modulation; \
|
||||
} \
|
||||
";
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_VertexSrc_Default = {
|
||||
GL_VERTEX_SHADER,
|
||||
GLES2_SOURCE_SHADER,
|
||||
sizeof(GLES2_VertexSrc_Default_),
|
||||
GLES2_VertexSrc_Default_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentSrc_SolidSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GLES2_SOURCE_SHADER,
|
||||
sizeof(GLES2_FragmentSrc_SolidSrc_),
|
||||
GLES2_FragmentSrc_SolidSrc_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentSrc_TextureSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GLES2_SOURCE_SHADER,
|
||||
sizeof(GLES2_FragmentSrc_TextureSrc_),
|
||||
GLES2_FragmentSrc_TextureSrc_
|
||||
};
|
||||
|
||||
/*************************************************************************************************
|
||||
* Vertex/fragment shader binaries (NVIDIA Tegra 1/2) *
|
||||
*************************************************************************************************/
|
||||
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
|
||||
#define GL_NVIDIA_PLATFORM_BINARY_NV 0x890B
|
||||
|
||||
static const Uint8 GLES2_VertexTegra_Default_[] = {
|
||||
243, 193, 1, 142, 31, 109, 131, 38, 6, 0, 1, 0, 5, 0, 0, 0, 17, 0, 0, 0, 1, 0, 0, 0, 73, 0,
|
||||
0, 0, 46, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 85, 0, 0, 0, 2, 0, 0, 0, 24, 0, 0, 0, 3, 0, 0, 0,
|
||||
91, 0, 0, 0, 1, 0, 0, 0, 16, 0, 0, 0, 5, 0, 0, 0, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 95, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0,
|
||||
13, 0, 0, 0, 102, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 16, 0, 0, 0, 104, 0, 0, 0, 1, 0, 0, 0, 32, 0, 0, 0, 17, 0, 0, 0, 112, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 112, 0, 0, 0, 80, 0, 0, 0, 80, 0, 0, 0, 19, 0, 0, 0, 132, 0,
|
||||
0, 0, 104, 0, 0, 0, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 97, 110, 70, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 97,
|
||||
95, 112, 111, 115, 105, 116, 105, 111, 110, 0, 97, 95, 116, 101, 120, 67, 111, 111, 114, 100,
|
||||
0, 118, 95, 116, 101, 120, 67, 111, 111, 114, 100, 0, 117, 95, 112, 114, 111, 106, 101, 99,
|
||||
116, 105, 111, 110, 0, 0, 0, 0, 0, 0, 0, 82, 139, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 80, 139, 0,
|
||||
0, 1, 0, 0, 0, 22, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 33, 0, 0, 0, 92, 139, 0, 0,
|
||||
1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 240, 0, 0, 0, 0, 0, 0, 1, 0,
|
||||
0, 0, 64, 0, 0, 0, 80, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 193, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 66, 24, 0, 6, 34, 108, 28,
|
||||
0, 0, 42, 16, 128, 0, 195, 192, 6, 129, 252, 255, 65, 96, 108, 28, 0, 0, 0, 0, 0, 1, 195, 192,
|
||||
6, 1, 252, 255, 33, 96, 108, 156, 31, 64, 8, 1, 64, 0, 131, 192, 6, 1, 156, 159, 65, 96, 108,
|
||||
28, 0, 0, 85, 32, 0, 1, 195, 192, 6, 1, 252, 255, 33, 96, 108, 156, 31, 64, 0, 64, 64, 0, 131,
|
||||
192, 134, 1, 152, 31, 65, 96, 108, 156, 31, 64, 127, 48, 0, 1, 195, 192, 6, 129, 129, 255, 33,
|
||||
96
|
||||
};
|
||||
|
||||
static const Uint8 GLES2_FragmentTegra_None_SolidSrc_[] = {
|
||||
155, 191, 159, 1, 47, 109, 131, 38, 6, 0, 1, 0, 5, 0, 0, 0, 17, 0, 0, 0, 1, 0, 0, 0, 73, 0,
|
||||
0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 75,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0,
|
||||
75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 75, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, 13, 0,
|
||||
0, 0, 82, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 14, 0, 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
22, 0, 0, 0, 84, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 23, 0, 0, 0, 92, 0, 0, 0, 1, 0, 0, 0, 4,
|
||||
0, 0, 0, 15, 0, 0, 0, 93, 0, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 17, 0, 0, 0, 113, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 113, 0, 0,
|
||||
0, 108, 0, 0, 0, 108, 0, 0, 0, 20, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0,
|
||||
0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 97, 110, 70, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 117, 95, 99, 111, 108, 111, 114, 0, 0, 0, 0, 0, 82, 139, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 241, 0, 0, 0, 240, 0, 0,
|
||||
0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 21, 32, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 20, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 82, 50, 48, 45, 66, 73, 78, 1,
|
||||
0, 0, 0, 1, 0, 0, 0, 1, 0, 65, 37, 0, 0, 0, 0, 1, 0, 0, 21, 0, 0, 0, 0, 1, 0, 1, 38, 0, 0, 0,
|
||||
0, 1, 0, 1, 39, 0, 0, 0, 0, 1, 0, 1, 40, 1, 0, 0, 0, 8, 0, 4, 40, 0, 40, 0, 0, 0, 242, 65, 63,
|
||||
192, 200, 0, 0, 0, 242, 65, 63, 128, 168, 0, 0, 0, 242, 65, 63, 64, 72, 0, 0, 0, 242, 65, 63,
|
||||
1, 0, 6, 40, 0, 0, 0, 0, 1, 0, 1, 41, 5, 0, 2, 0
|
||||
};
|
||||
|
||||
static const Uint8 GLES2_FragmentTegra_Alpha_SolidSrc_[] = {
|
||||
169, 153, 195, 28, 47, 109, 131, 38, 6, 0, 1, 0, 5, 0, 0, 0, 17, 0, 0, 0, 1, 0, 0, 0, 73, 0,
|
||||
0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 75,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0,
|
||||
75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 75, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, 13, 0,
|
||||
0, 0, 82, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 14, 0, 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
22, 0, 0, 0, 84, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 23, 0, 0, 0, 92, 0, 0, 0, 1, 0, 0, 0, 4,
|
||||
0, 0, 0, 15, 0, 0, 0, 93, 0, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 17, 0, 0, 0, 113, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 113, 0, 0,
|
||||
0, 220, 0, 0, 0, 220, 0, 0, 0, 20, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0,
|
||||
0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 97, 110, 70, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 117, 95, 99, 111, 108, 111, 114, 0, 0, 0, 0, 0, 82, 139, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 48, 0, 0, 0, 0, 0, 0, 118, 118, 17, 241, 0, 0, 0, 240, 0,
|
||||
0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 21, 32, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 82, 50, 48, 45, 66, 73, 78,
|
||||
1, 0, 0, 0, 3, 0, 0, 0, 3, 0, 65, 37, 8, 0, 129, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 21, 0,
|
||||
0, 0, 0, 3, 0, 1, 38, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 39, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 3, 0, 1, 40, 1, 0, 0, 0, 5, 0, 0, 0, 9, 0, 0, 0, 24, 0, 4, 40, 232, 231, 15,
|
||||
0, 0, 242, 65, 62, 194, 72, 1, 0, 0, 250, 65, 63, 194, 40, 1, 0, 0, 250, 65, 63, 192, 168, 1,
|
||||
0, 0, 242, 1, 64, 192, 168, 1, 0, 0, 242, 1, 68, 168, 32, 0, 0, 0, 50, 64, 0, 192, 168, 15,
|
||||
0, 0, 242, 1, 66, 168, 64, 0, 16, 0, 242, 65, 1, 232, 231, 15, 0, 0, 242, 65, 62, 168, 160,
|
||||
0, 0, 0, 50, 64, 2, 104, 192, 0, 0, 36, 48, 66, 4, 232, 231, 15, 0, 0, 242, 65, 62, 3, 0, 6,
|
||||
40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 1, 41, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 2, 0
|
||||
};
|
||||
|
||||
static const Uint8 GLES2_FragmentTegra_Additive_SolidSrc_[] = {
|
||||
59, 71, 42, 17, 47, 109, 131, 38, 6, 0, 1, 0, 5, 0, 0, 0, 17, 0, 0, 0, 1, 0, 0, 0, 73, 0, 0,
|
||||
0, 8, 0, 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 75,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0,
|
||||
75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 75, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, 13, 0,
|
||||
0, 0, 82, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 14, 0, 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
22, 0, 0, 0, 84, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 23, 0, 0, 0, 92, 0, 0, 0, 1, 0, 0, 0, 4,
|
||||
0, 0, 0, 15, 0, 0, 0, 93, 0, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 17, 0, 0, 0, 113, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 113, 0, 0,
|
||||
0, 108, 0, 0, 0, 108, 0, 0, 0, 20, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0,
|
||||
0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 97, 110, 70, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 117, 95, 99, 111, 108, 111, 114, 0, 0, 0, 0, 0, 82, 139, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 48, 0, 0, 0, 0, 0, 0, 22, 22, 17, 241, 0, 0, 0, 240, 0,
|
||||
0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 21, 32, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 82, 50, 48, 45, 66, 73, 78,
|
||||
1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 65, 37, 8, 0, 129, 0, 1, 0, 0, 21, 0, 0, 0, 0, 1, 0, 1, 38, 0,
|
||||
0, 0, 0, 1, 0, 1, 39, 0, 0, 0, 0, 1, 0, 1, 40, 1, 0, 0, 0, 8, 0, 4, 40, 192, 200, 0, 0, 0, 26,
|
||||
0, 70, 192, 40, 0, 0, 0, 2, 0, 64, 192, 72, 0, 0, 0, 10, 0, 66, 192, 168, 0, 0, 0, 18, 0, 68,
|
||||
1, 0, 6, 40, 0, 0, 0, 0, 1, 0, 1, 41, 5, 0, 2, 0
|
||||
};
|
||||
|
||||
static const Uint8 GLES2_FragmentTegra_Modulated_SolidSrc_[] = {
|
||||
37, 191, 49, 17, 47, 109, 131, 38, 6, 0, 1, 0, 5, 0, 0, 0, 17, 0, 0, 0, 1, 0, 0, 0, 73, 0, 0,
|
||||
0, 8, 0, 0, 0, 8, 0, 0, 0, 2, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 75,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0,
|
||||
75, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 75, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, 13, 0,
|
||||
0, 0, 82, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 14, 0, 0, 0, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
22, 0, 0, 0, 84, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 23, 0, 0, 0, 92, 0, 0, 0, 1, 0, 0, 0, 4,
|
||||
0, 0, 0, 15, 0, 0, 0, 93, 0, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 17, 0, 0, 0, 113, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 113, 0, 0,
|
||||
0, 108, 0, 0, 0, 108, 0, 0, 0, 20, 0, 0, 0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21, 0, 0,
|
||||
0, 113, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 97, 110, 70, 73, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 117, 95, 99, 111, 108, 111, 114, 0, 0, 0, 0, 0, 82, 139, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 48, 0, 0, 0, 0, 0, 0, 32, 32, 17, 241, 0, 0, 0, 240, 0,
|
||||
0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 21, 32, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 65, 82, 50, 48, 45, 66, 73, 78,
|
||||
1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 65, 37, 8, 0, 129, 0, 1, 0, 0, 21, 0, 0, 0, 0, 1, 0, 1, 38, 0,
|
||||
0, 0, 0, 1, 0, 1, 39, 0, 0, 0, 0, 1, 0, 1, 40, 1, 0, 0, 0, 8, 0, 4, 40, 104, 192, 0, 0, 0, 242,
|
||||
1, 70, 8, 32, 0, 0, 0, 242, 1, 64, 40, 64, 0, 0, 0, 242, 1, 66, 72, 160, 0, 0, 0, 242, 1, 68,
|
||||
1, 0, 6, 40, 0, 0, 0, 0, 1, 0, 1, 41, 5, 0, 2, 0
|
||||
};
|
||||
|
||||
static const Uint8 GLES2_FragmentTegra_None_TextureSrc_[] = {
|
||||
220, 217, 41, 211, 47, 109, 131, 38, 6, 0, 1, 0, 5, 0, 0, 0, 17, 0, 0, 0, 1, 0, 0, 0, 73, 0,
|
||||
0, 0, 34, 0, 0, 0, 36, 0, 0, 0, 2, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0,
|
||||
82, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 6, 0, 0, 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0,
|
||||
0, 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 87, 0, 0, 0, 2, 0, 0, 0, 56, 0, 0, 0,
|
||||
13, 0, 0, 0, 101, 0, 0, 0, 4, 0, 0, 0, 16, 0, 0, 0, 14, 0, 0, 0, 105, 0, 0, 0, 1, 0, 0, 0, 4,
|
||||
0, 0, 0, 22, 0, 0, 0, 106, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 23, 0, 0, 0, 114, 0, 0, 0, 1, 0,
|
||||
0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 115, 0, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 17, 0, 0, 0, 135, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 135,
|
||||
0, 0, 0, 120, 0, 0, 0, 120, 0, 0, 0, 20, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21,
|
||||
0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 97, 110, 70, 73, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 118, 95, 116, 101, 120, 67, 111, 111, 114, 100, 0, 117, 95, 109, 111, 100, 117, 108,
|
||||
97, 116, 105, 111, 110, 0, 117, 95, 116, 101, 120, 116, 117, 114, 101, 0, 0, 0, 0, 0, 0, 0,
|
||||
2, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 82, 139, 0, 0, 1, 0, 0, 0, 1,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 94, 139, 0, 0, 1, 0, 0, 0, 1, 0, 0,
|
||||
0, 2, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 5, 48, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 1, 0, 0, 0, 241, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240,
|
||||
0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 1, 0,
|
||||
0, 0, 1, 0, 0, 0, 21, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0,
|
||||
0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 65, 82, 50, 48, 45, 66, 73, 78, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 65, 37, 0, 0, 0, 0, 1, 0,
|
||||
0, 21, 0, 0, 0, 0, 1, 0, 1, 38, 1, 0, 0, 0, 2, 0, 4, 38, 186, 81, 78, 16, 2, 1, 0, 0, 1, 0,
|
||||
1, 39, 0, 4, 0, 0, 1, 0, 1, 40, 1, 0, 0, 0, 8, 0, 4, 40, 104, 192, 0, 0, 0, 242, 1, 70, 8, 32,
|
||||
0, 0, 0, 242, 1, 64, 40, 64, 0, 0, 0, 242, 1, 66, 72, 160, 0, 0, 0, 242, 1, 68, 1, 0, 6, 40,
|
||||
0, 0, 0, 0, 1, 0, 1, 41, 5, 0, 2, 0
|
||||
};
|
||||
|
||||
static const Uint8 GLES2_FragmentTegra_Alpha_TextureSrc_[] = {
|
||||
71, 202, 114, 229, 47, 109, 131, 38, 6, 0, 1, 0, 5, 0, 0, 0, 17, 0, 0, 0, 1, 0, 0, 0, 73, 0,
|
||||
0, 0, 34, 0, 0, 0, 36, 0, 0, 0, 2, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0,
|
||||
82, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 6, 0, 0, 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0,
|
||||
0, 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 87, 0, 0, 0, 2, 0, 0, 0, 56, 0, 0, 0,
|
||||
13, 0, 0, 0, 101, 0, 0, 0, 4, 0, 0, 0, 16, 0, 0, 0, 14, 0, 0, 0, 105, 0, 0, 0, 1, 0, 0, 0, 4,
|
||||
0, 0, 0, 22, 0, 0, 0, 106, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 23, 0, 0, 0, 114, 0, 0, 0, 1, 0,
|
||||
0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 115, 0, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 17, 0, 0, 0, 135, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 135,
|
||||
0, 0, 0, 176, 0, 0, 0, 176, 0, 0, 0, 20, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21,
|
||||
0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 97, 110, 70, 73, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 118, 95, 116, 101, 120, 67, 111, 111, 114, 100, 0, 117, 95, 109, 111, 100, 117, 108,
|
||||
97, 116, 105, 111, 110, 0, 117, 95, 116, 101, 120, 116, 117, 114, 101, 0, 0, 0, 0, 0, 0, 0,
|
||||
2, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 82, 139, 0, 0, 1, 0, 0, 0, 1,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 94, 139, 0, 0, 1, 0, 0, 0, 1, 0, 0,
|
||||
0, 2, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 5, 48, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 1, 118, 118, 17, 241, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0,
|
||||
240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 2, 0, 0, 0,
|
||||
1, 0, 0, 0, 2, 0, 0, 0, 21, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 16, 0, 0, 0, 16,
|
||||
0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 65, 82, 50, 48, 45, 66, 73, 78, 1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 65, 37, 0, 0, 0, 0,
|
||||
8, 0, 129, 0, 1, 0, 0, 21, 0, 0, 0, 0, 2, 0, 1, 38, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 4, 38, 186,
|
||||
81, 78, 16, 2, 1, 0, 0, 2, 0, 1, 39, 0, 4, 0, 0, 0, 0, 0, 0, 2, 0, 1, 40, 1, 0, 0, 0, 5, 0,
|
||||
0, 0, 16, 0, 4, 40, 40, 160, 1, 0, 0, 242, 1, 66, 8, 192, 1, 0, 0, 242, 1, 64, 104, 32, 1, 0,
|
||||
0, 242, 1, 70, 72, 64, 1, 0, 0, 242, 1, 68, 154, 192, 0, 0, 37, 34, 64, 3, 8, 32, 0, 0, 5, 58,
|
||||
208, 4, 40, 64, 0, 0, 5, 50, 208, 4, 72, 160, 0, 0, 37, 42, 208, 4, 2, 0, 6, 40, 0, 0, 0, 0,
|
||||
0, 0, 0, 0, 2, 0, 1, 41, 0, 0, 0, 0, 5, 0, 2, 0
|
||||
};
|
||||
|
||||
static const Uint8 GLES2_FragmentTegra_Additive_TextureSrc_[] = {
|
||||
161, 234, 193, 234, 47, 109, 131, 38, 6, 0, 1, 0, 5, 0, 0, 0, 17, 0, 0, 0, 1, 0, 0, 0, 73, 0,
|
||||
0, 0, 34, 0, 0, 0, 36, 0, 0, 0, 2, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0,
|
||||
82, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 6, 0, 0, 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0,
|
||||
0, 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 87, 0, 0, 0, 2, 0, 0, 0, 56, 0, 0, 0,
|
||||
13, 0, 0, 0, 101, 0, 0, 0, 4, 0, 0, 0, 16, 0, 0, 0, 14, 0, 0, 0, 105, 0, 0, 0, 1, 0, 0, 0, 4,
|
||||
0, 0, 0, 22, 0, 0, 0, 106, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 23, 0, 0, 0, 114, 0, 0, 0, 1, 0,
|
||||
0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 115, 0, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 17, 0, 0, 0, 135, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 135,
|
||||
0, 0, 0, 176, 0, 0, 0, 176, 0, 0, 0, 20, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21,
|
||||
0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 97, 110, 70, 73, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 118, 95, 116, 101, 120, 67, 111, 111, 114, 100, 0, 117, 95, 109, 111, 100, 117, 108,
|
||||
97, 116, 105, 111, 110, 0, 117, 95, 116, 101, 120, 116, 117, 114, 101, 0, 0, 0, 0, 0, 0, 0,
|
||||
2, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 82, 139, 0, 0, 1, 0, 0, 0, 1,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 94, 139, 0, 0, 1, 0, 0, 0, 1, 0, 0,
|
||||
0, 2, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 5, 48, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 1, 22, 22, 17, 241, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240,
|
||||
0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 2, 0, 0, 0, 1, 0,
|
||||
0, 0, 2, 0, 0, 0, 21, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0,
|
||||
0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 65, 82, 50, 48, 45, 66, 73, 78, 1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 65, 37, 0, 0, 0, 0, 8, 0,
|
||||
129, 0, 1, 0, 0, 21, 0, 0, 0, 0, 2, 0, 1, 38, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 4, 38, 186, 81,
|
||||
78, 16, 2, 1, 0, 0, 2, 0, 1, 39, 0, 4, 0, 0, 0, 0, 0, 0, 2, 0, 1, 40, 1, 0, 0, 0, 5, 0, 0, 0,
|
||||
16, 0, 4, 40, 40, 160, 1, 0, 0, 242, 1, 66, 104, 32, 1, 0, 0, 242, 1, 70, 8, 192, 1, 0, 0, 242,
|
||||
1, 64, 72, 64, 1, 0, 0, 242, 1, 68, 136, 192, 0, 0, 0, 26, 64, 4, 136, 32, 0, 0, 0, 2, 64, 7,
|
||||
136, 64, 0, 0, 0, 10, 64, 6, 136, 160, 0, 0, 0, 18, 64, 5, 2, 0, 6, 40, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 2, 0, 1, 41, 0, 0, 0, 0, 5, 0, 2, 0
|
||||
};
|
||||
|
||||
static const Uint8 GLES2_FragmentTegra_Modulated_TextureSrc_[] = {
|
||||
75, 132, 201, 227, 47, 109, 131, 38, 6, 0, 1, 0, 5, 0, 0, 0, 17, 0, 0, 0, 1, 0, 0, 0, 73, 0,
|
||||
0, 0, 34, 0, 0, 0, 36, 0, 0, 0, 2, 0, 0, 0, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0,
|
||||
82, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 6, 0, 0, 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0,
|
||||
0, 0, 87, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 87, 0, 0, 0, 2, 0, 0, 0, 56, 0, 0, 0,
|
||||
13, 0, 0, 0, 101, 0, 0, 0, 4, 0, 0, 0, 16, 0, 0, 0, 14, 0, 0, 0, 105, 0, 0, 0, 1, 0, 0, 0, 4,
|
||||
0, 0, 0, 22, 0, 0, 0, 106, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 23, 0, 0, 0, 114, 0, 0, 0, 1, 0,
|
||||
0, 0, 4, 0, 0, 0, 15, 0, 0, 0, 115, 0, 0, 0, 1, 0, 0, 0, 80, 0, 0, 0, 17, 0, 0, 0, 135, 0, 0,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 135,
|
||||
0, 0, 0, 176, 0, 0, 0, 176, 0, 0, 0, 20, 0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21,
|
||||
0, 0, 0, 135, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 109, 97, 110, 70, 73, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 0, 118, 95, 116, 101, 120, 67, 111, 111, 114, 100, 0, 117, 95, 109, 111, 100, 117, 108,
|
||||
97, 116, 105, 111, 110, 0, 117, 95, 116, 101, 120, 116, 117, 114, 101, 0, 0, 0, 0, 0, 0, 0,
|
||||
2, 0, 0, 0, 0, 0, 0, 0, 220, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 82, 139, 0, 0, 1, 0, 0, 0, 1,
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 94, 139, 0, 0, 1, 0, 0, 0, 1, 0, 0,
|
||||
0, 2, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 5, 48, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 1, 32, 32, 17, 241, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 240,
|
||||
0, 0, 0, 240, 0, 0, 0, 240, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 7, 0, 0, 0, 2, 0, 0, 0, 1, 0,
|
||||
0, 0, 2, 0, 0, 0, 21, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0,
|
||||
0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 65, 82, 50, 48, 45, 66, 73, 78, 1, 0, 0, 0, 2, 0, 0, 0, 2, 0, 65, 37, 0, 0, 0, 0, 8, 0,
|
||||
129, 0, 1, 0, 0, 21, 0, 0, 0, 0, 2, 0, 1, 38, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 4, 38, 186, 81,
|
||||
78, 16, 2, 1, 0, 0, 2, 0, 1, 39, 0, 4, 0, 0, 0, 0, 0, 0, 2, 0, 1, 40, 1, 0, 0, 0, 5, 0, 0, 0,
|
||||
16, 0, 4, 40, 40, 160, 1, 0, 0, 242, 1, 66, 8, 192, 1, 0, 0, 242, 1, 64, 104, 32, 1, 0, 0, 242,
|
||||
1, 70, 72, 64, 1, 0, 0, 242, 1, 68, 104, 192, 0, 0, 0, 242, 65, 4, 232, 32, 0, 0, 0, 242, 65,
|
||||
0, 40, 64, 0, 0, 0, 242, 65, 6, 72, 160, 0, 0, 0, 242, 65, 5, 2, 0, 6, 40, 0, 0, 0, 0, 0, 0,
|
||||
0, 0, 2, 0, 1, 41, 0, 0, 0, 0, 5, 0, 2, 0
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_VertexTegra_Default = {
|
||||
GL_VERTEX_SHADER,
|
||||
GL_NVIDIA_PLATFORM_BINARY_NV,
|
||||
sizeof(GLES2_VertexTegra_Default_),
|
||||
GLES2_VertexTegra_Default_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentTegra_None_SolidSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GL_NVIDIA_PLATFORM_BINARY_NV,
|
||||
sizeof(GLES2_FragmentTegra_None_SolidSrc_),
|
||||
GLES2_FragmentTegra_None_SolidSrc_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentTegra_Alpha_SolidSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GL_NVIDIA_PLATFORM_BINARY_NV,
|
||||
sizeof(GLES2_FragmentTegra_Alpha_SolidSrc_),
|
||||
GLES2_FragmentTegra_Alpha_SolidSrc_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentTegra_Additive_SolidSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GL_NVIDIA_PLATFORM_BINARY_NV,
|
||||
sizeof(GLES2_FragmentTegra_Additive_SolidSrc_),
|
||||
GLES2_FragmentTegra_Additive_SolidSrc_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentTegra_Modulated_SolidSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GL_NVIDIA_PLATFORM_BINARY_NV,
|
||||
sizeof(GLES2_FragmentTegra_Modulated_SolidSrc_),
|
||||
GLES2_FragmentTegra_Modulated_SolidSrc_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentTegra_None_TextureSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GL_NVIDIA_PLATFORM_BINARY_NV,
|
||||
sizeof(GLES2_FragmentTegra_None_TextureSrc_),
|
||||
GLES2_FragmentTegra_None_TextureSrc_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentTegra_Alpha_TextureSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GL_NVIDIA_PLATFORM_BINARY_NV,
|
||||
sizeof(GLES2_FragmentTegra_Alpha_TextureSrc_),
|
||||
GLES2_FragmentTegra_Alpha_TextureSrc_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentTegra_Additive_TextureSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GL_NVIDIA_PLATFORM_BINARY_NV,
|
||||
sizeof(GLES2_FragmentTegra_Additive_TextureSrc_),
|
||||
GLES2_FragmentTegra_Additive_TextureSrc_
|
||||
};
|
||||
|
||||
static const GLES2_ShaderInstance GLES2_FragmentTegra_Modulated_TextureSrc = {
|
||||
GL_FRAGMENT_SHADER,
|
||||
GL_NVIDIA_PLATFORM_BINARY_NV,
|
||||
sizeof(GLES2_FragmentTegra_Modulated_TextureSrc_),
|
||||
GLES2_FragmentTegra_Modulated_TextureSrc_
|
||||
};
|
||||
|
||||
#endif /* GLES2_INCLUDE_NVIDIA_SHADERS */
|
||||
|
||||
/*************************************************************************************************
|
||||
* Vertex/fragment shader definitions *
|
||||
*************************************************************************************************/
|
||||
|
||||
static GLES2_Shader GLES2_VertexShader_Default = {
|
||||
2,
|
||||
{
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
&GLES2_VertexTegra_Default,
|
||||
#endif
|
||||
&GLES2_VertexSrc_Default
|
||||
}
|
||||
};
|
||||
|
||||
static GLES2_Shader GLES2_FragmentShader_None_SolidSrc = {
|
||||
2,
|
||||
{
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
&GLES2_FragmentTegra_None_SolidSrc,
|
||||
#endif
|
||||
&GLES2_FragmentSrc_SolidSrc
|
||||
}
|
||||
};
|
||||
|
||||
static GLES2_Shader GLES2_FragmentShader_Alpha_SolidSrc = {
|
||||
2,
|
||||
{
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
&GLES2_FragmentTegra_Alpha_SolidSrc,
|
||||
#endif
|
||||
&GLES2_FragmentSrc_SolidSrc
|
||||
}
|
||||
};
|
||||
|
||||
static GLES2_Shader GLES2_FragmentShader_Additive_SolidSrc = {
|
||||
2,
|
||||
{
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
&GLES2_FragmentTegra_Additive_SolidSrc,
|
||||
#endif
|
||||
&GLES2_FragmentSrc_SolidSrc
|
||||
}
|
||||
};
|
||||
|
||||
static GLES2_Shader GLES2_FragmentShader_Modulated_SolidSrc = {
|
||||
2,
|
||||
{
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
&GLES2_FragmentTegra_Modulated_SolidSrc,
|
||||
#endif
|
||||
&GLES2_FragmentSrc_SolidSrc
|
||||
}
|
||||
};
|
||||
|
||||
static GLES2_Shader GLES2_FragmentShader_None_TextureSrc = {
|
||||
2,
|
||||
{
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
&GLES2_FragmentTegra_None_TextureSrc,
|
||||
#endif
|
||||
&GLES2_FragmentSrc_TextureSrc
|
||||
}
|
||||
};
|
||||
|
||||
static GLES2_Shader GLES2_FragmentShader_Alpha_TextureSrc = {
|
||||
2,
|
||||
{
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
&GLES2_FragmentTegra_Alpha_TextureSrc,
|
||||
#endif
|
||||
&GLES2_FragmentSrc_TextureSrc
|
||||
}
|
||||
};
|
||||
|
||||
static GLES2_Shader GLES2_FragmentShader_Additive_TextureSrc = {
|
||||
2,
|
||||
{
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
&GLES2_FragmentTegra_Additive_TextureSrc,
|
||||
#endif
|
||||
&GLES2_FragmentSrc_TextureSrc
|
||||
}
|
||||
};
|
||||
|
||||
static GLES2_Shader GLES2_FragmentShader_Modulated_TextureSrc = {
|
||||
2,
|
||||
{
|
||||
#if GLES2_INCLUDE_NVIDIA_SHADERS
|
||||
&GLES2_FragmentTegra_Modulated_TextureSrc,
|
||||
#endif
|
||||
&GLES2_FragmentSrc_TextureSrc
|
||||
}
|
||||
};
|
||||
|
||||
/*************************************************************************************************
|
||||
* Shader selector *
|
||||
*************************************************************************************************/
|
||||
|
||||
const GLES2_Shader *GLES2_GetShader(GLES2_ShaderType type, SDL_BlendMode blendMode)
|
||||
{
|
||||
switch (type)
|
||||
{
|
||||
case GLES2_SHADER_VERTEX_DEFAULT:
|
||||
return &GLES2_VertexShader_Default;
|
||||
case GLES2_SHADER_FRAGMENT_SOLID_SRC:
|
||||
switch (blendMode)
|
||||
{
|
||||
case SDL_BLENDMODE_NONE:
|
||||
return &GLES2_FragmentShader_None_SolidSrc;
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
return &GLES2_FragmentShader_Alpha_SolidSrc;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
return &GLES2_FragmentShader_Additive_SolidSrc;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
return &GLES2_FragmentShader_Modulated_SolidSrc;
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
case GLES2_SHADER_FRAGMENT_TEXTURE_SRC:
|
||||
switch (blendMode)
|
||||
{
|
||||
case SDL_BLENDMODE_NONE:
|
||||
return &GLES2_FragmentShader_None_TextureSrc;
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
return &GLES2_FragmentShader_Alpha_TextureSrc;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
return &GLES2_FragmentShader_Additive_TextureSrc;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
return &GLES2_FragmentShader_Modulated_TextureSrc;
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* SDL_VIDEO_RENDER_OGL_ES2 && !SDL_RENDER_DISABLED */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
57
project/jni/sdl-1.3/src/render/opengles2/SDL_shaders_gles2.h
Normal file
57
project/jni/sdl-1.3/src/render/opengles2/SDL_shaders_gles2.h
Normal file
@@ -0,0 +1,57 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if SDL_VIDEO_RENDER_OGL_ES2
|
||||
|
||||
#ifndef SDL_shaderdata_h_
|
||||
#define SDL_shaderdata_h_
|
||||
|
||||
typedef struct GLES2_ShaderInstance
|
||||
{
|
||||
GLenum type;
|
||||
GLenum format;
|
||||
int length;
|
||||
const void *data;
|
||||
} GLES2_ShaderInstance;
|
||||
|
||||
typedef struct GLES2_Shader
|
||||
{
|
||||
int instance_count;
|
||||
const GLES2_ShaderInstance *instances[4];
|
||||
} GLES2_Shader;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
GLES2_SHADER_VERTEX_DEFAULT,
|
||||
GLES2_SHADER_FRAGMENT_SOLID_SRC,
|
||||
GLES2_SHADER_FRAGMENT_TEXTURE_SRC
|
||||
} GLES2_ShaderType;
|
||||
|
||||
#define GLES2_SOURCE_SHADER (GLenum)-1
|
||||
|
||||
const GLES2_Shader *GLES2_GetShader(GLES2_ShaderType type, SDL_BlendMode blendMode);
|
||||
|
||||
#endif /* SDL_shaderdata_h_ */
|
||||
|
||||
#endif /* SDL_VIDEO_RENDER_OGL_ES2 */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
342
project/jni/sdl-1.3/src/render/software/SDL_blendfillrect.c
Normal file
342
project/jni/sdl-1.3/src/render/software/SDL_blendfillrect.c
Normal file
@@ -0,0 +1,342 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if !SDL_RENDER_DISABLED
|
||||
|
||||
#include "SDL_draw.h"
|
||||
#include "SDL_blendfillrect.h"
|
||||
|
||||
|
||||
static int
|
||||
SDL_BlendFillRect_RGB555(SDL_Surface * dst, const SDL_Rect * rect,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB555);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB555);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_MOD_RGB555);
|
||||
break;
|
||||
default:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_RGB555);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendFillRect_RGB565(SDL_Surface * dst, const SDL_Rect * rect,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB565);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB565);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_MOD_RGB565);
|
||||
break;
|
||||
default:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_RGB565);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendFillRect_RGB888(SDL_Surface * dst, const SDL_Rect * rect,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB888);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB888);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_MOD_RGB888);
|
||||
break;
|
||||
default:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_RGB888);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendFillRect_ARGB8888(SDL_Surface * dst, const SDL_Rect * rect,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_ADD_ARGB8888);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_MOD_ARGB8888);
|
||||
break;
|
||||
default:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_ARGB8888);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendFillRect_RGB(SDL_Surface * dst, const SDL_Rect * rect,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
SDL_PixelFormat *fmt = dst->format;
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (fmt->BytesPerPixel) {
|
||||
case 2:
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_BLEND_RGB);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_ADD_RGB);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_MOD_RGB);
|
||||
break;
|
||||
default:
|
||||
FILLRECT(Uint16, DRAW_SETPIXEL_RGB);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
case 4:
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGB);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGB);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_MOD_RGB);
|
||||
break;
|
||||
default:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_RGB);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
default:
|
||||
SDL_Unsupported();
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendFillRect_RGBA(SDL_Surface * dst, const SDL_Rect * rect,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
SDL_PixelFormat *fmt = dst->format;
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (fmt->BytesPerPixel) {
|
||||
case 4:
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_BLEND_RGBA);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_ADD_RGBA);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_MOD_RGBA);
|
||||
break;
|
||||
default:
|
||||
FILLRECT(Uint32, DRAW_SETPIXEL_RGBA);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
default:
|
||||
SDL_Unsupported();
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
SDL_BlendFillRect(SDL_Surface * dst, const SDL_Rect * rect,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
SDL_Rect clipped;
|
||||
|
||||
if (!dst) {
|
||||
SDL_SetError("Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* This function doesn't work on surfaces < 8 bpp */
|
||||
if (dst->format->BitsPerPixel < 8) {
|
||||
SDL_SetError("SDL_BlendFillRect(): Unsupported surface format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* If 'rect' == NULL, then fill the whole surface */
|
||||
if (rect) {
|
||||
/* Perform clipping */
|
||||
if (!SDL_IntersectRect(rect, &dst->clip_rect, &clipped)) {
|
||||
return 0;
|
||||
}
|
||||
rect = &clipped;
|
||||
} else {
|
||||
rect = &dst->clip_rect;
|
||||
}
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(r, a);
|
||||
g = DRAW_MUL(g, a);
|
||||
b = DRAW_MUL(b, a);
|
||||
}
|
||||
|
||||
switch (dst->format->BitsPerPixel) {
|
||||
case 15:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0x7C00:
|
||||
return SDL_BlendFillRect_RGB555(dst, rect, blendMode, r, g, b, a);
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0xF800:
|
||||
return SDL_BlendFillRect_RGB565(dst, rect, blendMode, r, g, b, a);
|
||||
}
|
||||
break;
|
||||
case 32:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0x00FF0000:
|
||||
if (!dst->format->Amask) {
|
||||
return SDL_BlendFillRect_RGB888(dst, rect, blendMode, r, g, b, a);
|
||||
} else {
|
||||
return SDL_BlendFillRect_ARGB8888(dst, rect, blendMode, r, g, b, a);
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!dst->format->Amask) {
|
||||
return SDL_BlendFillRect_RGB(dst, rect, blendMode, r, g, b, a);
|
||||
} else {
|
||||
return SDL_BlendFillRect_RGBA(dst, rect, blendMode, r, g, b, a);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
SDL_BlendFillRects(SDL_Surface * dst, const SDL_Rect * rects, int count,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
SDL_Rect rect;
|
||||
int i;
|
||||
int (*func)(SDL_Surface * dst, const SDL_Rect * rect,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
|
||||
int status = 0;
|
||||
|
||||
if (!dst) {
|
||||
SDL_SetError("Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* This function doesn't work on surfaces < 8 bpp */
|
||||
if (dst->format->BitsPerPixel < 8) {
|
||||
SDL_SetError("SDL_BlendFillRects(): Unsupported surface format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(r, a);
|
||||
g = DRAW_MUL(g, a);
|
||||
b = DRAW_MUL(b, a);
|
||||
}
|
||||
|
||||
/* FIXME: Does this function pointer slow things down significantly? */
|
||||
switch (dst->format->BitsPerPixel) {
|
||||
case 15:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0x7C00:
|
||||
func = SDL_BlendFillRect_RGB555;
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0xF800:
|
||||
func = SDL_BlendFillRect_RGB565;
|
||||
}
|
||||
break;
|
||||
case 32:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0x00FF0000:
|
||||
if (!dst->format->Amask) {
|
||||
func = SDL_BlendFillRect_RGB888;
|
||||
} else {
|
||||
func = SDL_BlendFillRect_ARGB8888;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!func) {
|
||||
if (!dst->format->Amask) {
|
||||
func = SDL_BlendFillRect_RGB;
|
||||
} else {
|
||||
func = SDL_BlendFillRect_RGBA;
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < count; ++i) {
|
||||
/* Perform clipping */
|
||||
if (!SDL_IntersectRect(&rects[i], &dst->clip_rect, &rect)) {
|
||||
continue;
|
||||
}
|
||||
status = func(dst, &rect, blendMode, r, g, b, a);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
#endif /* !SDL_RENDER_DISABLED */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
27
project/jni/sdl-1.3/src/render/software/SDL_blendfillrect.h
Normal file
27
project/jni/sdl-1.3/src/render/software/SDL_blendfillrect.h
Normal file
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
|
||||
extern int SDL_BlendFillRect(SDL_Surface * dst, const SDL_Rect * rect, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
|
||||
extern int SDL_BlendFillRects(SDL_Surface * dst, const SDL_Rect * rects, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
781
project/jni/sdl-1.3/src/render/software/SDL_blendline.c
Normal file
781
project/jni/sdl-1.3/src/render/software/SDL_blendline.c
Normal file
@@ -0,0 +1,781 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if !SDL_RENDER_DISABLED
|
||||
|
||||
#include "SDL_draw.h"
|
||||
#include "SDL_blendline.h"
|
||||
#include "SDL_blendpoint.h"
|
||||
|
||||
|
||||
static void
|
||||
SDL_BlendLine_RGB2(SDL_Surface * dst, int x1, int y1, int x2, int y2,
|
||||
SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
const SDL_PixelFormat *fmt = dst->format;
|
||||
unsigned r, g, b, a, inva;
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(_r, _a);
|
||||
g = DRAW_MUL(_g, _a);
|
||||
b = DRAW_MUL(_b, _a);
|
||||
a = _a;
|
||||
} else {
|
||||
r = _r;
|
||||
g = _g;
|
||||
b = _b;
|
||||
a = _a;
|
||||
}
|
||||
inva = (a ^ 0xff);
|
||||
|
||||
if (y1 == y2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
|
||||
break;
|
||||
default:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (x1 == x2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
|
||||
break;
|
||||
default:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB, draw_end);
|
||||
break;
|
||||
default:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_RGB, draw_end);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY2_BLEND_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY2_ADD_RGB, DRAW_SETPIXELXY2_ADD_RGB,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY2_MOD_RGB, DRAW_SETPIXELXY2_MOD_RGB,
|
||||
draw_end);
|
||||
break;
|
||||
default:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY2_RGB, DRAW_SETPIXELXY2_BLEND_RGB,
|
||||
draw_end);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
SDL_BlendLine_RGB555(SDL_Surface * dst, int x1, int y1, int x2, int y2,
|
||||
SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
unsigned r, g, b, a, inva;
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(_r, _a);
|
||||
g = DRAW_MUL(_g, _a);
|
||||
b = DRAW_MUL(_b, _a);
|
||||
a = _a;
|
||||
} else {
|
||||
r = _r;
|
||||
g = _g;
|
||||
b = _b;
|
||||
a = _a;
|
||||
}
|
||||
inva = (a ^ 0xff);
|
||||
|
||||
if (y1 == y2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
|
||||
break;
|
||||
default:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (x1 == x2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
|
||||
break;
|
||||
default:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB555, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB555, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB555, draw_end);
|
||||
break;
|
||||
default:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_RGB555, draw_end);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_BLEND_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_ADD_RGB555, DRAW_SETPIXELXY_ADD_RGB555,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_MOD_RGB555, DRAW_SETPIXELXY_MOD_RGB555,
|
||||
draw_end);
|
||||
break;
|
||||
default:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_RGB555, DRAW_SETPIXELXY_BLEND_RGB555,
|
||||
draw_end);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
SDL_BlendLine_RGB565(SDL_Surface * dst, int x1, int y1, int x2, int y2,
|
||||
SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
unsigned r, g, b, a, inva;
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(_r, _a);
|
||||
g = DRAW_MUL(_g, _a);
|
||||
b = DRAW_MUL(_b, _a);
|
||||
a = _a;
|
||||
} else {
|
||||
r = _r;
|
||||
g = _g;
|
||||
b = _b;
|
||||
a = _a;
|
||||
}
|
||||
inva = (a ^ 0xff);
|
||||
|
||||
if (y1 == y2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
|
||||
break;
|
||||
default:
|
||||
HLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (x1 == x2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
|
||||
break;
|
||||
default:
|
||||
VLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_BLEND_RGB565, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_ADD_RGB565, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_MOD_RGB565, draw_end);
|
||||
break;
|
||||
default:
|
||||
DLINE(Uint16, DRAW_SETPIXEL_RGB565, draw_end);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_BLEND_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_ADD_RGB565, DRAW_SETPIXELXY_ADD_RGB565,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_MOD_RGB565, DRAW_SETPIXELXY_MOD_RGB565,
|
||||
draw_end);
|
||||
break;
|
||||
default:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_RGB565, DRAW_SETPIXELXY_BLEND_RGB565,
|
||||
draw_end);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
SDL_BlendLine_RGB4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
|
||||
SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
const SDL_PixelFormat *fmt = dst->format;
|
||||
unsigned r, g, b, a, inva;
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(_r, _a);
|
||||
g = DRAW_MUL(_g, _a);
|
||||
b = DRAW_MUL(_b, _a);
|
||||
a = _a;
|
||||
} else {
|
||||
r = _r;
|
||||
g = _g;
|
||||
b = _b;
|
||||
a = _a;
|
||||
}
|
||||
inva = (a ^ 0xff);
|
||||
|
||||
if (y1 == y2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
|
||||
break;
|
||||
default:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (x1 == x2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
|
||||
break;
|
||||
default:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_MOD_RGB, draw_end);
|
||||
break;
|
||||
default:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_RGB, draw_end);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY4_BLEND_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY4_ADD_RGB, DRAW_SETPIXELXY4_ADD_RGB,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY4_MOD_RGB, DRAW_SETPIXELXY4_MOD_RGB,
|
||||
draw_end);
|
||||
break;
|
||||
default:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY4_RGB, DRAW_SETPIXELXY4_BLEND_RGB,
|
||||
draw_end);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
SDL_BlendLine_RGBA4(SDL_Surface * dst, int x1, int y1, int x2, int y2,
|
||||
SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
const SDL_PixelFormat *fmt = dst->format;
|
||||
unsigned r, g, b, a, inva;
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(_r, _a);
|
||||
g = DRAW_MUL(_g, _a);
|
||||
b = DRAW_MUL(_b, _a);
|
||||
a = _a;
|
||||
} else {
|
||||
r = _r;
|
||||
g = _g;
|
||||
b = _b;
|
||||
a = _a;
|
||||
}
|
||||
inva = (a ^ 0xff);
|
||||
|
||||
if (y1 == y2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
|
||||
break;
|
||||
default:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (x1 == x2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
|
||||
break;
|
||||
default:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGBA, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_ADD_RGBA, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_MOD_RGBA, draw_end);
|
||||
break;
|
||||
default:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_RGBA, draw_end);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY4_BLEND_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY4_ADD_RGBA, DRAW_SETPIXELXY4_ADD_RGBA,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY4_MOD_RGBA, DRAW_SETPIXELXY4_MOD_RGBA,
|
||||
draw_end);
|
||||
break;
|
||||
default:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY4_RGBA, DRAW_SETPIXELXY4_BLEND_RGBA,
|
||||
draw_end);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
SDL_BlendLine_RGB888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
|
||||
SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
unsigned r, g, b, a, inva;
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(_r, _a);
|
||||
g = DRAW_MUL(_g, _a);
|
||||
b = DRAW_MUL(_b, _a);
|
||||
a = _a;
|
||||
} else {
|
||||
r = _r;
|
||||
g = _g;
|
||||
b = _b;
|
||||
a = _a;
|
||||
}
|
||||
inva = (a ^ 0xff);
|
||||
|
||||
if (y1 == y2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_MOD_RGB888, draw_end);
|
||||
break;
|
||||
default:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (x1 == x2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_MOD_RGB888, draw_end);
|
||||
break;
|
||||
default:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_BLEND_RGB888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_ADD_RGB888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_MOD_RGB888, draw_end);
|
||||
break;
|
||||
default:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_RGB888, draw_end);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_BLEND_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_ADD_RGB888, DRAW_SETPIXELXY_ADD_RGB888,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_MOD_RGB888, DRAW_SETPIXELXY_MOD_RGB888,
|
||||
draw_end);
|
||||
break;
|
||||
default:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_RGB888, DRAW_SETPIXELXY_BLEND_RGB888,
|
||||
draw_end);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
SDL_BlendLine_ARGB8888(SDL_Surface * dst, int x1, int y1, int x2, int y2,
|
||||
SDL_BlendMode blendMode, Uint8 _r, Uint8 _g, Uint8 _b, Uint8 _a,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
unsigned r, g, b, a, inva;
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(_r, _a);
|
||||
g = DRAW_MUL(_g, _a);
|
||||
b = DRAW_MUL(_b, _a);
|
||||
a = _a;
|
||||
} else {
|
||||
r = _r;
|
||||
g = _g;
|
||||
b = _b;
|
||||
a = _a;
|
||||
}
|
||||
inva = (a ^ 0xff);
|
||||
|
||||
if (y1 == y2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
|
||||
break;
|
||||
default:
|
||||
HLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (x1 == x2) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
|
||||
break;
|
||||
default:
|
||||
VLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
|
||||
break;
|
||||
}
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_BLEND_ARGB8888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_ADD_ARGB8888, draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_MOD_ARGB8888, draw_end);
|
||||
break;
|
||||
default:
|
||||
DLINE(Uint32, DRAW_SETPIXEL_ARGB8888, draw_end);
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_BLEND_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_ADD_ARGB8888, DRAW_SETPIXELXY_ADD_ARGB8888,
|
||||
draw_end);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_MOD_ARGB8888, DRAW_SETPIXELXY_MOD_ARGB8888,
|
||||
draw_end);
|
||||
break;
|
||||
default:
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_SETPIXELXY_ARGB8888, DRAW_SETPIXELXY_BLEND_ARGB8888,
|
||||
draw_end);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
typedef void (*BlendLineFunc) (SDL_Surface * dst,
|
||||
int x1, int y1, int x2, int y2,
|
||||
SDL_BlendMode blendMode,
|
||||
Uint8 r, Uint8 g, Uint8 b, Uint8 a,
|
||||
SDL_bool draw_end);
|
||||
|
||||
static BlendLineFunc
|
||||
SDL_CalculateBlendLineFunc(const SDL_PixelFormat * fmt)
|
||||
{
|
||||
switch (fmt->BytesPerPixel) {
|
||||
case 2:
|
||||
if (fmt->Rmask == 0x7C00) {
|
||||
return SDL_BlendLine_RGB555;
|
||||
} else if (fmt->Rmask == 0xF800) {
|
||||
return SDL_BlendLine_RGB565;
|
||||
} else {
|
||||
return SDL_BlendLine_RGB2;
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
if (fmt->Rmask == 0x00FF0000) {
|
||||
if (fmt->Amask) {
|
||||
return SDL_BlendLine_ARGB8888;
|
||||
} else {
|
||||
return SDL_BlendLine_RGB888;
|
||||
}
|
||||
} else {
|
||||
if (fmt->Amask) {
|
||||
return SDL_BlendLine_RGBA4;
|
||||
} else {
|
||||
return SDL_BlendLine_RGB4;
|
||||
}
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int
|
||||
SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
BlendLineFunc func;
|
||||
|
||||
if (!dst) {
|
||||
SDL_SetError("SDL_BlendLine(): Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
func = SDL_CalculateBlendLineFunc(dst->format);
|
||||
if (!func) {
|
||||
SDL_SetError("SDL_BlendLine(): Unsupported surface format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Perform clipping */
|
||||
/* FIXME: We don't actually want to clip, as it may change line slope */
|
||||
if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, SDL_TRUE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
int i;
|
||||
int x1, y1;
|
||||
int x2, y2;
|
||||
SDL_bool draw_end;
|
||||
BlendLineFunc func;
|
||||
|
||||
if (!dst) {
|
||||
SDL_SetError("SDL_BlendLines(): Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
func = SDL_CalculateBlendLineFunc(dst->format);
|
||||
if (!func) {
|
||||
SDL_SetError("SDL_BlendLines(): Unsupported surface format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (i = 1; i < count; ++i) {
|
||||
x1 = points[i-1].x;
|
||||
y1 = points[i-1].y;
|
||||
x2 = points[i].x;
|
||||
y2 = points[i].y;
|
||||
|
||||
/* Perform clipping */
|
||||
/* FIXME: We don't actually want to clip, as it may change line slope */
|
||||
if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Draw the end if it was clipped */
|
||||
draw_end = (x2 != points[i].x || y2 != points[i].y);
|
||||
|
||||
func(dst, x1, y1, x2, y2, blendMode, r, g, b, a, draw_end);
|
||||
}
|
||||
if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
|
||||
SDL_BlendPoint(dst, points[count-1].x, points[count-1].y,
|
||||
blendMode, r, g, b, a);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* !SDL_RENDER_DISABLED */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
27
project/jni/sdl-1.3/src/render/software/SDL_blendline.h
Normal file
27
project/jni/sdl-1.3/src/render/software/SDL_blendline.h
Normal file
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
|
||||
extern int SDL_BlendLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
|
||||
extern int SDL_BlendLines(SDL_Surface * dst, const SDL_Point * points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
349
project/jni/sdl-1.3/src/render/software/SDL_blendpoint.c
Normal file
349
project/jni/sdl-1.3/src/render/software/SDL_blendpoint.c
Normal file
@@ -0,0 +1,349 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if !SDL_RENDER_DISABLED
|
||||
|
||||
#include "SDL_draw.h"
|
||||
#include "SDL_blendpoint.h"
|
||||
|
||||
|
||||
static int
|
||||
SDL_BlendPoint_RGB555(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
|
||||
Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DRAW_SETPIXELXY_BLEND_RGB555(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DRAW_SETPIXELXY_ADD_RGB555(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DRAW_SETPIXELXY_MOD_RGB555(x, y);
|
||||
break;
|
||||
default:
|
||||
DRAW_SETPIXELXY_RGB555(x, y);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendPoint_RGB565(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
|
||||
Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DRAW_SETPIXELXY_BLEND_RGB565(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DRAW_SETPIXELXY_ADD_RGB565(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DRAW_SETPIXELXY_MOD_RGB565(x, y);
|
||||
break;
|
||||
default:
|
||||
DRAW_SETPIXELXY_RGB565(x, y);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendPoint_RGB888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
|
||||
Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DRAW_SETPIXELXY_BLEND_RGB888(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DRAW_SETPIXELXY_ADD_RGB888(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DRAW_SETPIXELXY_MOD_RGB888(x, y);
|
||||
break;
|
||||
default:
|
||||
DRAW_SETPIXELXY_RGB888(x, y);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendPoint_ARGB8888(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode,
|
||||
Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DRAW_SETPIXELXY_BLEND_ARGB8888(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DRAW_SETPIXELXY_ADD_ARGB8888(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DRAW_SETPIXELXY_MOD_ARGB8888(x, y);
|
||||
break;
|
||||
default:
|
||||
DRAW_SETPIXELXY_ARGB8888(x, y);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendPoint_RGB(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
|
||||
Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
SDL_PixelFormat *fmt = dst->format;
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (fmt->BytesPerPixel) {
|
||||
case 2:
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DRAW_SETPIXELXY2_BLEND_RGB(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DRAW_SETPIXELXY2_ADD_RGB(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DRAW_SETPIXELXY2_MOD_RGB(x, y);
|
||||
break;
|
||||
default:
|
||||
DRAW_SETPIXELXY2_RGB(x, y);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
case 4:
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DRAW_SETPIXELXY4_BLEND_RGB(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DRAW_SETPIXELXY4_ADD_RGB(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DRAW_SETPIXELXY4_MOD_RGB(x, y);
|
||||
break;
|
||||
default:
|
||||
DRAW_SETPIXELXY4_RGB(x, y);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
default:
|
||||
SDL_Unsupported();
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
SDL_BlendPoint_RGBA(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
|
||||
Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
SDL_PixelFormat *fmt = dst->format;
|
||||
unsigned inva = 0xff - a;
|
||||
|
||||
switch (fmt->BytesPerPixel) {
|
||||
case 4:
|
||||
switch (blendMode) {
|
||||
case SDL_BLENDMODE_BLEND:
|
||||
DRAW_SETPIXELXY4_BLEND_RGBA(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_ADD:
|
||||
DRAW_SETPIXELXY4_ADD_RGBA(x, y);
|
||||
break;
|
||||
case SDL_BLENDMODE_MOD:
|
||||
DRAW_SETPIXELXY4_MOD_RGBA(x, y);
|
||||
break;
|
||||
default:
|
||||
DRAW_SETPIXELXY4_RGBA(x, y);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
default:
|
||||
SDL_Unsupported();
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
SDL_BlendPoint(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r,
|
||||
Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
if (!dst) {
|
||||
SDL_SetError("Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* This function doesn't work on surfaces < 8 bpp */
|
||||
if (dst->format->BitsPerPixel < 8) {
|
||||
SDL_SetError("SDL_BlendPoint(): Unsupported surface format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Perform clipping */
|
||||
if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
|
||||
x >= (dst->clip_rect.x + dst->clip_rect.w) ||
|
||||
y >= (dst->clip_rect.y + dst->clip_rect.h)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(r, a);
|
||||
g = DRAW_MUL(g, a);
|
||||
b = DRAW_MUL(b, a);
|
||||
}
|
||||
|
||||
switch (dst->format->BitsPerPixel) {
|
||||
case 15:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0x7C00:
|
||||
return SDL_BlendPoint_RGB555(dst, x, y, blendMode, r, g, b, a);
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0xF800:
|
||||
return SDL_BlendPoint_RGB565(dst, x, y, blendMode, r, g, b, a);
|
||||
}
|
||||
break;
|
||||
case 32:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0x00FF0000:
|
||||
if (!dst->format->Amask) {
|
||||
return SDL_BlendPoint_RGB888(dst, x, y, blendMode, r, g, b,
|
||||
a);
|
||||
} else {
|
||||
return SDL_BlendPoint_ARGB8888(dst, x, y, blendMode, r, g, b,
|
||||
a);
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!dst->format->Amask) {
|
||||
return SDL_BlendPoint_RGB(dst, x, y, blendMode, r, g, b, a);
|
||||
} else {
|
||||
return SDL_BlendPoint_RGBA(dst, x, y, blendMode, r, g, b, a);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
SDL_BlendPoints(SDL_Surface * dst, const SDL_Point * points, int count,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a)
|
||||
{
|
||||
int minx, miny;
|
||||
int maxx, maxy;
|
||||
int i;
|
||||
int x, y;
|
||||
int (*func)(SDL_Surface * dst, int x, int y,
|
||||
SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a) = NULL;
|
||||
int status = 0;
|
||||
|
||||
if (!dst) {
|
||||
SDL_SetError("Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* This function doesn't work on surfaces < 8 bpp */
|
||||
if (dst->format->BitsPerPixel < 8) {
|
||||
SDL_SetError("SDL_BlendPoints(): Unsupported surface format");
|
||||
return (-1);
|
||||
}
|
||||
|
||||
if (blendMode == SDL_BLENDMODE_BLEND || blendMode == SDL_BLENDMODE_ADD) {
|
||||
r = DRAW_MUL(r, a);
|
||||
g = DRAW_MUL(g, a);
|
||||
b = DRAW_MUL(b, a);
|
||||
}
|
||||
|
||||
/* FIXME: Does this function pointer slow things down significantly? */
|
||||
switch (dst->format->BitsPerPixel) {
|
||||
case 15:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0x7C00:
|
||||
func = SDL_BlendPoint_RGB555;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 16:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0xF800:
|
||||
func = SDL_BlendPoint_RGB565;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case 32:
|
||||
switch (dst->format->Rmask) {
|
||||
case 0x00FF0000:
|
||||
if (!dst->format->Amask) {
|
||||
func = SDL_BlendPoint_RGB888;
|
||||
} else {
|
||||
func = SDL_BlendPoint_ARGB8888;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (!func) {
|
||||
if (!dst->format->Amask) {
|
||||
func = SDL_BlendPoint_RGB;
|
||||
} else {
|
||||
func = SDL_BlendPoint_RGBA;
|
||||
}
|
||||
}
|
||||
|
||||
minx = dst->clip_rect.x;
|
||||
maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
|
||||
miny = dst->clip_rect.y;
|
||||
maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
|
||||
|
||||
for (i = 0; i < count; ++i) {
|
||||
x = points[i].x;
|
||||
y = points[i].y;
|
||||
|
||||
if (x < minx || x > maxx || y < miny || y > maxy) {
|
||||
continue;
|
||||
}
|
||||
status = func(dst, x, y, blendMode, r, g, b, a);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
#endif /* !SDL_RENDER_DISABLED */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
27
project/jni/sdl-1.3/src/render/software/SDL_blendpoint.h
Normal file
27
project/jni/sdl-1.3/src/render/software/SDL_blendpoint.h
Normal file
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
|
||||
extern int SDL_BlendPoint(SDL_Surface * dst, int x, int y, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
|
||||
extern int SDL_BlendPoints(SDL_Surface * dst, const SDL_Point * points, int count, SDL_BlendMode blendMode, Uint8 r, Uint8 g, Uint8 b, Uint8 a);
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
575
project/jni/sdl-1.3/src/render/software/SDL_draw.h
Normal file
575
project/jni/sdl-1.3/src/render/software/SDL_draw.h
Normal file
@@ -0,0 +1,575 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#include "../../video/SDL_blit.h"
|
||||
|
||||
/* This code assumes that r, g, b, a are the source color,
|
||||
* and in the blend and add case, the RGB values are premultiplied by a.
|
||||
*/
|
||||
|
||||
#define DRAW_MUL(_a, _b) (((unsigned)(_a)*(_b))/255)
|
||||
|
||||
#define DRAW_FASTSETPIXEL(type) \
|
||||
*pixel = (type) color
|
||||
|
||||
#define DRAW_FASTSETPIXEL1 DRAW_FASTSETPIXEL(Uint8)
|
||||
#define DRAW_FASTSETPIXEL2 DRAW_FASTSETPIXEL(Uint16)
|
||||
#define DRAW_FASTSETPIXEL4 DRAW_FASTSETPIXEL(Uint32)
|
||||
|
||||
#define DRAW_FASTSETPIXELXY(x, y, type, bpp, color) \
|
||||
*(type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
|
||||
+ (x) * bpp) = (type) color
|
||||
|
||||
#define DRAW_FASTSETPIXELXY1(x, y) DRAW_FASTSETPIXELXY(x, y, Uint8, 1, color)
|
||||
#define DRAW_FASTSETPIXELXY2(x, y) DRAW_FASTSETPIXELXY(x, y, Uint16, 2, color)
|
||||
#define DRAW_FASTSETPIXELXY4(x, y) DRAW_FASTSETPIXELXY(x, y, Uint32, 4, color)
|
||||
|
||||
#define DRAW_SETPIXEL(setpixel) \
|
||||
do { \
|
||||
unsigned sr = r, sg = g, sb = b, sa = a; (void) sa; \
|
||||
setpixel; \
|
||||
} while (0)
|
||||
|
||||
#define DRAW_SETPIXEL_BLEND(getpixel, setpixel) \
|
||||
do { \
|
||||
unsigned sr, sg, sb, sa; (void) sa; \
|
||||
getpixel; \
|
||||
sr = DRAW_MUL(inva, sr) + r; \
|
||||
sg = DRAW_MUL(inva, sg) + g; \
|
||||
sb = DRAW_MUL(inva, sb) + b; \
|
||||
setpixel; \
|
||||
} while (0)
|
||||
|
||||
#define DRAW_SETPIXEL_ADD(getpixel, setpixel) \
|
||||
do { \
|
||||
unsigned sr, sg, sb, sa; (void) sa; \
|
||||
getpixel; \
|
||||
sr += r; if (sr > 0xff) sr = 0xff; \
|
||||
sg += g; if (sg > 0xff) sg = 0xff; \
|
||||
sb += b; if (sb > 0xff) sb = 0xff; \
|
||||
setpixel; \
|
||||
} while (0)
|
||||
|
||||
#define DRAW_SETPIXEL_MOD(getpixel, setpixel) \
|
||||
do { \
|
||||
unsigned sr, sg, sb, sa; (void) sa; \
|
||||
getpixel; \
|
||||
sr = DRAW_MUL(sr, r); \
|
||||
sg = DRAW_MUL(sg, g); \
|
||||
sb = DRAW_MUL(sb, b); \
|
||||
setpixel; \
|
||||
} while (0)
|
||||
|
||||
#define DRAW_SETPIXELXY(x, y, type, bpp, op) \
|
||||
do { \
|
||||
type *pixel = (type *)((Uint8 *)dst->pixels + (y) * dst->pitch \
|
||||
+ (x) * bpp); \
|
||||
op; \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Define draw operators for RGB555
|
||||
*/
|
||||
|
||||
#define DRAW_SETPIXEL_RGB555 \
|
||||
DRAW_SETPIXEL(RGB555_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_BLEND_RGB555 \
|
||||
DRAW_SETPIXEL_BLEND(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
|
||||
RGB555_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_ADD_RGB555 \
|
||||
DRAW_SETPIXEL_ADD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
|
||||
RGB555_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_MOD_RGB555 \
|
||||
DRAW_SETPIXEL_MOD(RGB_FROM_RGB555(*pixel, sr, sg, sb), \
|
||||
RGB555_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXELXY_RGB555(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB555)
|
||||
|
||||
#define DRAW_SETPIXELXY_BLEND_RGB555(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB555)
|
||||
|
||||
#define DRAW_SETPIXELXY_ADD_RGB555(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB555)
|
||||
|
||||
#define DRAW_SETPIXELXY_MOD_RGB555(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MOD_RGB555)
|
||||
|
||||
/*
|
||||
* Define draw operators for RGB565
|
||||
*/
|
||||
|
||||
#define DRAW_SETPIXEL_RGB565 \
|
||||
DRAW_SETPIXEL(RGB565_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_BLEND_RGB565 \
|
||||
DRAW_SETPIXEL_BLEND(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
|
||||
RGB565_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_ADD_RGB565 \
|
||||
DRAW_SETPIXEL_ADD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
|
||||
RGB565_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_MOD_RGB565 \
|
||||
DRAW_SETPIXEL_MOD(RGB_FROM_RGB565(*pixel, sr, sg, sb), \
|
||||
RGB565_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXELXY_RGB565(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB565)
|
||||
|
||||
#define DRAW_SETPIXELXY_BLEND_RGB565(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB565)
|
||||
|
||||
#define DRAW_SETPIXELXY_ADD_RGB565(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB565)
|
||||
|
||||
#define DRAW_SETPIXELXY_MOD_RGB565(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MOD_RGB565)
|
||||
|
||||
/*
|
||||
* Define draw operators for RGB888
|
||||
*/
|
||||
|
||||
#define DRAW_SETPIXEL_RGB888 \
|
||||
DRAW_SETPIXEL(RGB888_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_BLEND_RGB888 \
|
||||
DRAW_SETPIXEL_BLEND(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
|
||||
RGB888_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_ADD_RGB888 \
|
||||
DRAW_SETPIXEL_ADD(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
|
||||
RGB888_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_MOD_RGB888 \
|
||||
DRAW_SETPIXEL_MOD(RGB_FROM_RGB888(*pixel, sr, sg, sb), \
|
||||
RGB888_FROM_RGB(*pixel, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXELXY_RGB888(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB888)
|
||||
|
||||
#define DRAW_SETPIXELXY_BLEND_RGB888(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB888)
|
||||
|
||||
#define DRAW_SETPIXELXY_ADD_RGB888(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB888)
|
||||
|
||||
#define DRAW_SETPIXELXY_MOD_RGB888(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_RGB888)
|
||||
|
||||
/*
|
||||
* Define draw operators for ARGB8888
|
||||
*/
|
||||
|
||||
#define DRAW_SETPIXEL_ARGB8888 \
|
||||
DRAW_SETPIXEL(ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
|
||||
|
||||
#define DRAW_SETPIXEL_BLEND_ARGB8888 \
|
||||
DRAW_SETPIXEL_BLEND(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
|
||||
ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
|
||||
|
||||
#define DRAW_SETPIXEL_ADD_ARGB8888 \
|
||||
DRAW_SETPIXEL_ADD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
|
||||
ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
|
||||
|
||||
#define DRAW_SETPIXEL_MOD_ARGB8888 \
|
||||
DRAW_SETPIXEL_MOD(RGBA_FROM_ARGB8888(*pixel, sr, sg, sb, sa), \
|
||||
ARGB8888_FROM_RGBA(*pixel, sr, sg, sb, sa))
|
||||
|
||||
#define DRAW_SETPIXELXY_ARGB8888(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ARGB8888)
|
||||
|
||||
#define DRAW_SETPIXELXY_BLEND_ARGB8888(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_ARGB8888)
|
||||
|
||||
#define DRAW_SETPIXELXY_ADD_ARGB8888(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_ARGB8888)
|
||||
|
||||
#define DRAW_SETPIXELXY_MOD_ARGB8888(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_ARGB8888)
|
||||
|
||||
/*
|
||||
* Define draw operators for general RGB
|
||||
*/
|
||||
|
||||
#define DRAW_SETPIXEL_RGB \
|
||||
DRAW_SETPIXEL(PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_BLEND_RGB \
|
||||
DRAW_SETPIXEL_BLEND(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
|
||||
PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_ADD_RGB \
|
||||
DRAW_SETPIXEL_ADD(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
|
||||
PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXEL_MOD_RGB \
|
||||
DRAW_SETPIXEL_MOD(RGB_FROM_PIXEL(*pixel, fmt, sr, sg, sb), \
|
||||
PIXEL_FROM_RGB(*pixel, fmt, sr, sg, sb))
|
||||
|
||||
#define DRAW_SETPIXELXY2_RGB(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_RGB)
|
||||
|
||||
#define DRAW_SETPIXELXY4_RGB(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGB)
|
||||
|
||||
#define DRAW_SETPIXELXY2_BLEND_RGB(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_BLEND_RGB)
|
||||
|
||||
#define DRAW_SETPIXELXY4_BLEND_RGB(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGB)
|
||||
|
||||
#define DRAW_SETPIXELXY2_ADD_RGB(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_ADD_RGB)
|
||||
|
||||
#define DRAW_SETPIXELXY4_ADD_RGB(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGB)
|
||||
|
||||
#define DRAW_SETPIXELXY2_MOD_RGB(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint16, 2, DRAW_SETPIXEL_MOD_RGB)
|
||||
|
||||
#define DRAW_SETPIXELXY4_MOD_RGB(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_RGB)
|
||||
|
||||
|
||||
/*
|
||||
* Define draw operators for general RGBA
|
||||
*/
|
||||
|
||||
#define DRAW_SETPIXEL_RGBA \
|
||||
DRAW_SETPIXEL(PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
|
||||
|
||||
#define DRAW_SETPIXEL_BLEND_RGBA \
|
||||
DRAW_SETPIXEL_BLEND(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
|
||||
PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
|
||||
|
||||
#define DRAW_SETPIXEL_ADD_RGBA \
|
||||
DRAW_SETPIXEL_ADD(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
|
||||
PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
|
||||
|
||||
#define DRAW_SETPIXEL_MOD_RGBA \
|
||||
DRAW_SETPIXEL_MOD(RGBA_FROM_PIXEL(*pixel, fmt, sr, sg, sb, sa), \
|
||||
PIXEL_FROM_RGBA(*pixel, fmt, sr, sg, sb, sa))
|
||||
|
||||
#define DRAW_SETPIXELXY4_RGBA(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_RGBA)
|
||||
|
||||
#define DRAW_SETPIXELXY4_BLEND_RGBA(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_BLEND_RGBA)
|
||||
|
||||
#define DRAW_SETPIXELXY4_ADD_RGBA(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_ADD_RGBA)
|
||||
|
||||
#define DRAW_SETPIXELXY4_MOD_RGBA(x, y) \
|
||||
DRAW_SETPIXELXY(x, y, Uint32, 4, DRAW_SETPIXEL_MOD_RGBA)
|
||||
|
||||
/*
|
||||
* Define line drawing macro
|
||||
*/
|
||||
|
||||
#define ABS(_x) ((_x) < 0 ? -(_x) : (_x))
|
||||
|
||||
/* Horizontal line */
|
||||
#define HLINE(type, op, draw_end) \
|
||||
{ \
|
||||
int length; \
|
||||
int pitch = (dst->pitch / dst->format->BytesPerPixel); \
|
||||
type *pixel; \
|
||||
if (x1 <= x2) { \
|
||||
pixel = (type *)dst->pixels + y1 * pitch + x1; \
|
||||
length = draw_end ? (x2-x1+1) : (x2-x1); \
|
||||
} else { \
|
||||
pixel = (type *)dst->pixels + y1 * pitch + x2; \
|
||||
if (!draw_end) { \
|
||||
++pixel; \
|
||||
} \
|
||||
length = draw_end ? (x1-x2+1) : (x1-x2); \
|
||||
} \
|
||||
while (length--) { \
|
||||
op; \
|
||||
++pixel; \
|
||||
} \
|
||||
}
|
||||
|
||||
/* Vertical line */
|
||||
#define VLINE(type, op, draw_end) \
|
||||
{ \
|
||||
int length; \
|
||||
int pitch = (dst->pitch / dst->format->BytesPerPixel); \
|
||||
type *pixel; \
|
||||
if (y1 <= y2) { \
|
||||
pixel = (type *)dst->pixels + y1 * pitch + x1; \
|
||||
length = draw_end ? (y2-y1+1) : (y2-y1); \
|
||||
} else { \
|
||||
pixel = (type *)dst->pixels + y2 * pitch + x1; \
|
||||
if (!draw_end) { \
|
||||
pixel += pitch; \
|
||||
} \
|
||||
length = draw_end ? (y1-y2+1) : (y1-y2); \
|
||||
} \
|
||||
while (length--) { \
|
||||
op; \
|
||||
pixel += pitch; \
|
||||
} \
|
||||
}
|
||||
|
||||
/* Diagonal line */
|
||||
#define DLINE(type, op, draw_end) \
|
||||
{ \
|
||||
int length; \
|
||||
int pitch = (dst->pitch / dst->format->BytesPerPixel); \
|
||||
type *pixel; \
|
||||
if (y1 <= y2) { \
|
||||
pixel = (type *)dst->pixels + y1 * pitch + x1; \
|
||||
if (x1 <= x2) { \
|
||||
++pitch; \
|
||||
} else { \
|
||||
--pitch; \
|
||||
} \
|
||||
length = (y2-y1); \
|
||||
} else { \
|
||||
pixel = (type *)dst->pixels + y2 * pitch + x2; \
|
||||
if (x2 <= x1) { \
|
||||
++pitch; \
|
||||
} else { \
|
||||
--pitch; \
|
||||
} \
|
||||
if (!draw_end) { \
|
||||
pixel += pitch; \
|
||||
} \
|
||||
length = (y1-y2); \
|
||||
} \
|
||||
if (draw_end) { \
|
||||
++length; \
|
||||
} \
|
||||
while (length--) { \
|
||||
op; \
|
||||
pixel += pitch; \
|
||||
} \
|
||||
}
|
||||
|
||||
/* Bresenham's line algorithm */
|
||||
#define BLINE(x1, y1, x2, y2, op, draw_end) \
|
||||
{ \
|
||||
int i, deltax, deltay, numpixels; \
|
||||
int d, dinc1, dinc2; \
|
||||
int x, xinc1, xinc2; \
|
||||
int y, yinc1, yinc2; \
|
||||
\
|
||||
deltax = ABS(x2 - x1); \
|
||||
deltay = ABS(y2 - y1); \
|
||||
\
|
||||
if (deltax >= deltay) { \
|
||||
numpixels = deltax + 1; \
|
||||
d = (2 * deltay) - deltax; \
|
||||
dinc1 = deltay * 2; \
|
||||
dinc2 = (deltay - deltax) * 2; \
|
||||
xinc1 = 1; \
|
||||
xinc2 = 1; \
|
||||
yinc1 = 0; \
|
||||
yinc2 = 1; \
|
||||
} else { \
|
||||
numpixels = deltay + 1; \
|
||||
d = (2 * deltax) - deltay; \
|
||||
dinc1 = deltax * 2; \
|
||||
dinc2 = (deltax - deltay) * 2; \
|
||||
xinc1 = 0; \
|
||||
xinc2 = 1; \
|
||||
yinc1 = 1; \
|
||||
yinc2 = 1; \
|
||||
} \
|
||||
\
|
||||
if (x1 > x2) { \
|
||||
xinc1 = -xinc1; \
|
||||
xinc2 = -xinc2; \
|
||||
} \
|
||||
if (y1 > y2) { \
|
||||
yinc1 = -yinc1; \
|
||||
yinc2 = -yinc2; \
|
||||
} \
|
||||
\
|
||||
x = x1; \
|
||||
y = y1; \
|
||||
\
|
||||
if (!draw_end) { \
|
||||
--numpixels; \
|
||||
} \
|
||||
for (i = 0; i < numpixels; ++i) { \
|
||||
op(x, y); \
|
||||
if (d < 0) { \
|
||||
d += dinc1; \
|
||||
x += xinc1; \
|
||||
y += yinc1; \
|
||||
} else { \
|
||||
d += dinc2; \
|
||||
x += xinc2; \
|
||||
y += yinc2; \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
/* Xiaolin Wu's line algorithm, based on Michael Abrash's implementation */
|
||||
#define WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
|
||||
{ \
|
||||
Uint16 ErrorAdj, ErrorAcc; \
|
||||
Uint16 ErrorAccTemp, Weighting; \
|
||||
int DeltaX, DeltaY, Temp, XDir; \
|
||||
unsigned r, g, b, a, inva; \
|
||||
\
|
||||
/* Draw the initial pixel, which is always exactly intersected by \
|
||||
the line and so needs no weighting */ \
|
||||
opaque_op(x1, y1); \
|
||||
\
|
||||
/* Draw the final pixel, which is always exactly intersected by the line \
|
||||
and so needs no weighting */ \
|
||||
if (draw_end) { \
|
||||
opaque_op(x2, y2); \
|
||||
} \
|
||||
\
|
||||
/* Make sure the line runs top to bottom */ \
|
||||
if (y1 > y2) { \
|
||||
Temp = y1; y1 = y2; y2 = Temp; \
|
||||
Temp = x1; x1 = x2; x2 = Temp; \
|
||||
} \
|
||||
DeltaY = y2 - y1; \
|
||||
\
|
||||
if ((DeltaX = x2 - x1) >= 0) { \
|
||||
XDir = 1; \
|
||||
} else { \
|
||||
XDir = -1; \
|
||||
DeltaX = -DeltaX; /* make DeltaX positive */ \
|
||||
} \
|
||||
\
|
||||
/* line is not horizontal, diagonal, or vertical */ \
|
||||
ErrorAcc = 0; /* initialize the line error accumulator to 0 */ \
|
||||
\
|
||||
/* Is this an X-major or Y-major line? */ \
|
||||
if (DeltaY > DeltaX) { \
|
||||
/* Y-major line; calculate 16-bit fixed-point fractional part of a \
|
||||
pixel that X advances each time Y advances 1 pixel, truncating the \
|
||||
result so that we won't overrun the endpoint along the X axis */ \
|
||||
ErrorAdj = ((unsigned long) DeltaX << 16) / (unsigned long) DeltaY; \
|
||||
/* Draw all pixels other than the first and last */ \
|
||||
while (--DeltaY) { \
|
||||
ErrorAccTemp = ErrorAcc; /* remember currrent accumulated error */ \
|
||||
ErrorAcc += ErrorAdj; /* calculate error for next pixel */ \
|
||||
if (ErrorAcc <= ErrorAccTemp) { \
|
||||
/* The error accumulator turned over, so advance the X coord */ \
|
||||
x1 += XDir; \
|
||||
} \
|
||||
y1++; /* Y-major, so always advance Y */ \
|
||||
/* The IntensityBits most significant bits of ErrorAcc give us the \
|
||||
intensity weighting for this pixel, and the complement of the \
|
||||
weighting for the paired pixel */ \
|
||||
Weighting = ErrorAcc >> 8; \
|
||||
{ \
|
||||
a = DRAW_MUL(_a, (Weighting ^ 255)); \
|
||||
r = DRAW_MUL(_r, a); \
|
||||
g = DRAW_MUL(_g, a); \
|
||||
b = DRAW_MUL(_b, a); \
|
||||
inva = (a ^ 0xFF); \
|
||||
blend_op(x1, y1); \
|
||||
} \
|
||||
{ \
|
||||
a = DRAW_MUL(_a, Weighting); \
|
||||
r = DRAW_MUL(_r, a); \
|
||||
g = DRAW_MUL(_g, a); \
|
||||
b = DRAW_MUL(_b, a); \
|
||||
inva = (a ^ 0xFF); \
|
||||
blend_op(x1 + XDir, y1); \
|
||||
} \
|
||||
} \
|
||||
} else { \
|
||||
/* X-major line; calculate 16-bit fixed-point fractional part of a \
|
||||
pixel that Y advances each time X advances 1 pixel, truncating the \
|
||||
result to avoid overrunning the endpoint along the X axis */ \
|
||||
ErrorAdj = ((unsigned long) DeltaY << 16) / (unsigned long) DeltaX; \
|
||||
/* Draw all pixels other than the first and last */ \
|
||||
while (--DeltaX) { \
|
||||
ErrorAccTemp = ErrorAcc; /* remember currrent accumulated error */ \
|
||||
ErrorAcc += ErrorAdj; /* calculate error for next pixel */ \
|
||||
if (ErrorAcc <= ErrorAccTemp) { \
|
||||
/* The error accumulator turned over, so advance the Y coord */ \
|
||||
y1++; \
|
||||
} \
|
||||
x1 += XDir; /* X-major, so always advance X */ \
|
||||
/* The IntensityBits most significant bits of ErrorAcc give us the \
|
||||
intensity weighting for this pixel, and the complement of the \
|
||||
weighting for the paired pixel */ \
|
||||
Weighting = ErrorAcc >> 8; \
|
||||
{ \
|
||||
a = DRAW_MUL(_a, (Weighting ^ 255)); \
|
||||
r = DRAW_MUL(_r, a); \
|
||||
g = DRAW_MUL(_g, a); \
|
||||
b = DRAW_MUL(_b, a); \
|
||||
inva = (a ^ 0xFF); \
|
||||
blend_op(x1, y1); \
|
||||
} \
|
||||
{ \
|
||||
a = DRAW_MUL(_a, Weighting); \
|
||||
r = DRAW_MUL(_r, a); \
|
||||
g = DRAW_MUL(_g, a); \
|
||||
b = DRAW_MUL(_b, a); \
|
||||
inva = (a ^ 0xFF); \
|
||||
blend_op(x1, y1 + 1); \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
}
|
||||
|
||||
#ifdef AA_LINES
|
||||
#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
|
||||
WULINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end)
|
||||
#else
|
||||
#define AALINE(x1, y1, x2, y2, opaque_op, blend_op, draw_end) \
|
||||
BLINE(x1, y1, x2, y2, opaque_op, draw_end)
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Define fill rect macro
|
||||
*/
|
||||
|
||||
#define FILLRECT(type, op) \
|
||||
do { \
|
||||
int width = rect->w; \
|
||||
int height = rect->h; \
|
||||
int pitch = (dst->pitch / dst->format->BytesPerPixel); \
|
||||
int skip = pitch - width; \
|
||||
type *pixel = (type *)dst->pixels + rect->y * pitch + rect->x; \
|
||||
while (height--) { \
|
||||
{ int n = (width+3)/4; \
|
||||
switch (width & 3) { \
|
||||
case 0: do { op; pixel++; \
|
||||
case 3: op; pixel++; \
|
||||
case 2: op; pixel++; \
|
||||
case 1: op; pixel++; \
|
||||
} while ( --n > 0 ); \
|
||||
} \
|
||||
} \
|
||||
pixel += skip; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
214
project/jni/sdl-1.3/src/render/software/SDL_drawline.c
Normal file
214
project/jni/sdl-1.3/src/render/software/SDL_drawline.c
Normal file
@@ -0,0 +1,214 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if !SDL_RENDER_DISABLED
|
||||
|
||||
#include "SDL_draw.h"
|
||||
#include "SDL_drawline.h"
|
||||
#include "SDL_drawpoint.h"
|
||||
|
||||
|
||||
static void
|
||||
SDL_DrawLine1(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
if (y1 == y2) {
|
||||
//HLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
|
||||
int length;
|
||||
int pitch = (dst->pitch / dst->format->BytesPerPixel);
|
||||
Uint8 *pixel;
|
||||
if (x1 <= x2) {
|
||||
pixel = (Uint8 *)dst->pixels + y1 * pitch + x1;
|
||||
length = draw_end ? (x2-x1+1) : (x2-x1);
|
||||
} else {
|
||||
pixel = (Uint8 *)dst->pixels + y1 * pitch + x2;
|
||||
if (!draw_end) {
|
||||
++pixel;
|
||||
}
|
||||
length = draw_end ? (x1-x2+1) : (x1-x2);
|
||||
}
|
||||
SDL_memset(pixel, color, length);
|
||||
} else if (x1 == x2) {
|
||||
VLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
DLINE(Uint8, DRAW_FASTSETPIXEL1, draw_end);
|
||||
} else {
|
||||
BLINE(x1, y1, x2, y2, DRAW_FASTSETPIXELXY1, draw_end);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
SDL_DrawLine2(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
if (y1 == y2) {
|
||||
HLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
|
||||
} else if (x1 == x2) {
|
||||
VLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
DLINE(Uint16, DRAW_FASTSETPIXEL2, draw_end);
|
||||
} else {
|
||||
Uint8 _r, _g, _b, _a;
|
||||
const SDL_PixelFormat * fmt = dst->format;
|
||||
SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
|
||||
if (fmt->Rmask == 0x7C00) {
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB555,
|
||||
draw_end);
|
||||
} else if (fmt->Rmask == 0xF800) {
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY_BLEND_RGB565,
|
||||
draw_end);
|
||||
} else {
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_FASTSETPIXELXY2, DRAW_SETPIXELXY2_BLEND_RGB,
|
||||
draw_end);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
SDL_DrawLine4(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color,
|
||||
SDL_bool draw_end)
|
||||
{
|
||||
if (y1 == y2) {
|
||||
HLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
|
||||
} else if (x1 == x2) {
|
||||
VLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
|
||||
} else if (ABS(x1 - x2) == ABS(y1 - y2)) {
|
||||
DLINE(Uint32, DRAW_FASTSETPIXEL4, draw_end);
|
||||
} else {
|
||||
Uint8 _r, _g, _b, _a;
|
||||
const SDL_PixelFormat * fmt = dst->format;
|
||||
SDL_GetRGBA(color, fmt, &_r, &_g, &_b, &_a);
|
||||
if (fmt->Rmask == 0x00FF0000) {
|
||||
if (!fmt->Amask) {
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_RGB888,
|
||||
draw_end);
|
||||
} else {
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY_BLEND_ARGB8888,
|
||||
draw_end);
|
||||
}
|
||||
} else {
|
||||
AALINE(x1, y1, x2, y2,
|
||||
DRAW_FASTSETPIXELXY4, DRAW_SETPIXELXY4_BLEND_RGB,
|
||||
draw_end);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
typedef void (*DrawLineFunc) (SDL_Surface * dst,
|
||||
int x1, int y1, int x2, int y2,
|
||||
Uint32 color, SDL_bool draw_end);
|
||||
|
||||
static DrawLineFunc
|
||||
SDL_CalculateDrawLineFunc(const SDL_PixelFormat * fmt)
|
||||
{
|
||||
switch (fmt->BytesPerPixel) {
|
||||
case 1:
|
||||
if (fmt->BitsPerPixel < 8) {
|
||||
break;
|
||||
}
|
||||
return SDL_DrawLine1;
|
||||
case 2:
|
||||
return SDL_DrawLine2;
|
||||
case 4:
|
||||
return SDL_DrawLine4;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int
|
||||
SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color)
|
||||
{
|
||||
DrawLineFunc func;
|
||||
|
||||
if (!dst) {
|
||||
SDL_SetError("SDL_DrawLine(): Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
func = SDL_CalculateDrawLineFunc(dst->format);
|
||||
if (!func) {
|
||||
SDL_SetError("SDL_DrawLine(): Unsupported surface format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Perform clipping */
|
||||
/* FIXME: We don't actually want to clip, as it may change line slope */
|
||||
if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
func(dst, x1, y1, x2, y2, color, SDL_TRUE);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count,
|
||||
Uint32 color)
|
||||
{
|
||||
int i;
|
||||
int x1, y1;
|
||||
int x2, y2;
|
||||
SDL_bool draw_end;
|
||||
DrawLineFunc func;
|
||||
|
||||
if (!dst) {
|
||||
SDL_SetError("SDL_DrawLines(): Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
func = SDL_CalculateDrawLineFunc(dst->format);
|
||||
if (!func) {
|
||||
SDL_SetError("SDL_DrawLines(): Unsupported surface format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (i = 1; i < count; ++i) {
|
||||
x1 = points[i-1].x;
|
||||
y1 = points[i-1].y;
|
||||
x2 = points[i].x;
|
||||
y2 = points[i].y;
|
||||
|
||||
/* Perform clipping */
|
||||
/* FIXME: We don't actually want to clip, as it may change line slope */
|
||||
if (!SDL_IntersectRectAndLine(&dst->clip_rect, &x1, &y1, &x2, &y2)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Draw the end if it was clipped */
|
||||
draw_end = (x2 != points[i].x || y2 != points[i].y);
|
||||
|
||||
func(dst, x1, y1, x2, y2, color, draw_end);
|
||||
}
|
||||
if (points[0].x != points[count-1].x || points[0].y != points[count-1].y) {
|
||||
SDL_DrawPoint(dst, points[count-1].x, points[count-1].y, color);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* !SDL_RENDER_DISABLED */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
27
project/jni/sdl-1.3/src/render/software/SDL_drawline.h
Normal file
27
project/jni/sdl-1.3/src/render/software/SDL_drawline.h
Normal file
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
|
||||
extern int SDL_DrawLine(SDL_Surface * dst, int x1, int y1, int x2, int y2, Uint32 color);
|
||||
extern int SDL_DrawLines(SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
120
project/jni/sdl-1.3/src/render/software/SDL_drawpoint.c
Normal file
120
project/jni/sdl-1.3/src/render/software/SDL_drawpoint.c
Normal file
@@ -0,0 +1,120 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if !SDL_RENDER_DISABLED
|
||||
|
||||
#include "SDL_draw.h"
|
||||
#include "SDL_drawpoint.h"
|
||||
|
||||
|
||||
int
|
||||
SDL_DrawPoint(SDL_Surface * dst, int x, int y, Uint32 color)
|
||||
{
|
||||
if (!dst) {
|
||||
SDL_SetError("Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* This function doesn't work on surfaces < 8 bpp */
|
||||
if (dst->format->BitsPerPixel < 8) {
|
||||
SDL_SetError("SDL_DrawPoint(): Unsupported surface format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Perform clipping */
|
||||
if (x < dst->clip_rect.x || y < dst->clip_rect.y ||
|
||||
x >= (dst->clip_rect.x + dst->clip_rect.w) ||
|
||||
y >= (dst->clip_rect.y + dst->clip_rect.h)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
switch (dst->format->BytesPerPixel) {
|
||||
case 1:
|
||||
DRAW_FASTSETPIXELXY1(x, y);
|
||||
break;
|
||||
case 2:
|
||||
DRAW_FASTSETPIXELXY2(x, y);
|
||||
break;
|
||||
case 3:
|
||||
SDL_Unsupported();
|
||||
return -1;
|
||||
case 4:
|
||||
DRAW_FASTSETPIXELXY4(x, y);
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
SDL_DrawPoints(SDL_Surface * dst, const SDL_Point * points, int count,
|
||||
Uint32 color)
|
||||
{
|
||||
int minx, miny;
|
||||
int maxx, maxy;
|
||||
int i;
|
||||
int x, y;
|
||||
|
||||
if (!dst) {
|
||||
SDL_SetError("Passed NULL destination surface");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* This function doesn't work on surfaces < 8 bpp */
|
||||
if (dst->format->BitsPerPixel < 8) {
|
||||
SDL_SetError("SDL_DrawPoints(): Unsupported surface format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
minx = dst->clip_rect.x;
|
||||
maxx = dst->clip_rect.x + dst->clip_rect.w - 1;
|
||||
miny = dst->clip_rect.y;
|
||||
maxy = dst->clip_rect.y + dst->clip_rect.h - 1;
|
||||
|
||||
for (i = 0; i < count; ++i) {
|
||||
x = points[i].x;
|
||||
y = points[i].y;
|
||||
|
||||
if (x < minx || x > maxx || y < miny || y > maxy) {
|
||||
continue;
|
||||
}
|
||||
|
||||
switch (dst->format->BytesPerPixel) {
|
||||
case 1:
|
||||
DRAW_FASTSETPIXELXY1(x, y);
|
||||
break;
|
||||
case 2:
|
||||
DRAW_FASTSETPIXELXY2(x, y);
|
||||
break;
|
||||
case 3:
|
||||
SDL_Unsupported();
|
||||
return -1;
|
||||
case 4:
|
||||
DRAW_FASTSETPIXELXY4(x, y);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* !SDL_RENDER_DISABLED */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
27
project/jni/sdl-1.3/src/render/software/SDL_drawpoint.h
Normal file
27
project/jni/sdl-1.3/src/render/software/SDL_drawpoint.h
Normal file
@@ -0,0 +1,27 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
|
||||
extern int SDL_DrawPoint(SDL_Surface * dst, int x, int y, Uint32 color);
|
||||
extern int SDL_DrawPoints(SDL_Surface * dst, const SDL_Point * points, int count, Uint32 color);
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
546
project/jni/sdl-1.3/src/render/software/SDL_render_sw.c
Normal file
546
project/jni/sdl-1.3/src/render/software/SDL_render_sw.c
Normal file
@@ -0,0 +1,546 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
#include "SDL_config.h"
|
||||
|
||||
#if !SDL_RENDER_DISABLED
|
||||
|
||||
#include "../SDL_sysrender.h"
|
||||
#include "SDL_render_sw_c.h"
|
||||
|
||||
#include "SDL_draw.h"
|
||||
#include "SDL_blendfillrect.h"
|
||||
#include "SDL_blendline.h"
|
||||
#include "SDL_blendpoint.h"
|
||||
#include "SDL_drawline.h"
|
||||
#include "SDL_drawpoint.h"
|
||||
|
||||
|
||||
/* SDL surface based renderer implementation */
|
||||
|
||||
static SDL_Renderer *SW_CreateRenderer(SDL_Window * window, Uint32 flags);
|
||||
static void SW_WindowEvent(SDL_Renderer * renderer,
|
||||
const SDL_WindowEvent *event);
|
||||
static int SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
static int SW_SetTextureColorMod(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int SW_SetTextureAlphaMod(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int SW_SetTextureBlendMode(SDL_Renderer * renderer,
|
||||
SDL_Texture * texture);
|
||||
static int SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels,
|
||||
int pitch);
|
||||
static int SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, void **pixels, int *pitch);
|
||||
static void SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
static int SW_UpdateViewport(SDL_Renderer * renderer);
|
||||
static int SW_RenderClear(SDL_Renderer * renderer);
|
||||
static int SW_RenderDrawPoints(SDL_Renderer * renderer,
|
||||
const SDL_Point * points, int count);
|
||||
static int SW_RenderDrawLines(SDL_Renderer * renderer,
|
||||
const SDL_Point * points, int count);
|
||||
static int SW_RenderFillRects(SDL_Renderer * renderer,
|
||||
const SDL_Rect * rects, int count);
|
||||
static int SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect, const SDL_Rect * dstrect);
|
||||
static int SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
|
||||
Uint32 format, void * pixels, int pitch);
|
||||
static void SW_RenderPresent(SDL_Renderer * renderer);
|
||||
static void SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture);
|
||||
static void SW_DestroyRenderer(SDL_Renderer * renderer);
|
||||
|
||||
|
||||
SDL_RenderDriver SW_RenderDriver = {
|
||||
SW_CreateRenderer,
|
||||
{
|
||||
"software",
|
||||
SDL_RENDERER_SOFTWARE,
|
||||
8,
|
||||
{
|
||||
SDL_PIXELFORMAT_RGB555,
|
||||
SDL_PIXELFORMAT_RGB565,
|
||||
SDL_PIXELFORMAT_RGB888,
|
||||
SDL_PIXELFORMAT_BGR888,
|
||||
SDL_PIXELFORMAT_ARGB8888,
|
||||
SDL_PIXELFORMAT_RGBA8888,
|
||||
SDL_PIXELFORMAT_ABGR8888,
|
||||
SDL_PIXELFORMAT_BGRA8888
|
||||
},
|
||||
0,
|
||||
0}
|
||||
};
|
||||
|
||||
typedef struct
|
||||
{
|
||||
SDL_Surface *surface;
|
||||
} SW_RenderData;
|
||||
|
||||
|
||||
static SDL_Surface *
|
||||
SW_ActivateRenderer(SDL_Renderer * renderer)
|
||||
{
|
||||
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
|
||||
|
||||
if (!data->surface) {
|
||||
data->surface = SDL_GetWindowSurface(renderer->window);
|
||||
|
||||
SW_UpdateViewport(renderer);
|
||||
}
|
||||
return data->surface;
|
||||
}
|
||||
|
||||
SDL_Renderer *
|
||||
SW_CreateRendererForSurface(SDL_Surface * surface)
|
||||
{
|
||||
SDL_Renderer *renderer;
|
||||
SW_RenderData *data;
|
||||
|
||||
if (!surface) {
|
||||
SDL_SetError("Can't create renderer for NULL surface");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
renderer = (SDL_Renderer *) SDL_calloc(1, sizeof(*renderer));
|
||||
if (!renderer) {
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
data = (SW_RenderData *) SDL_calloc(1, sizeof(*data));
|
||||
if (!data) {
|
||||
SW_DestroyRenderer(renderer);
|
||||
SDL_OutOfMemory();
|
||||
return NULL;
|
||||
}
|
||||
data->surface = surface;
|
||||
|
||||
renderer->WindowEvent = SW_WindowEvent;
|
||||
renderer->CreateTexture = SW_CreateTexture;
|
||||
renderer->SetTextureColorMod = SW_SetTextureColorMod;
|
||||
renderer->SetTextureAlphaMod = SW_SetTextureAlphaMod;
|
||||
renderer->SetTextureBlendMode = SW_SetTextureBlendMode;
|
||||
renderer->UpdateTexture = SW_UpdateTexture;
|
||||
renderer->LockTexture = SW_LockTexture;
|
||||
renderer->UnlockTexture = SW_UnlockTexture;
|
||||
renderer->UpdateViewport = SW_UpdateViewport;
|
||||
renderer->DestroyTexture = SW_DestroyTexture;
|
||||
renderer->RenderClear = SW_RenderClear;
|
||||
renderer->RenderDrawPoints = SW_RenderDrawPoints;
|
||||
renderer->RenderDrawLines = SW_RenderDrawLines;
|
||||
renderer->RenderFillRects = SW_RenderFillRects;
|
||||
renderer->RenderCopy = SW_RenderCopy;
|
||||
renderer->RenderReadPixels = SW_RenderReadPixels;
|
||||
renderer->RenderPresent = SW_RenderPresent;
|
||||
renderer->DestroyRenderer = SW_DestroyRenderer;
|
||||
renderer->info = SW_RenderDriver.info;
|
||||
renderer->driverdata = data;
|
||||
|
||||
SW_ActivateRenderer(renderer);
|
||||
|
||||
return renderer;
|
||||
}
|
||||
|
||||
SDL_Renderer *
|
||||
SW_CreateRenderer(SDL_Window * window, Uint32 flags)
|
||||
{
|
||||
SDL_Surface *surface;
|
||||
|
||||
surface = SDL_GetWindowSurface(window);
|
||||
if (!surface) {
|
||||
return NULL;
|
||||
}
|
||||
return SW_CreateRendererForSurface(surface);
|
||||
}
|
||||
|
||||
static void
|
||||
SW_WindowEvent(SDL_Renderer * renderer, const SDL_WindowEvent *event)
|
||||
{
|
||||
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
|
||||
|
||||
if (event->event == SDL_WINDOWEVENT_SIZE_CHANGED) {
|
||||
data->surface = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
int bpp;
|
||||
Uint32 Rmask, Gmask, Bmask, Amask;
|
||||
|
||||
if (!SDL_PixelFormatEnumToMasks
|
||||
(texture->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
|
||||
SDL_SetError("Unknown texture format");
|
||||
return -1;
|
||||
}
|
||||
|
||||
texture->driverdata =
|
||||
SDL_CreateRGBSurface(0, texture->w, texture->h, bpp, Rmask, Gmask,
|
||||
Bmask, Amask);
|
||||
SDL_SetSurfaceColorMod(texture->driverdata, texture->r, texture->g,
|
||||
texture->b);
|
||||
SDL_SetSurfaceAlphaMod(texture->driverdata, texture->a);
|
||||
SDL_SetSurfaceBlendMode(texture->driverdata, texture->blendMode);
|
||||
|
||||
if (texture->access == SDL_TEXTUREACCESS_STATIC) {
|
||||
SDL_SetSurfaceRLE(texture->driverdata, 1);
|
||||
}
|
||||
|
||||
if (!texture->driverdata) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SW_SetTextureColorMod(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
|
||||
return SDL_SetSurfaceColorMod(surface, texture->r, texture->g,
|
||||
texture->b);
|
||||
}
|
||||
|
||||
static int
|
||||
SW_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
|
||||
return SDL_SetSurfaceAlphaMod(surface, texture->a);
|
||||
}
|
||||
|
||||
static int
|
||||
SW_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
|
||||
return SDL_SetSurfaceBlendMode(surface, texture->blendMode);
|
||||
}
|
||||
|
||||
static int
|
||||
SW_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, const void *pixels, int pitch)
|
||||
{
|
||||
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
|
||||
Uint8 *src, *dst;
|
||||
int row;
|
||||
size_t length;
|
||||
|
||||
if(SDL_MUSTLOCK(surface))
|
||||
SDL_LockSurface(surface);
|
||||
src = (Uint8 *) pixels;
|
||||
dst = (Uint8 *) surface->pixels +
|
||||
rect->y * surface->pitch +
|
||||
rect->x * surface->format->BytesPerPixel;
|
||||
length = rect->w * surface->format->BytesPerPixel;
|
||||
for (row = 0; row < rect->h; ++row) {
|
||||
SDL_memcpy(dst, src, length);
|
||||
src += pitch;
|
||||
dst += surface->pitch;
|
||||
}
|
||||
if(SDL_MUSTLOCK(surface))
|
||||
SDL_UnlockSurface(surface);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SW_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * rect, void **pixels, int *pitch)
|
||||
{
|
||||
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
|
||||
|
||||
*pixels =
|
||||
(void *) ((Uint8 *) surface->pixels + rect->y * surface->pitch +
|
||||
rect->x * surface->format->BytesPerPixel);
|
||||
*pitch = surface->pitch;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void
|
||||
SW_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
}
|
||||
|
||||
static int
|
||||
SW_UpdateViewport(SDL_Renderer * renderer)
|
||||
{
|
||||
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
|
||||
SDL_Surface *surface = data->surface;
|
||||
|
||||
if (!surface) {
|
||||
/* We'll update the viewport after we recreate the surface */
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!renderer->viewport.w && !renderer->viewport.h) {
|
||||
/* There may be no window, so update the viewport directly */
|
||||
renderer->viewport.w = surface->w;
|
||||
renderer->viewport.h = surface->h;
|
||||
}
|
||||
SDL_SetClipRect(data->surface, &renderer->viewport);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SW_RenderClear(SDL_Renderer * renderer)
|
||||
{
|
||||
SDL_Surface *surface = SW_ActivateRenderer(renderer);
|
||||
Uint32 color;
|
||||
SDL_Rect clip_rect;
|
||||
|
||||
if (!surface) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
color = SDL_MapRGBA(surface->format,
|
||||
renderer->r, renderer->g, renderer->b, renderer->a);
|
||||
|
||||
/* By definition the clear ignores the clip rect */
|
||||
clip_rect = surface->clip_rect;
|
||||
SDL_SetClipRect(surface, NULL);
|
||||
SDL_FillRect(surface, NULL, color);
|
||||
SDL_SetClipRect(surface, &clip_rect);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
SW_RenderDrawPoints(SDL_Renderer * renderer, const SDL_Point * points,
|
||||
int count)
|
||||
{
|
||||
SDL_Surface *surface = SW_ActivateRenderer(renderer);
|
||||
SDL_Point *temp = NULL;
|
||||
int status;
|
||||
|
||||
if (!surface) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (renderer->viewport.x || renderer->viewport.y) {
|
||||
int i;
|
||||
int x = renderer->viewport.x;
|
||||
int y = renderer->viewport.y;
|
||||
|
||||
temp = SDL_stack_alloc(SDL_Point, count);
|
||||
for (i = 0; i < count; ++i) {
|
||||
temp[i].x = x + points[i].x;
|
||||
temp[i].y = y + points[i].x;
|
||||
}
|
||||
points = temp;
|
||||
}
|
||||
|
||||
/* Draw the points! */
|
||||
if (renderer->blendMode == SDL_BLENDMODE_NONE) {
|
||||
Uint32 color = SDL_MapRGBA(surface->format,
|
||||
renderer->r, renderer->g, renderer->b,
|
||||
renderer->a);
|
||||
|
||||
status = SDL_DrawPoints(surface, points, count, color);
|
||||
} else {
|
||||
status = SDL_BlendPoints(surface, points, count,
|
||||
renderer->blendMode,
|
||||
renderer->r, renderer->g, renderer->b,
|
||||
renderer->a);
|
||||
}
|
||||
|
||||
if (temp) {
|
||||
SDL_stack_free(temp);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
static int
|
||||
SW_RenderDrawLines(SDL_Renderer * renderer, const SDL_Point * points,
|
||||
int count)
|
||||
{
|
||||
SDL_Surface *surface = SW_ActivateRenderer(renderer);
|
||||
SDL_Point *temp = NULL;
|
||||
int status;
|
||||
|
||||
if (!surface) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (renderer->viewport.x || renderer->viewport.y) {
|
||||
int i;
|
||||
int x = renderer->viewport.x;
|
||||
int y = renderer->viewport.y;
|
||||
|
||||
temp = SDL_stack_alloc(SDL_Point, count);
|
||||
for (i = 0; i < count; ++i) {
|
||||
temp[i].x = x + points[i].x;
|
||||
temp[i].y = y + points[i].y;
|
||||
}
|
||||
points = temp;
|
||||
}
|
||||
|
||||
/* Draw the lines! */
|
||||
if (renderer->blendMode == SDL_BLENDMODE_NONE) {
|
||||
Uint32 color = SDL_MapRGBA(surface->format,
|
||||
renderer->r, renderer->g, renderer->b,
|
||||
renderer->a);
|
||||
|
||||
status = SDL_DrawLines(surface, points, count, color);
|
||||
} else {
|
||||
status = SDL_BlendLines(surface, points, count,
|
||||
renderer->blendMode,
|
||||
renderer->r, renderer->g, renderer->b,
|
||||
renderer->a);
|
||||
}
|
||||
|
||||
if (temp) {
|
||||
SDL_stack_free(temp);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
static int
|
||||
SW_RenderFillRects(SDL_Renderer * renderer, const SDL_Rect * rects, int count)
|
||||
{
|
||||
SDL_Surface *surface = SW_ActivateRenderer(renderer);
|
||||
SDL_Rect *temp = NULL;
|
||||
int status;
|
||||
|
||||
if (!surface) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (renderer->viewport.x || renderer->viewport.y) {
|
||||
int i;
|
||||
int x = renderer->viewport.x;
|
||||
int y = renderer->viewport.y;
|
||||
|
||||
temp = SDL_stack_alloc(SDL_Rect, count);
|
||||
for (i = 0; i < count; ++i) {
|
||||
temp[i].x = x + rects[i].x;
|
||||
temp[i].y = y + rects[i].y;
|
||||
temp[i].w = rects[i].w;
|
||||
temp[i].h = rects[i].h;
|
||||
}
|
||||
rects = temp;
|
||||
}
|
||||
|
||||
if (renderer->blendMode == SDL_BLENDMODE_NONE) {
|
||||
Uint32 color = SDL_MapRGBA(surface->format,
|
||||
renderer->r, renderer->g, renderer->b,
|
||||
renderer->a);
|
||||
status = SDL_FillRects(surface, rects, count, color);
|
||||
} else {
|
||||
status = SDL_BlendFillRects(surface, rects, count,
|
||||
renderer->blendMode,
|
||||
renderer->r, renderer->g, renderer->b,
|
||||
renderer->a);
|
||||
}
|
||||
|
||||
if (temp) {
|
||||
SDL_stack_free(temp);
|
||||
}
|
||||
return status;
|
||||
}
|
||||
|
||||
static int
|
||||
SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
|
||||
const SDL_Rect * srcrect, const SDL_Rect * dstrect)
|
||||
{
|
||||
SDL_Surface *surface = SW_ActivateRenderer(renderer);
|
||||
SDL_Surface *src = (SDL_Surface *) texture->driverdata;
|
||||
SDL_Rect final_rect = *dstrect;
|
||||
|
||||
if (!surface) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (renderer->viewport.x || renderer->viewport.y) {
|
||||
final_rect.x += renderer->viewport.x;
|
||||
final_rect.y += renderer->viewport.y;
|
||||
}
|
||||
if ( srcrect->w == final_rect.w && srcrect->h == final_rect.h ) {
|
||||
return SDL_BlitSurface(src, srcrect, surface, &final_rect);
|
||||
} else {
|
||||
return SDL_BlitScaled(src, srcrect, surface, &final_rect);
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
|
||||
Uint32 format, void * pixels, int pitch)
|
||||
{
|
||||
SDL_Surface *surface = SW_ActivateRenderer(renderer);
|
||||
Uint32 src_format;
|
||||
void *src_pixels;
|
||||
SDL_Rect final_rect;
|
||||
|
||||
if (!surface) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (renderer->viewport.x || renderer->viewport.y) {
|
||||
final_rect.x = renderer->viewport.x + rect->x;
|
||||
final_rect.y = renderer->viewport.y + rect->y;
|
||||
final_rect.w = rect->w;
|
||||
final_rect.h = rect->h;
|
||||
rect = &final_rect;
|
||||
}
|
||||
|
||||
if (rect->x < 0 || rect->x+rect->w > surface->w ||
|
||||
rect->y < 0 || rect->y+rect->h > surface->h) {
|
||||
SDL_SetError("Tried to read outside of surface bounds");
|
||||
return -1;
|
||||
}
|
||||
|
||||
src_format = surface->format->format;
|
||||
src_pixels = (void*)((Uint8 *) surface->pixels +
|
||||
rect->y * surface->pitch +
|
||||
rect->x * surface->format->BytesPerPixel);
|
||||
|
||||
return SDL_ConvertPixels(rect->w, rect->h,
|
||||
src_format, src_pixels, surface->pitch,
|
||||
format, pixels, pitch);
|
||||
}
|
||||
|
||||
static void
|
||||
SW_RenderPresent(SDL_Renderer * renderer)
|
||||
{
|
||||
SDL_Window *window = renderer->window;
|
||||
|
||||
if (window) {
|
||||
SDL_UpdateWindowSurface(window);
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
SW_DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
|
||||
{
|
||||
SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
|
||||
|
||||
SDL_FreeSurface(surface);
|
||||
}
|
||||
|
||||
static void
|
||||
SW_DestroyRenderer(SDL_Renderer * renderer)
|
||||
{
|
||||
SW_RenderData *data = (SW_RenderData *) renderer->driverdata;
|
||||
|
||||
if (data) {
|
||||
SDL_free(data);
|
||||
}
|
||||
SDL_free(renderer);
|
||||
}
|
||||
|
||||
#endif /* !SDL_RENDER_DISABLED */
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
24
project/jni/sdl-1.3/src/render/software/SDL_render_sw_c.h
Normal file
24
project/jni/sdl-1.3/src/render/software/SDL_render_sw_c.h
Normal file
@@ -0,0 +1,24 @@
|
||||
/*
|
||||
Simple DirectMedia Layer
|
||||
Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
*/
|
||||
|
||||
extern SDL_Renderer * SW_CreateRendererForSurface(SDL_Surface * surface);
|
||||
|
||||
/* vi: set ts=4 sw=4 expandtab: */
|
||||
Reference in New Issue
Block a user