matthew/The-Powder-Toy
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Clean out graphics, add openGL graphics in seperate file, change brush to use unsigned char rather than boolean for bitmap/outline

Browse Source
This commit is contained in:
Simon Robertshaw 2012-04-21 22:46:37 +01:00
parent 75a9460c83
commit 96506610b2
17 changed files with 1158 additions and 2055 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1980
src/Graphics.cpp
View File

File diff suppressed because it is too large Load Diff

124
src/Graphics.h
View File

@ -91,92 +91,84 @@ enum Icon
IconReport IconReport
}; };
//"Graphics lite" - slightly lower performance due to variable size,
class VideoBuffer
{
public:
pixel * Buffer;
int Width, Height;
VideoBuffer(int width, int height): Width(width), Height(height), Buffer((pixel*)calloc(width*height, PIXELSIZE)) { };
void BlendPixel(int x, int y, int r, int g, int b, int a);
void AddPixel(int x, int y, int r, int g, int b, int a);
void SetPixel(int x, int y, int r, int g, int b, int a);
int BlendCharacter(int x, int y, int c, int r, int g, int b, int a);
int AddCharacter(int x, int y, int c, int r, int g, int b, int a);
int SetCharacter(int x, int y, int c, int r, int g, int b, int a);
~VideoBuffer() { free(Buffer); };
};
class Graphics class Graphics
{ {
public: public:
SDL_Surface * sdl_scrn;
pixel *vid; pixel *vid;
pixel *render_packed_rgb(void *image, int width, int height, int cmp_size); int sdl_scale;
#ifdef OGLR
//OpenGL specific instance variables
GLuint vidBuf, textTexture;
#else
SDL_Surface * sdl_scrn;
#endif
//Common graphics methods in Graphics.cpp
static char * GenerateGradient(pixel * colours, float * points, int pointcount, int size); static char * GenerateGradient(pixel * colours, float * points, int pointcount, int size);
//void draw_other();
void draw_rgba_image(unsigned char *data, int x, int y, float a); //PTIF methods
static void *ptif_pack(pixel *src, int w, int h, int *result_size); static void *ptif_pack(pixel *src, int w, int h, int *result_size);
static pixel *ptif_unpack(void *datain, int size, int *w, int *h); static pixel *ptif_unpack(void *datain, int size, int *w, int *h);
static pixel *resample_img_nn(pixel *src, int sw, int sh, int rw, int rh); static pixel *resample_img_nn(pixel *src, int sw, int sh, int rw, int rh);
static pixel *resample_img(pixel *src, int sw, int sh, int rw, int rh); static pixel *resample_img(pixel *src, int sw, int sh, int rw, int rh);
static pixel *rescale_img(pixel *src, int sw, int sh, int *qw, int *qh, int f); static pixel *rescale_img(pixel *src, int sw, int sh, int *qw, int *qh, int f);
//void render_gravlensing(pixel *src, pixel * dst); static pixel *render_packed_rgb(void *image, int width, int height, int cmp_size);
//void sdl_blit_1(int x, int y, int w, int h, pixel *src, int pitch);
//void sdl_blit_2(int x, int y, int w, int h, pixel *src, int pitch); //Font/text metrics
//void sdl_blit(int x, int y, int w, int h, pixel *src, int pitch);
inline void drawblob(int x, int y, unsigned char cr, unsigned char cg, unsigned char cb);
void draw_tool(int b, int sl, int sr, unsigned pc, unsigned iswall);
//int draw_tool_xy(pixel *vid_buf, int x, int y, int b, unsigned pc);
//void draw_menu(pixel *vid_buf, int i, int hover);
void drawpixel(int x, int y, int r, int g, int b, int a);
inline int addchar(int x, int y, int c, int r, int g, int b, int a);
inline int drawchar(int x, int y, int c, int r, int g, int b, int a);
int drawtext(int x, int y, std::string &s, int r, int g, int b, int a);
int drawtext(int x, int y, const char *s, int r, int g, int b, int a);
int drawtext_outline(int x, int y, const char *s, int r, int g, int b, int a, int olr, int olg, int olb, int ola);
int drawtextwrap(int x, int y, int w, const char *s, int r, int g, int b, int a);
void drawrect(int x, int y, int w, int h, int r, int g, int b, int a);
void fillrect(int x, int y, int w, int h, int r, int g, int b, int a);
void clearrect(int x, int y, int w, int h);
void drawdots(int x, int y, int h, int r, int g, int b, int a);
static int textwidth(char *s);
int drawtextmax(int x, int y, int w, char *s, int r, int g, int b, int a);
static int textnwidth(char *s, int n); static int textnwidth(char *s, int n);
static void textnpos(char *s, int n, int w, int *cx, int *cy); static void textnpos(char *s, int n, int w, int *cx, int *cy);
static int textwidthx(char *s, int w); static int textwidthx(char *s, int w);
static int textposxy(char *s, int width, int w, int h); static int textposxy(char *s, int width, int w, int h);
static int textwrapheight(char *s, int width); static int textwrapheight(char *s, int width);
inline void blendpixel(int x, int y, int r, int g, int b, int a); static int textwidth(const char *s);
static void textsize(const char * s, int & width, int & height);
void blendpixel(int x, int y, int r, int g, int b, int a);
void addpixel(int x, int y, int r, int g, int b, int a);
void draw_icon(int x, int y, Icon icon); void draw_icon(int x, int y, Icon icon);
//void draw_air();
//void draw_grav_zones(pixel *vid);
//void draw_grav(pixel *vid);
void draw_line(int x1, int y1, int x2, int y2, int r, int g, int b, int a);
inline void addpixel(int x, int y, int r, int g, int b, int a);
void xor_pixel(int x, int y);
void xor_line(int x1, int y1, int x2, int y2);
void xor_rect(int x, int y, int w, int h);
inline void blend_line(int x1, int y1, int x2, int y2, int r, int g, int b, int a);
//void render_parts(pixel *vid);
// #ifdef OGLR
// void draw_parts_fbo();
// #endif
// void draw_parts();
// void draw_walls(pixel *vid);
// void create_decorations(int x, int y, int rx, int ry, int r, int g, int b, int click, int tool);
// void create_decoration(int x, int y, int r, int g, int b, int click, int tool);
// void line_decorations(int x1, int y1, int x2, int y2, int rx, int ry, int r, int g, int b, int click, int tool);
// void box_decorations(int x1, int y1, int x2, int y2, int r, int g, int b, int click, int tool);
// void draw_color_menu(pixel *vid_buf, int i, int hover);
inline void draw_wavelengths(int x, int y, int h, int wl);
//void render_signs();
// void render_fire(pixel *dst);
// void prepare_alpha(int size, float intensity);
inline void draw_image(pixel *img, int x, int y, int w, int h, int a);
static void dim_copy(pixel *dst, pixel *src);
static void dim_copy_pers(pixel *dst, pixel *src);
//void render_zoom(pixel *img);
//int render_thumb(void *thumb, int size, int bzip2, pixel *vid_buf, int px, int py, int scl);
//void render_cursor(pixel *vid, int x, int y, int t, int rx, int ry);
//int sdl_open(void);
//int draw_debug_info(pixel* vid, int lm, int lx, int ly, int cx, int cy, int line_x, int line_y);
void Clear(); void Clear();
void Blit();
void AttachSDLSurface(SDL_Surface * surface); void AttachSDLSurface(SDL_Surface * surface);
#ifdef OGLR void Blit();
void clearScreen(float alpha); //
void ogl_blit(int x, int y, int w, int h, pixel *src, int pitch, int scale); int drawtext(int x, int y, const char *s, int r, int g, int b, int a);
#endif int drawtext(int x, int y, std::string s, int r, int g, int b, int a);
int drawchar(int x, int y, int c, int r, int g, int b, int a);
int addchar(int x, int y, int c, int r, int g, int b, int a);
void xor_pixel(int x, int y);
void xor_line(int x, int y, int x2, int y2);
void xor_rect(int x, int y, int width, int height);
void xor_bitmap(unsigned char * bitmap, int x, int y, int w, int h);
void draw_line(int x, int y, int x2, int y2, int r, int g, int b, int a);
void drawrect(int x, int y, int width, int height, int r, int g, int b, int a);
void fillrect(int x, int y, int width, int height, int r, int g, int b, int a);
void clearrect(int x, int y, int width, int height);
void gradientrect(int x, int y, int width, int height, int r, int g, int b, int a, int r2, int g2, int b2, int a2);
void draw_image(pixel *img, int x, int y, int w, int h, int a);
Graphics(); Graphics();
~Graphics(); ~Graphics();
#ifdef OGLR
GLuint vidBuf;
#endif
}; };
#endif #endif

399
src/OpenGLGraphics.cpp Normal file
View File

