void setDrawMode (onScreenPerson * thisPerson) {
if (thisPerson->colourmix) {
//glEnable(GL_COLOR_SUM); FIXME: replace line?
setSecondaryColor(curLight[0]*thisPerson->r*thisPerson->colourmix/65025/255.f, curLight[1]*thisPerson->g*thisPerson->colourmix/65025/255.f, curLight[2]*thisPerson->b*thisPerson->colourmix/65025/255.f, 1.0f);
}
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
setPrimaryColor(curLight[0]*(255-thisPerson->colourmix)/65025.f, curLight[1]*(255-thisPerson->colourmix)/65025.f, curLight[2]*(255-thisPerson->colourmix)/65025.f, 1.0f - thisPerson->transparency/255.f);
}
void fontSprite (bool flip, int x, int y, sprite & single, const spritePalette & fontPal) {
float tx1 = (float)(single.tex_x-0.5) / fontPal.tex_w[single.texNum];
float ty1 = 0.0;
float tx2 = (float)(single.tex_x + single.width+(flip ? 1.0 : 0.5)) / fontPal.tex_w[single.texNum];
float ty2 = (float)(single.height+2)/fontPal.tex_h[single.texNum];
float x1 = (float)x - (float)single.xhot/cameraZoom;
float y1 = (float)y - (float)single.yhot/cameraZoom;
float x2 = x1 + (float)single.width/cameraZoom;
float y2 = y1 + (float)single.height/cameraZoom;
GLfloat vertices[] = {
x1, y1, 0.0f,
x2, y1, 0.0f,
x1, y2, 0.0f,
x2, y2, 0.0f
};
if (flip) {
vertices[0] = x2;
vertices[3] = x1;
vertices[6] = x2;
vertices[9] = x1;
}
const GLfloat texCoords[] = {
tx1, ty1,
tx2, ty1,
tx1, ty2,
tx2, ty2
};
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); // GL_MODULATE instead of decal mixes the colours!
setPrimaryColor(fontPal.originalRed/255.f, fontPal.originalGreen/255.f, fontPal.originalBlue/255.f, 1.0f);
glBindTexture (GL_TEXTURE_2D, fontPal.tex_names[single.texNum]);
glUseProgram(shader.smartScaler);
GLuint uniform = glGetUniformLocation(shader.smartScaler, "useLightTexture");
if (uniform >= 0) glUniform1i(uniform, 0);
setPMVMatrix(shader.smartScaler);
if (gameSettings.antiAlias == 1) {
glUniform1i(glGetUniformLocation(shader.smartScaler, "antialias"), 1);
} else {
glUniform1i(glGetUniformLocation(shader.smartScaler, "antialias"), 0);
}
glEnable(GL_BLEND);
drawQuad(shader.smartScaler, vertices, 1, texCoords);
glDisable(GL_BLEND);
glUseProgram(0);
}
void blankScreen (int x1, int y1, int x2, int y2) {
if (y1 < 0) y1 = 0;
if (x1 < 0) x1 = 0;
if (x2 > (int) sceneWidth) x2 = (int)sceneWidth;
if (y2 > (int) sceneHeight) y2 = (int)sceneHeight;
int picWidth = x2-x1;
int picHeight = y2-y1;
setPixelCoords (true);
int xoffset = 0;
while (xoffset < picWidth) {
int w = (picWidth-xoffset < viewportWidth) ? picWidth-xoffset : viewportWidth;
int yoffset = 0;
while (yoffset < picHeight) {
int h = (picHeight-yoffset < viewportHeight) ? picHeight-yoffset : viewportHeight;
// Render the scene
const GLfloat vertices[] = {
-10.325f, -1.325f, 0.0f,
w+1.325f, -1.325f, 0.0f,
-10.325f, h+1.325f, 0.0f,
w+1.325f, h+1.325f, 0.0f
};
glUseProgram(shader.color);
setPMVMatrix(shader.color);
setPrimaryColor(redValue(currentBlankColour)/255.0f, greenValue(currentBlankColour)/255.0f, blueValue(currentBlankColour)/255.0f, 1.0f);
drawQuad(shader.color, vertices, 0);
glUseProgram(0);
// Copy Our ViewPort To The Texture
copyTexSubImage2D(GL_TEXTURE_2D, 0, x1+xoffset, y1+yoffset, viewportOffsetX, viewportOffsetY, w, h, backdropTextureName);
yoffset += viewportHeight;
}
xoffset += viewportWidth;
}
setPixelCoords (false);
}
EnergyMeter::EnergyMeter(const sf::Sprite &overlay, const float &maximumValue)
: value(maximumValue)
, maximumValue(maximumValue)
, orientation(-1)
, overlay(overlay)
, primaryColor(DEFAULT_PRIMARY_COLOR)
, secondaryColor(DEFAULT_SECONDARY_COLOR)
, fillColor(DEFAULT_FILL_COLOR)
{
setVisible(true);
foreground.setSize(
sf::Vector2f(
overlay.getLocalBounds().width,
overlay.getLocalBounds().height
)
);
primaryBackground.setSize(foreground.getSize());
secondaryBackground.setSize(
sf::Vector2f(
2.0f,
foreground.getSize().y
)
);
setFillColor(fillColor);
setPrimaryColor(primaryColor);
setSecondaryColor(secondaryColor);
setPosition(
sf::Vector2i(
static_cast<int>(overlay.getPosition().x),
static_cast<int>(overlay.getPosition().y)
)
);
setOrientation(VERTICAL_ORIENTATION);
updateFill();
}
void ColorSelector::resetColors()
{
setPrimaryColor(sf::Color::White);
setSecondaryColor(sf::Color::Black);
}
void ColorSelector::swapColors()
{
sf::Color primaryColor(getPrimaryColor());
setPrimaryColor(getSecondaryColor());
setSecondaryColor(primaryColor);
}
bool loadHSI (FILE * fp, int x, int y, bool reserve) {
int t1, t2, n;
unsigned short c;
GLubyte * target;
int32_t transCol = reserve ? -1 : 63519;
int picWidth;
int picHeight;
int realPicWidth, realPicHeight;
long file_pointer = ftell (fp);
png_structp png_ptr;
png_infop info_ptr, end_info;
int fileIsPNG = true;
// Is this a PNG file?
char tmp[10];
size_t bytes_read = fread(tmp, 1, 8, fp);
if (bytes_read != 8 && ferror (fp)) {
debugOut("Reading error in loadHSI.\n");
}
if (png_sig_cmp((png_byte *) tmp, 0, 8)) {
// No, it's old-school HSI
fileIsPNG = false;
fseek(fp, file_pointer, SEEK_SET);
picWidth = realPicWidth = get2bytes (fp);
picHeight = realPicHeight = get2bytes (fp);
} else {
// Read the PNG header
png_ptr = png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
return false;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_read_struct(&png_ptr, (png_infopp) NULL, (png_infopp) NULL);
return false;
}
end_info = png_create_info_struct(png_ptr);
if (!end_info) {
png_destroy_read_struct(&png_ptr, &info_ptr, (png_infopp)NULL);
return false;
}
png_init_io(png_ptr, fp); // Tell libpng which file to read
png_set_sig_bytes(png_ptr, 8); // 8 bytes already read
png_read_info(png_ptr, info_ptr);
png_uint_32 width, height;
int bit_depth, color_type, interlace_type, compression_type, filter_method;
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
picWidth = realPicWidth = width;
picHeight = realPicHeight = height;
if (bit_depth < 8) png_set_packing(png_ptr);
png_set_expand(png_ptr);
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA) png_set_gray_to_rgb(png_ptr);
if (bit_depth == 16) png_set_strip_16(png_ptr);
png_set_add_alpha(png_ptr, 0xff, PNG_FILLER_AFTER);
png_read_update_info(png_ptr, info_ptr);
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type, &interlace_type, &compression_type, &filter_method);
//int rowbytes = png_get_rowbytes(png_ptr, info_ptr);
}
GLfloat texCoordW = 1.0;
GLfloat texCoordH = 1.0;
if (! NPOT_textures) {
picWidth = getNextPOT(picWidth);
picHeight = getNextPOT(picHeight);
texCoordW = ((double)realPicWidth) / picWidth;
texCoordH = ((double)realPicHeight) / picHeight;
}
if (reserve) {
if (! resizeBackdrop (realPicWidth, realPicHeight)) return false;
}
if (x == IN_THE_CENTRE) x = (sceneWidth - realPicWidth) >> 1;
if (y == IN_THE_CENTRE) y = (sceneHeight - realPicHeight) >> 1;
if (x < 0 || x + realPicWidth > sceneWidth || y < 0 || y + realPicHeight > sceneHeight) return false;
if (fileIsPNG) {
unsigned char * row_pointers[realPicHeight];
for (int i = 0; i<realPicHeight; i++)
row_pointers[i] = backdropTexture + 4*i*picWidth;
png_read_image(png_ptr, (png_byte **) row_pointers);
png_read_end(png_ptr, NULL);
png_destroy_read_struct(&png_ptr, &info_ptr, &end_info);
} else {
for (t2 = 0; t2 < realPicHeight; t2 ++) {
t1 = 0;
while (t1 < realPicWidth) {
c = (unsigned short) get2bytes (fp);
if (c & 32) {
n = fgetc (fp) + 1;
c -= 32;
} else {
n = 1;
}
while (n --) {
target = backdropTexture + 4*picWidth*t2 + t1*4;
if (c == transCol || c == 2015) {
target[0] = (GLubyte) 0;
target[1] = (GLubyte) 0;
target[2] = (GLubyte) 0;
target[3] = (GLubyte) 0;
} else {
target[0] = (GLubyte) redValue(c);
target[1] = (GLubyte) greenValue(c);
target[2] = (GLubyte) blueValue(c);
target[3] = (GLubyte) 255;
}
t1++;
}
}
}
}
GLuint tmpTex;
glGenTextures (1, &tmpTex);
glBindTexture(GL_TEXTURE_2D, tmpTex);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
if (gameSettings.antiAlias < 0) {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
} else {
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
texImage2D (GL_TEXTURE_2D, 0, GL_RGBA, picWidth, picHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, backdropTexture, tmpTex);
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
float btx1;
float btx2;
float bty1;
float bty2;
if (! NPOT_textures) {
btx1 = backdropTexW * x / sceneWidth;
btx2 = backdropTexW * (x+realPicWidth) / sceneWidth;
bty1 = backdropTexH * y / sceneHeight;
bty2 = backdropTexH * (y+realPicHeight) / sceneHeight;
} else {
btx1 = (float) x / sceneWidth;
btx2 = (float) (x+realPicWidth) / sceneWidth;
bty1 = (float) y / sceneHeight;
bty2 = (float) (y+realPicHeight) / sceneHeight;
}
const GLfloat btexCoords[] = {
btx1, bty1,
btx2, bty1,
btx1, bty2,
btx2, bty2
};
setPixelCoords (true);
int xoffset = 0;
while (xoffset < realPicWidth) {
int w = (realPicWidth-xoffset < viewportWidth) ? realPicWidth-xoffset : viewportWidth;
int yoffset = 0;
while (yoffset < realPicHeight) {
int h = (realPicHeight-yoffset < viewportHeight) ? realPicHeight-yoffset : viewportHeight;
glClear(GL_COLOR_BUFFER_BIT); // Clear The Screen
const GLfloat vertices[] = {
(GLfloat)-xoffset, (GLfloat)-yoffset, 0.,
(GLfloat)realPicWidth-xoffset, (GLfloat)-yoffset, 0.,
(GLfloat)-xoffset, (GLfloat)-yoffset+realPicHeight, 0.,
(GLfloat)realPicWidth-xoffset, (GLfloat)-yoffset+realPicHeight, 0.
};
const GLfloat texCoords[] = {
0.0f, 0.0f,
texCoordW, 0.0f,
0.0f, texCoordH,
texCoordW, texCoordH
};
if (backdropExists) {
// Render the sprite to the backdrop
// (using mulitexturing, so the old backdrop is seen where alpha < 1.0)
glActiveTexture(GL_TEXTURE2);
glBindTexture (GL_TEXTURE_2D, backdropTextureName);
glActiveTexture(GL_TEXTURE0);
glUseProgram(shader.paste);
GLint uniform = glGetUniformLocation(shader.paste, "useLightTexture");
if (uniform >= 0) glUniform1i(uniform, 0); // No lighting
setPMVMatrix(shader.paste);
setPrimaryColor(1.0, 1.0, 1.0, 1.0);
glBindTexture(GL_TEXTURE_2D, tmpTex);
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
drawQuad(shader.paste, vertices, 3, texCoords, NULL, btexCoords);
glUseProgram(0);
} else {
// It's all new - nothing special to be done.
glUseProgram(shader.texture);
setPMVMatrix(shader.texture);
glBindTexture(GL_TEXTURE_2D, tmpTex);
setPrimaryColor(1.0, 0.0, 0.0, 0.0);
drawQuad(shader.texture, vertices, 1, texCoords);
glUseProgram(0);
}
// Copy Our ViewPort To The Texture
copyTexSubImage2D(GL_TEXTURE_2D, 0, x+xoffset, y+yoffset, viewportOffsetX, viewportOffsetY, w, h, backdropTextureName);
yoffset += viewportHeight;
}
xoffset += viewportWidth;
}
deleteTextures(1, &tmpTex);
setPixelCoords (false);
backdropExists = true;
return true;
}
void drawBackDrop () {
setPrimaryColor(1.0, 1.0, 1.0, 1.0);
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glEnable(GL_BLEND);
glUseProgram(shader.smartScaler);
GLuint uniform = glGetUniformLocation(shader.smartScaler, "useLightTexture");
if (uniform >= 0) glUniform1i(uniform, 0);
setPMVMatrix(shader.smartScaler);
if (gameSettings.antiAlias == 1) {
glUniform1i(glGetUniformLocation(shader.smartScaler, "antialias"), 1);
} else {
glUniform1i(glGetUniformLocation(shader.smartScaler, "antialias"), 0);
}
if (parallaxStuff) {
parallaxLayer * ps = parallaxStuff;
while (ps->next) ps = ps->next;
while (ps) {
ps -> cameraX = sortOutPCamera (cameraX, ps -> fractionX, (int)(sceneWidth - (float)winWidth/cameraZoom), (int)(ps -> width - (float)winWidth/cameraZoom));
ps -> cameraY = sortOutPCamera (cameraY, ps -> fractionY, (int)(sceneHeight - (float)winHeight/cameraZoom), (int)(ps -> height - (float)winHeight/cameraZoom));
glBindTexture (GL_TEXTURE_2D, ps->textureName);
float w = (ps->wrapS) ? sceneWidth : ps->width;
float h = (ps->wrapT) ? sceneHeight : ps->height;
float texw;
float texh;
if (! NPOT_textures) {
texw = (ps->wrapS) ? (float) sceneWidth / ps->width: (float) ps->width / getNextPOT(ps->width);
texh = (ps->wrapT) ? (float) sceneHeight / ps->height: (float) ps->height / getNextPOT(ps->height);
} else {
texw = (ps->wrapS) ? (float) sceneWidth / ps->width: 1.0;
texh = (ps->wrapT) ? (float) sceneHeight / ps->height: 1.0;
}
const GLfloat vertices[] = {
(GLfloat)-ps -> cameraX, (GLfloat)-ps -> cameraY, 0.1f,
w -ps -> cameraX, (GLfloat)-ps -> cameraY, 0.1f,
(GLfloat)-ps -> cameraX, h -ps -> cameraY, 0.1f,
w -ps -> cameraX, h -ps -> cameraY, 0.1f
};
const GLfloat texCoords[] = {
0.0f, 0.0f,
texw, 0.0f,
0.0f, texh,
texw, texh
};
drawQuad(shader.smartScaler, vertices, 1, texCoords);
ps = ps -> prev;
}
}
glBindTexture (GL_TEXTURE_2D, backdropTextureName);
const GLfloat backdropTexCoords[] = {
0.0f, 0.0f,
backdropTexW, 0.0f,
0.0f, backdropTexH,
backdropTexW, backdropTexH
};
const GLfloat vertices[] = {
(GLfloat)-cameraX, (GLfloat)-cameraY, 0.,
(GLfloat)sceneWidth- (GLfloat)cameraX, (GLfloat)-cameraY, 0.,
(GLfloat)-cameraX, (GLfloat)sceneHeight- (GLfloat)cameraY, 0.,
(GLfloat)sceneWidth- (GLfloat)cameraX, (GLfloat)sceneHeight- (GLfloat)cameraY, 0.
};
drawQuad(shader.smartScaler, vertices, 1, backdropTexCoords);
glDisable(GL_BLEND);
glUseProgram(0);
}
void darkScreen () {
setPixelCoords (true);
int xoffset = 0;
while (xoffset < sceneWidth) {
int w = (sceneWidth-xoffset < viewportWidth) ? sceneWidth-xoffset : viewportWidth;
int yoffset = 0;
while (yoffset < sceneHeight) {
int h = (sceneHeight-yoffset < viewportHeight) ? sceneHeight-yoffset : viewportHeight;
// Render the scene - first the old backdrop
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBindTexture (GL_TEXTURE_2D, backdropTextureName);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
const GLfloat vertices[] = {
(GLfloat)-xoffset, (GLfloat)-yoffset, 0.,
(GLfloat)sceneWidth-xoffset, (GLfloat)-yoffset, 0.,
(GLfloat)-xoffset, (GLfloat)sceneHeight-yoffset, 0.,
(GLfloat)sceneWidth-xoffset, (GLfloat)sceneHeight-yoffset, 0.
};
const GLfloat texCoords[] = {
0.0f, 0.0f,
backdropTexW, 0.0f,
0.0f, backdropTexH,
backdropTexW, backdropTexH
};
glUseProgram(shader.texture);
setPMVMatrix(shader.texture);
drawQuad(shader.texture, vertices, 1, texCoords);
// Then the darkness
glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
glEnable(GL_BLEND);
glUseProgram(shader.color);
setPMVMatrix(shader.color);
setPrimaryColor(0.0f, 0.0f, 0.0f, 0.5f);
drawQuad(shader.color, vertices, 0);
glUseProgram(0);
glDisable(GL_BLEND);
glColorMask (GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Copy Our ViewPort To The Texture
copyTexSubImage2D(GL_TEXTURE_2D, 0, xoffset, yoffset, viewportOffsetX, viewportOffsetY, w, h, backdropTextureName);
yoffset += h;
glClear(GL_COLOR_BUFFER_BIT);
}
xoffset += w;
}
setPixelCoords (false);
}
void burnSpriteToBackDrop (int x1, int y1, sprite & single, const spritePalette & fontPal) {
float tx1 = (float)(single.tex_x - 0.5) / fontPal.tex_w[single.texNum];
float ty1 = 0.0;
float tx2 = (float)(single.tex_x + single.width + 0.5) / fontPal.tex_w[single.texNum];
float ty2 = (float)(single.height+2)/fontPal.tex_h[single.texNum];
const GLfloat spriteTexCoords[] = {
tx1, ty1,
tx2, ty1,
tx1, ty2,
tx2, ty2
};
x1 -= single.xhot;
y1 -= single.yhot-1;
float bx1 = (float)x1*backdropTexW/sceneWidth;
float by1 = (float)y1*backdropTexH/sceneHeight;
float bx2 = (float)(x1+single.width-1)*backdropTexW/sceneWidth;
float by2 = (float)(y1+single.height-1)*backdropTexH/sceneHeight;
const GLfloat backdropTexCoords[] = {
bx1, by1,
bx2, by1,
bx1, by2,
bx2, by2
};
const GLfloat backdropTexCoords2[] = {
0.0f, 0.0f,
backdropTexW, 0.0f,
0.0f, backdropTexH,
backdropTexW, backdropTexH
};
int diffX = single.width+1;
int diffY = single.height+2;
if (x1 < 0) diffX += x1;
if (y1 < 0) diffY += y1;
if (x1 + diffX > sceneWidth) diffX = sceneWidth - x1;
if (y1 + diffY > sceneHeight) diffY = sceneHeight - y1;
if (diffX < 0) return;
if (diffY < 0) return;
setPixelCoords (true);
setPrimaryColor(currentBurnR/255.f, currentBurnG/255.f, currentBurnB/255.f, 1.0f);
GLfloat xoffset = 0.0f;
while (xoffset < diffX) {
int w = (diffX-xoffset < viewportWidth) ? diffX-xoffset : viewportWidth;
GLfloat yoffset = 0.0f;
while (yoffset < diffY) {
int h = (diffY-yoffset < viewportHeight) ? diffY-yoffset : viewportHeight;
const GLfloat backdropVertices[] = {
-x1-xoffset, -y1+yoffset, 0.0f,
sceneWidth-1.0f-x1-xoffset, -y1+yoffset, 0.0f,
-x1-xoffset, sceneHeight-1.0f-y1+yoffset, 0.0f,
sceneWidth-1.0f-x1-xoffset, sceneHeight-1.0f-y1+yoffset, 0.0f
};
const GLfloat spriteVertices[] = {
-xoffset, -yoffset, 0.0f,
single.width-1-xoffset, -yoffset, 0.0f,
-xoffset, single.height-1-yoffset, 0.0f,
single.width-1-xoffset, single.height-1-yoffset, 0.0f
};
glBindTexture (GL_TEXTURE_2D, backdropTextureName);
glUseProgram(shader.texture);
setPMVMatrix(shader.texture);
drawQuad(shader.texture, backdropVertices, 1, backdropTexCoords2);
glActiveTexture(GL_TEXTURE2);
glBindTexture (GL_TEXTURE_2D, backdropTextureName);
glActiveTexture(GL_TEXTURE0);
glUseProgram(shader.paste);
GLint uniform = glGetUniformLocation(shader.paste, "useLightTexture");
if (uniform >= 0) glUniform1i(uniform, 0); // No lighting
setPMVMatrix(shader.paste);
glBindTexture (GL_TEXTURE_2D, fontPal.burnTex_names[single.texNum]);
//FIXME: Test this some more. Also pasting the backdrop again is not strictly necessary but allows using the paste shader.
drawQuad(shader.paste, spriteVertices, 3, spriteTexCoords, NULL, backdropTexCoords);
glUseProgram(0);
// Copy Our ViewPort To The Texture
copyTexSubImage2D(GL_TEXTURE_2D, 0, (x1<0) ? xoffset : x1+xoffset, (y1<0) ? yoffset: y1+yoffset, viewportOffsetX, viewportOffsetY, w, h, backdropTextureName);
yoffset += viewportHeight;
}
xoffset += viewportWidth;
}
setPixelCoords (false);
}
void pasteSpriteToBackDrop (int x1, int y1, sprite & single, const spritePalette & fontPal) {
float tx1 = (float)(single.tex_x) / fontPal.tex_w[single.texNum];
float ty1 = 0.0;
float tx2 = (float)(single.tex_x + single.width) / fontPal.tex_w[single.texNum];
float ty2 = (float)(single.height)/fontPal.tex_h[single.texNum];
float btx1;
float btx2;
float bty1;
float bty2;
int diffX = single.width;
int diffY = single.height;
x1 -= single.xhot;
y1 -= single.yhot;
if (! NPOT_textures) {
btx1 = backdropTexW * x1 / sceneWidth;
btx2 = backdropTexW * (x1+single.width) / sceneWidth;
bty1 = backdropTexH * y1 / sceneHeight;
bty2 = backdropTexH * (y1+single.height) / sceneHeight;
} else {
btx1 = (float) x1 / sceneWidth;
btx2 = (float) (x1+single.width) / sceneWidth;
bty1 = (float) y1 / sceneHeight;
bty2 = (float) (y1+single.height) / sceneHeight;
}
const GLfloat btexCoords[] = {
btx1, bty1,
btx2, bty1,
btx1, bty2,
btx2, bty2
};
if (x1 < 0) diffX += x1;
if (y1 < 0) diffY += y1;
if (x1 + diffX > sceneWidth) diffX = sceneWidth - x1;
if (y1 + diffY > sceneHeight) diffY = sceneHeight - y1;
if (diffX < 0) return;
if (diffY < 0) return;
setPixelCoords (true);
int xoffset = 0;
while (xoffset < diffX) {
int w = (diffX-xoffset < viewportWidth) ? diffX-xoffset : viewportWidth;
int yoffset = 0;
while (yoffset < diffY) {
int h = (diffY-yoffset < viewportHeight) ? diffY-yoffset : viewportHeight;
// Render the sprite to the backdrop
// (using mulitexturing, so the backdrop is seen where alpha < 1.0)
glActiveTexture(GL_TEXTURE2);
glBindTexture (GL_TEXTURE_2D, backdropTextureName);
glActiveTexture(GL_TEXTURE0);
glUseProgram(shader.paste);
GLint uniform = glGetUniformLocation(shader.paste, "useLightTexture");
if (uniform >= 0) glUniform1i(uniform, 0); // No lighting
setPMVMatrix(shader.paste);
setPrimaryColor(fontPal.originalRed/255.f, fontPal.originalGreen/255.f, fontPal.originalBlue/255.f, 1.0f);
glBindTexture (GL_TEXTURE_2D, fontPal.tex_names[single.texNum]);
//glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
const GLfloat vertices[] = {
(GLfloat)-xoffset, (GLfloat)-yoffset, 0.,
(GLfloat)single.width-xoffset, (GLfloat)-yoffset, 0.,
(GLfloat)-xoffset, (GLfloat)single.height-yoffset, 0.,
(GLfloat)single.width-xoffset, (GLfloat)single.height-yoffset, 0.
};
const GLfloat texCoords[] = {
tx1, ty1,
tx2, ty1,
tx1, ty2,
tx2, ty2
};
drawQuad(shader.paste, vertices, 3, texCoords, NULL, btexCoords);
// Copy Our ViewPort To The Texture
glUseProgram(0);
copyTexSubImage2D(GL_TEXTURE_2D, 0, (int) ((x1<0) ? xoffset: x1+xoffset), (int) ((y1<0) ? yoffset: y1+yoffset), (int) ((x1<0) ?viewportOffsetX-x1:viewportOffsetX), (int) ((y1<0) ?viewportOffsetY-y1:viewportOffsetY), w, h, backdropTextureName);
yoffset += viewportHeight;
}
xoffset += viewportWidth;
}
setPixelCoords (false);
}