instsprite.cpp

跨平台2D引擎

//instSprite.cpp
#ifndef INST_SPRITE_CPP
#define INST_SPRITE_CPP


#include "instSprite.h"


namespace inst
{


CLayerMgr::CLayerMgr()
{
	m_bBkTransparent=False;
	m_pLayers=new SList<ILayer *>;
	m_vp.x=m_vp.y=m_vp.w=m_vp.h=0;
}

void CLayerMgr::AddLayer(ILayer *layer)
{
	if(!layer)return;
	if(!m_pLayers)return;
	for(Int32 i=0;i<m_pLayers->Count();i++)
		if(layer==m_pLayers->Get(i))return;
	m_pLayers->Add(layer);
}

void CLayerMgr::InsertLayer(Int32 index,ILayer *layer)
{
	if(!layer)return;
	if(!m_pLayers)return;
	for(Int32 i=0;i<m_pLayers->Count();i++)
		if(layer==m_pLayers->Get(i))return;
	m_pLayers->Insert(index,layer);
}

void CLayerMgr::RemoveLayer(ILayer *layer)
{
	if(!layer)return;
	if(!m_pLayers)return;
	for(Int32 i=0;i<m_pLayers->Count();i++)
		if(layer==m_pLayers->Get(i))
		{
			m_pLayers->Remove(i);
			return;
		}
}

void CLayerMgr::Render(ISurf *surf,POS vpdestx,POS vpdesty)
{
	if(!m_bBkTransparent)
		surf->FillRect(vpdestx,vpdesty,m_vp.w,m_vp.h,Rgb(0,0,0));
	if(!m_pLayers)return;
	ILayer *tmp=null;
	for(Int32 i=0;i<m_pLayers->Count();i++)
		if(null!=(tmp=m_pLayers->Get(i)))
			tmp->Render(surf,vpdestx,vpdesty,m_vp.x,m_vp.y,m_vp.w,m_vp.h);
}

//////////////////////////////////////////////////////////////

void CTiledLayer::ToStdVector(POS *x,POS *y,Int32 col,Int32 row)
{
	if(m_TileW==0 || m_TileH==0)return;
	if(x!=NULL) *x = (col+row)*((Int32)(m_TileW/2));
	if(y!=NULL) *y = (row-col)*((Int32)(m_TileH/2));
}

void CTiledLayer::ToStdVector(POS *x,POS *y,Float col,Float row)
{
	if(m_TileW==0 || m_TileH==0)return;
	if(x!=NULL) *x = (col+row)*((Int32)(m_TileW/2));
	if(y!=NULL) *y = (row-col)*((Int32)(m_TileH/2));
}

void CTiledLayer::ToTileVector(Int32 *col,Int32 *row,POS x,POS y)
{
	if(m_TileW==0 || m_TileH==0)return;
	if(col!=NULL) *col = x/m_TileW - y/m_TileH;
	if(row!=NULL) *row = x/m_TileW + y/m_TileH;
}

void CTiledLayer::ToTileVector(Float *col,Float *row,POS x,POS y)
{
	if(m_TileW==0 || m_TileH==0)return;
	if(col!=NULL) *col = (Float)x/m_TileW - (Float)y/m_TileH;
	if(row!=NULL) *row = (Float)x/m_TileW + (Float)y/m_TileH;
}

void CTiledLayer::ToStdCoord(POS *x,POS *y,Int32 col,Int32 row)
{
	ToStdVector(x,y,col,row);
	if(y!=NULL) *y+=m_h/2;
}

void CTiledLayer::ToStdCoord(POS *x,POS *y,Float col,Float row)
{
	ToStdVector(x,y,col,row);
	if(y!=NULL) *y+=m_h/2;
}

void CTiledLayer::ToTileCoord(Int32 *col,Int32 *row,POS x,POS y)
{
	ToTileVector(col,row,x,y-m_h/2);
}

void CTiledLayer::ToTileCoord(Float *col,Float *row,POS x,POS y)
{
	ToTileVector(col,row,x,y-m_h/2);
}

CTiledLayer::CTiledLayer(Int32 numcols,Int32 numrows,ISurf *image,POS TileW,POS TileH)
{
	m_x=m_y=0;
	m_bVisible=True;

	m_numCols=numcols;
	m_numRows=numrows;
	m_ppCells=new Int16*[m_numRows];
	for(Int32 i=0;i<m_numRows;i++)
	{
		m_ppCells[i]=new Int16[m_numCols];
		for(Int32 j=0;j<m_numCols;j++)
		{
			m_ppCells[i][j]=0;
		}
	}

	m_pImage=image;

	m_TileW=TileW;
	m_TileH=TileH;

	//这时候m_w,m_h还没有计算，决不可以调用ToStdCoord!
	ToStdVector(&m_w,NULL,m_numCols,m_numRows);
	POS h1,h2;
	ToStdVector(NULL,&h1,m_numCols,0); //h1 < 0
	ToStdVector(NULL,&h2,0,m_numRows); //h2 > 0
	m_h=h2-h1;
}

CTiledLayer::~CTiledLayer()
{
	if(!m_ppCells)return;
	for(Int32 i=0;i<m_numRows;i++)
		SafeDelArray(m_ppCells[i]);
	delete m_ppCells;
}

void CTiledLayer::Render(ISurf *surf,POS vpdestx,POS vpdesty,POS vpx,POS vpy,POS vpw,POS vph)
{
	POS x=0,y=0;
	Int16 CrrtTile=0;

	UInt32 NumRawFramesX=0;
	NumRawFramesX=(int)(m_pImage->GetW() / m_TileW);
	
	for(Int32 row=0;row<m_numRows;row++)
	{
		for(Int32 col=0;col<m_numCols;col++)
		{
			CrrtTile=m_ppCells[row][col];

			UInt32 tmpx=(CrrtTile+1-1) % NumRawFramesX + 1 - 1;
			UInt32 tmpy=(int)((CrrtTile+1-1) / NumRawFramesX) + 1 - 1;

			ToStdCoord(&x,&y,col,row); //从tile坐标系(原点在左侧顶点)转换到(本地)std坐标系(原点在左上角)

			surf->BltRgn(m_x+x-vpx,m_y+y-vpy,vpdestx,vpdesty,vpw,vph,m_pImage,tmpx*m_TileW,tmpy*m_TileH,m_TileW,m_TileH);
		}
	}
}

//////////////////////////////////////////////////////////////

CSprite::CSprite(ISurf *image,POS w,POS h)
{
	m_x=m_y=0;
	m_w=w;
	m_h=h;
	m_offx=m_offy=0;
	m_bVisible=True;
	m_pImage=image;
	m_CollisionRect.x=m_CollisionRect.y=0;
	m_CollisionRect.w=w;
	m_CollisionRect.h=h;
	m_Alpha=255;
	m_bStretch=False;
	m_SrcW=w;
	m_SrcH=h;
	m_pSeq=null;
	m_SeqLen=0;
	m_CrrtFrame=0;
}

UInt32 CSprite::GetRawFrameCount()const
{
	UInt32 NumRawFramesX=0,NumRawFramesY=0;
	if(!m_bStretch)
	{
		NumRawFramesX=(int)(m_pImage->GetW() / m_w);
		NumRawFramesY=(int)(m_pImage->GetH() / m_h);
	}
	else
	{	
		NumRawFramesX=(int)(m_pImage->GetW() / m_SrcW);
		NumRawFramesY=(int)(m_pImage->GetH() / m_SrcH);
	}
	return NumRawFramesX*NumRawFramesY;
}

void CSprite::Render(ISurf *surf,POS vpdestx,POS vpdesty,POS vpx,POS vpy,POS vpw,POS vph)
{
	if(!surf)return;
	if(!m_bVisible)return;
	if(!m_pImage)return;
	//注意:表面的范围是 0 ~ GetW()-1，
	//换言之，下面的GetW()不需要"-1"，因为GetW()就是水平像素的数量。
	UInt32 CrrtRawFrame;
	if(!m_pSeq)
	{
		CrrtRawFrame=m_CrrtFrame;
	}
	else
	{
		if(m_CrrtFrame<0 || m_CrrtFrame>=m_SeqLen)return;
		CrrtRawFrame=m_pSeq[m_CrrtFrame];
	}
	UInt32 NumRawFramesX=0;
	if(!m_bStretch)
		NumRawFramesX=(int)(m_pImage->GetW() / m_w);
	else
		NumRawFramesX=(int)(m_pImage->GetW() / m_SrcW);
	UInt32 tmpx=(CrrtRawFrame+1-1) % NumRawFramesX + 1 - 1;
	UInt32 tmpy=(int)((CrrtRawFrame+1-1) / NumRawFramesX) + 1 - 1;
	if(!m_bStretch)
		surf->BltRgn(m_x-vpx,m_y-vpy,vpdestx,vpdesty,vpw,vph,m_pImage,tmpx*m_w,tmpy*m_h,m_w,m_h,m_Alpha);
	else
		surf->StretchBltRgn(m_x-vpx,m_y-vpy,m_w,m_h,vpdestx,vpdesty,vpw,vph,m_pImage,tmpx*m_SrcW,tmpy*m_SrcH,m_SrcW,m_SrcH,m_Alpha);
}


}// end of namespace inst


#endif