@ -0,0 +1,399 @@
#include "Graphics.h"
#include "font.h"
#ifdef OGLR
Graphics::Graphics():
sdl_scale(1)
{
}
Graphics::~Graphics()
{
}
void Graphics::Clear()
{
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
}
void Graphics::AttachSDLSurface(SDL_Surface * surface)
{
//sdl_scrn = surface;
SDL_GL_SetAttribute (SDL_GL_DOUBLEBUFFER, 1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
//glOrtho(0, (XRES+BARSIZE)*sdl_scale, 0, (YRES+MENUSIZE)*sdl_scale, -1, 1);
glOrtho(0, (XRES+BARSIZE)*sdl_scale, (YRES+MENUSIZE)*sdl_scale, 0, -1, 1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
//glRasterPos2i(0, (YRES+MENUSIZE));
glRasterPos2i(0, 0);
glPixelZoom(1, 1);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//Texture for main UI
glEnable(GL_TEXTURE_2D);
glGenTextures(1, &vidBuf);
glBindTexture(GL_TEXTURE_2D, vidBuf);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, XRES+BARSIZE, YRES+MENUSIZE, 0, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
glGenTextures(1, &textTexture);
glBindTexture(GL_TEXTURE_2D, textTexture);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
}
void Graphics::Blit()
{
//glDrawPixels(w,h,GL_BGRA,GL_UNSIGNED_BYTE,src); //Why does this still think it's ABGR?
/*glEnable( GL_TEXTURE_2D );
glBindTexture(GL_TEXTURE_2D, vidBuf);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, XRES+BARSIZE, YRES+MENUSIZE, GL_BGRA, GL_UNSIGNED_BYTE, vid);
glBegin(GL_QUADS);
glTexCoord2d(1, 0);
glVertex3f((XRES+BARSIZE)*sdl_scale, (YRES+MENUSIZE)*sdl_scale, 1.0);
glTexCoord2d(0, 0);
glVertex3f(0, (YRES+MENUSIZE)*sdl_scale, 1.0);
glTexCoord2d(0, 1);
glVertex3f(0, 0, 1.0);
glTexCoord2d(1, 1);
glVertex3f((XRES+BARSIZE)*sdl_scale, 0, 1.0);
glEnd();
glDisable( GL_TEXTURE_2D );*/
glFlush();
SDL_GL_SwapBuffers ();
}
int Graphics::drawtext(int x, int y, const char *s, int r, int g, int b, int a)
{
if(!strlen(s))
return 0;
int width, height;
Graphics::textsize(s, width, height);
VideoBuffer texture(width, height);
int characterX = 0, characterY = 0;
int startX = characterX;
for (; *s; s++)
{
if (*s == '\n')
{
characterX = startX;
characterY += FONT_H+2;
}
else if (*s == '\b')
{
switch (s[1])
{
case 'w':
r = g = b = 255;
break;
case 'g':
r = g = b = 192;
break;
case 'o':
r = 255;
g = 216;
b = 32;
break;
case 'r':
r = 255;
g = b = 0;
break;
case 'l':
r = 255;
g = b = 75;
break;
case 'b':
r = g = 0;
b = 255;
break;
case 't':
b = 255;
g = 170;
r = 32;
break;
}
s++;
}
else
{
characterX = texture.SetCharacter(characterX, characterY, *(unsigned char *)s, r, g, b, a);
}
}
glEnable(GL_TEXTURE_2D);
//Generate texture
glBindTexture(GL_TEXTURE_2D, textTexture);
//Draw texture
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture.Width, texture.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, texture.Buffer);
//glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texture.Width, texture.Height, GL_BGRA, GL_UNSIGNED_BYTE, texture.Buffer);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex2f(x, y);
glTexCoord2d(1, 0);
glVertex2f(x+texture.Width, y);
glTexCoord2d(1, 1);
glVertex2f(x+texture.Width, y+texture.Height);
glTexCoord2d(0, 1);
glVertex2f(x, y+texture.Height);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
return x;
}
int Graphics::drawtext(int x, int y, std::string s, int r, int g, int b, int a)
{
return drawtext(x, y, s.c_str(), r, g, b, a);
}
TPT_INLINE int Graphics::drawchar(int x, int y, int c, int r, int g, int b, int a)
{
int i, j, w, bn = 0, ba = 0;
char *rp = font_data + font_ptrs[c];
w = *(rp++);
VideoBuffer texture(w, 12);
texture.SetCharacter(0, 0, c, r, g, b, a);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, textTexture);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture.Width, texture.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, texture.Buffer);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex2f(x, y);
glTexCoord2d(1, 0);
glVertex2f(x+texture.Width, y);
glTexCoord2d(1, 1);
glVertex2f(x+texture.Width, y+texture.Height);
glTexCoord2d(0, 1);
glVertex2f(x, y+texture.Height);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
return x + w;
}
TPT_INLINE int Graphics::addchar(int x, int y, int c, int r, int g, int b, int a)
{
int i, j, w, bn = 0, ba = 0;
char *rp = font_data + font_ptrs[c];
w = *(rp++);
VideoBuffer texture(w, 12);
texture.AddCharacter(0, 0, c, r, g, b, a);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, textTexture);
glBlendFunc(GL_ONE, GL_ONE);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture.Width, texture.Height, 0, GL_BGRA, GL_UNSIGNED_BYTE, texture.Buffer);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex2f(x, y);
glTexCoord2d(1, 0);
glVertex2f(x+texture.Width, y);
glTexCoord2d(1, 1);
glVertex2f(x+texture.Width, y+texture.Height);
glTexCoord2d(0, 1);
glVertex2f(x, y+texture.Height);
glEnd();
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
return x + w;
}
TPT_INLINE void Graphics::xor_pixel(int x, int y)
{
//OpenGL doesn't support single pixel manipulation, there are ways around it, but with poor performance
}
TPT_INLINE void Graphics::blendpixel(int x, int y, int r, int g, int b, int a)
{
//OpenGL doesn't support single pixel manipulation, there are ways around it, but with poor performance
}
TPT_INLINE void Graphics::addpixel(int x, int y, int r, int g, int b, int a)
{
//OpenGL doesn't support single pixel manipulation, there are ways around it, but with poor performance
}
void Graphics::xor_line(int x, int y, int x2, int y2)
{
glEnable(GL_COLOR_LOGIC_OP);
//glEnable(GL_LINE_SMOOTH);
glLogicOp(GL_XOR);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_LINES);
glVertex2i(x, y);
glVertex2i(x2, y2);
glEnd();
glDisable(GL_COLOR_LOGIC_OP);
}
void Graphics::xor_rect(int x, int y, int width, int height)
{
glEnable(GL_COLOR_LOGIC_OP);
//glEnable(GL_LINE_SMOOTH);
glLogicOp(GL_XOR);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_LINE_STRIP);
glVertex2i(x, y);
glVertex2i(x+width, y);
glVertex2i(x+width, y+height);
glVertex2i(x, y+height);
glVertex2i(x, y);
glEnd();
glDisable(GL_COLOR_LOGIC_OP);
}
void Graphics::xor_bitmap(unsigned char * bitmap, int x, int y, int w, int h)
{
//glEnable(GL_COLOR_LOGIC_OP);
//glLogicOp(GL_XOR);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, textTexture);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, w, h, 0, GL_ALPHA, GL_UNSIGNED_BYTE, bitmap);
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex2f(x, y);
glTexCoord2d(1, 0);
glVertex2f(x+w, y);
glTexCoord2d(1, 1);
glVertex2f(x+w, y+h);
glTexCoord2d(0, 1);
glVertex2f(x, y+h);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
//glDisable(GL_COLOR_LOGIC_OP);
}
void Graphics::draw_line(int x, int y, int x2, int y2, int r, int g, int b, int a)
{
a = 255;
glColor4ub(r, g, b, a);
glBegin(GL_LINES);
glVertex2i(x, y);
glVertex2i(x2, y2);
glEnd();
}
void Graphics::drawrect(int x, int y, int width, int height, int r, int g, int b, int a)
{
x++;
glColor4ub(r, g, b, a);
glBegin(GL_LINE_STRIP);
glVertex2i(x, y);
glVertex2i(x+width, y);
glVertex2i(x+width, y+height);
glVertex2i(x, y+height+1); //+1 is a hack to prevent squares from missing their corners, will make smoothed lines look like SHIT
glVertex2i(x, y);
glEnd();
}
void Graphics::fillrect(int x, int y, int width, int height, int r, int g, int b, int a)
{
x++;
y++;
width-=1;
height-=1;
glColor4ub(r, g, b, a);
glBegin(GL_QUADS);
glVertex2i(x, y);
glVertex2i(x+width, y);
glVertex2i(x+width, y+height);
glVertex2i(x, y+height);
glEnd();
}
void Graphics::gradientrect(int x, int y, int width, int height, int r, int g, int b, int a, int r2, int g2, int b2, int a2)
{
glBegin(GL_QUADS);
glColor4ub(r, g, b, a);
glVertex2i(x, y);
glColor4ub(r2, g2, b2, a2);
glVertex2i(x+width, y);
glColor4ub(r2, g2, b2, a2);
glVertex2i(x+width, y+height);
glColor4ub(r, g, b, a);
glVertex2i(x, y+height);
glEnd();
}
void Graphics::clearrect(int x, int y, int width, int height)
{
glColor4ub(0, 0, 0, 255);
glBegin(GL_QUADS);
glVertex2i(x, y);
glVertex2i(x+width, y);
glVertex2i(x+width, y+height);
glVertex2i(x, y+height);
glEnd();
}
void Graphics::draw_image(pixel *img, int x, int y, int w, int h, int a)
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, textTexture);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_BGRA, GL_UNSIGNED_BYTE, img);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex2f(x, y);
glTexCoord2d(1, 0);
glVertex2f(x+w, y);
glTexCoord2d(1, 1);
glVertex2f(x+w, y+h);
glTexCoord2d(0, 1);
glVertex2f(x, y+h);
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
}
#endif

