render3d.cpp

liu7788414

#include "render3d.h"
#include "..\system\gfx.h"

/*
void CRender3D::RenderModel(int modelid, int* pos, int* rot, int frameid)
{
//	CMatrix44 mat1;
//	GetWorldMat(pos, rot, &mat1);
	
//	m_pG3D->SetMatrix(0, &mat1);
//	if (modelid != 2)
	{
//		m_Models[modelid].SetCurrentFrame(frameid);
//		m_Models[modelid].DrawMesh(m_pG3D);
	}
//	else
//		m_pG3D->DrawBall(rot);
}
*/

extern CGraphics3D *pG3D;
extern unsigned short* pData;
extern CRenderTarget *m_pTarget;

bool CRender3D::LoadModel(char* modelfile, int index)
{
	if(index < 0)
		return true;
	return m_Models[index].LoadMesh(pG3D, modelfile);
}


void CRender3D::ReleaseModel(int id)
{
	if (id<0)
		for (int i=0; i<m_modelCnt; i++)
		{
			m_Models[i].Release();
		}
	else
		m_Models[id].Release();

}

void CRender3D::SetEngine(void)
{
//	m_pEngine = pEngine;
	if( !m_pTarget )
		m_pTarget = new CRenderTarget();
//	m_pG3D = new CGraphics3D();
	m_pG3D = pG3D;
//	SetColorBuffer((unsigned short*)m_pEngine->GetGfx()->GetVideo()->pData);
	SetColorBuffer(pData);
	if (m_pG3D == NULL)
		SYS_ASSERT(-1);
	pG3D->SetRenderTarget(m_pTarget);
}

unsigned short * CRender3D::SetColorBuffer(unsigned short *us)
{
	unsigned short *old = m_pTarget->m_pColorBuffer;
	m_pTarget->m_pColorBuffer = us;
	return old;
}

CRender3D::~CRender3D()
{
	delete m_pTarget;
	m_pTarget = NULL;
	//delete m_pG3D;
	m_pG3D = NULL;
	if (m_modelCnt > 0)
		delete [] m_Models;
}


void CRender3D::UpdateCamera()
{
/*
	CMatrix44 mat;
	mat.LookAt(m_eye, m_lookat, m_up);
	m_pG3D->SetMatrix(1, &mat);
	m_pG3D->SetEye(&m_eye);
*/
}

CRender3D::CRender3D()
{
	m_pTarget = NULL;
}

void CRender3D::EndRender3D()
{
/*
	int i,j;
	for (i=0; i<64; i++)
		for (j=0; j<64; j++)
			m_pG3D->DrawPixel(i, j, i, j);
*/
	//m_pG3D->EasyAntialiasing();

//	DBGPRINTF("Triangles: %d \t Flat: %d \t Alpha: %d", m_pG3D->m_triRendered, m_pG3D->m_flatRendered, m_pG3D->m_alphaRendered);
}

extern DWORD rgbCurrent;
void CRender3D::StartRender3D()
{
	short background;

	byte br = GetRValue(rgbCurrent);
	byte bg = GetGValue(rgbCurrent);
	byte bb = GetBValue(rgbCurrent);

	background = MAKERGB(br, bg, bb);

	unsigned short *p = (unsigned short*)m_pTarget->m_pColorBuffer;
	for( int i=0; i<SCREEN_HEIGHT; i++ )
		for( int j=0; j<SCREEN_WIDTH; j++ )
		{
			*p=background;
			p++;
		}
	//MEMSET(m_pTarget->m_pColorBuffer, 0, SCREEN_WIDTH*SCREEN_HEIGHT*2);
	MEMSET(m_pTarget->m_pZBuffer, 0, SCREEN_WIDTH*SCREEN_HEIGHT*4);
	MEMSET(m_pTarget->m_pMirrorBuffer, 0, SCREEN_WIDTH*SCREEN_HEIGHT*4);
	m_pG3D->m_pixelWritten = 0;
	m_pG3D->m_triRendered = 0;
	m_pG3D->m_flatRendered = 0;
	m_pG3D->m_alphaRendered = 0;
}

