/// This is just a very basic sprite drawing routine. all it uses are screen coords
void c_sprite::draw_screen(int x, int y)
{
	int sheetx = sheetindex % SHEET_OBJECTSWIDE;
	int sheety = sheetindex / SHEET_OBJECTSWIDE;
	if(fileindex == -1)
	{
		if(config.block_count)
			config.drawcount ++;

		al_draw_bitmap_region(IMGObjectSheet, sheetx * spritewidth * spritescale, sheety * spriteheight * spritescale, spritewidth * spritescale, spriteheight * spritescale, x + offset_x, y + offset_y, 0);
	}
	else 
	{
		if(config.block_count)
			config.drawcount ++;

		al_draw_bitmap_region(getImgFile(fileindex), sheetx * spritewidth * spritescale, sheety * spriteheight * spritescale, spritewidth * spritescale, spriteheight * spritescale, x + offset_x, y + (offset_y - WALLHEIGHT * spritescale), 0);
	}
	if(!subsprites.empty())
	{
		for(int i = 0; i < subsprites.size(); i++)
		{
			subsprites[i].draw_screen(x, y);
		}
	}
}
Exemple #2
0
inline ALLEGRO_BITMAP* imageSheet(t_subSprite sprite, ALLEGRO_BITMAP* defaultBmp)
{
    if (sprite.fileIndex == -1) {
        return defaultBmp;
    } else {
        return getImgFile(sprite.fileIndex);
    }
}
Exemple #3
0
inline BITMAP* imageSheet(t_SpriteWithOffset sprite, BITMAP* defaultBmp)
{
    if (sprite.fileIndex == -1)
    {
    	return defaultBmp;
	}
    else
    {
    	return getImgFile(sprite.fileIndex);
	}
}
void
GUIPolygon::drawGL(const GUIVisualizationSettings& s) const {
    Boundary boundary = myShape.getBoxBoundary();
    if (s.scale * MAX2(boundary.getWidth(), boundary.getHeight()) < s.minPolySize) {
        return;
    }
    if (getFill()) {
        if (myShape.size() < 3) {
            return;
        }
    } else {
        if (myShape.size() < 2) {
            return;
        }
    }
    AbstractMutex::ScopedLocker locker(myLock);
    //if (myDisplayList == 0 || (!getFill() && myLineWidth != s.polyExaggeration)) {
    //    storeTesselation(s.polyExaggeration);
    //}
    glPushName(getGlID());
    glPushMatrix();
    glTranslated(0, 0, getLayer());
    // XXX shape should be rotated around its center when initializing the polygon. do we even need this?
    //glRotated(getAngle(), 0, 0, 1);
    GLHelper::setColor(getColor());

    int textureID = -1;
    if (getFill()) {
        const std::string& file = getImgFile();
        if (file != "") {
            textureID = GUITexturesHelper::getTextureID(file);
        }
    }
    // init generation of texture coordinates
    if (textureID >= 0) {
        glEnable(GL_TEXTURE_2D);
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        glDisable(GL_CULL_FACE);
        glDisable(GL_DEPTH_TEST); // without DEPTH_TEST vehicles may be drawn below roads
        glDisable(GL_LIGHTING);
        glDisable(GL_COLOR_MATERIAL);
        glDisable(GL_ALPHA_TEST);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        glBindTexture(GL_TEXTURE_2D, textureID);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        // http://www.gamedev.net/topic/133564-glutesselation-and-texture-mapping/
        glEnable(GL_TEXTURE_GEN_S);
        glEnable(GL_TEXTURE_GEN_T);
        glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
        glTexGenfv(GL_S, GL_OBJECT_PLANE, xPlane);
        glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
        glTexGenfv(GL_T, GL_OBJECT_PLANE, yPlane);
    }
    // recall tesselation
    //glCallList(myDisplayList);
    performTesselation(s.polyExaggeration);
    // de-init generation of texture coordinates
    if (textureID >= 0) {
        glEnable(GL_DEPTH_TEST);
        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_TEXTURE_GEN_S);
        glDisable(GL_TEXTURE_GEN_T);
    }
    glPopMatrix();
    drawName(myShape.getPolygonCenter(), s.scale, s.polyName);
    glPopName();
}
void c_sprite::draw_world_offset(int x, int y, int z, Block * b, int tileoffset, bool chop)
{
	if(defaultsheet == 0) defaultsheet = IMGObjectSheet;
	//sprites can be offset by a random amount, both animationwise, and just variationwise.
	//the base offset is set here.
	int rando = randomCube[(b->x)%RANDOM_CUBE][(b->y)%RANDOM_CUBE][(b->z)%RANDOM_CUBE];
	//and the random offset of the animation frame is set here, provided the sprite iis set to use random animation frames. 
	int offsetAnimFrame = ((randomanimation?rando:0) + currentAnimationFrame) % MAX_ANIMFRAME;
	//the following stuff is only bothered with if the animation frames say it should be drawn. this can be over-ridden
	// by setting animate to 0

	if(sheetindex == 48)
	{
		int spam = 0;
		spam++;
	}

	if ((animframes & (1 << offsetAnimFrame)) || !animate)
	{
		//if set by the xml file, a random offset between 0 and 'variations' is added to the sprite.
		int randoffset = 0;
		if(variations)
			randoffset = rando%variations;

		if(!b)
			return;
		//if the xml says that this is a blood sprite, and offset is set here for proper pooling. this over-rides the random offset.
		if(bloodsprite)
			randoffset = getBloodOffset(b);
		if((water_direction < 0) || (water_direction == get_relative_water_direction(b)))
		{
			if(( //these are all border conditions. this first section is a list of positive conditions. if at least one of the border conditions is met, the tile can be shown.
				(openborders & b->openborders) ||
				(upstairborders & b->upstairborders) ||
				(downstairborders & b->downstairborders) ||
				(rampborders & b->rampborders) ||
				(wallborders & b->wallborders) ||
				(floorborders & b->floorborders) ||
				(lightborders & b->lightborders)
				) && !( //This second block consists of negative conditions. if /any/ of these border conditions are met, the tile will not be drawn
				(notopenborders & b->openborders) ||
				(notupstairborders & b->upstairborders) ||
				(notdownstairborders & b->downstairborders) ||
				(notrampborders & b->rampborders) ||
				(notwallborders & b->wallborders) ||
				(notfloorborders & b->floorborders) ||
				(darkborders & b->lightborders)
				))
			{
				int foo = 0;
				if(
					(
						snowmin <= b->snowlevel &&
						(snowmax == -1 || snowmax >= b->snowlevel)
					) &&
					(
						bloodmin <= b->bloodlevel &&
						(bloodmax == -1 || bloodmax >= b->bloodlevel)
					) &&
					(
						mudmin <= b->mudlevel &&
						(mudmax == -1 || mudmax >= b->mudlevel)
					) &&
					(
						grassmin <= b->grasslevel &&
						(grassmax == -1 || grassmax >= b->grasslevel)
					) &&
					//only bother with this tile if it's in the light, or not.
					(
						(light==LIGHTANY) ||
						(
							(light==LIGHTYES) && b->designation.bits.outside
						)
						||
						(
                            (light==LIGHTNO) && !(b->designation.bits.outside)
						)
					) &&
					(
						(grasstype == -1) || (grasstype == b->grassmat)
					) &&
					(
						(grass_growth == GRASS_GROWTH_ANY) || 
						(
							(grass_growth == GRASS_GROWTH_NORMAL) && 
							(
							(b->tileMaterial == tiletype_material::GRASS_DARK) ||
								(b->tileMaterial == tiletype_material::GRASS_LIGHT)
							)
						) ||
						(
							(grass_growth == GRASS_GROWTH_DRY) &&
							(b->tileMaterial == tiletype_material::GRASS_DRY)
						) ||
						(
							(grass_growth == GRASS_GROWTH_DEAD) &&
							(b->tileMaterial == tiletype_material::GRASS_DEAD)
							)
							)
							)
				{
					int32_t drawx = x;
					int32_t drawy = y;
					int32_t drawz = z; //- ownerSegment->sizez + 1;

					correctBlockForSegmetOffset( drawx, drawy, drawz);
					correctBlockForRotation( drawx, drawy, drawz, b->ownerSegment->rotation);
					int32_t viewx = drawx;
					int32_t viewy = drawy;
					int32_t viewz = drawz;
					pointToScreen((int*)&drawx, (int*)&drawy, drawz);
					drawx -= (TILEWIDTH>>1)*config.scale;

					if(((drawx + spritewidth*config.scale) < 0) || (drawx > al_get_bitmap_width(al_get_target_bitmap())) || ((drawy + spriteheight*config.scale) < 0) || (drawy > al_get_bitmap_height(al_get_target_bitmap())))
						return;

					int sheetx, sheety;
					if(tilelayout == BLOCKTILE)
					{
						sheetx = ((sheetindex+tileoffset+randoffset) % SHEET_OBJECTSWIDE) * spritewidth;
						sheety = ((sheetindex+tileoffset+randoffset) / SHEET_OBJECTSWIDE) * spriteheight;
					}
					else if(tilelayout == RAMPBOTTOMTILE)
					{
						sheetx = SPRITEWIDTH * b->ramp.index;
						sheety = ((TILEHEIGHT + FLOORHEIGHT + SPRITEHEIGHT) * (sheetindex+tileoffset+randoffset))+(TILEHEIGHT + FLOORHEIGHT);
					}
					else if(tilelayout == RAMPTOPTILE)
					{
						sheetx = SPRITEWIDTH * b->ramp.index;
						sheety = (TILEHEIGHT + FLOORHEIGHT + SPRITEHEIGHT) * (sheetindex+tileoffset+randoffset);
					}
					else
					{
						sheetx = ((sheetindex+tileoffset+randoffset) % SHEET_OBJECTSWIDE) * spritewidth;
						sheety = ((sheetindex+tileoffset+randoffset) / SHEET_OBJECTSWIDE) * spriteheight;
					}
					ALLEGRO_COLOR shade_color = get_color(b);
					if(!b->designation.bits.pile && config.fog_of_war && (contentLoader->gameMode.g_mode == GAMEMODE_ADVENTURE))
					{
						shade_color.r *= 0.25f;
						shade_color.g *= 0.25f;
						shade_color.b *= 0.25f;
					}
					if(chop && ( halftile == HALFTILECHOP))
					{
						if(fileindex < 0)
						{
							if(config.block_count)
								config.drawcount ++;
							if(shade_color.a > 0.001f)
								al_draw_tinted_scaled_bitmap(
								defaultsheet, premultiply(shade_color),
								sheetx * spritescale,
								(sheety+WALL_CUTOFF_HEIGHT) * spritescale,
								spritewidth * spritescale,
								(spriteheight-WALL_CUTOFF_HEIGHT) * spritescale,
								drawx + (offset_x + offset_user_x)*config.scale,
								drawy + (offset_user_y + (offset_y - WALLHEIGHT)+WALL_CUTOFF_HEIGHT)*config.scale,
								spritewidth*config.scale,
								(spriteheight-WALL_CUTOFF_HEIGHT)*config.scale,
								0);
						}
						else 
						{
							if(config.block_count)
								config.drawcount ++;

							if(shade_color.a > 0.001f)
								al_draw_tinted_scaled_bitmap(
								getImgFile(fileindex),
								premultiply(shade_color),
								sheetx * spritescale,
								(sheety+WALL_CUTOFF_HEIGHT) * spritescale,
								spritewidth * spritescale,
								(spriteheight-WALL_CUTOFF_HEIGHT) * spritescale,
								drawx + (offset_x + offset_user_x)*config.scale,
								drawy + (offset_user_y + (offset_y - WALLHEIGHT)+WALL_CUTOFF_HEIGHT)*config.scale,
								spritewidth*config.scale,
								(spriteheight-WALL_CUTOFF_HEIGHT)*config.scale,
								0);
						}
						//draw cut-off floor thing
						if(config.block_count)
							config.drawcount ++;

						if(shade_color.a > 0.001f)
							al_draw_scaled_bitmap(IMGObjectSheet, 
							TILEWIDTH * SPRITEFLOOR_CUTOFF, 0,
							SPRITEWIDTH, SPRITEWIDTH, 
							drawx+offset_x, drawy+offset_y-((SPRITEHEIGHT-WALL_CUTOFF_HEIGHT)/2),
							SPRITEWIDTH*config.scale, SPRITEWIDTH*config.scale, 0);
					}
					else if ((chop && (halftile == HALFTILEYES)) || (!chop && (halftile == HALFTILENO)) || (!chop && (halftile == HALFTILECHOP)) || (halftile == HALFTILEBOTH))
					{
						if((isoutline == OUTLINENONE) || ((isoutline == OUTLINERIGHT) && (b->depthBorderNorth)) || ((isoutline == OUTLINELEFT) && (b->depthBorderWest)) || ((isoutline == OUTLINEBOTTOM) && (b->depthBorderDown)))
						{
							if(fileindex < 0)
							{
								if(config.block_count)
									config.drawcount ++;

								if(shade_color.a > 0.001f)
									al_draw_tinted_scaled_bitmap(
									defaultsheet, premultiply(shade_color),
									sheetx * spritescale,
									sheety * spritescale,
									spritewidth * spritescale,
									spriteheight * spritescale,
									drawx + (offset_x + offset_user_x)*config.scale,
									drawy + (offset_user_y + (offset_y - WALLHEIGHT))*config.scale,
									spritewidth*config.scale,
									spriteheight*config.scale,
									0);
							}
							else 
							{
								if(config.block_count)
									config.drawcount ++;

								if(shade_color.a > 0.001f)
									al_draw_tinted_scaled_bitmap(
									getImgFile(fileindex),
									premultiply(shade_color),
									sheetx * spritescale,
									sheety * spritescale,
									spritewidth * spritescale,
									spriteheight * spritescale,
									drawx + (offset_x + offset_user_x)*config.scale,
									drawy + (offset_user_y + (offset_y - WALLHEIGHT))*config.scale,
									spritewidth*config.scale,
									spriteheight*config.scale,
									0);
							}
						}
						if(needoutline)
						{
							//drawy -= (WALLHEIGHT);
							//Northern border
							if(b->depthBorderNorth)
								DrawSpriteFromSheet(281, IMGObjectSheet, al_map_rgb(255,255,255), drawx + (offset_x)*config.scale, drawy + (offset_y)*config.scale, b );

							//Western border
							if(b->depthBorderWest)
								DrawSpriteFromSheet(280, IMGObjectSheet, al_map_rgb(255,255,255), drawx + (offset_x)*config.scale, drawy + (offset_y)*config.scale, b );

							//drawy += (WALLHEIGHT);
						}
					}
					//draw_textf_border(font, al_map_rgb(255,255,255), drawx, drawy, 0, "%d,%d", fileindex, sheetindex);
				}
			}
Exemple #6
0
void
GUIPolygon::drawGL(const GUIVisualizationSettings& s) const {
    if (s.polySize.getExaggeration(s) == 0) {
        return;
    }
    Boundary boundary = myShape.getBoxBoundary();
    if (s.scale * MAX2(boundary.getWidth(), boundary.getHeight()) < s.polySize.minSize) {
        return;
    }
    if (getFill()) {
        if (myShape.size() < 3) {
            return;
        }
    } else {
        if (myShape.size() < 2) {
            return;
        }
    }
    AbstractMutex::ScopedLocker locker(myLock);
    //if (myDisplayList == 0 || (!getFill() && myLineWidth != s.polySize.getExaggeration(s))) {
    //    storeTesselation(s.polySize.getExaggeration(s));
    //}
    glPushName(getGlID());
    glPushMatrix();
    glTranslated(0, 0, getLayer());
    glRotated(-getNaviDegree(), 0, 0, 1);
    GLHelper::setColor(getColor());

    int textureID = -1;
    if (getFill()) {
        const std::string& file = getImgFile();
        if (file != "") {
            textureID = GUITexturesHelper::getTextureID(file, true);
        }
    }
    // init generation of texture coordinates
    if (textureID >= 0) {
        glEnable(GL_TEXTURE_2D);
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
        glDisable(GL_CULL_FACE);
        glDisable(GL_DEPTH_TEST); // without DEPTH_TEST vehicles may be drawn below roads
        glDisable(GL_LIGHTING);
        glDisable(GL_COLOR_MATERIAL);
        glDisable(GL_ALPHA_TEST);
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        glBindTexture(GL_TEXTURE_2D, textureID);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
        // http://www.gamedev.net/topic/133564-glutesselation-and-texture-mapping/
        glEnable(GL_TEXTURE_GEN_S);
        glEnable(GL_TEXTURE_GEN_T);
        glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
        glTexGenfv(GL_S, GL_OBJECT_PLANE, xPlane);
        glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_OBJECT_LINEAR);
        glTexGenfv(GL_T, GL_OBJECT_PLANE, yPlane);
    }
    // recall tesselation
    //glCallList(myDisplayList);
    performTesselation(myLineWidth * s.polySize.getExaggeration(s));
    // de-init generation of texture coordinates
    if (textureID >= 0) {
        glEnable(GL_DEPTH_TEST);
        glBindTexture(GL_TEXTURE_2D, 0);
        glDisable(GL_TEXTURE_2D);
        glDisable(GL_TEXTURE_GEN_S);
        glDisable(GL_TEXTURE_GEN_T);
    }
#ifdef GUIPolygon_DEBUG_DRAW_VERTICES
    GLHelper::debugVertices(myShape, 80 / s.scale);
#endif
    glPopMatrix();
    const Position namePos = myShape.getPolygonCenter();
    drawName(namePos, s.scale, s.polyName);
    if (s.polyType.show) {
        GLHelper::drawText(myType, namePos + Position(0, -0.6 * s.polyType.size / s.scale),
                           GLO_MAX, s.polyType.size / s.scale, s.polyType.color);
    }
    glPopName();
}