380
src/RasterGraphics.cpp Normal file
View File

@ -0,0 +1,380 @@
#include "Graphics.h"
#include "font.h"
#ifndef OGLR
Graphics::Graphics():
sdl_scale(1)
{
vid = (pixel *)malloc(PIXELSIZE * ((XRES+BARSIZE) * (YRES+MENUSIZE)));
}
Graphics::~Graphics()
{
free(vid);
}
void Graphics::Clear()
{
memset(vid, 0, PIXELSIZE * ((XRES+BARSIZE) * (YRES+MENUSIZE)));
}
void Graphics::AttachSDLSurface(SDL_Surface * surface)
{
sdl_scrn = surface;
}
void Graphics::Blit()
{
if(sdl_scrn)
{
pixel * dst;
pixel * src = vid;
int j, x = 0, y = 0, w = XRES+BARSIZE, h = YRES+MENUSIZE, pitch = XRES+BARSIZE;
if (SDL_MUSTLOCK(sdl_scrn))
if (SDL_LockSurface(sdl_scrn)<0)
return;
dst=(pixel *)sdl_scrn->pixels+y*sdl_scrn->pitch/PIXELSIZE+x;
for (j=0; j<h; j++)
{
memcpy(dst, src, w*PIXELSIZE);
dst+=sdl_scrn->pitch/PIXELSIZE;
src+=pitch;
}
if (SDL_MUSTLOCK(sdl_scrn))
SDL_UnlockSurface(sdl_scrn);
SDL_UpdateRect(sdl_scrn,0,0,0,0);
}
}
int Graphics::drawtext(int x, int y, const char *s, int r, int g, int b, int a)
{
if(!strlen(s))
return 0;
int width, height;
int characterX = x, characterY = y;
int startX = characterX;
for (; *s; s++)
{
if (*s == '\n')
{
characterX = startX;
characterY += FONT_H+2;
}
else if (*s == '\b')
{
switch (s[1])
{
case 'w':
r = g = b = 255;
break;
case 'g':
r = g = b = 192;
break;
case 'o':
r = 255;
g = 216;
b = 32;
break;
case 'r':
r = 255;
g = b = 0;
break;
case 'l':
r = 255;
g = b = 75;
break;
case 'b':
r = g = 0;
b = 255;
break;
case 't':
b = 255;
g = 170;
r = 32;
break;
}
s++;
}
else
{
characterX = drawchar(characterX, characterY, *(unsigned char *)s, r, g, b, a);
}
}
return x;
}
int Graphics::drawtext(int x, int y, std::string s, int r, int g, int b, int a)
{
return drawtext(x, y, s.c_str(), r, g, b, a);
}
TPT_INLINE int Graphics::drawchar(int x, int y, int c, int r, int g, int b, int a)
{
int i, j, w, bn = 0, ba = 0;
char *rp = font_data + font_ptrs[c];
w = *(rp++);
for (j=0; j<FONT_H; j++)
for (i=0; i<w; i++)
{
if (!bn)
{
ba = *(rp++);
bn = 8;
}
blendpixel(x+i, y+j, r, g, b, ((ba&3)*a)/3);
ba >>= 2;
bn -= 2;
}
return x + w;
}
TPT_INLINE int Graphics::addchar(int x, int y, int c, int r, int g, int b, int a)
{
int i, j, w, bn = 0, ba = 0;
char *rp = font_data + font_ptrs[c];
w = *(rp++);
for (j=0; j<FONT_H; j++)
for (i=0; i<w; i++)
{
if (!bn)
{
ba = *(rp++);
bn = 8;
}
{
addpixel(x+i, y+j, r, g, b, ((ba&3)*a)/3);
}
ba >>= 2;
bn -= 2;
}
return x + w;
}
TPT_INLINE void Graphics::xor_pixel(int x, int y)
{
int c;
if (x<0 || y<0 || x>=XRES || y>=YRES)
return;
c = vid[y*(XRES+BARSIZE)+x];
c = PIXB(c) + 3*PIXG(c) + 2*PIXR(c);
if (c<512)
vid[y*(XRES+BARSIZE)+x] = PIXPACK(0xC0C0C0);
else
vid[y*(XRES+BARSIZE)+x] = PIXPACK(0x404040);
}
TPT_INLINE void Graphics::blendpixel(int x, int y, int r, int g, int b, int a)
{
pixel t;
if (x<0 || y<0 || x>=XRES+BARSIZE || y>=YRES+MENUSIZE)
return;
if (a!=255)
{
t = vid[y*(XRES+BARSIZE)+x];
r = (a*r + (255-a)*PIXR(t)) >> 8;
g = (a*g + (255-a)*PIXG(t)) >> 8;
b = (a*b + (255-a)*PIXB(t)) >> 8;
}
vid[y*(XRES+BARSIZE)+x] = PIXRGB(r,g,b);
}
TPT_INLINE void Graphics::addpixel(int x, int y, int r, int g, int b, int a)
{
pixel t;
if (x<0 || y<0 || x>=XRES+BARSIZE || y>=YRES+MENUSIZE)
return;
t = vid[y*(XRES+BARSIZE)+x];
r = (a*r + 255*PIXR(t)) >> 8;
g = (a*g + 255*PIXG(t)) >> 8;
b = (a*b + 255*PIXB(t)) >> 8;
if (r>255)
r = 255;
if (g>255)
g = 255;
if (b>255)
b = 255;
vid[y*(XRES+BARSIZE)+x] = PIXRGB(r,g,b);
}
void Graphics::xor_line(int x1, int y1, int x2, int y2)
{
int cp=abs(y2-y1)>abs(x2-x1), x, y, dx, dy, sy;
float e, de;
if (cp)
{
y = x1;
x1 = y1;
y1 = y;
y = x2;
x2 = y2;
y2 = y;
}
if (x1 > x2)
{
y = x1;
x1 = x2;
x2 = y;
y = y1;
y1 = y2;
y2 = y;
}
dx = x2 - x1;
dy = abs(y2 - y1);
e = 0.0f;
if (dx)
de = dy/(float)dx;
else
de = 0.0f;
y = y1;
sy = (y1<y2) ? 1 : -1;
for (x=x1; x<=x2; x++)
{
if (cp)
xor_pixel(y, x);
else
xor_pixel(x, y);
e += de;
if (e >= 0.5f)
{
y += sy;
e -= 1.0f;
}
}
}
void Graphics::xor_rect(int x, int y, int w, int h)
{
int i;
for (i=0; i<w; i+=2)
{
xor_pixel(x+i, y);
xor_pixel(x+i, y+h-1);
}
for (i=2; i<h; i+=2)
{
xor_pixel(x, y+i);
xor_pixel(x+w-1, y+i);
}
}
void Graphics::xor_bitmap(unsigned char * bitmap, int x, int y, int w, int h)
{
for(int x1 = 0; x1 < w; x1++)
{
for(int y1 = 0; y1 < h; y1++)
{
if(bitmap[y1*w+x1])
xor_pixel(x+x1, y+y1);
}
}
}
void Graphics::draw_line(int x1, int y1, int x2, int y2, int r, int g, int b, int a)
{
int cp=abs(y2-y1)>abs(x2-x1), x, y, dx, dy, sy;
float e, de;
if (cp)
{
y = x1;
x1 = y1;
y1 = y;
y = x2;
x2 = y2;
y2 = y;
}
if (x1 > x2)
{
y = x1;
x1 = x2;
x2 = y;
y = y1;
y1 = y2;
y2 = y;
}
dx = x2 - x1;
dy = abs(y2 - y1);
e = 0.0f;
if (dx)
de = dy/(float)dx;
else
de = 0.0f;
y = y1;
sy = (y1<y2) ? 1 : -1;
for (x=x1; x<=x2; x++)
{
if (cp)
blendpixel(y, x, r, g, b, a);
else
blendpixel(x, y, r, g, b, a);
e += de;
if (e >= 0.5f)
{
y += sy;
e -= 1.0f;
}
}
}
void Graphics::drawrect(int x, int y, int w, int h, int r, int g, int b, int a)
{
int i;
for (i=0; i<=w; i++)
{
blendpixel(x+i, y, r, g, b, a);
blendpixel(x+i, y+h, r, g, b, a);
}
for (i=1; i<h; i++)
{
blendpixel(x, y+i, r, g, b, a);
blendpixel(x+w, y+i, r, g, b, a);
}
}
void Graphics::fillrect(int x, int y, int w, int h, int r, int g, int b, int a)
{
int i,j;
for (j=1; j<h; j++)
for (i=1; i<w; i++)
blendpixel(x+i, y+j, r, g, b, a);
}
void Graphics::gradientrect(int x, int y, int width, int height, int r, int g, int b, int a, int r2, int g2, int b2, int a2)
{
}
void Graphics::clearrect(int x, int y, int w, int h)
{
int i;
for (i=1; i<h; i++)
memset(vid+(x+1+(XRES+BARSIZE)*(y+i)), 0, PIXELSIZE*(w-1));
}
void Graphics::draw_image(pixel *img, int x, int y, int w, int h, int a)
{
int i, j, r, g, b;
if (!img) return;
if(y + h > YRES+MENUSIZE) h = (YRES+MENUSIZE)-y; //Adjust height to prevent drawing off the bottom
if(a >= 255)
for (j=0; j<h; j++)
for (i=0; i<w; i++)
{
vid[(y+j)*(XRES+BARSIZE)+(x+i)] = *img;
img++;
}
else
for (j=0; j<h; j++)
for (i=0; i<w; i++)
{
r = PIXR(*img);
g = PIXG(*img);
b = PIXB(*img);
blendpixel(x+i, y+j, r, g, b, a);
img++;
}
}
#endif

