mirror of
https://github.com/vcmi/vcmi.git
synced 2024-12-26 22:57:00 +02:00
349 lines
9.4 KiB
C++
349 lines
9.4 KiB
C++
#include "StdInc.h"
|
|
#include "CCreatureAnimation.h"
|
|
|
|
#include "../../lib/filesystem/CResourceLoader.h"
|
|
#include "../../lib/VCMI_Lib.h"
|
|
#include "../../lib/vcmi_endian.h"
|
|
#include "../gui/SDL_Extensions.h"
|
|
#include "../gui/SDL_Pixels.h"
|
|
|
|
/*
|
|
* CCreatureAnimation.cpp, part of VCMI engine
|
|
*
|
|
* Authors: listed in file AUTHORS in main folder
|
|
*
|
|
* License: GNU General Public License v2.0 or later
|
|
* Full text of license available in license.txt file, in main folder
|
|
*
|
|
*/
|
|
|
|
CCreatureAnim::EAnimType CCreatureAnimation::getType() const
|
|
{
|
|
return type;
|
|
}
|
|
|
|
void CCreatureAnimation::setType(CCreatureAnim::EAnimType type)
|
|
{
|
|
assert(framesInGroup(type) > 0 && "Bad type for void CCreatureAnimation::setType(int type)!");
|
|
this->type = type;
|
|
internalFrame = 0;
|
|
if(type!=-1)
|
|
{
|
|
curFrame = frameGroups[type][0];
|
|
}
|
|
else
|
|
{
|
|
if(curFrame>=frames)
|
|
{
|
|
curFrame = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
CCreatureAnimation::CCreatureAnimation(std::string name) : internalFrame(0), once(false)
|
|
{
|
|
//load main file
|
|
FDef = CResourceHandler::get()->loadData(
|
|
ResourceID(std::string("SPRITES/") + name, EResType::ANIMATION)).first.release();
|
|
|
|
//init anim data
|
|
int i,j, totalInBlock;
|
|
|
|
defName=name;
|
|
i = 0;
|
|
DEFType = read_le_u32(FDef + i); i+=4;
|
|
fullWidth = read_le_u32(FDef + i); i+=4;
|
|
fullHeight = read_le_u32(FDef + i); i+=4;
|
|
i=0xc;
|
|
totalBlocks = read_le_u32(FDef + i); i+=4;
|
|
|
|
i=0x10;
|
|
for (int it=0;it<256;it++)
|
|
{
|
|
palette[it].R = FDef[i++];
|
|
palette[it].G = FDef[i++];
|
|
palette[it].B = FDef[i++];
|
|
palette[it].F = 0;
|
|
}
|
|
i=0x310;
|
|
totalEntries=0;
|
|
for (int z=0; z<totalBlocks; z++)
|
|
{
|
|
std::vector<int> frameIDs;
|
|
int group = read_le_u32(FDef + i); i+=4; //block ID
|
|
totalInBlock = read_le_u32(FDef + i); i+=4;
|
|
for (j=SEntries.size(); j<totalEntries+totalInBlock; j++)
|
|
{
|
|
SEntries.push_back(SEntry());
|
|
SEntries[j].group = group;
|
|
frameIDs.push_back(j);
|
|
}
|
|
/*int unknown2 = read_le_u32(FDef + i);*/ i+=4; //TODO use me
|
|
/*int unknown3 = read_le_u32(FDef + i);*/ i+=4; //TODO use me
|
|
i+=13*totalInBlock; //omitting names
|
|
for (j=0; j<totalInBlock; j++)
|
|
{
|
|
SEntries[totalEntries+j].offset = read_le_u32(FDef + i); i+=4;
|
|
}
|
|
//totalEntries+=totalInBlock;
|
|
for(int hh=0; hh<totalInBlock; ++hh)
|
|
{
|
|
++totalEntries;
|
|
}
|
|
frameGroups[group] = frameIDs;
|
|
}
|
|
|
|
//init vars
|
|
curFrame = 0;
|
|
type = CCreatureAnim::WHOLE_ANIM;
|
|
frames = totalEntries;
|
|
}
|
|
|
|
int CCreatureAnimation::nextFrameMiddle(SDL_Surface *dest, int x, int y, bool attacker, ui8 animCount, bool incrementFrame, bool yellowBorder, bool blueBorder, SDL_Rect * destRect)
|
|
{
|
|
return nextFrame(dest, x-fullWidth/2, y-fullHeight/2, attacker, animCount, incrementFrame, yellowBorder, blueBorder, destRect);
|
|
}
|
|
|
|
void CCreatureAnimation::incrementFrame()
|
|
{
|
|
if(type!=-1) //when a specific part of animation is played
|
|
{
|
|
++internalFrame;
|
|
if(internalFrame == frameGroups[type].size()) //rewind
|
|
{
|
|
internalFrame = 0;
|
|
if(once) //playing animation once - return to standing animation
|
|
{
|
|
type = CCreatureAnim::HOLDING;
|
|
once = false;
|
|
curFrame = frameGroups[2][0];
|
|
}
|
|
else //
|
|
{
|
|
curFrame = frameGroups[type][0];
|
|
}
|
|
}
|
|
curFrame = frameGroups[type][internalFrame];
|
|
}
|
|
else //when whole animation is played
|
|
{
|
|
++curFrame;
|
|
if(curFrame>=frames)
|
|
curFrame = 0;
|
|
}
|
|
}
|
|
|
|
int CCreatureAnimation::getFrame() const
|
|
{
|
|
return curFrame;
|
|
}
|
|
|
|
int CCreatureAnimation::getAnimationFrame() const
|
|
{
|
|
return internalFrame;
|
|
}
|
|
|
|
bool CCreatureAnimation::onFirstFrameInGroup()
|
|
{
|
|
return internalFrame == 0;
|
|
}
|
|
|
|
bool CCreatureAnimation::onLastFrameInGroup()
|
|
{
|
|
if(internalFrame == frameGroups[type].size() - 1)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
void CCreatureAnimation::playOnce( CCreatureAnim::EAnimType type )
|
|
{
|
|
setType(type);
|
|
once = true;
|
|
}
|
|
|
|
|
|
template<int bpp>
|
|
int CCreatureAnimation::nextFrameT(SDL_Surface * dest, int x, int y, bool attacker, ui8 animCount, bool IncrementFrame /*= true*/, bool yellowBorder /*= false*/, bool blueBorder /*= false*/, SDL_Rect * destRect /*= NULL*/)
|
|
{
|
|
//increasing frame number
|
|
int SIndex = curFrame;
|
|
if (IncrementFrame)
|
|
incrementFrame();
|
|
|
|
#if 0
|
|
long SpriteWidth, SpriteHeight, //sprite format
|
|
LeftMargin, RightMargin, TopMargin,BottomMargin,
|
|
i, FullHeight,
|
|
|
|
#endif
|
|
ui8 SegmentType, SegmentLength;
|
|
ui32 i;
|
|
|
|
i = SEntries[SIndex].offset;
|
|
|
|
/*int prSize = read_le_u32(FDef + i);*/ i += 4; //TODO use me
|
|
const ui32 defType2 = read_le_u32(FDef + i); i += 4;
|
|
const ui32 FullWidth = read_le_u32(FDef + i); i += 4;
|
|
const ui32 FullHeight = read_le_u32(FDef + i); i += 4;
|
|
const ui32 SpriteWidth = read_le_u32(FDef + i); i += 4;
|
|
const ui32 SpriteHeight = read_le_u32(FDef + i); i += 4;
|
|
const int LeftMargin = read_le_u32(FDef + i); i += 4;
|
|
const int TopMargin = read_le_u32(FDef + i); i += 4;
|
|
const int RightMargin = FullWidth - SpriteWidth - LeftMargin;
|
|
const int BottomMargin = FullHeight - SpriteHeight - TopMargin;
|
|
|
|
if (defType2 == 1) //as it should be always in creature animations
|
|
{
|
|
const int BaseOffsetor = i;
|
|
int ftcp = 0;
|
|
|
|
if (TopMargin > 0)
|
|
{
|
|
ftcp += FullWidth * TopMargin;
|
|
}
|
|
ui32 *RLEntries = (ui32 *)(FDef + BaseOffsetor);
|
|
|
|
for (int i = 0; i < SpriteHeight; i++)
|
|
{
|
|
int BaseOffset = BaseOffsetor + read_le_u32(RLEntries + i);
|
|
int TotalRowLength; // length of read segment
|
|
|
|
if (LeftMargin > 0)
|
|
{
|
|
ftcp += LeftMargin;
|
|
}
|
|
|
|
TotalRowLength = 0;
|
|
|
|
// Note: Bug fixed (Rev 2115): The implementation of omitting lines was false.
|
|
// We've to calculate several things so not showing/putting pixels should suffice.
|
|
|
|
int yB = ftcp / FullWidth + y;
|
|
|
|
do
|
|
{
|
|
SegmentType = FDef[BaseOffset++];
|
|
SegmentLength = FDef[BaseOffset++];
|
|
|
|
const int remainder = ftcp % FullWidth;
|
|
int xB = (attacker ? remainder : FullWidth - remainder - 1) + x;
|
|
|
|
const ui8 aCountMod = (animCount & 0x20) ? ((animCount & 0x1e) >> 1) << 4 : (0x0f - ((animCount & 0x1e) >> 1)) << 4;
|
|
|
|
for (int k = 0; k <= SegmentLength; k++)
|
|
{
|
|
if(xB >= 0 && xB < dest->w && yB >= 0 && yB < dest->h)
|
|
{
|
|
if(!destRect || (destRect->x <= xB && destRect->x + destRect->w > xB && destRect->y <= yB && destRect->y + destRect->h > yB))
|
|
{
|
|
const ui8 colorNr = SegmentType == 0xff ? FDef[BaseOffset+k] : SegmentType;
|
|
putPixel<bpp>(dest, xB, yB, palette[colorNr], colorNr, yellowBorder, blueBorder, aCountMod);
|
|
}
|
|
}
|
|
ftcp++; //increment pos
|
|
if(attacker)
|
|
xB++;
|
|
else
|
|
xB--;
|
|
if ( SegmentType == 0xFF && TotalRowLength+k+1 >= SpriteWidth )
|
|
break;
|
|
}
|
|
if (SegmentType == 0xFF)
|
|
{
|
|
BaseOffset += SegmentLength+1;
|
|
}
|
|
|
|
TotalRowLength+=SegmentLength+1;
|
|
} while(TotalRowLength < SpriteWidth);
|
|
if (RightMargin > 0)
|
|
{
|
|
ftcp += RightMargin;
|
|
}
|
|
}
|
|
if (BottomMargin > 0)
|
|
{
|
|
ftcp += BottomMargin * FullWidth;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int CCreatureAnimation::nextFrame(SDL_Surface *dest, int x, int y, bool attacker, ui8 animCount, bool IncrementFrame, bool yellowBorder, bool blueBorder, SDL_Rect * destRect)
|
|
{
|
|
switch(dest->format->BytesPerPixel)
|
|
{
|
|
case 2: return nextFrameT<2>(dest, x, y, attacker, animCount, IncrementFrame, yellowBorder, blueBorder, destRect);
|
|
case 3: return nextFrameT<3>(dest, x, y, attacker, animCount, IncrementFrame, yellowBorder, blueBorder, destRect);
|
|
case 4: return nextFrameT<4>(dest, x, y, attacker, animCount, IncrementFrame, yellowBorder, blueBorder, destRect);
|
|
default:
|
|
logGlobal->errorStream() << (int)dest->format->BitsPerPixel << " bpp is not supported!!!";
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
int CCreatureAnimation::framesInGroup(CCreatureAnim::EAnimType group) const
|
|
{
|
|
if(frameGroups.find(group) == frameGroups.end())
|
|
return 0;
|
|
return frameGroups.find(group)->second.size();
|
|
}
|
|
|
|
CCreatureAnimation::~CCreatureAnimation()
|
|
{
|
|
delete [] FDef;
|
|
}
|
|
|
|
template<int bpp>
|
|
inline void CCreatureAnimation::putPixel(
|
|
SDL_Surface * dest,
|
|
const int & ftcpX,
|
|
const int & ftcpY,
|
|
const BMPPalette & color,
|
|
const ui8 & palc,
|
|
const bool & yellowBorder,
|
|
const bool & blueBorder,
|
|
const ui8 & animCount
|
|
) const
|
|
{
|
|
if(palc!=0)
|
|
{
|
|
Uint8 * p = (Uint8*)dest->pixels + ftcpX*dest->format->BytesPerPixel + ftcpY*dest->pitch;
|
|
if(palc > 7) //normal color
|
|
{
|
|
ColorPutter<bpp, 0>::PutColor(p, color.R, color.G, color.B);
|
|
}
|
|
else if((yellowBorder || blueBorder) && (palc == 6 || palc == 7)) //selection highlight
|
|
{
|
|
if(blueBorder)
|
|
ColorPutter<bpp, 0>::PutColor(p, 0, 0x0f + animCount, 0x0f + animCount);
|
|
else
|
|
ColorPutter<bpp, 0>::PutColor(p, 0x0f + animCount, 0x0f + animCount, 0);
|
|
}
|
|
else if (palc == 5) //selection highlight or transparent
|
|
{
|
|
if(blueBorder)
|
|
ColorPutter<bpp, 0>::PutColor(p, color.B, color.G - 0xf0 + animCount, color.R - 0xf0 + animCount); //shouldn't it be reversed? its bgr instead of rgb
|
|
else if (yellowBorder)
|
|
ColorPutter<bpp, 0>::PutColor(p, color.R - 0xf0 + animCount, color.G - 0xf0 + animCount, color.B);
|
|
}
|
|
else //shadow
|
|
{
|
|
//determining transparency value, 255 or 0 should be already filtered
|
|
static Uint16 colToAlpha[8] = {255,192,128,128,128,255,128,192};
|
|
Uint16 alpha = colToAlpha[palc];
|
|
|
|
if(bpp != 3 && bpp != 4)
|
|
{
|
|
ColorPutter<bpp, 0>::PutColor(p, 0, 0, 0, alpha);
|
|
}
|
|
else
|
|
{
|
|
p[0] = (p[0] * alpha)>>8;
|
|
p[1] = (p[1] * alpha)>>8;
|
|
p[2] = (p[2] * alpha)>>8;
|
|
}
|
|
}
|
|
}
|
|
}
|