SpritePtr ETHGraphicResourceManager::GetPointer(
VideoPtr video,
const str_type::string &fileRelativePath, const str_type::string &programPath,
const str_type::string &searchPath, const bool cutOutBlackPixels)
{
if (fileRelativePath == GS_L(""))
return SpritePtr();
str_type::string fileName = ETHGlobal::GetFileName(fileRelativePath);
str_type::string resourceFullPath = AssembleResourceFullPath(programPath, searchPath, fileName);
if (!m_resource.empty())
{
SpritePtr sprite = FindSprite(resourceFullPath, fileName);
if (sprite)
{
return sprite;
}
}
// we can set a search path to search the file in case
// it hasn't been loaded yet
if (searchPath != GS_L(""))
{
AddFile(video, resourceFullPath, cutOutBlackPixels);
return FindSprite(resourceFullPath, fileName);
}
return SpritePtr();
}
void App::Run() {
// inicjalizacja okna
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO);
Resize(m_window_width, m_window_height);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); // podwójne buforowanie
// inicjalizacja OpenGL
glClearColor(0, 0, 0, 0);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_TEXTURE_2D);
// niewyœwietlanie przezroczystych fragmentów sprite'a
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GEQUAL, 0.1);
const std::string atlas_filename = "data/dinoGra.bmp";
Engine& engine = Engine::Get();
engine.Load();
engine.FRenderer()->LoadTexture(atlas_filename);
m_player->SetSprites(
SpritePtr(new Sprite(engine.FSpriteConfig()->
Get("player_left"))),
SpritePtr(new Sprite(engine.FSpriteConfig()->
Get("player_right"))),
SpritePtr(new Sprite(engine.FSpriteConfig()->
Get("player_stop"))),
SpritePtr(new Sprite(engine.FSpriteConfig()->
Get("player_up"))),
SpritePtr(new Sprite(engine.FSpriteConfig()->
Get("player_down"))) );
Engine::Get().FSound()->LoadSounds();
Engine::Get().FSound()->PlayMusic("game");
// pêtla g³ówna
is_done = false;
size_t last_ticks = SDL_GetTicks();
while (!is_done) {
ProcessEvents();
// time update
size_t ticks = SDL_GetTicks();
double delta_time = (ticks - last_ticks) / 1000.0;
last_ticks = ticks;
// update & render
if (delta_time > 0) {
Update(delta_time);
}
Draw();
}
SDL_Quit();
}
SpritePtr GameEngine::LoadSprite(const char * filename)
{
std::map<std::string, ImageData>::const_iterator iter = _images.find(filename);
if (iter != _images.end())
{
return SpritePtr(new Sprite(iter->second.num, iter->second.width, iter->second.height));
}
ImageData data;
data.num = _renderer->LoadSprite(filename);
_renderer->GetSpriteSize(data.num, &data.width, &data.height);
_images[filename] = data;
return SpritePtr(new Sprite(data.num, data.width, data.height));
}
void ClientEntity::setAnimationType (const Animation& animation)
{
_animation = &animation;
SoundControl.halt(_animationSound);
_animationSound = -1;
SoundMappingConstIter soundIter = _soundMapping.find(_animation);
if (soundIter != _soundMapping.end()) {
_animationSound = SoundControl.play(soundIter->second, getPos(), _animation->loop);
}
const std::string name = SpriteDefinition::get().getSpriteName(_type, *_animation);
if (name.empty())
return;
SpritesMapConstIter i = _sprites.find(_animation);
if (i == _sprites.end()) {
_currSprite = SpritePtr(UI::get().loadSprite(name)->copy());
_currSprite->setLoop(_animation->loop);
_sprites[_animation] = _currSprite;
} else {
_currSprite = i->second;
}
if (!_animation->loop)
_currSprite->setCurrentFrame(0);
setScreenSize(_currSprite->getMaxWidth(), _currSprite->getMaxHeight());
}
SpritePtr ETHGraphicResourceManager::AddFile(VideoPtr video, const str_type::string &path, const bool cutOutBlackPixels)
{
str_type::string fileName = ETHGlobal::GetFileName(path);
{
SpritePtr sprite = FindSprite(path, fileName);
if (sprite)
return sprite;
}
SpritePtr pBitmap;
str_type::string fixedName(path);
Platform::FixSlashes(fixedName);
ETHSpriteDensityManager::DENSITY_LEVEL densityLevel;
const str_type::string finalFileName(m_densityManager.ChooseSpriteVersion(fixedName, video, densityLevel));
if (!(pBitmap = video->CreateSprite(finalFileName, (cutOutBlackPixels)? 0xFF000000 : 0xFFFF00FF)))
{
pBitmap.reset();
ETH_STREAM_DECL(ss) << GS_L("(Not loaded) ") << path;
ETHResourceProvider::Log(ss.str(), Platform::Logger::ERROR);
return SpritePtr();
}
m_densityManager.SetSpriteDensity(pBitmap, densityLevel);
//#ifdef _DEBUG
ETH_STREAM_DECL(ss) << GS_L("(Loaded) ") << fileName;
ETHResourceProvider::Log(ss.str(), Platform::Logger::INFO);
//#endif
m_resource.insert(std::pair<str_type::string, SpriteResource>(fileName, SpriteResource(fixedName, pBitmap)));
return pBitmap;
}
Ship::Ship(const string& name, const string& collision, Sprite* body)
: PhysicNode(collision)
, m_name(name)
, m_ship(SpritePtr(body))
{
setCamera(Painter::GetInstance()->getSceneCamera());
setMoveDirection(vec2d(0.0f, 1.0f));
}
void Engine::NextLevel(){
++m_level_of_game;
m_entity_factory.reset(new EntityFactory());
m_aabb.reset( new Aabb() );
m_treasure.reset( new Treasure );
m_entity_factory.reset(new EntityFactory());
m_level.reset(new Level( m_entity_factory.get()) );
string Text("data/");
std::ostringstream ss;
ss << m_level_of_game;
Text+=ss.str();
Text+=".lvl";
m_level->LoadFromFile(Text.c_str());
m_grid=*(new SpriteGrid());
m_grid.StoreSprite(FT::PlatformLeft, SpritePtr(new Sprite(Engine::Get().GetSpriteConfig()->Get("platform_left"))));
m_grid.StoreSprite(FT::PlatformDown, SpritePtr(new Sprite(Engine::Get().GetSpriteConfig()->Get("platform_down"))));
m_grid.StoreSprite(FT::PlatformUp, SpritePtr(new Sprite(Engine::Get().GetSpriteConfig()->Get("platform_up"))));
m_grid.StoreSprite(FT::PlatformRight, SpritePtr(new Sprite(Engine::Get().GetSpriteConfig()->Get("platform_right"))));
m_grid.StoreSprite(FT::PlatformHorizontal, SpritePtr(new Sprite(Engine::Get().GetSpriteConfig()->Get("platform_h"))));
m_grid.StoreSprite(FT::PlatformVertical, SpritePtr(new Sprite(Engine::Get().GetSpriteConfig()->Get("platform_v"))));
m_grid.StoreSprite(FT::Coin, SpritePtr(new Sprite(Engine::Get().GetSpriteConfig()->Get("coin"))));
m_grid.SetLevel(m_level);
GetTreasure()->SetGrid( GetGrid() );
}
bool GLVideo::EndTargetScene()
{
SetRenderTarget(SpritePtr(), 0);
m_rendering = false;
UnbindFrameBuffer();
UpdateInternalShadersViewData(GetScreenSizeF(), false);
return true;
}
ClientMapTile::ClientMapTile (const EntityType& type, uint16_t id, const std::string& sprite,
const Animation& animation, float x, float y, float sizeX, float sizeY, EntityAngle angle,
const SoundMapping& soundMapping, EntityAlignment align) :
ClientEntity(type, id, x, y, sizeX, sizeY, soundMapping, align, angle)
{
_currSprite = UI::get().loadSprite(sprite);
if (_currSprite->getFrameCount() > 1)
_currSprite = SpritePtr(_currSprite->copy());
setScreenSize(_currSprite->getMaxWidth(), _currSprite->getMaxHeight());
}
gs2d::SpritePtr ETHGraphicResourceManager::FindSprite(const str_type::string& fullFilePath, const str_type::string& fileName)
{
std::map<str_type::string, SpriteResource>::iterator iter = m_resource.find(fileName);
if (iter != m_resource.end())
{
str_type::string fixedPath(fullFilePath);
Platform::FixSlashes(fixedPath);
if (fixedPath != iter->second.m_fullOriginPath)
{
str_type::stringstream ss; ss << GS_L("Duplicate resource name found: ") << fixedPath
<< GS_L(" <-> ") << iter->second.m_fullOriginPath;
ETHResourceProvider::Log(ss.str(), Platform::Logger::ERROR);
}
return iter->second.m_sprite;
}
else
{
return SpritePtr();
}
}
ETHLightmapGen::ETHLightmapGen(ETHRenderEntity* entity,
boost::shared_ptr<ETHShaderManager> shaderManager, std::list<ETHLight>::iterator iBegin, std::list<ETHLight>::iterator iEnd,
ETHBucketManager& buckets, const Vector3& oldPos, const Vector3& newPos, const float minHeight, const float maxHeight,
const ETHSceneProperties &sceneProps)
{
const SpritePtr& sprite = entity->m_pSprite;
const ETHEntityProperties& props = entity->m_properties;
if (!sprite || !props.staticEntity || !props.applyLight)
{
return;
}
const VideoPtr& video = entity->m_provider->GetVideo();
const Platform::FileLogger* logger = entity->m_provider->GetLogger();
if (video->Rendering())
{
ETH_STREAM_DECL(ss) << GS_L("Entity ID #") << entity->GetID() << GS_L(": lightmaps can't be generated during application render.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
return;
}
const Vector2 v2Size = (sprite->GetNumRects() <= 1) ? sprite->GetBitmapSizeF() : sprite->GetRect().size;
if (!(entity->m_pLightmap = video->CreateRenderTarget(static_cast<unsigned int>(v2Size.x), static_cast<unsigned int>(v2Size.y))))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't create the render target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
// Paint it black
video->SetRenderTarget(entity->m_pLightmap);
if (!video->BeginTargetScene(GS_BLACK))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't render to target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
video->EndTargetScene();
entity->m_controller->SetPos(newPos);
Vector2 v2CamPos = video->GetCameraPos();
video->SetCameraPos(Vector2(0,0));
for (std::list<ETHLight>::iterator iter = iBegin; iter != iEnd; iter++)
{
if (!iter->staticLight)
continue;
SpritePtr tempTarget;
if (!(tempTarget = video->CreateRenderTarget(static_cast<unsigned int>(v2Size.x), static_cast<unsigned int>(v2Size.y))))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't create temporary render target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
if (!video->SetRenderTarget(tempTarget))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't set render target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
if (!video->BeginTargetScene(GS_BLACK))
{
ETH_STREAM_DECL(ss) << GS_L("ETHRenderEntity::GenerateLightmap: coudn't render to temporary target.");
logger->Log(ss.str(), Platform::FileLogger::ERROR);
entity->m_pLightmap.reset();
return;
}
// draw light
if (shaderManager->BeginLightPass(entity, &(*iter), video->GetScreenSizeF().y, 0.0f, sceneProps.lightIntensity, 0, true))
{
entity->DrawLightPass(sceneProps.zAxisDirection, true);
shaderManager->EndLightPass();
}
// draw shadows
if (entity->GetType() != ETH_VERTICAL)
{
for (ETHBucketMap::iterator bucketIter = buckets.GetFirstBucket(); bucketIter != buckets.GetLastBucket(); bucketIter++)
{
for (ETHEntityList::iterator entityIter = bucketIter->second.begin();
entityIter != bucketIter->second.end(); entityIter++)
{
if (!(*entityIter)->IsStatic())
continue;
Vector3 oldPos2 = (*entityIter)->GetPosition();
Vector3 newPos2 = oldPos2-(oldPos-newPos);
(*entityIter)->SetOrphanPosition(newPos2);
if (shaderManager->BeginShadowPass((*entityIter), &(*iter), maxHeight, minHeight))
{
(*entityIter)->DrawShadow(maxHeight, minHeight, sceneProps, *iter, 0, true, true, entity->GetAngle(), entity->GetPosition());
shaderManager->EndShadowPass();
}
(*entityIter)->SetOrphanPosition(oldPos2);
}
}
}
video->EndTargetScene();
// draw the shadowed light by adding it to the final lightmap
video->SetRenderTarget(entity->m_pLightmap);
video->BeginTargetScene(GS_BLACK, false);
const GS_ALPHA_MODE oldAM = video->GetAlphaMode();
video->SetAlphaMode(GSAM_ADD);
tempTarget->Draw(Vector2(0,0));
video->SetAlphaMode(oldAM);
video->EndTargetScene();
}
entity->m_pLightmap->GenerateBackup();
video->SetRenderTarget(SpritePtr());
video->SetCameraPos(v2CamPos);
}
AnimationFrame::AnimationFrame(MainWindow *parent) : GLWindow(parent)
{
mParent = parent;
mCanvas = new Canvas(this);
setWindowTitle("Animation Editor");
mCentralWidget = new QWidget(this);
setCentralWidget(mCentralWidget);
QVBoxLayout *mainLayout = new QVBoxLayout;
mCentralWidget->setLayout(mainLayout);
QSplitter *splitter = new QSplitter(Qt::Vertical, this);
mModel = new SpriteModel(this);
splitter->addWidget(mCanvas);
animator = new AnimationView(this);
animator->setModel(mModel);
splitter->addWidget(animator);
mainLayout->addWidget(splitter);
mSubmit = new YesNoWidget(this);
mainLayout->addWidget(mSubmit);
mToolBar = new AnimationToolBar(this);
mMenuBar = new AnimationMenu(this);
setMenuBar(mMenuBar);
addToolBar(mToolBar);
resize(800,600);
QImage checkers = createCheckers();
mCheckers = SpritePtr(new Sprite(checkers, width(), height()));
statusBar()->setStyleSheet("QStatusBar::item { border: 0px solid black }; ");
statusBar()->addPermanentWidget(new QLabel("Animator", this, 0), 1);
mWidth = new QLabel("Width: 0px", this, 0);
mHeight = new QLabel("Height: 0px", this, 0);
mFrames = new QLabel("Frames: 0", this, 0);
statusBar()->addPermanentWidget(mWidth, 0);
statusBar()->addPermanentWidget(mHeight, 0);
statusBar()->addPermanentWidget(mFrames, 0);
mActions->aOpen->setText("Import");
mActions->aSave->setText("Export");
connect(mActions->aAddBlank, &QAction::triggered, this, &AnimationFrame::insertImage);
connect(mActions->aDeleteImg, &QAction::triggered, this, &AnimationFrame::deleteImage);
connect(mActions->aCut, &QAction::triggered, this, &AnimationFrame::cut);
connect(mActions->aCopy, &QAction::triggered, this, &AnimationFrame::copy);
connect(mActions->aPaste, &QAction::triggered, this, &AnimationFrame::paste);
connect(mActions->aOpen, &QAction::triggered, this, &AnimationFrame::import);
connect(mActions->aSave, &QAction::triggered, this, &AnimationFrame::exportStrip);
connect(mSubmit, &YesNoWidget::yes, this, &AnimationFrame::submit);
connect(mSubmit, &YesNoWidget::no, this, &AnimationFrame::close);
connect(mToolBar->speed, static_cast<void (QDoubleSpinBox::*)(double)>(&QDoubleSpinBox::valueChanged), this, &GLWindow::setSpeed);
connect(mToolBar->frame, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged), this, &AnimationFrame::setFrame);
mSpr = Q_NULLPTR;
}
SpritePtr
Sprite::clone() const
{
return SpritePtr(new Sprite(*this));
}
SpritePtr ETHVertexLightDiffuse::GetDefaultNormalMap()
{
return SpritePtr();
}
void App::Run() {
SDL_Init(SDL_INIT_EVERYTHING);
Engine::Get().Resize(Engine::Get().getWindowWidth(), Engine::Get().getWindowHeigth());
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
glClearColor(0.3, 0.66, 0.89, 0);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
const std::string atlas_filename = "data/tex.png";
Engine& engine = Engine::Get();
engine.Load();
engine.getRenderer()->LoadTexture(atlas_filename);
if (Engine::Get().getPlayerSprite() == PT::Ninja) {
m_player->setSprites(SpritePtr(new Sprite(engine.getSpriteConfig()->Get("ninja_right"))),
SpritePtr(new Sprite(engine.getSpriteConfig()->Get("ninja_left"))),
SpritePtr(new Sprite(engine.getSpriteConfig()->Get("ninja_stop"))));
}
else if (Engine::Get().getPlayerSprite() == PT::Samurai) {
m_player->setSprites(SpritePtr(new Sprite(engine.getSpriteConfig()->Get("samurai_right"))),
SpritePtr(new Sprite(engine.getSpriteConfig()->Get("samurai_left"))),
SpritePtr(new Sprite(engine.getSpriteConfig()->Get("samurai_stop"))));
}
in_game = true;
size_t last_ticks = SDL_GetTicks();
Engine::Get().setGameState(GS::Menu);
while (Engine::Get().getState() != GS::Quit) {
switch (Engine::Get().getState()) {
case GS::InGame:
ProcessEvents();
break;
case GS::HallOfFame:
if (!m_hall_of_fame->isActual())
m_hall_of_fame.reset(new HallOfFame());
m_hall_of_fame->proccessEvents();
break;
case GS::ScoreSubmit:
m_score_submit->ProcessEvents();
break;
case GS::Menu:
m_menu->ProcessEvents();
break;
case GS::Options:
m_options->processEvents();
}
size_t ticks = SDL_GetTicks();
delta_time = (ticks - last_ticks) / (CLOCKS_PER_SEC/10.0);
if ((delta_time*(CLOCKS_PER_SEC / 10.0)) < ((CLOCKS_PER_SEC / 10.0) / Engine::Get().fps))
SDL_Delay(((CLOCKS_PER_SEC / 10.0) / Engine::Get().fps) - (delta_time*(CLOCKS_PER_SEC / 10.0)));
delta_time = ((CLOCKS_PER_SEC / 10.0) / Engine::Get().fps)/ (CLOCKS_PER_SEC / 10.0);
last_ticks = ticks;
switch (Engine::Get().getState()) {
case GS::InGame:
if (delta_time > 0.0) {
Update(delta_time);
}
Draw();
break;
case GS::HallOfFame:
m_hall_of_fame->draw();
break;
case GS::ScoreSubmit:
m_score_submit->Draw();
break;
case GS::Menu:
m_menu->Draw();
break;
case GS::Options:
m_options->draw();
break;
}
}
SDL_Quit();
}