185
src/Renderer.cpp
View File

@ -210,20 +210,25 @@ void Renderer::FinaliseParts()
glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_QUADS); glBegin(GL_QUADS);
glTexCoord2d(1, 0); glTexCoord2d(1, 0);
glVertex3f(XRES*sdl_scale, (YRES+MENUSIZE)*sdl_scale, 1.0); //glVertex3f(XRES*sdl_scale, (YRES+MENUSIZE)*sdl_scale, 1.0);
glVertex3f(XRES*sdl_scale, YRES*sdl_scale, 1.0);
glTexCoord2d(0, 0); glTexCoord2d(0, 0);
glVertex3f(0, (YRES+MENUSIZE)*sdl_scale, 1.0); //glVertex3f(0, (YRES+MENUSIZE)*sdl_scale, 1.0);
glVertex3f(0, YRES*sdl_scale, 1.0);
glTexCoord2d(0, 1); glTexCoord2d(0, 1);
glVertex3f(0, MENUSIZE*sdl_scale, 1.0); //glVertex3f(0, MENUSIZE*sdl_scale, 1.0);
glVertex3f(0, 0, 1.0);
glTexCoord2d(1, 1); glTexCoord2d(1, 1);
glVertex3f(XRES*sdl_scale, MENUSIZE*sdl_scale, 1.0); //glVertex3f(XRES*sdl_scale, MENUSIZE*sdl_scale, 1.0);
glVertex3f(XRES*sdl_scale, 0, 1.0);
glEnd(); glEnd();
if(display_mode & DISPLAY_WARP) if(display_mode & DISPLAY_WARP)
{ {
glUseProgram(0); glUseProgram(0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
} }
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable( GL_TEXTURE_2D ); glDisable( GL_TEXTURE_2D );
#endif #endif
} }
@ -238,11 +243,12 @@ void Renderer::RenderZoom()
float zcx1, zcx0, zcy1, zcy0, yfactor, xfactor, i; //X-Factor is shit, btw float zcx1, zcx0, zcy1, zcy0, yfactor, xfactor, i; //X-Factor is shit, btw
xfactor = 1.0f/(float)XRES; xfactor = 1.0f/(float)XRES;
yfactor = 1.0f/(float)YRES; yfactor = 1.0f/(float)YRES;
yfactor*=-1.0f;
zcx0 = (zoomScopePosition.X)*xfactor; zcx1 = (zoomScopePosition.X)*xfactor;
zcx1 = (zoomScopePosition.X+zoomScopeSize)*xfactor; zcx0 = (zoomScopePosition.X+zoomScopeSize)*xfactor;
zcy0 = (zoomScopePosition.Y)*yfactor; zcy1 = (zoomScopePosition.Y)*yfactor;
zcy1 = ((zoomScopePosition.Y+zoomScopeSize))*yfactor; zcy0 = ((zoomScopePosition.Y+zoomScopeSize))*yfactor;
glGetIntegerv(GL_BLEND_SRC, &origBlendSrc); glGetIntegerv(GL_BLEND_SRC, &origBlendSrc);
glGetIntegerv(GL_BLEND_DST, &origBlendDst); glGetIntegerv(GL_BLEND_DST, &origBlendDst);
@ -252,46 +258,49 @@ void Renderer::RenderZoom()
//glReadBuffer(GL_AUX0); //glReadBuffer(GL_AUX0);
glBindTexture(GL_TEXTURE_2D, partsFboTex); glBindTexture(GL_TEXTURE_2D, partsFboTex);
//Draw zoomed texture
glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_QUADS); glBegin(GL_QUADS);
glTexCoord2d(zcx1, zcy1); glTexCoord2d(zcx1, zcy1);
glVertex3f((zoomWindowPosition.X+zoomScopeSize*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR))*sdl_scale, 1.0); glVertex2i(zoomWindowPosition.X, zoomWindowPosition.Y);
glTexCoord2d(zcx0, zcy1); glTexCoord2d(zcx0, zcy1);
glVertex3f(zoomWindowPosition.X*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR))*sdl_scale, 1.0); glVertex2i(zoomWindowPosition.X+(zoomScopeSize*ZFACTOR), zoomWindowPosition.Y);
glTexCoord2d(zcx0, zcy0); glTexCoord2d(zcx0, zcy0);
glVertex3f(zoomWindowPosition.X*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale, 1.0); glVertex2i(zoomWindowPosition.X+(zoomScopeSize*ZFACTOR), zoomWindowPosition.Y+(zoomScopeSize*ZFACTOR));
glTexCoord2d(zcx1, zcy0); glTexCoord2d(zcx1, zcy0);
glVertex3f((zoomWindowPosition.X+zoomScopeSize*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale, 1.0); glVertex2i(zoomWindowPosition.X, zoomWindowPosition.Y+(zoomScopeSize*ZFACTOR));
glEnd(); glEnd();
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
glDisable( GL_TEXTURE_2D ); glDisable( GL_TEXTURE_2D );
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//Lines to make the pixels stand out
glLineWidth(sdl_scale); glLineWidth(sdl_scale);
glEnable(GL_LINE_SMOOTH); //glEnable(GL_LINE_SMOOTH);
glBegin(GL_LINES); glBegin(GL_LINES);
glColor4f(0.0f, 0.0f, 0.0f, 1.0f); glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
for(i = 0; i < zoomScopeSize; i++) for(i = 0; i < zoomScopeSize; i++)
{ {
glVertex2f((zoomWindowPosition.X+zoomScopeSize*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR)+i*ZFACTOR)*sdl_scale); //Across
glVertex2f(zoomWindowPosition.X*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR)+i*ZFACTOR)*sdl_scale); glVertex2i(zoomWindowPosition.X, zoomWindowPosition.Y+(i*ZFACTOR));
glVertex2f((zoomWindowPosition.X+i*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR))*sdl_scale); glVertex2i(zoomWindowPosition.X+(zoomScopeSize*ZFACTOR), zoomWindowPosition.Y+(i*ZFACTOR));
glVertex2f((zoomWindowPosition.X+i*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale);
//Down
glVertex2i(zoomWindowPosition.X+(i*ZFACTOR), zoomWindowPosition.Y);
glVertex2i(zoomWindowPosition.X+(i*ZFACTOR), zoomWindowPosition.Y+(zoomScopeSize*ZFACTOR));
} }
glEnd(); glEnd();
//Draw zoom window border
glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_LOOP);
glVertex3i((zoomWindowPosition.X-1)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale, 0); glVertex2i(zoomWindowPosition.X, zoomWindowPosition.Y);
glVertex3i((zoomWindowPosition.X-1)*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR))*sdl_scale, 0); glVertex2i(zoomWindowPosition.X+(zoomScopeSize*ZFACTOR), zoomWindowPosition.Y);
glVertex3i((zoomWindowPosition.X+zoomScopeSize*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR))*sdl_scale, 0); glVertex2i(zoomWindowPosition.X+(zoomScopeSize*ZFACTOR), zoomWindowPosition.Y+(zoomScopeSize*ZFACTOR));
glVertex3i((zoomWindowPosition.X+zoomScopeSize*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale, 0); glVertex2i(zoomWindowPosition.X, zoomWindowPosition.Y+(zoomScopeSize*ZFACTOR));
glVertex3i((zoomWindowPosition.X-1)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale, 0);
glEnd(); glEnd();
glDisable(GL_LINE_SMOOTH); //glDisable(GL_LINE_SMOOTH);
glDisable(GL_LINE_SMOOTH);
if(zoomEnabled) if(zoomEnabled)
{ {
@ -299,12 +308,16 @@ void Renderer::RenderZoom()
//glEnable(GL_LINE_SMOOTH); //glEnable(GL_LINE_SMOOTH);
glLogicOp(GL_XOR); glLogicOp(GL_XOR);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f); glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_LOOP);
glVertex3i((zoomScopePosition.X-1)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y-1))*sdl_scale, 0); glVertex2i(zoomScopePosition.X, zoomScopePosition.Y);
glVertex2i(zoomScopePosition.X+zoomScopeSize, zoomScopePosition.Y);
glVertex2i(zoomScopePosition.X+zoomScopeSize, zoomScopePosition.Y+zoomScopeSize);
glVertex2i(zoomScopePosition.X, zoomScopePosition.Y+zoomScopeSize);
/*glVertex3i((zoomScopePosition.X-1)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y-1))*sdl_scale, 0);
glVertex3i((zoomScopePosition.X-1)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y+zoomScopeSize))*sdl_scale, 0); glVertex3i((zoomScopePosition.X-1)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y+zoomScopeSize))*sdl_scale, 0);
glVertex3i((zoomScopePosition.X+zoomScopeSize)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y+zoomScopeSize))*sdl_scale, 0); glVertex3i((zoomScopePosition.X+zoomScopeSize)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y+zoomScopeSize))*sdl_scale, 0);
glVertex3i((zoomScopePosition.X+zoomScopeSize)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y-1))*sdl_scale, 0); glVertex3i((zoomScopePosition.X+zoomScopeSize)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y-1))*sdl_scale, 0);
glVertex3i((zoomScopePosition.X-1)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y-1))*sdl_scale, 0); glVertex3i((zoomScopePosition.X-1)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y-1))*sdl_scale, 0);*/
glEnd(); glEnd();
glDisable(GL_COLOR_LOGIC_OP); glDisable(GL_COLOR_LOGIC_OP);
} }
@ -343,6 +356,7 @@ void Renderer::RenderZoom()
void Renderer::DrawWalls() void Renderer::DrawWalls()
{ {
#ifndef OGLR
int x, y, i, j, cr, cg, cb; int x, y, i, j, cr, cg, cb;
unsigned char wt; unsigned char wt;
pixel pc; pixel pc;
@ -447,30 +461,30 @@ void Renderer::DrawWalls()
{ {
for (j=0; j<CELL; j+=2) for (j=0; j<CELL; j+=2)
for (i=(j>>1)&1; i<CELL; i+=2) for (i=(j>>1)&1; i<CELL; i+=2)
g->drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc)); drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc));
} }
else if (wtypes[wt].drawstyle==2) else if (wtypes[wt].drawstyle==2)
{ {
for (j=0; j<CELL; j+=2) for (j=0; j<CELL; j+=2)
for (i=0; i<CELL; i+=2) for (i=0; i<CELL; i+=2)
g->drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc)); drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc));
} }
else if (wtypes[wt].drawstyle==3) else if (wtypes[wt].drawstyle==3)
{ {
for (j=0; j<CELL; j++) for (j=0; j<CELL; j++)
for (i=0; i<CELL; i++) for (i=0; i<CELL; i++)
g->drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc)); drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc));
} }
else if (wtypes[wt].drawstyle==4) else if (wtypes[wt].drawstyle==4)
{ {
for (j=0; j<CELL; j++) for (j=0; j<CELL; j++)
for (i=0; i<CELL; i++) for (i=0; i<CELL; i++)
if(i == j) if(i == j)
g->drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc)); drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc));
else if (i == j+1 || (i == 0 && j == CELL-1)) else if (i == j+1 || (i == 0 && j == CELL-1))
g->drawblob((x*CELL+i), (y*CELL+j), PIXR(gc), PIXG(gc), PIXB(gc)); drawblob((x*CELL+i), (y*CELL+j), PIXR(gc), PIXG(gc), PIXB(gc));
else else
g->drawblob((x*CELL+i), (y*CELL+j), 0x20, 0x20, 0x20); drawblob((x*CELL+i), (y*CELL+j), 0x20, 0x20, 0x20);
} }
if (bmap[y][x]==WL_EWALL) if (bmap[y][x]==WL_EWALL)
{ {
@ -479,14 +493,14 @@ void Renderer::DrawWalls()
for (j=0; j<CELL; j++) for (j=0; j<CELL; j++)
for (i=0; i<CELL; i++) for (i=0; i<CELL; i++)
if (i&j&1) if (i&j&1)
g->drawblob((x*CELL+i), (y*CELL+j), 0x80, 0x80, 0x80); drawblob((x*CELL+i), (y*CELL+j), 0x80, 0x80, 0x80);
} }
else else
{ {
for (j=0; j<CELL; j++) for (j=0; j<CELL; j++)
for (i=0; i<CELL; i++) for (i=0; i<CELL; i++)
if (!(i&j&1)) if (!(i&j&1))
g->drawblob((x*CELL+i), (y*CELL+j), 0x80, 0x80, 0x80); drawblob((x*CELL+i), (y*CELL+j), 0x80, 0x80, 0x80);
} }
} }
else if (bmap[y][x]==WL_WALLELEC) else if (bmap[y][x]==WL_WALLELEC)
@ -495,9 +509,9 @@ void Renderer::DrawWalls()
for (i=0; i<CELL; i++) for (i=0; i<CELL; i++)
{ {
if (!((y*CELL+j)%2) && !((x*CELL+i)%2)) if (!((y*CELL+j)%2) && !((x*CELL+i)%2))
g->drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc)); drawblob((x*CELL+i), (y*CELL+j), PIXR(pc), PIXG(pc), PIXB(pc));
else else
g->drawblob((x*CELL+i), (y*CELL+j), 0x80, 0x80, 0x80); drawblob((x*CELL+i), (y*CELL+j), 0x80, 0x80, 0x80);
} }
} }
else if (bmap[y][x]==WL_EHOLE) else if (bmap[y][x]==WL_EHOLE)
@ -506,7 +520,7 @@ void Renderer::DrawWalls()
{ {
for (j=0; j<CELL; j++) for (j=0; j<CELL; j++)
for (i=0; i<CELL; i++) for (i=0; i<CELL; i++)
g->drawblob((x*CELL+i), (y*CELL+j), 0x24, 0x24, 0x24); drawblob((x*CELL+i), (y*CELL+j), 0x24, 0x24, 0x24);
for (j=0; j<CELL; j+=2) for (j=0; j<CELL; j+=2)
for (i=0; i<CELL; i+=2) for (i=0; i<CELL; i+=2)
vid[(y*CELL+j)*(XRES+BARSIZE)+(x*CELL+i)] = PIXPACK(0x000000); vid[(y*CELL+j)*(XRES+BARSIZE)+(x*CELL+i)] = PIXPACK(0x000000);
@ -515,7 +529,7 @@ void Renderer::DrawWalls()
{ {
for (j=0; j<CELL; j+=2) for (j=0; j<CELL; j+=2)
for (i=0; i<CELL; i+=2) for (i=0; i<CELL; i+=2)
g->drawblob((x*CELL+i), (y*CELL+j), 0x24, 0x24, 0x24); drawblob((x*CELL+i), (y*CELL+j), 0x24, 0x24, 0x24);
} }
} }
} }
@ -535,6 +549,7 @@ void Renderer::DrawWalls()
} }
} }
#endif
} }
void Renderer::get_sign_pos(int i, int *x0, int *y0, int *w, int *h) void Renderer::get_sign_pos(int i, int *x0, int *y0, int *w, int *h)
@ -577,6 +592,10 @@ void Renderer::DrawSigns()
{ {
int i, j, x, y, w, h, dx, dy,mx,my,b=1,bq; int i, j, x, y, w, h, dx, dy,mx,my,b=1,bq;
sign *signs = sim->signs; sign *signs = sim->signs;
#ifdef OGLR
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo);
glTranslated(0, MENUSIZE, 0);
#endif
for (i=0; i<MAXSIGNS; i++) for (i=0; i<MAXSIGNS; i++)
if (signs[i].text[0]) if (signs[i].text[0])
{ {
@ -626,12 +645,20 @@ void Renderer::DrawSigns()
y = signs[i].y; y = signs[i].y;
dx = 1 - signs[i].ju; dx = 1 - signs[i].ju;
dy = (signs[i].y > 18) ? -1 : 1; dy = (signs[i].y > 18) ? -1 : 1;
#ifdef OGLR
glBegin(GL_LINES);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glVertex2i(x, y);
glVertex2i(x+(dx*4), y+(dy*4));
glEnd();
#else
for (j=0; j<4; j++) for (j=0; j<4; j++)
{ {
g->drawpixel(x, y, 192, 192, 192, 255); g->blendpixel(x, y, 192, 192, 192, 255);
x+=dx; x+=dx;
y+=dy; y+=dy;
} }
#endif
/*if (MSIGN==i) /*if (MSIGN==i)
{ {
bq = b; bq = b;
@ -642,10 +669,15 @@ void Renderer::DrawSigns()
signs[i].y = my; signs[i].y = my;
}*/ }*/
} }
#ifdef OGLR
glTranslated(0, -MENUSIZE, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
#endif
} }
void Renderer::render_gravlensing() void Renderer::render_gravlensing()
{ {
#ifndef OGLR
int nx, ny, rx, ry, gx, gy, bx, by, co; int nx, ny, rx, ry, gx, gy, bx, by, co;
int r, g, b; int r, g, b;
pixel t; pixel t;
@ -675,27 +707,15 @@ void Renderer::render_gravlensing()
if (b>255) if (b>255)
b = 255; b = 255;
dst[ny*(XRES+BARSIZE)+nx] = PIXRGB(r,g,b); dst[ny*(XRES+BARSIZE)+nx] = PIXRGB(r,g,b);
// addpixel(dst, nx, ny, PIXR(src[ry*(XRES+BARSIZE)+rx]), PIXG(src[gy*(XRES+BARSIZE)+gx]), PIXB(src[by*(XRES+BARSIZE)+bx]), 255);
} }
/*rx = nx+(gravxf[(ny*XRES)+nx]*0.5f);
ry = ny+(gravyf[(ny*XRES)+nx]*0.5f);
gx = nx+(gravxf[(ny*XRES)+nx]*0.75f);
gy = ny+(gravyf[(ny*XRES)+nx]*0.75f);
bx = nx+(gravxf[(ny*XRES)+nx]);
by = ny+(gravyf[(ny*XRES)+nx]);
if(rx > 0 && rx < XRES && ry > 0 && ry < YRES && gravp[ny/CELL][nx/CELL]*0.5f > -8.0f)
addpixel(dst, rx, ry, PIXR(src[ry*(XRES+BARSIZE)+rx]), 0, 0, 255);
if(gx > 0 && gx < XRES && gy > 0 && gy < YRES && gravp[ny/CELL][nx/CELL]*0.75f > -8.0f)
addpixel(dst, gx, gy, 0, PIXG(src[ry*(XRES+BARSIZE)+rx]), 0, 255);
if(bx > 0 && bx < XRES && by > 0 && by < YRES && gravp[ny/CELL][nx/CELL] > -8.0f)
addpixel(dst, bx, by, 0, 0, PIXB(src[ry*(XRES+BARSIZE)+rx]), 255);*/
} }
} }
#endif
} }
void Renderer::render_fire() void Renderer::render_fire()
{ {
#ifndef OGLR
int i,j,x,y,r,g,b,nx,ny; int i,j,x,y,r,g,b,nx,ny;
for (j=0; j<YRES/CELL; j++) for (j=0; j<YRES/CELL; j++)
for (i=0; i<XRES/CELL; i++) for (i=0; i<XRES/CELL; i++)
@ -725,6 +745,7 @@ void Renderer::render_fire()
fire_g[j][i] = g>4 ? g-4 : 0; fire_g[j][i] = g>4 ? g-4 : 0;
fire_b[j][i] = b>4 ? b-4 : 0; fire_b[j][i] = b>4 ? b-4 : 0;
} }
#endif
} }
float temp[CELL*3][CELL*3]; float temp[CELL*3][CELL*3];
@ -840,6 +861,7 @@ void Renderer::render_parts()
glGetIntegerv(GL_BLEND_DST, &origBlendDst); glGetIntegerv(GL_BLEND_DST, &origBlendDst);
//Render to the particle FBO //Render to the particle FBO
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo);
glTranslated(0, MENUSIZE, 0);
#else #else
/*if (GRID_MODE)//draws the grid /*if (GRID_MODE)//draws the grid
{ {
@ -878,27 +900,6 @@ void Renderer::render_parts()
decg = (sim->parts[i].dcolour>>8)&0xFF; decg = (sim->parts[i].dcolour>>8)&0xFF;
decb = (sim->parts[i].dcolour)&0xFF; decb = (sim->parts[i].dcolour)&0xFF;
/*if(display_mode == RENDER_NONE)
{
if(decorations_enable)
{
colr = (deca*decr + (255-deca)*colr) >> 8;
colg = (deca*decg + (255-deca)*colg) >> 8;
colb = (deca*decb + (255-deca)*colb) >> 8;
}
#ifdef OGLR
flatV[cflatV++] = nx;
flatV[cflatV++] = ny;
flatC[cflatC++] = ((float)colr)/255.0f;
flatC[cflatC++] = ((float)colg)/255.0f;
flatC[cflatC++] = ((float)colb)/255.0f;
flatC[cflatC++] = 1.0f;
cflat++;
#else
vid[ny*(XRES+BARSIZE)+nx] = PIXRGB(colr,colg,colb);
#endif
}
else*/
{ {
if (graphicscache[t].isready) if (graphicscache[t].isready)
{ {
@ -1758,10 +1759,9 @@ void Renderer::render_parts()
glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY);
//Reset FBO //Reset FBO
glTranslated(0, -MENUSIZE, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
//Drawing the FBO onto the screen sounds like a cool idea now
glBlendFunc(origBlendSrc, origBlendDst); glBlendFunc(origBlendSrc, origBlendDst);
#endif #endif
} }
@ -1777,6 +1777,8 @@ void Renderer::draw_other() // EMP effect
if (emp_decor>0) if (emp_decor>0)
{ {
#ifdef OGLR #ifdef OGLR
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo);
glTranslated(0, MENUSIZE, 0);
float femp_decor = ((float)emp_decor)/255.0f; float femp_decor = ((float)emp_decor)/255.0f;
/*int r=emp_decor*2.5, g=100+emp_decor*1.5, b=255; /*int r=emp_decor*2.5, g=100+emp_decor*1.5, b=255;
int a=(1.0*emp_decor/110)*255; int a=(1.0*emp_decor/110)*255;
@ -1791,6 +1793,8 @@ void Renderer::draw_other() // EMP effect
glVertex2f(XRES, YRES+MENUSIZE); glVertex2f(XRES, YRES+MENUSIZE);
glVertex2f(0, YRES+MENUSIZE); glVertex2f(0, YRES+MENUSIZE);
glEnd(); glEnd();
glTranslated(0, -MENUSIZE, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
#else #else
int r=emp_decor*2.5, g=100+emp_decor*1.5, b=255; int r=emp_decor*2.5, g=100+emp_decor*1.5, b=255;
int a=(1.0*emp_decor/110)*255; int a=(1.0*emp_decor/110)*255;
@ -1801,7 +1805,7 @@ void Renderer::draw_other() // EMP effect
for (j=0; j<YRES; j++) for (j=0; j<YRES; j++)
for (i=0; i<XRES; i++) for (i=0; i<XRES; i++)
{ {
this->g->drawpixel(i, j, r, g, b, a); this->g->blendpixel(i, j, r, g, b, a);
} }
#endif #endif
} }
@ -1926,6 +1930,7 @@ void Renderer::draw_air()
glEnable( GL_TEXTURE_2D ); glEnable( GL_TEXTURE_2D );
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo);
glTranslated(0, MENUSIZE, 0);
glUseProgram(airProg); glUseProgram(airProg);
@ -1957,6 +1962,7 @@ void Renderer::draw_air()
glUseProgram(0); glUseProgram(0);
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
glTranslated(0, -MENUSIZE, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glDisable( GL_TEXTURE_2D ); glDisable( GL_TEXTURE_2D );
#endif #endif
@ -1974,14 +1980,27 @@ void Renderer::draw_grav_zones()
for (j=0; j<CELL; j++)//draws the colors for (j=0; j<CELL; j++)//draws the colors
for (i=0; i<CELL; i++) for (i=0; i<CELL; i++)
if(i == j) if(i == j)
g->drawpixel(x*CELL+i, y*CELL+j, 255, 200, 0, 120); g->blendpixel(x*CELL+i, y*CELL+j, 255, 200, 0, 120);
else else
g->drawpixel(x*CELL+i, y*CELL+j, 32, 32, 32, 120); g->blendpixel(x*CELL+i, y*CELL+j, 32, 32, 32, 120);
} }
} }
} }
} }
void Renderer::drawblob(int x, int y, unsigned char cr, unsigned char cg, unsigned char cb)
{
g->blendpixel(x+1, y, cr, cg, cb, 112);
g->blendpixel(x-1, y, cr, cg, cb, 112);
g->blendpixel(x, y+1, cr, cg, cb, 112);
g->blendpixel(x, y-1, cr, cg, cb, 112);
g->blendpixel(x+1, y-1, cr, cg, cb, 64);
g->blendpixel(x-1, y-1, cr, cg, cb, 64);
g->blendpixel(x+1, y+1, cr, cg, cb, 64);
g->blendpixel(x-1, y+1, cr, cg, cb, 64);
}
Renderer::Renderer(Graphics * g, Simulation * sim): Renderer::Renderer(Graphics * g, Simulation * sim):
sim(NULL), sim(NULL),
g(NULL), g(NULL),

1
src/Renderer.h
View File

@ -89,6 +89,7 @@ public:
void loadShaders(); void loadShaders();
#endif #endif
void drawblob(int x, int y, unsigned char cr, unsigned char cg, unsigned char cb);
//... //...
void get_sign_pos(int i, int *x0, int *y0, int *w, int *h); void get_sign_pos(int i, int *x0, int *y0, int *w, int *h);

24
src/cat/LuaScriptInterface.cpp
View File

@ -1444,7 +1444,7 @@ int luatpt_get_property(lua_State* l)
int luatpt_drawpixel(lua_State* l) int luatpt_drawpixel(lua_State* l)
{ {
int x, y, r, g, b, a; /*int x, y, r, g, b, a;
x = luaL_optint(l, 1, 0); x = luaL_optint(l, 1, 0);
y = luaL_optint(l, 2, 0); y = luaL_optint(l, 2, 0);
r = luaL_optint(l, 3, 255); r = luaL_optint(l, 3, 255);
@ -1466,8 +1466,8 @@ int luatpt_drawpixel(lua_State* l)
{ {
luacon_g->drawpixel(x, y, r, g, b, a); luacon_g->drawpixel(x, y, r, g, b, a);
return 0; return 0;
} }*/
return luaL_error(l, "Screen buffer does not exist"); return luaL_error(l, "Deprecated");
} }
int luatpt_drawrect(lua_State* l) int luatpt_drawrect(lua_State* l)
@ -1496,11 +1496,7 @@ int luatpt_drawrect(lua_State* l)
if (b>255) b = 255; if (b>255) b = 255;
if (a<0) a = 0; if (a<0) a = 0;
if (a>255) a = 255; if (a>255) a = 255;
if (luacon_g->vid!=NULL) luacon_g->drawrect(x, y, w, h, r, g, b, a);
{
luacon_g->drawrect(x, y, w, h, r, g, b, a);
return 0;
}
return luaL_error(l, "Screen buffer does not exist"); return luaL_error(l, "Screen buffer does not exist");
} }
@ -1530,11 +1526,7 @@ int luatpt_fillrect(lua_State* l)
if (b>255) b = 255; if (b>255) b = 255;
if (a<0) a = 0; if (a<0) a = 0;
if (a>255) a = 255; if (a>255) a = 255;
if (luacon_g->vid!=NULL) luacon_g->fillrect(x, y, w, h, r, g, b, a);
{
luacon_g->fillrect(x, y, w, h, r, g, b, a);
return 0;
}
return luaL_error(l, "Screen buffer does not exist"); return luaL_error(l, "Screen buffer does not exist");
} }
@ -1559,11 +1551,7 @@ int luatpt_drawline(lua_State* l)
if (b>255) b = 255; if (b>255) b = 255;
if (a<0) a = 0; if (a<0) a = 0;
if (a>255) a = 255; if (a>255) a = 255;
if (luacon_g->vid!=NULL) luacon_g->draw_line(x1, y1, x2, y2, r, g, b, a);
{
luacon_g->blend_line(x1, y1, x2, y2, r, g, b, a);
return 0;
}
return luaL_error(l, "Screen buffer does not exist"); return luaL_error(l, "Screen buffer does not exist");
} }