void CRender3D::GetWorldMat(int *pos, int *rot, CMatrix44 *pMat)
{
	SYS_ASSERT(pos != NULL);
	pMat->DefTranslate(pos[0], pos[1], pos[2]);
	if (rot != NULL) {
		if (rot[2] != 0) {
			pMat->RotateZ(rot[2]);
		}
		if (rot[1] != 0) {
			pMat->RotateY(rot[1]);
		}
		if (rot[0] != 0) {
			pMat->RotateX(rot[0]);
		}
	}	
}

void CRender3D::GetWorldMat(Vector4s *pos, Vector4s *rot, CMatrix44 *pMat)
{
	SYS_ASSERT (pos != NULL);
	pMat->DefTranslate(pos->x, pos->y, pos->z);
	if (rot != NULL) {
		if (rot->z != 0) {
			pMat->RotateZ(rot->z);
		}
		if (rot->y != 0) {
			pMat->RotateY(rot->y);
		}
		if (rot->x != 0) {
			pMat->RotateX(rot->x);
		}
	}	
}

void CRender3D::RenderModel(int modelid, CMatrix44 *pWorldMat, int frameid, int texid)
{	
	if(modelid < 0 || modelid>=m_modelCnt)
		return;
	CMatrix44 mat;
	if (pWorldMat)
		m_pG3D->SetMatrix(0, pWorldMat);
	else
		m_pG3D->SetMatrix(0, &mat);
	m_Models[modelid].SetCurrentFrame(frameid);
	if (texid == -1)
		m_Models[modelid].DrawMesh(m_pG3D);
	else 
		m_Models[modelid].DrawTexturedMesh(m_pG3D, texid);
}


void CRender3D::DrawBallColorMask(int x, int y, int percentile)
{
	// calculate area ball occupied on screen
	int startx, endx, starty, endy, z;
	int i, j;
	int r, g, b;
	if (x<0)
		x = 0;
	if (x>=SCREEN_WIDTH)
		x = SCREEN_WIDTH-1;
	if (y<0)
		y = 0;
	if (y>=SCREEN_HEIGHT)
		y = SCREEN_HEIGHT-1;
	z = m_pTarget->m_pZBuffer[y*SCREEN_WIDTH+x];
	if (z == 0)
		return;
	int *zbuf = m_pTarget->m_pZBuffer+y*SCREEN_WIDTH;
	startx = x;
	while (startx >=0)
		if (zbuf[startx] == z)
			startx--;
		else
			break;
	endx = x+x-startx;
	while (endx <SCREEN_WIDTH)
		if (zbuf[endx] == z)
			endx++;
		else
			break;
	starty = y-(endx-x);
	while (starty >=0)
		if (m_pTarget->m_pZBuffer[starty*SCREEN_WIDTH+x] == z)
			starty--;
		else
			break;
	endy = y+y-starty;
	while (endy <SCREEN_HEIGHT)
		if (m_pTarget->m_pZBuffer[endy*SCREEN_WIDTH+x] == z)
			endy++;
		else
			break;
	startx = x-(endy-y);
	endx = x+(endy-y);
	starty = y-(endy-y);
	if (startx<0)
		startx = 0;
	if (starty<0)
		starty = 0;
	if (endx >=SCREEN_WIDTH)
		endx = SCREEN_WIDTH-1;
	if (endy >=SCREEN_HEIGHT)
		endy = SCREEN_HEIGHT-1;
	// copy
	zbuf = m_pTarget->m_pZBuffer+starty*SCREEN_WIDTH+startx;
	unsigned short *buf = m_pTarget->m_pColorBuffer+starty*SCREEN_WIDTH+startx;
	for (i=0; i<endy-starty; i++)	{
		for (j=0; j<=endx-startx; j++)
			if (zbuf[j] == z)	{
				r = percentile*RCOLOR(buf[j])>>8;
				g = percentile*GCOLOR(buf[j])>>8;
				b = percentile*BCOLOR(buf[j])>>8;
				buf[j] = MAKERGB(r, g, b);
			}
		buf += SCREEN_WIDTH;
		zbuf += SCREEN_WIDTH;
	}
}