void sq_dorender() const
{
vd->setMaterial(mat);
vd->setTransform(ETS_WORLD, core::IdentityMatrix);
vd->setTransform(ETS_VIEW, core::IdentityMatrix);
vd->setTransform(ETS_PROJECTION, core::IdentityMatrix);
vd->drawVertexPrimitiveList(vertices, 4, indices, 2, EVT_STANDARD,
scene::EPT_TRIANGLE_STRIP);
}
void RTSCamera::render()
{
IVideoDriver* driver = SceneManager->getVideoDriver();
if ( driver)
{
driver->setTransform(video::ETS_PROJECTION, ViewArea.getTransform ( video::ETS_PROJECTION) );
driver->setTransform(video::ETS_VIEW, ViewArea.getTransform ( video::ETS_VIEW) );
}
}
// ----------------------------------------------------------------------------
void Terrain::render()
{
if (!m_visible) return;
IVideoDriver* driver = SceneManager->getVideoDriver();
driver->setMaterial(m_material);
driver->setTransform(video::ETS_WORLD, IdentityMatrix);
driver->drawVertexPrimitiveList(&m_mesh.vertices[0], m_mesh.vertex_count,
&m_mesh.indices[0], m_mesh.quad_count * 2,
video::EVT_2TCOORDS, EPT_TRIANGLES,
video::EIT_16BIT);
if (m_highlight_mesh.vertices && m_highlight_visible)
{
driver->setMaterial(m_highlight_material);
driver->drawVertexPrimitiveList(&m_highlight_mesh.vertices[0],
m_highlight_mesh.vertex_count,
&m_highlight_mesh.indices[0],
m_highlight_mesh.quad_count * 2,
video::EVT_2TCOORDS, EPT_TRIANGLES,
video::EIT_16BIT);
}
} // render
void Sprite::render()
{
IVideoDriver* driver = SceneManager->getVideoDriver();
driver->setMaterial(Material);
driver->setTransform(ETS_WORLD, AbsoluteTransformation);
driver->drawIndexedTriangleList(&Vertices[0], 4, &Indices[0], 4);
}
//! render
void CLightSceneNode::render()
{
IVideoDriver* driver = SceneManager->getVideoDriver();
if (!driver)
return;
if (DebugDataVisible & EDS_BBOX)
{
driver->setTransform(ETS_WORLD, AbsoluteTransformation);
SMaterial m;
m.Lighting = false;
driver->setMaterial(m);
switch (LightData.Type)
{
case ELT_POINT:
case ELT_SPOT:
driver->draw3DBox(BBox, LightData.DiffuseColor);
break;
case ELT_DIRECTIONAL:
driver->draw3DLine(Vector3(0.f, 0.f, 0.f),
LightData.Direction * LightData.Radius,
LightData.DiffuseColor);
break;
default:
break;
}
}
DriverLightIndex = driver->addDynamicLight(LightData);
setVisible(LightIsOn);
}
virtual void render()
{
IVideoDriver* driver = SceneManager->getVideoDriver();
driver->setMaterial(Material);
driver->setTransform(ETS_WORLD, AbsoluteTransformation);
driver->drawIndexedTriangleList(VertexBuffer, IndexBuffer, Descriptor, 4);
}
void DecalSceneNode::render()
{
u16 indices[] = { 0,1,2, 0,2,3};
IVideoDriver* driver = SceneManager->getVideoDriver();
driver->setMaterial(Material);
driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
driver->drawIndexedTriangleList(&Vertices[0], 4, &indices[0], 2);
}
virtual void render()
{
u16 indices[] = { 0,1,3, 3,1,2, 1,0,2, 2,0,3 };
IVideoDriver* driver = SceneManager->getVideoDriver();
driver->setMaterial(Material);
driver->setTransform(ETS_WORLD, AbsoluteTransformation);
driver->drawIndexedTriangleList(&Vertices[0], 4, &indices[0], 4);
}
void CSampleSceneNode::render()
{
u16 indices[] = { 0,2,3, 2,1,3, 1,0,3, 2,0,1 };
IVideoDriver* driver = SceneManager->getVideoDriver();
driver->setMaterial(Material);
driver->setTransform(ETS_WORLD, AbsoluteTransformation);
driver->drawVertexPrimitiveList(&Vertices[0], 4, &indices[0], 4, EVT_STANDARD, EPT_TRIANGLES, EIT_16BIT);
}
void WorldState::OnReload(GameGraph* game)
{
IVideoDriver* driver = game->GetVideoDriver();
ResourceManager* resourceManager = game->GetResourceManager();
ISceneManager* sceneManager = game->GetSceneManager();
if (!heroSet->RegisterTextures(driver, resourceManager))
{
LOGE("Unable to register heros textures on reload for world.");
}
if (!monsterSet->RegisterTextures(driver, resourceManager))
{
LOGE("Unable to register monster textures on reload for world.");
}
if (tileSet->RegisterTileTextures(driver, resourceManager))
{
coordinateTranslator = currentMap->GetCoordinateTranslator();
driver->setTransform(ETS_WORLD, matrix4());
driver->setTransform(ETS_VIEW, matrix4());
//Build game layer and hard code wih map
if (NULL != currentMap)
{
LOGI("Map:\nDimensions(%d, %d)\nTextureName: %s", currentMap->GetMapDimensions().Width, currentMap->GetMapDimensions().Height, currentMap->GetTextureFilename().c_str());
GameLayer* gameLayer = new GameLayer(currentMap,
game->GetResourceManager(),
game->GetSceneManager()->getRootSceneNode(), game->GetSceneManager(),
1234);
}
}
else
{
LOGE("Unable to register tile textures on reload for world.");
}
}
//! does nothing.
void CGameParticleContainerSceneNode::render()
{
IVideoDriver *driver = getIView()->getDriver();
#ifdef GSEDITOR
CGameObject::EObjectState state = m_owner->getObjectState();
// draw bbox on select
if (
state == CGameObject::Move ||
state == CGameObject::Review
)
setDebugDataVisible( EDS_BBOX );
else
setDebugDataVisible( 0 );
// call object draw
m_owner->drawObject();
#endif
if ( DebugDataVisible & scene::EDS_BBOX )
{
driver->setTransform(video::ETS_WORLD, getAbsoluteTransformation() );
video::SMaterial deb_m;
deb_m.Lighting = false;
driver->setMaterial(deb_m);
driver->draw3DBox( Box, video::SColor(255,255,255,255));
}
#ifdef GSEDITOR
// draw move
if (
state == CGameObject::Move ||
state == CGameObject::Rotation ||
state == CGameObject::Scale
)
m_owner->drawFrontUpLeftVector();
if ( state == CGameObject::Rotation )
m_owner->drawCircleAroundObject();
#endif
}
//! does nothing.
void CGameContainerSceneNode::render()
{
if ( m_owner == NULL )
return;
IVideoDriver *driver = getIView()->getDriver();
if ( DebugDataVisible & scene::EDS_BBOX )
{
driver->setTransform(video::ETS_WORLD, AbsoluteTransformation);
video::SMaterial deb_m;
deb_m.Lighting = false;
driver->setMaterial(deb_m);
core::aabbox3d<f32> tbox = Box;
getAbsoluteTransformation().transformBoxEx(tbox);
driver->draw3DBox( tbox, video::SColor(255,255,0,255));
}
}
// drawObject
void CWayPoint::drawObject()
{
if ( m_visible && m_next )
{
IVideoDriver *driver = getIView()->getDriver();
// set material
SMaterial debug_mat;
debug_mat.Lighting = false;
debug_mat.AntiAliasing=0;
driver->setMaterial(debug_mat);
// reset transform
core::matrix4 mat;
mat.makeIdentity();
driver->setTransform(video::ETS_WORLD, mat);
// draw up
driver->draw3DLine( m_position, m_next->getPosition(), SColor(255, 0, 255, 0) );
}
}
void GrassNode::render()
{
IVideoDriver* driver = SceneManager->getVideoDriver();
driver->setMaterial(Material);
driver->setTransform(ETS_WORLD, AbsoluteTransformation);
float Z = -5;
for (int i = 0; i < particle.size(); i++)
{
Vertices[0].Pos = vector3df(particle[i]->pos.X + -fx, particle[i]->pos.Y + -fy,Z);//, 0,0,0,SColor(255,255,255,255),0,1);
Vertices[1].Pos = vector3df(particle[i]->pos.X + fx, particle[i]->pos.Y + -fy,Z);//, 0,0,0,SColor(255,255,255,255),1,1);
Vertices[2].Pos = vector3df(particle[i]->pos.X + fx, particle[i]->pos.Y + fy,Z);//, 0,0,0,SColor(255,255,255,255),1,0);
Vertices[3].Pos = vector3df(particle[i]->pos.X + -fx, particle[i]->pos.Y + fy,Z);//, 0,0,0,SColor(255,255,255,255),0,0);
if (particle[i]->dir <= 0) {
float x = (particle[i]->crntFrm % stepww)*fWidth;
float y = (particle[i]->crntFrm / stepww)*fHeight;
Vertices[0].TCoords.X = x;
Vertices[0].TCoords.Y = y+fHeight;
Vertices[1].TCoords.X = x+fWidth;
Vertices[1].TCoords.Y = y+fHeight;
Vertices[2].TCoords.X = x+fWidth;
Vertices[2].TCoords.Y = y;
Vertices[3].TCoords.X = x;
Vertices[3].TCoords.Y = y;
} else if (particle[i]->dir > 0)
{
float x = (particle[i]->crntFrm % stepww)*fWidth;
float y = (particle[i]->crntFrm / stepww)*fHeight;
Vertices[1].TCoords.X = x;
Vertices[1].TCoords.Y = y+fHeight;
Vertices[0].TCoords.X = x+fWidth;
Vertices[0].TCoords.Y = y+fHeight;
Vertices[3].TCoords.X = x+fWidth;
Vertices[3].TCoords.Y = y;
Vertices[2].TCoords.X = x;
Vertices[2].TCoords.Y = y;
}
driver->drawIndexedTriangleList(&Vertices[0], 4, &Indices[0], 4);
}
}
// drawObject
void CGameCamera::drawObject()
{
if ( m_visible && m_objectID != -1 && getIView()->getActiveCamera() != this )
{
IVideoDriver *driver = getIView()->getDriver();
// set material
SMaterial debug_mat;
debug_mat.Lighting = false;
debug_mat.AntiAliasing=0;
driver->setMaterial(debug_mat);
// reset transform
core::matrix4 mat;
mat.makeIdentity();
driver->setTransform(video::ETS_WORLD, mat);
// draw up
core::vector3df ray = (m_targetPos - m_position).normalize();
driver->draw3DLine( m_position, m_position + ray*100, SColor(255, 255, 255, 0) );
}
}
void CGameColladaContainerSceneNode::render()
{
if (m_owner == NULL)
return;
#ifdef GSEDITOR
CGameObject::EObjectState state = m_owner->getObjectState();
// draw bbox on select
if (
state == CGameObject::Move ||
state == CGameObject::Review
)
setDebugDataVisible( EDS_BBOX );
else
setDebugDataVisible( 0 );
// call object draw
m_owner->drawObject();
// draw bouding box
if ( DebugDataVisible & scene::EDS_BBOX )
{
IVideoDriver *driver = getIView()->getDriver();
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
video::SMaterial deb_m;
deb_m.Lighting = false;
driver->setMaterial(deb_m);
core::aabbox3d<f32> tbox = Box;
getAbsoluteTransformation().transformBoxEx(tbox);
driver->draw3DBox( tbox, video::SColor(255,255,255,255));
}
// draw move
if (
state == CGameObject::Move ||
state == CGameObject::Rotation ||
state == CGameObject::Scale
)
m_owner->drawFrontUpLeftVector();
if ( state == CGameObject::Rotation )
m_owner->drawCircleAroundObject();
#else
if ( DebugDataVisible & scene::EDS_BBOX )
{
IVideoDriver *driver = getIView()->getDriver();
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
video::SMaterial deb_m;
deb_m.Lighting = false;
driver->setMaterial(deb_m);
core::aabbox3d<f32> tbox = Box;
getAbsoluteTransformation().transformBoxEx(tbox);
driver->draw3DBox( tbox, video::SColor(255,0,255,0));
}
#endif
}
// render
// irr scenenode impl
void CGameGrassSceneNode::render()
{
ISceneManager *smgr = getSceneManager();
IVideoDriver *driver = smgr->getVideoDriver();
#ifdef GSEDITOR
CGameObject::EObjectState state = m_owner->getObjectState();
// draw bbox on select
if (
state == CGameObject::Move ||
state == CGameObject::Review
)
setDebugDataVisible( EDS_BBOX );
else
setDebugDataVisible( 0 );
// call object draw
m_owner->drawObject();
#endif
// set world transform
driver->setTransform( video::ETS_WORLD, getAbsoluteTransformation());
// set current material with config shader
driver->setMaterial( m_Material);
// draw mesh with grass shader
int meshCount = m_mesh->getMeshBufferCount();
for ( int i = 0; i < meshCount; i++ )
driver->drawMeshBuffer(m_mesh->getMeshBuffer(i));
// draw bouding box
if ( DebugDataVisible & scene::EDS_BBOX )
{
driver->setTransform(video::ETS_WORLD, core::IdentityMatrix);
video::SMaterial deb_m;
deb_m.Lighting = false;
driver->setMaterial(deb_m);
core::aabbox3d<f32> tbox = m_mesh->getBoundingBox();
getAbsoluteTransformation().transformBoxEx(tbox);
driver->draw3DBox( tbox, video::SColor(255,255,255,255));
}
#ifdef GSEDITOR
// draw move
if (
state == CGameObject::Move ||
state == CGameObject::Rotation ||
state == CGameObject::Scale
)
m_owner->drawFrontUpLeftVector();
if ( state == CGameObject::Rotation )
m_owner->drawCircleAroundObject();
#endif
}
//! Tests projection matrices
static bool runTestWithDriver(E_DRIVER_TYPE driverType)
{
IrrlichtDevice *device = createDevice( driverType, dimension2d<u32>(160, 120), 32);
if (!device)
return true; // Treat a failure to create a driver as benign; this saves a lot of #ifdefs
IVideoDriver* driver = device->getVideoDriver();
stabilizeScreenBackground(driver);
logTestString("Testing driver %ls\n", driver->getName());
bool result = true;
driver->beginScene(true, false, SColor(255,0,0,0));
SMaterial mat;
mat.MaterialType = EMT_SOLID;
mat.Lighting = false;
mat.ZBuffer = false;
mat.ZWriteEnable = false;
mat.Thickness = 1;
driver->setMaterial(mat);
core::dimension2d<f32> dims(driver->getCurrentRenderTargetSize());
//apply custom projection, no offset
core::matrix4 pmtx = matrix4().buildProjectionMatrixOrthoLH(dims.Width, dims.Height, 0, 100);
driver->setTransform(ETS_PROJECTION, pmtx);
driver->setTransform(ETS_VIEW, matrix4());
driver->setTransform(ETS_WORLD, matrix4());
//the red cross appears at center
for (u32 i=0; i<10; ++i)
{
driver->draw3DLine(vector3df(0.f+i,-50.f,1.f), vector3df(0.f+i,50.f,1.f), SColor(255,255,0,0));
driver->draw3DLine(vector3df(-50.f,0.f+i,1.f), vector3df(50.f,0.f+i,1.f), SColor(255,255,0,0));
}
//apply custom projection, offset to right-top
pmtx.setTranslation(vector3df(0.7f, 0.7f, 0.f));
driver->setTransform(ETS_PROJECTION, pmtx);
driver->setTransform(ETS_VIEW, matrix4());
driver->setTransform(ETS_WORLD, matrix4());
//The green cross must be in right-top corner. But for OpenGL driver it is in left-top corner
for (u32 i=0; i<10; ++i)
{
driver->draw3DLine(vector3df(0.f+i,-50,1), vector3df(0.f+i,50,1), SColor(255,0,255,0));
driver->draw3DLine(vector3df(-50,0.f+i,1), vector3df(50,0.f+i,1), SColor(255,0,255,0));
}
driver->endScene();
result = takeScreenshotAndCompareAgainstReference(driver, "-projMat.png", 98.71f);
device->closeDevice();
device->run();
device->drop();
return result;
}
int main()
{
MyEventReceiver receiver;
IrrlichtDevice *device =
createDevice( video::EDT_OPENGL, dimension2d<u32>(1280, 800), 16,
false, false, false, &receiver);
if (!device)
return 1;
IVideoDriver* driver = device->getVideoDriver();
ISceneManager* smgr = device->getSceneManager();
IGUIEnvironment* guienv = device->getGUIEnvironment();
scene::ISceneNode* o = smgr->addSphereSceneNode(20);
//o->setMaterialFlag(video::EMF_LIGHTING, false);
o->setPosition(core::vector3df(0,0,0));
SMaterial &m = o->getMaterial(0);
m.EmissiveColor = SColor(255, 255, 0, 0);
vector3df sssPos(0, 60, 0);
scene::ISceneNode* sss = smgr->addCubeSceneNode(30);
sss->setMaterialFlag(video::EMF_LIGHTING, true);
//sss->setMaterialTexture(0, driver->getTexture("wall.bmp"));
sss->setPosition(sssPos);
SMaterial &sssm = sss->getMaterial(0);
sssm.EmissiveColor = SColor(100, 255, 255, 255);
scene::ISceneNode* hp = smgr->addSphereSceneNode(10);
SMaterial &hpm = hp->getMaterial(0);
hpm.EmissiveColor = SColor(255, 0, 0, 255);
scene::ISceneNode* hd = smgr->addSphereSceneNode(10);
SMaterial &hdm = hd->getMaterial(0);
hdm.EmissiveColor = SColor(255, 0, 0, 100);
scene::ISceneNode* node[10];
for (int i = 0; i < 10; ++i)
{
node[i] = smgr->addSphereSceneNode(5);
//node[i]->setMaterialFlag(video::EMF_LIGHTING, false);
node[i]->setVisible(false);
SMaterial &m = node[i]->getMaterial(0);
m.EmissiveColor = SColor(255, 255, 0, 0);
}
scene::ICameraSceneNode* cam = smgr->addCameraSceneNodeFPS();
vector3df camPos(0,0,200);
vector3df camshift(0,0,0);
cam->setPosition(camPos);
cam->setTarget(core::vector3df(0,0,0));
u32 then = device->getTimer()->getTime();
const f32 MOVEMENT_SPEED = 50.f;
irr::video::S3DVertex m_cPlaneVertices[4];
irr::u16 m_iPlaneIndices[6];
m_cPlaneVertices[0] = irr::video::S3DVertex(-100.0f, -100.0f, -100.0f,1,1,0, irr::video::SColor(255,255,255,255), 0.0f, 0.0f);
m_cPlaneVertices[1] = irr::video::S3DVertex(-100.0f, 100.0f, -100.0f,1,1,0, irr::video::SColor(255,255,255,255), 0.0f, 1.0f);
m_cPlaneVertices[2] = irr::video::S3DVertex( 100.0f, 100.0f, -100.0f,1,1,0, irr::video::SColor(255,255,255,255), 1.0f, 1.0f);
m_cPlaneVertices[3] = irr::video::S3DVertex( 100.0f, -100.0f, -100.0f,1,1,0, irr::video::SColor(255,255,255,255), 1.0f, 0.0f);
m_iPlaneIndices[0] = 0;
m_iPlaneIndices[1] = 2;
m_iPlaneIndices[2] = 1;
m_iPlaneIndices[3] = 0;
m_iPlaneIndices[4] = 3;
m_iPlaneIndices[5] = 2;
SMaterial m_cRenderMaterial;
m_cRenderMaterial.Wireframe = false;
m_cRenderMaterial.Lighting = false;
m_cRenderMaterial.TextureLayer[0].TextureWrapU = irr::video::ETC_CLAMP;
m_cRenderMaterial.TextureLayer[0].TextureWrapV = irr::video::ETC_CLAMP;
ITexture *m_pRenderTexture = 0;
CvCapture *capture;
IplImage *frame;
char AviFileName[]="Accel World.mp4";
capture = cvCaptureFromAVI(AviFileName);
if (driver->queryFeature(irr::video::EVDF_RENDER_TO_TARGET))
{
m_pRenderTexture = driver->addRenderTargetTexture(irr::core::dimension2d<irr::u32>((irr::u32)(720), (irr::u32)(480)));
m_cRenderMaterial.setTexture(0, m_pRenderTexture);
}
// m_pRenderTexture = driver->getTexture("wall.bmp");
// m_cRenderMaterial.setTexture(0, m_pRenderTexture);
while(device->run())
{
const u32 now = device->getTimer()->getTime();
const f32 frameDeltaTime = (f32)(now - then) / 1000.f; // Time in seconds
then = now;
if(receiver.IsKeyDown(irr::KEY_KEY_W))
camshift.Z -= MOVEMENT_SPEED * frameDeltaTime;
else if(receiver.IsKeyDown(irr::KEY_KEY_S))
camshift.Z += MOVEMENT_SPEED * frameDeltaTime;
if(receiver.IsKeyDown(irr::KEY_KEY_A))
camshift.X -= MOVEMENT_SPEED * frameDeltaTime;
else if(receiver.IsKeyDown(irr::KEY_KEY_D))
camshift.X += MOVEMENT_SPEED * frameDeltaTime;
if(receiver.IsKeyDown(irr::KEY_KEY_X))
camshift.Y -= MOVEMENT_SPEED * frameDeltaTime;
else if(receiver.IsKeyDown(irr::KEY_SPACE))
camshift.Y += MOVEMENT_SPEED * frameDeltaTime;
cam->setPosition(camPos + camshift);
driver->beginScene(true, true, SColor(255,0,0,0));
driver->setRenderTarget(m_pRenderTexture, true, true, irr::video::SColor(0,0,0,0));
if(cvGrabFrame(capture))
{
frame=cvRetrieveFrame(capture);
void* pBits = m_pRenderTexture->lock();
u32 Pitch = m_pRenderTexture->getPitch();
int wmin= Pitch;
// for(int h=0; h< 100; h++)
// memcpy((char*)pBits+((h)*wmin),(char*)frame->imageDataOrigin + h * wmin, wmin);
char* tmp = new char[frame->imageSize + 720 * 480];
for (int i = 0; i < 480; ++i)
{
for (int j = 0; j < 720; ++j)
{
tmp[(i * 720 + j) * 4] = frame->imageDataOrigin[(i * 720 + j) * 3];
tmp[(i * 720 + j) * 4 + 1] = frame->imageDataOrigin[(i * 720 + j) * 3 + 1];
tmp[(i * 720 + j) * 4 + 2] = frame->imageDataOrigin[(i * 720 + j) * 3 + 2];
tmp[(i * 720 + j) * 4 + 3] = 255;
}
}
memcpy(pBits,tmp, frame->imageSize + 720 * 480);
delete []tmp;
m_pRenderTexture->unlock();
}
driver->setRenderTarget(0, false, false, irr::video::SColor(0,100,100,100));
//driver->setTransform(video::ETS_VIEW, core::matrix4());
driver->setTransform(video::ETS_WORLD, core::matrix4());
//driver->setTransform(video::ETS_PROJECTION, core::matrix4());
driver->setMaterial(m_cRenderMaterial);
driver->drawIndexedTriangleList(m_cPlaneVertices, 4, m_iPlaneIndices, 2);
smgr->drawAll();
driver->endScene();
}
//controller.removeListener(listener);
device->drop();
return 0;
}
//! draws the element and its children
void CGUIMeshViewer::draw()
{
if (!IsVisible)
return;
IGUISkin* skin = Environment->getSkin();
IVideoDriver* driver = Environment->getVideoDriver();
rect<SINT32> viewPort = AbsoluteRect;
viewPort.LowerRightCorner.x -= 1;
viewPort.LowerRightCorner.y -= 1;
viewPort.UpperLeftCorner.x += 1;
viewPort.UpperLeftCorner.y += 1;
viewPort.clipAgainst(AbsoluteClippingRect);
// draw the frame
rect<SINT32> frameRect(AbsoluteRect);
frameRect.LowerRightCorner.y = frameRect.UpperLeftCorner.y + 1;
skin->draw2DRectangle(this, skin->getColor(EGDC_3D_SHADOW), frameRect, &AbsoluteClippingRect);
frameRect.LowerRightCorner.y = AbsoluteRect.LowerRightCorner.y;
frameRect.LowerRightCorner.x = frameRect.UpperLeftCorner.x + 1;
skin->draw2DRectangle(this, skin->getColor(EGDC_3D_SHADOW), frameRect, &AbsoluteClippingRect);
frameRect = AbsoluteRect;
frameRect.UpperLeftCorner.x = frameRect.LowerRightCorner.x - 1;
skin->draw2DRectangle(this, skin->getColor(EGDC_3D_HIGH_LIGHT), frameRect, &AbsoluteClippingRect);
frameRect = AbsoluteRect;
frameRect.UpperLeftCorner.y = AbsoluteRect.LowerRightCorner.y - 1;
skin->draw2DRectangle(this, skin->getColor(EGDC_3D_HIGH_LIGHT), frameRect, &AbsoluteClippingRect);
// draw the mesh
if (Mesh)
{
//TODO: if outside of screen, dont draw.
// - why is the absolute clipping rect not already the screen?
rect<SINT32> oldViewPort = driver->getViewPort();
driver->setViewPort(viewPort);
Matrix4 mat;
//CameraControl->calculateProjectionMatrix(mat);
//driver->setTransform(TS_PROJECTION, mat);
mat = Matrix4::IDENTITY;
mat.setTrans(Vector3(0, 0, 0));
//mat.setTranslation(Vector3(0, 0, 0));
driver->setTransform(ETS_WORLD, mat);
//CameraControl->calculateViewMatrix(mat);
//driver->setTransform(TS_VIEW, mat);
driver->setMaterial(Material);
UINT32 frame = 0;
if (Mesh->getFrameCount())
frame = (Timer::getTime() / 20) % Mesh->getFrameCount();
const IMesh* const m = Mesh->getMesh(frame);
for (UINT32 i = 0; i<m->getMeshBufferCount(); ++i)
{
IMeshBuffer* mb = m->getMeshBuffer(i);
driver->drawVertexPrimitiveList(mb->getVertices(),
mb->getVertexCount(), mb->getIndices(),
mb->getIndexCount() / 3, mb->getVertexType(),
EPT_TRIANGLES, mb->getIndexType());
}
driver->setViewPort(oldViewPort);
}
IGUIElement::draw();
}
void WorldState::OnEnter(GameGraph* game)
{
IVideoDriver* driver = game->GetVideoDriver();
ResourceManager* resourceManager = game->GetResourceManager();
ISceneManager* sceneManager = game->GetSceneManager();
//1) BUILD HERO
heroSet = CreatureDefinitionFileManager::PopulateCreatureSet(resourceManager,
"heroes.amr");
if (NULL != heroSet)
{
if (!heroSet->RegisterTextures(driver, resourceManager))
{
LOGE("Unable to read in textures for creature set!");
}
else
{
LOGI("A creature set with %d creatures was populated from the resource.",
heroSet->GetNumberOfCreatures());
CreatureDefinition* creatureDefinition = heroSet->GetByName("hero");
if (NULL != creatureDefinition)
{
LOGI("The creature definition has been found and has the name %s",
creatureDefinition->GetName().c_str());
hero = new PlayerCharacter(creatureDefinition, position2d<s32> (0, 0));
if (NULL != hero)
{
LOGI("Hero created with H x W (%d x %d)!", hero->GetWidth(),
hero->GetHeight());
ITexture* heroTexture = driver->getTexture(hero->GetTextureName());
if (NULL != heroTexture)
{
LOGD("Hero created succesfully");
}
else
{
LOGE("Unable to load hero texture named %s",
hero->GetTextureName().c_str());
}
}
else
{
LOGE("Failed to create hero!");
}
}
else
{
LOGE(
"An error occurred while attempting to pull the creature named %s from the creature set.",
"hero");
}
}
}
else
{
LOGE(
"An error occured while attempting to populate a creature set from the supplied resource.");
}
//2) BUILD MONSTER SET
Monster* skeleton = NULL;
monsterSet = CreatureDefinitionFileManager::PopulateCreatureSet(
resourceManager, "monsters.amr");
if (NULL != monsterSet)
{
if (!monsterSet->RegisterTextures(driver, resourceManager))
{
LOGE("Unable to read in textures for monster set!");
}
else
{
LOGI("A monster set with %d monsters was populated from the resource.", monsterSet->GetNumberOfCreatures());
CreatureDefinition* monsterDefinition = monsterSet->GetByName("skeleton");
if (NULL != monsterDefinition)
{
LOGI("The monster definition has been found and has the name %s", monsterDefinition->GetName().c_str());
skeleton = new Monster(monsterDefinition, vector2d<s32> (4, 4));
if (NULL != skeleton)
{
LOGI("Skeleton successfully created!");
}
else
{
LOGE("Failed to create skeleton!");
}
}
else
{
LOGE("An error occurred while attempting to pull the creature named %s from the creature set.", "hero");
}
}
}
else
{
LOGE("An error occured while attempting to populate a creature set from the supplied resource.");
}
//3) BUILD MAP
tileSet = TileDefinitionFileManager::PopulateHexTileDefinitionSet(
resourceManager, "latest.amr");
if (NULL != tileSet)
{
LOGI("The tile set contains %d tiles.", tileSet->GetNumberOfTiles());
LOGI("Tile width %f Tile height %f.", tileSet->GetTileWidth(), tileSet->GetTileHeight());
tileSet->RegisterTileTextures(driver, resourceManager);
LOGI("Registered tile textures.");
MapBuilder mapBuilder;
LOGI("Building map...");
currentMap = mapBuilder.Construct(dimension2d<int> (10, 10), tileSet);
LOGI("Adding hero...");
currentMap->SetPlayerCharacter(hero);
LOGI("Adding skeleton...");
currentMap->AddMonster(skeleton);
LOGI("Map completed!");
//Set global coordinate translator reference
coordinateTranslator = currentMap->GetCoordinateTranslator();
driver->setTransform(ETS_WORLD, matrix4());
driver->setTransform(ETS_VIEW, matrix4());
//Build game layer and hard code wih map
if (NULL != currentMap)
{
LOGI("Map:\nDimensions(%d, %d)\nTextureName: %s", currentMap->GetMapDimensions().Width, currentMap->GetMapDimensions().Height, currentMap->GetTextureFilename().c_str());
GameLayer* gameLayer = new GameLayer(currentMap,
game->GetResourceManager(),
game->GetSceneManager()->getRootSceneNode(), game->GetSceneManager(),
1234);
}
}
else
{
LOGE("The TileSet could not be loaded and, accordingly, a map could not be constructed.");
}
}