4
src/console/ConsoleView.cpp
View File

@ -88,8 +88,8 @@ void ConsoleView::OnDraw()
{ {
Graphics * g = ui::Engine::Ref().g; Graphics * g = ui::Engine::Ref().g;
g->fillrect(Position.X, Position.Y, Size.X, Size.Y, 0, 0, 0, 110); g->fillrect(Position.X, Position.Y, Size.X, Size.Y, 0, 0, 0, 110);
g->blend_line(Position.X, Position.Y+Size.Y-16, Position.X+Size.X, Position.Y+Size.Y-16, 255, 255, 255, 160); g->draw_line(Position.X, Position.Y+Size.Y-16, Position.X+Size.X, Position.Y+Size.Y-16, 255, 255, 255, 160);
g->blend_line(Position.X, Position.Y+Size.Y, Position.X+Size.X, Position.Y+Size.Y, 255, 255, 255, 200); g->draw_line(Position.X, Position.Y+Size.Y, Position.X+Size.X, Position.Y+Size.Y, 255, 255, 255, 200);
} }
ConsoleView::~ConsoleView() { ConsoleView::~ConsoleView() {

55
src/game/Brush.h
View File

@ -8,14 +8,16 @@
#ifndef BRUSH_H_ #ifndef BRUSH_H_
#define BRUSH_H_ #define BRUSH_H_
#include <iostream>
#include "interface/Point.h" #include "interface/Point.h"
class Brush class Brush
{ {
protected: protected:
bool * outline; unsigned char * outline;
bool * bitmap; unsigned char * bitmap;
ui::Point size; ui::Point size;
ui::Point radius;
void updateOutline() void updateOutline()
{ {
if(!bitmap) if(!bitmap)
@ -24,35 +26,35 @@ protected:
return; return;
if(outline) if(outline)
free(outline); free(outline);
int width = size.X*2; outline = (unsigned char *)calloc(size.X*size.Y, sizeof(unsigned char));
int height = size.Y*2; for(int x = 0; x < size.X; x++)
outline = (bool *)malloc(sizeof(bool)*((width+1)*(height+1)));
for(int x = 0; x <= width; x++)
{ {
for(int y = 0; y <= height; y++) for(int y = 0; y < size.Y; y++)
{ {
if(bitmap[y*width+x] && (!y || !x || y == height || x == width || !bitmap[y*width+(x+1)] || !bitmap[y*width+(x-1)] || !bitmap[(y-1)*width+x] || !bitmap[(y+1)*width+x])) if(bitmap[y*size.X+x] && (!y || !x || y == size.X-1 || x == size.Y-1 || !bitmap[y*size.X+(x+1)] || !bitmap[y*size.X+(x-1)] || !bitmap[(y-1)*size.X+x] || !bitmap[(y+1)*size.X+x]))
outline[y*width+x] = true; outline[y*size.X+x] = 255;
else else
outline[y*width+x] = false; outline[y*size.X+x] = 0;
} }
} }
} }
public: public:
Brush(ui::Point size_): Brush(ui::Point size_):
bitmap(NULL), bitmap(NULL),
size(size_), outline(NULL),
outline(NULL) radius(0, 0),
size(0, 0)
{ {
SetRadius(size_);
}; };
ui::Point GetRadius() ui::Point GetRadius()
{ {
return size; return radius;
} }
void SetRadius(ui::Point size) void SetRadius(ui::Point radius)
{ {
this->size = size; this->radius = radius;
this->size = radius+radius+ui::Point(1, 1);
GenerateBitmap(); GenerateBitmap();
updateOutline(); updateOutline();
} }
@ -93,37 +95,30 @@ public:
updateOutline(); updateOutline();
if(!outline) if(!outline)
return; return;
for(int x = 0; x <= size.X*2; x++) g->xor_bitmap(outline, position.X-radius.X, position.Y-radius.Y-1, size.X, size.Y);
{
for(int y = 0; y <= size.Y*2; y++)
{
if(outline[y*(size.X*2)+x])
g->xor_pixel(position.X-size.X+x, position.Y-size.Y+y);
}
}
} }
virtual void GenerateBitmap() virtual void GenerateBitmap()
{ {
if(bitmap) if(bitmap)
free(bitmap); free(bitmap);
bitmap = (bool *)malloc(sizeof(bool)*(((size.X*2)+1)*((size.Y*2)+1))); bitmap = (unsigned char *)calloc((size.X*size.Y), sizeof(unsigned char));
for(int x = 0; x <= size.X*2; x++) for(int x = 0; x < size.X; x++)
{ {
for(int y = 0; y <= size.Y*2; y++) for(int y = 0; y < size.Y; y++)
{ {
bitmap[y*(size.X*2)+x] = true; bitmap[(y*size.X)+x] = 255;
} }
} }
} }
//Get a bitmap for drawing particles //Get a bitmap for drawing particles
bool * GetBitmap() unsigned char * GetBitmap()
{ {
if(!bitmap) if(!bitmap)
GenerateBitmap(); GenerateBitmap();
return bitmap; return bitmap;
} }
bool * GetOutline() unsigned char * GetOutline()
{ {
if(!outline) if(!outline)
updateOutline(); updateOutline();

16
src/game/EllipseBrush.h
View File

@ -22,20 +22,20 @@ public:
{ {
if(bitmap) if(bitmap)
free(bitmap); free(bitmap);
bitmap = (bool *)malloc(sizeof(bool)*(((size.X*2)+1)*((size.Y*2)+1))); bitmap = (unsigned char*)calloc((size.X*size.Y), sizeof(unsigned char));
int rx = size.X; int rx = radius.X;
int ry = size.Y; int ry = radius.Y;
for(int x = 0; x <= size.X*2; x++) for(int x = 0; x <= radius.X*2; x++)
{ {
for(int y = 0; y <= size.Y*2; y++) for(int y = 0; y <= radius.Y*2; y++)
{ {
if((pow(x-size.X,2)*pow(ry,2)+pow(y-size.Y,2)*pow(rx,2)<=pow(rx,2)*pow(ry,2))) if((pow(x-radius.X,2)*pow(ry,2)+pow(y-radius.Y,2)*pow(rx,2)<=pow(rx,2)*pow(ry,2)))
{ {
bitmap[y*(size.X*2)+x] = true; bitmap[y*(size.X)+x] = 255;
} }
else else
{ {
bitmap[y*(size.X*2)+x] = false; bitmap[y*(size.X)+x] = 0;
} }
} }
} }

5
src/game/GameController.cpp
View File

@ -580,6 +580,9 @@ void GameController::ReloadSim()
std::string GameController::ElementResolve(int type) std::string GameController::ElementResolve(int type)
{ {
return std::string(gameModel->GetSimulation()->ptypes[type].name); if(gameModel && gameModel->GetSimulation() && gameModel->GetSimulation()->ptypes && type >= 0 && type < PT_NUM)
return std::string(gameModel->GetSimulation()->ptypes[type].name);
else
return "";
} }

6
src/game/GameView.cpp
View File

@ -857,9 +857,8 @@ void GameView::OnDraw()
ren->draw_air(); ren->draw_air();
ren->render_parts(); ren->render_parts();
ren->render_fire(); ren->render_fire();
//ren->draw_grav(); ren->draw_grav();
ren->DrawWalls(); ren->DrawWalls();
ren->FinaliseParts();
if(activeBrush && currentMouse.X > 0 && currentMouse.X < XRES && currentMouse.Y > 0 && currentMouse.Y < YRES) if(activeBrush && currentMouse.X > 0 && currentMouse.X < XRES && currentMouse.Y > 0 && currentMouse.Y < YRES)
{ {
if(drawMode==DrawRect && isMouseDown) if(drawMode==DrawRect && isMouseDown)
@ -875,8 +874,9 @@ void GameView::OnDraw()
activeBrush->RenderPoint(g, c->PointTranslate(currentMouse)); activeBrush->RenderPoint(g, c->PointTranslate(currentMouse));
} }
} }
ren->RenderZoom();
ren->DrawSigns(); ren->DrawSigns();
ren->FinaliseParts();
ren->RenderZoom();
if(selectMode!=SelectNone) if(selectMode!=SelectNone)
{ {

5
src/interface/Engine.cpp
View File

@ -74,7 +74,10 @@ void Engine::ShowWindow(Window * window)
prevBuffers.push(lastBuffer); prevBuffers.push(lastBuffer);
} }
lastBuffer = (pixel*)malloc((width_ * height_) * PIXELSIZE); lastBuffer = (pixel*)malloc((width_ * height_) * PIXELSIZE);
#ifndef OGLR
memcpy(lastBuffer, g->vid, (width_ * height_) * PIXELSIZE); memcpy(lastBuffer, g->vid, (width_ * height_) * PIXELSIZE);
#endif
windows.push(state_); windows.push(state_);
} }
@ -167,7 +170,9 @@ void Engine::Draw()
if(lastBuffer && !(state_->Position.X == 0 && state_->Position.Y == 0 && state_->Size.X == width_ && state_->Size.Y == height_)) if(lastBuffer && !(state_->Position.X == 0 && state_->Position.Y == 0 && state_->Size.X == width_ && state_->Size.Y == height_))
{ {
g->Clear(); g->Clear();
#ifndef OGLR
memcpy(g->vid, lastBuffer, (width_ * height_) * PIXELSIZE); memcpy(g->vid, lastBuffer, (width_ * height_) * PIXELSIZE);
#endif
} }
else else
{ {

12
src/interface/Slider.cpp
View File

@ -16,7 +16,9 @@ Slider::Slider(Point position, Point size, int steps):
sliderSteps(steps), sliderSteps(steps),
sliderPosition(0), sliderPosition(0),
isMouseDown(false), isMouseDown(false),
bgGradient(NULL) bgGradient(NULL),
col1(0, 0, 0, 0),
col2(0, 0, 0, 0)
{ {
// TODO Auto-generated constructor stub // TODO Auto-generated constructor stub
@ -79,6 +81,8 @@ void Slider::SetColour(Colour col1, Colour col2)
{ {
if(bgGradient) if(bgGradient)
free(bgGradient); free(bgGradient);
this->col1 = col1;
this->col2 = col2;
bgGradient = (unsigned char*)Graphics::GenerateGradient( bgGradient = (unsigned char*)Graphics::GenerateGradient(
(pixel[2]){PIXRGB(col1.Red, col1.Green, col1.Blue), PIXRGB(col2.Red, col2.Green, col2.Blue)}, (pixel[2]){PIXRGB(col1.Red, col1.Green, col1.Blue), PIXRGB(col2.Red, col2.Green, col2.Blue)},
(float[2]){0.0f, 1.0f}, 2, Size.X-6); (float[2]){0.0f, 1.0f}, 2, Size.X-6);
@ -100,9 +104,13 @@ void Slider::Draw(const Point& screenPos)
if(bgGradient) if(bgGradient)
{ {
#ifndef OGLR
for (int j = 3; j < Size.Y-6; j++) for (int j = 3; j < Size.Y-6; j++)
for (int i = 3; i < Size.X-6; i++) for (int i = 3; i < Size.X-6; i++)
g->drawpixel(screenPos.X+i+2, screenPos.Y+j+2, bgGradient[(i-3)*3], bgGradient[(i-3)*3+1], bgGradient[(i-3)*3+2], 255); g->blendpixel(screenPos.X+i+2, screenPos.Y+j+2, bgGradient[(i-3)*3], bgGradient[(i-3)*3+1], bgGradient[(i-3)*3+2], 255);
#else
g->gradientrect(screenPos.X+3, screenPos.Y+3, Size.X-6, Size.Y-6, col1.Red, col1.Green, col1.Blue, col1.Alpha, col2.Red, col2.Green, col2.Blue, col2.Alpha);
#endif
} }
g->drawrect(screenPos.X+3, screenPos.Y+3, Size.X-6, Size.Y-6, 255, 255, 255, 255); g->drawrect(screenPos.X+3, screenPos.Y+3, Size.X-6, Size.Y-6, 255, 255, 255, 255);

1
src/interface/Slider.h
View File

@ -26,6 +26,7 @@ class Slider: public ui::Component {
bool isMouseDown; bool isMouseDown;
unsigned char * bgGradient; unsigned char * bgGradient;
SliderAction * actionCallback; SliderAction * actionCallback;
Colour col1, col2;
void updatePosition(int position); void updatePosition(int position);
public: public:
Slider(Point position, Point size, int steps); Slider(Point position, Point size, int steps);

2
src/interface/Spinner.cpp
View File

@ -27,7 +27,7 @@ void Spinner::Draw(const Point& screenPos)
int baseY = screenPos.Y+(Size.Y/2); int baseY = screenPos.Y+(Size.Y/2);
for(float t = 0.0f; t < 1.0f; t+=0.05f) for(float t = 0.0f; t < 1.0f; t+=0.05f)
{ {
g->drawblob(baseX+(sin(cValue+t)*(Size.X/2)), baseY+(cos(cValue+t)*(Size.X/2)), t*255, t*255, t*255); //g->drawblob(baseX+(sin(cValue+t)*(Size.X/2)), baseY+(cos(cValue+t)*(Size.X/2)), t*255, t*255, t*255);
} }
} }
Spinner::~Spinner() Spinner::~Spinner()

14
src/simulation/Simulation.cpp
View File

@ -434,7 +434,7 @@ void Simulation::ApplyDecorationPoint(int x, int y, int rx, int ry, int colR, in
return; return;
} }
bool *bitmap = cBrush->GetBitmap(); unsigned char *bitmap = cBrush->GetBitmap();
for (j=-ry; j<=ry; j++) for (j=-ry; j<=ry; j++)
for (i=-rx; i<=rx; i++) for (i=-rx; i<=rx; i++)
if(bitmap[(j+ry)*(rx*2)+(i+rx)]) if(bitmap[(j+ry)*(rx*2)+(i+rx)])
@ -624,10 +624,10 @@ int Simulation::create_parts(int x, int y, int rx, int ry, int c, int flags, Bru
} }
else if(cBrush) else if(cBrush)
{ {
bool *bitmap = cBrush->GetBitmap(); unsigned char *bitmap = cBrush->GetBitmap();
for (j=-ry; j<=ry; j++) for (j=-ry; j<=ry; j++)
for (i=-rx; i<=rx; i++) for (i=-rx; i<=rx; i++)
if(bitmap[(j+ry)*(rx*2)+(i+rx)]) if(bitmap[(j+ry)*((rx*2)+1)+(i+rx+1)])
delete_part(x+i, y+j, 0); delete_part(x+i, y+j, 0);
} }
else else
@ -647,10 +647,10 @@ int Simulation::create_parts(int x, int y, int rx, int ry, int c, int flags, Bru
} }
else if(cBrush) else if(cBrush)
{ {
bool *bitmap = cBrush->GetBitmap(); unsigned char *bitmap = cBrush->GetBitmap();
for (j=-ry; j<=ry; j++) for (j=-ry; j<=ry; j++)
for (i=-rx; i<=rx; i++) for (i=-rx; i<=rx; i++)
if(bitmap[(j+ry)*(rx*2)+(i+rx)]) if(bitmap[(j+ry)*((rx*2)+1)+(i+rx+1)])
{ {
if ( x+i<0 || y+j<0 || x+i>=XRES || y+j>=YRES) if ( x+i<0 || y+j<0 || x+i>=XRES || y+j>=YRES)
continue; continue;
@ -678,10 +678,10 @@ int Simulation::create_parts(int x, int y, int rx, int ry, int c, int flags, Bru
} }
else if(cBrush) else if(cBrush)
{ {
bool *bitmap = cBrush->GetBitmap(); unsigned char *bitmap = cBrush->GetBitmap();
for (j=-ry; j<=ry; j++) for (j=-ry; j<=ry; j++)
for (i=-rx; i<=rx; i++) for (i=-rx; i<=rx; i++)
if(bitmap[(j+ry)*(rx*2)+(i+rx)]) if(bitmap[(j+ry)*((rx*2)+1)+(i+rx+1)])
if (create_part_add_props(-2, x+i, y+j, c, rx, ry)==-1) if (create_part_add_props(-2, x+i, y+j, c, rx, ry)==-1)
f = 1; f = 1;
} }