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
};
//"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
{
public:
SDL_Surface * sdl_scrn;
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);
//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 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(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);
//void render_gravlensing(pixel *src, pixel * dst);
//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);
//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 pixel *render_packed_rgb(void *image, int width, int height, int cmp_size);
//Font/text metrics
static int textnwidth(char *s, int n);
static void textnpos(char *s, int n, int w, int *cx, int *cy);
static int textwidthx(char *s, int w);
static int textposxy(char *s, int width, int w, int h);
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_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 Blit();
void AttachSDLSurface(SDL_Surface * surface);
#ifdef OGLR
void clearScreen(float alpha);
void ogl_blit(int x, int y, int w, int h, pixel *src, int pitch, int scale);
#endif
void Blit();
//
int drawtext(int x, int y, const char *s, 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 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();
#ifdef OGLR
GLuint vidBuf;
#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);
glBegin(GL_QUADS);
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);
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);
glVertex3f(0, MENUSIZE*sdl_scale, 1.0);
//glVertex3f(0, MENUSIZE*sdl_scale, 1.0);
glVertex3f(0, 0, 1.0);
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();
if(display_mode & DISPLAY_WARP)
{
glUseProgram(0);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable( GL_TEXTURE_2D );
#endif
}
@ -238,11 +243,12 @@ void Renderer::RenderZoom()
float zcx1, zcx0, zcy1, zcy0, yfactor, xfactor, i; //X-Factor is shit, btw
xfactor = 1.0f/(float)XRES;
yfactor = 1.0f/(float)YRES;
yfactor*=-1.0f;
zcx0 = (zoomScopePosition.X)*xfactor;
zcx1 = (zoomScopePosition.X+zoomScopeSize)*xfactor;
zcy0 = (zoomScopePosition.Y)*yfactor;
zcy1 = ((zoomScopePosition.Y+zoomScopeSize))*yfactor;
zcx1 = (zoomScopePosition.X)*xfactor;
zcx0 = (zoomScopePosition.X+zoomScopeSize)*xfactor;
zcy1 = (zoomScopePosition.Y)*yfactor;
zcy0 = ((zoomScopePosition.Y+zoomScopeSize))*yfactor;
glGetIntegerv(GL_BLEND_SRC, &origBlendSrc);
glGetIntegerv(GL_BLEND_DST, &origBlendDst);
@ -252,46 +258,49 @@ void Renderer::RenderZoom()
//glReadBuffer(GL_AUX0);
glBindTexture(GL_TEXTURE_2D, partsFboTex);
//Draw zoomed texture
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_QUADS);
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);
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);
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);
glVertex3f((zoomWindowPosition.X+zoomScopeSize*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale, 1.0);
glVertex2i(zoomWindowPosition.X, zoomWindowPosition.Y+(zoomScopeSize*ZFACTOR));
glEnd();
glBindTexture(GL_TEXTURE_2D, 0);
glDisable( GL_TEXTURE_2D );
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//Lines to make the pixels stand out
glLineWidth(sdl_scale);
glEnable(GL_LINE_SMOOTH);
//glEnable(GL_LINE_SMOOTH);
glBegin(GL_LINES);
glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
for(i = 0; i < zoomScopeSize; i++)
{
glVertex2f((zoomWindowPosition.X+zoomScopeSize*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR)+i*ZFACTOR)*sdl_scale);
glVertex2f(zoomWindowPosition.X*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR)+i*ZFACTOR)*sdl_scale);
glVertex2f((zoomWindowPosition.X+i*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR))*sdl_scale);
glVertex2f((zoomWindowPosition.X+i*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale);
//Across
glVertex2i(zoomWindowPosition.X, zoomWindowPosition.Y+(i*ZFACTOR));
glVertex2i(zoomWindowPosition.X+(zoomScopeSize*ZFACTOR), zoomWindowPosition.Y+(i*ZFACTOR));
//Down
glVertex2i(zoomWindowPosition.X+(i*ZFACTOR), zoomWindowPosition.Y);
glVertex2i(zoomWindowPosition.X+(i*ZFACTOR), zoomWindowPosition.Y+(zoomScopeSize*ZFACTOR));
}
glEnd();
//Draw zoom window border
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_LINE_STRIP);
glVertex3i((zoomWindowPosition.X-1)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale, 0);
glVertex3i((zoomWindowPosition.X-1)*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR))*sdl_scale, 0);
glVertex3i((zoomWindowPosition.X+zoomScopeSize*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-(zoomWindowPosition.Y+zoomScopeSize*ZFACTOR))*sdl_scale, 0);
glVertex3i((zoomWindowPosition.X+zoomScopeSize*ZFACTOR)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale, 0);
glVertex3i((zoomWindowPosition.X-1)*sdl_scale, (YRES+MENUSIZE-zoomWindowPosition.Y)*sdl_scale, 0);
glBegin(GL_LINE_LOOP);
glVertex2i(zoomWindowPosition.X, zoomWindowPosition.Y);
glVertex2i(zoomWindowPosition.X+(zoomScopeSize*ZFACTOR), zoomWindowPosition.Y);
glVertex2i(zoomWindowPosition.X+(zoomScopeSize*ZFACTOR), zoomWindowPosition.Y+(zoomScopeSize*ZFACTOR));
glVertex2i(zoomWindowPosition.X, zoomWindowPosition.Y+(zoomScopeSize*ZFACTOR));
glEnd();
glDisable(GL_LINE_SMOOTH);
glDisable(GL_LINE_SMOOTH);
//glDisable(GL_LINE_SMOOTH);
if(zoomEnabled)
{
@ -299,12 +308,16 @@ void Renderer::RenderZoom()
//glEnable(GL_LINE_SMOOTH);
glLogicOp(GL_XOR);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
glBegin(GL_LINE_STRIP);
glVertex3i((zoomScopePosition.X-1)*sdl_scale, (YRES+MENUSIZE-(zoomScopePosition.Y-1))*sdl_scale, 0);
glBegin(GL_LINE_LOOP);
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+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-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();
glDisable(GL_COLOR_LOGIC_OP);
}
@ -343,6 +356,7 @@ void Renderer::RenderZoom()
void Renderer::DrawWalls()
{
#ifndef OGLR
int x, y, i, j, cr, cg, cb;
unsigned char wt;
pixel pc;
@ -447,30 +461,30 @@ void Renderer::DrawWalls()
{
for (j=0; j<CELL; j+=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)
{
for (j=0; j<CELL; j+=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)
{
for (j=0; j<CELL; j++)
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)
{
for (j=0; j<CELL; j++)
for (i=0; i<CELL; i++)
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))
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
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)
{
@ -479,14 +493,14 @@ void Renderer::DrawWalls()
for (j=0; j<CELL; j++)
for (i=0; i<CELL; i++)
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
{
for (j=0; j<CELL; j++)
for (i=0; i<CELL; i++)
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)
@ -495,9 +509,9 @@ void Renderer::DrawWalls()
for (i=0; i<CELL; i++)
{
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
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)
@ -506,7 +520,7 @@ void Renderer::DrawWalls()
{
for (j=0; j<CELL; j++)
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 (i=0; i<CELL; i+=2)
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 (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)
@ -577,6 +592,10 @@ void Renderer::DrawSigns()
{
int i, j, x, y, w, h, dx, dy,mx,my,b=1,bq;
sign *signs = sim->signs;
#ifdef OGLR
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo);
glTranslated(0, MENUSIZE, 0);
#endif
for (i=0; i<MAXSIGNS; i++)
if (signs[i].text[0])
{
@ -626,12 +645,20 @@ void Renderer::DrawSigns()
y = signs[i].y;
dx = 1 - signs[i].ju;
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++)
{
g->drawpixel(x, y, 192, 192, 192, 255);
g->blendpixel(x, y, 192, 192, 192, 255);
x+=dx;
y+=dy;
}
#endif
/*if (MSIGN==i)
{
bq = b;
@ -642,10 +669,15 @@ void Renderer::DrawSigns()
signs[i].y = my;
}*/
}
#ifdef OGLR
glTranslated(0, -MENUSIZE, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
#endif
}
void Renderer::render_gravlensing()
{
#ifndef OGLR
int nx, ny, rx, ry, gx, gy, bx, by, co;
int r, g, b;
pixel t;
@ -675,27 +707,15 @@ void Renderer::render_gravlensing()
if (b>255)
b = 255;
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()
{
#ifndef OGLR
int i,j,x,y,r,g,b,nx,ny;
for (j=0; j<YRES/CELL; j++)
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_b[j][i] = b>4 ? b-4 : 0;
}
#endif
}
float temp[CELL*3][CELL*3];
@ -840,6 +861,7 @@ void Renderer::render_parts()
glGetIntegerv(GL_BLEND_DST, &origBlendDst);
//Render to the particle FBO
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo);
glTranslated(0, MENUSIZE, 0);
#else
/*if (GRID_MODE)//draws the grid
{
@ -878,27 +900,6 @@ void Renderer::render_parts()
decg = (sim->parts[i].dcolour>>8)&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)
{
@ -1758,10 +1759,9 @@ void Renderer::render_parts()
glDisableClientState(GL_VERTEX_ARRAY);
//Reset FBO
glTranslated(0, -MENUSIZE, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
//Drawing the FBO onto the screen sounds like a cool idea now
glBlendFunc(origBlendSrc, origBlendDst);
#endif
}
@ -1777,6 +1777,8 @@ void Renderer::draw_other() // EMP effect
if (emp_decor>0)
{
#ifdef OGLR
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo);
glTranslated(0, MENUSIZE, 0);
float femp_decor = ((float)emp_decor)/255.0f;
/*int r=emp_decor*2.5, g=100+emp_decor*1.5, b=255;
int a=(1.0*emp_decor/110)*255;
@ -1791,6 +1793,8 @@ void Renderer::draw_other() // EMP effect
glVertex2f(XRES, YRES+MENUSIZE);
glVertex2f(0, YRES+MENUSIZE);
glEnd();
glTranslated(0, -MENUSIZE, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
#else
int r=emp_decor*2.5, g=100+emp_decor*1.5, b=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 (i=0; i<XRES; i++)
{
this->g->drawpixel(i, j, r, g, b, a);
this->g->blendpixel(i, j, r, g, b, a);
}
#endif
}
@ -1926,6 +1930,7 @@ void Renderer::draw_air()
glEnable( GL_TEXTURE_2D );
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, partsFbo);
glTranslated(0, MENUSIZE, 0);
glUseProgram(airProg);
@ -1957,6 +1962,7 @@ void Renderer::draw_air()
glUseProgram(0);
glBindTexture(GL_TEXTURE_2D, 0);
glTranslated(0, -MENUSIZE, 0);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glDisable( GL_TEXTURE_2D );
#endif
@ -1974,14 +1980,27 @@ void Renderer::draw_grav_zones()
for (j=0; j<CELL; j++)//draws the colors
for (i=0; i<CELL; i++)
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
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):
sim(NULL),
g(NULL),

1
src/Renderer.h
View File

@ -89,6 +89,7 @@ public:
void loadShaders();
#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);

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 x, y, r, g, b, a;
/*int x, y, r, g, b, a;
x = luaL_optint(l, 1, 0);
y = luaL_optint(l, 2, 0);
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);
return 0;
}
return luaL_error(l, "Screen buffer does not exist");
}*/
return luaL_error(l, "Deprecated");
}
int luatpt_drawrect(lua_State* l)
@ -1496,11 +1496,7 @@ int luatpt_drawrect(lua_State* l)
if (b>255) b = 255;
if (a<0) a = 0;
if (a>255) a = 255;
if (luacon_g->vid!=NULL)
{
luacon_g->drawrect(x, y, w, h, r, g, b, a);
return 0;
}
luacon_g->drawrect(x, y, w, h, r, g, b, a);
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 (a<0) a = 0;
if (a>255) a = 255;
if (luacon_g->vid!=NULL)
{
luacon_g->fillrect(x, y, w, h, r, g, b, a);
return 0;
}
luacon_g->fillrect(x, y, w, h, r, g, b, a);
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 (a<0) a = 0;
if (a>255) a = 255;
if (luacon_g->vid!=NULL)
{
luacon_g->blend_line(x1, y1, x2, y2, r, g, b, a);
return 0;
}
luacon_g->draw_line(x1, y1, x2, y2, r, g, b, a);
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;
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->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-16, Position.X+Size.X, Position.Y+Size.Y-16, 255, 255, 255, 160);
g->draw_line(Position.X, Position.Y+Size.Y, Position.X+Size.X, Position.Y+Size.Y, 255, 255, 255, 200);
}
ConsoleView::~ConsoleView() {

55
src/game/Brush.h
View File

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

16
src/game/EllipseBrush.h
View File

@ -22,20 +22,20 @@ public:
{
if(bitmap)
free(bitmap);
bitmap = (bool *)malloc(sizeof(bool)*(((size.X*2)+1)*((size.Y*2)+1)));
int rx = size.X;
int ry = size.Y;
for(int x = 0; x <= size.X*2; x++)
bitmap = (unsigned char*)calloc((size.X*size.Y), sizeof(unsigned char));
int rx = radius.X;
int ry = radius.Y;
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
{
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)
{
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->render_parts();
ren->render_fire();
//ren->draw_grav();
ren->draw_grav();
ren->DrawWalls();
ren->FinaliseParts();
if(activeBrush && currentMouse.X > 0 && currentMouse.X < XRES && currentMouse.Y > 0 && currentMouse.Y < YRES)
{
if(drawMode==DrawRect && isMouseDown)
@ -875,8 +874,9 @@ void GameView::OnDraw()
activeBrush->RenderPoint(g, c->PointTranslate(currentMouse));
}
}
ren->RenderZoom();
ren->DrawSigns();
ren->FinaliseParts();
ren->RenderZoom();
if(selectMode!=SelectNone)
{

5
src/interface/Engine.cpp
View File

@ -74,7 +74,10 @@ void Engine::ShowWindow(Window * window)
prevBuffers.push(lastBuffer);
}
lastBuffer = (pixel*)malloc((width_ * height_) * PIXELSIZE);
#ifndef OGLR
memcpy(lastBuffer, g->vid, (width_ * height_) * PIXELSIZE);
#endif
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_))
{
g->Clear();
#ifndef OGLR
memcpy(g->vid, lastBuffer, (width_ * height_) * PIXELSIZE);
#endif
}
else
{

12
src/interface/Slider.cpp
View File

@ -16,7 +16,9 @@ Slider::Slider(Point position, Point size, int steps):
sliderSteps(steps),
sliderPosition(0),
isMouseDown(false),
bgGradient(NULL)
bgGradient(NULL),
col1(0, 0, 0, 0),
col2(0, 0, 0, 0)
{
// TODO Auto-generated constructor stub
@ -79,6 +81,8 @@ void Slider::SetColour(Colour col1, Colour col2)
{
if(bgGradient)
free(bgGradient);
this->col1 = col1;
this->col2 = col2;
bgGradient = (unsigned char*)Graphics::GenerateGradient(
(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);
@ -100,9 +104,13 @@ void Slider::Draw(const Point& screenPos)
if(bgGradient)
{
#ifndef OGLR
for (int j = 3; j < Size.Y-6; j++)
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);

1
src/interface/Slider.h
View File

@ -26,6 +26,7 @@ class Slider: public ui::Component {
bool isMouseDown;
unsigned char * bgGradient;
SliderAction * actionCallback;
Colour col1, col2;
void updatePosition(int position);
public:
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);
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()

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;
}
bool *bitmap = cBrush->GetBitmap();
unsigned char *bitmap = cBrush->GetBitmap();
for (j=-ry; j<=ry; j++)
for (i=-rx; i<=rx; i++)
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)
{
bool *bitmap = cBrush->GetBitmap();
unsigned char *bitmap = cBrush->GetBitmap();
for (j=-ry; j<=ry; j++)
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);
}
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)
{
bool *bitmap = cBrush->GetBitmap();
unsigned char *bitmap = cBrush->GetBitmap();
for (j=-ry; j<=ry; j++)
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)
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)
{
bool *bitmap = cBrush->GetBitmap();
unsigned char *bitmap = cBrush->GetBitmap();
for (j=-ry; j<=ry; j++)
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)
f = 1;
}