void DrawSprite ( const std::string& sheetname, int sheet_x, int sheet_y, vec2 position, vec2 size, float rotation, colour col )
{
SetShader("Sprite");
EnableTexturing();
EnableBlending();
ClearColour();
SetColour(col);
SpriteSheet* sheet;
SheetMap::iterator iter = spriteSheets.find(sheetname);
if (iter == spriteSheets.end())
{
// load it
sheet = new SpriteSheet(sheetname);
spriteSheets[sheetname] = sheet;
}
else
{
sheet = iter->second;
}
Matrices::SetViewMatrix(matrix2x3::Translate(position));
Matrices::SetModelMatrix(matrix2x3::Identity());
if (sheet->IsRotational())
{
assert(sheet_x == 0);
assert(sheet_y == 0);
sheet->DrawRotation(size, rotation);
}
else
{
glRotatef(RAD2DEG(rotation), 0.0f, 0.0f, 1.0f);
sheet->Draw(sheet_x, sheet_y, size);
}
}
void DrawSpriteFrame ( const std::string& sheetname, vec2 position, vec2 size, int index, float rotation, colour col )
{
SetShader("Sprite");
EnableTexturing();
EnableBlending();
ClearColour();
SetColour(col);
SpriteSheet* sheet;
SheetMap::iterator iter = spriteSheets.find(sheetname);
if (iter == spriteSheets.end())
{
sheet = new SpriteSheet(sheetname);
spriteSheets[sheetname] = sheet;
}
else
{
sheet = iter->second;
}
Matrices::SetViewMatrix(matrix2x3::Translate(position));
Matrices::SetModelMatrix(matrix2x3::Identity());
glRotatef(RAD2DEG(rotation), 0.0f, 0.0f, 1.0f);
int x = index % sheet->SheetTilesX();
int y = (index - x) / sheet->SheetTilesX();
sheet->Draw(x, y, size);
}
Sprite::Sprite(SpriteSheet& spriteSheet, std::string spriteKey, float scale) :
texture_(spriteSheet.texture()),
source_(spriteSheet.getRegion(spriteKey))
{
width_ = (int)(source_->w * scale);
height_ = (int)(source_->h * scale);
}
std::vector<Halley::Path> Halley::SpriteSheetImporter::import(const ImportingAsset& asset, Path dstDir, ProgressReporter reporter, AssetCollector collector)
{
SpriteSheet sheet;
Path dstFile = asset.inputFiles[0].name.replaceExtension("");
sheet.loadJson(gsl::as_bytes(gsl::span<const Byte>(asset.inputFiles.at(0).data)));
FileSystem::writeFile(dstDir / dstFile, Serializer::toBytes(sheet));
return { dstFile };
}
SpriteSheet* SpriteSheet::CloneTo( std::string Filename )
{
SpriteSheet* result = new SpriteSheet( Filename );
for( int i = 0; i < frames.size(); i++ )
{
SpriteSheetRegion* r = frames.at( i );
result->AddSprite( r->X, r->Y, r->Width, r->Height );
}
return result;
}
SpriteSheet* RenderManager::createSpriteSheet(
int _layer, std::wstring _filename, int _width, int _height, int _delay)
{
SpriteSheet *isheet = new SpriteSheet( _filename, _width, _height, _delay );
isheet->setLayer(_layer);
isheet->m_prev = NULL;
isheet->m_next = m_rendlist;
if (m_rendlist)
m_rendlist->m_prev = isheet;
m_rendlist = isheet;
return isheet;
}
SpriteSheet* GerenciadorDeRecursos::carregarSpriteSheet(const string& nome, const string& caminho, int num_animacoes, int num_max_frames)
{
SpriteSheet* sheet = new SpriteSheet;
if(sheet->carregar(caminho, num_animacoes, num_max_frames))
{
mSpriteSheets.insert(pair<string, SpriteSheet*>(nome, sheet));
}
else
{
delete sheet;
sheet = NULL;
}
return sheet;
}
std::unique_ptr<Image> SpriteImporter::makeAtlas(const std::vector<BinPackResult>& result, Vector2i origSize, SpriteSheet& spriteSheet)
{
Vector2i size = shrinkAtlas(result);
auto image = std::make_unique<Image>(Image::Format::RGBA, size);
image->clear(0);
for (auto& packedImg: result) {
ImageData* img = reinterpret_cast<ImageData*>(packedImg.data);
image->blitFrom(packedImg.rect.getTopLeft(), *img->img, img->clip, packedImg.rotated);
const auto borderTL = img->clip.getTopLeft();
const auto borderBR = img->img->getSize() - img->clip.getSize() - borderTL;
const auto offset = Vector2f(0.0001f, 0.0001f);
SpriteSheetEntry entry;
entry.size = Vector2f(img->clip.getSize());
entry.rotated = packedImg.rotated;
entry.pivot = Vector2f(img->pivot - img->clip.getTopLeft()) / entry.size;
entry.origPivot = img->pivot;
entry.coords = (Rect4f(Vector2f(packedImg.rect.getTopLeft()) + offset, Vector2f(packedImg.rect.getBottomRight()) + offset)) / Vector2f(size);
entry.trimBorder = Vector4s(short(borderTL.x), short(borderTL.y), short(borderBR.x), short(borderBR.y));
entry.slices = img->slices;
for (auto& filename: img->filenames) {
spriteSheet.addSprite(filename, entry);
}
}
return image;
}
bool Haste::load(File* file){
static SpriteSheet ssHaste;
static bool loaded = false;
if (!loaded){
ssHaste = SpriteSheet(Vec2i(1, 1));
if (!ssHaste.load("haste.png")){
return false;
}
loaded = true;
}
m_sprite.setSpriteSheet(&ssHaste);
m_sprite.loadAnimation(&ssHaste, 0, 0, 1);
m_duration = 5.0f;
m_timeRemaining = m_duration;
return true;
}
vec2 SpriteDimensions ( const std::string& sheetname )
{
SpriteSheet* sheet;
SheetMap::iterator iter = spriteSheets.find(sheetname);
if (iter == spriteSheets.end())
{
// load it
sheet = new SpriteSheet(sheetname);
spriteSheets[sheetname] = sheet;
}
else
{
sheet = iter->second;
}
assert(sheet);
return vec2(sheet->TileSizeX(), sheet->TileSizeY());
}
bool Jelly::Load(File* file)
{
static SpriteSheet mySpriteSheet;
if (!mySpriteSheet.Load("jelly.png"))
{
return false;
}
mySpriteSheet.SetNumCells(2, 1);
m_sprite.SetSpriteSheet(&mySpriteSheet);
m_sprite.SetMaxCellTime(0.1f);
m_sprite.SetStartCell(0);
m_sprite.SetEndCell(1);
m_sprite.SetPos(Vec2f(ThePlatformManager::Instance()->m_posX, ThePlatformManager::Instance()->m_posY));
m_sprite.SetVel(Vec2f(-70, 0));
return true;
}
bool BossBullet::Load(File* file)
{
static SpriteSheet mySpriteSheet;
if (!mySpriteSheet.Load("bossbullet.png"))
{
return false;
}
mySpriteSheet.SetNumCells(2, 1);
m_sprite.SetSpriteSheet(&mySpriteSheet);
m_sprite.SetCurrentCell(0);
m_sprite.SetStartCell(0);
m_sprite.SetEndCell(1);
m_sprite.SetPos(Vec2f(TheBulletManager::Instance()->GetBulletPos().GetX(), TheBulletManager::Instance()->GetBulletPos().GetY() + rand() % 100));
m_sprite.SetVel(Vec2f(-100, 0));
return true;
}
Particle::Particle(const AABB2& boundingBox, const Vector2& position, float orientation, float duration, const RGBA& color, const SpriteSheet& m_spriteSheet)
: m_spriteSheet(m_spriteSheet)
, m_animation(m_spriteSheet, duration, AnimMode::ONE_SHOT, 0, m_spriteSheet.GetNumSprites() - 1)
, m_position(position)
, m_orientation(orientation)
, m_boundingBox (boundingBox)
, m_color(color)
{
}
SpriteSheet TexturePacker::createSpriteSheet(SpriteArray& sprites)
{
SpriteSheet sheet;
QImage& image = sheet.newImage(2048, 2048);
QPainter painter(&image);
QPoint border(1, 1);
const int baselength = Project::getActiveProject().getImagePath().length() + 1;
for ( const Sprite& sprite : sprites )
{
QImage image(sprite.mName);
assert(!image.isNull());
Sprite newSprite;
newSprite.mName = sprite.mName.right(sprite.mName.length() - baselength);
newSprite.mCoordinates = sprite.mCoordinates;
newSprite.mOriginalSize = sprite.mOriginalSize;
newSprite.mRotated = sprite.mRotated;
newSprite.translate(border);
sheet.addSprite(newSprite);
if ( newSprite.mRotated )
{
RotateImagePainter rpainter(painter);
rpainter.drawImage(newSprite.mCoordinates.topLeft(),
90,
image.width(),
image.height(),
newSprite.mCoordinates.width(),
newSprite.mCoordinates.height(),
image);
}
else
{
painter.drawImage(newSprite.mCoordinates, image);
}
}
return sheet;
}
void SpriteAnimationRepository::initialize(std::string filename) {
LOG(INFO) << "Loading sprite animation repository from " << filename;
string animationContent = FILESYS.getFileContent(filename);
string parseError;
auto json = Json::parse(animationContent, parseError);
if (!parseError.empty()) {
LOG(FATAL) << "Error while parsing JSON content from " << filename << ". Error: " << parseError;
} else {
for (auto& k : json["spriteSheets"].array_items()) {
SpriteSheet* sheet = new SpriteSheet();
sheet->texture = GFXSYS.loadTexture(k["texture"].string_value());
sheet->autoAdd(k["spriteWidth"].int_value(), k["spriteHeight"].int_value());
spriteSheets[k["name"].string_value()] = sheet;
}
for (auto& k : json["animations"].array_items()) {
AnimationData* animData = new AnimationData();
animationData[k["name"].string_value()] = animData;
animData->frameTimeInMilliseconds = (float) k["frameTimeInMilliseconds"].number_value();
animData->loopType = animationLoopType(k["loopType"].string_value());
for (auto& f : k["frames"].array_items()) {
string spriteSheetName = f["spriteSheet"].string_value();
if (spriteSheets.find(spriteSheetName) == spriteSheets.end())
LOG(FATAL) << "Animation " << k["name"].string_value() << " refers to unexistent spritesheet \"" << spriteSheetName << "\"";
int index = f["index"].int_value();
int indexTo = f["indexTo"].int_value();
if (indexTo > index) {
for (int i = index; i <= indexTo; i++)
animData->frames.push_back(Sprite(spriteSheets[spriteSheetName], i));
} else {
animData->frames.push_back(Sprite(spriteSheets[spriteSheetName], index));
}
}
}
}
}
SpriteSheet* GerenciadorDeRecursos::carregarSpriteSheet(const string& nome, const string& caminho, int num_animacoes, int num_max_frames, TipoQualidadeEscala qualidade_escala)
{
if(carregouSpriteSheet(nome))
{
uniErro("Recurso '" + nome + "' nao pode ser carregado, pois um SpriteSheet com esse nome ja existe.");
return NULL;
}
SpriteSheet* sheet = new SpriteSheet;
if(sheet->carregar(caminho, num_animacoes, num_max_frames, qualidade_escala))
{
mSpriteSheets.insert(pair<string, SpriteSheet*>(nome, sheet));
}
else
{
delete sheet;
sheet = NULL;
}
return sheet;
}
bool SceneObject::pointIn(double _x, double _y)
{
// Return false if we do not live in the world
if (!hasComponent("Transform"))
return false;
double x = ((TransformComponent*)m_Components["Transform"])->getPositionX();
double y = ((TransformComponent*)m_Components["Transform"])->getPositionY();
double width, height;
// Are we visible?
if (hasComponent("Renderable")) {
Camera& cam = RenderManager::getCurrentContext()->camera();
int layer;
if (((RenderComponent*)m_Components["Renderable"])->hasSprite()) {
Sprite *spr = ((RenderComponent*)m_Components["Renderable"])->getSprite();
width = spr->width();
height = spr->height();
layer = spr->layer();
}
if (((RenderComponent*)m_Components["Renderable"])->hasSpriteSheet()) {
SpriteSheet *spr = ((RenderComponent*)m_Components["Renderable"])->getSpriteSheet();
width = spr->width();
height = spr->height();
layer = spr->layer();
}
CameraTransform ctrans = cam.screenToWorld(width, height, layer);
CameraTransform ctrans2 = cam.screenToWorld(0.0, 0.0, layer);
width = ctrans.x - ctrans2.x;
height = ctrans.y - ctrans2.y;
}else// If we aren't visible, do we have a shape?
if (hasComponent("Physics")) {
}else{
width = 0.5;
height = 0.5;
}
}
void AnimatedSpriteRenderer::DrawSprite(SpriteSheet &sheet, glm::vec2 position, glm::vec2 size, GLfloat rotate, glm::vec3 color, int frame)
{
// Prepare transformations
this->shader.Use();
glm::mat4 model;
model = glm::translate(model, glm::vec3(position, 0.0f)); // First translate (transformations are: scale happens first, then rotation and then finall translation happens; reversed order)
model = glm::translate(model, glm::vec3(0.5f * size.x, 0.5f * size.y, 0.0f)); // Move origin of rotation to center of quad
model = glm::rotate(model, rotate, glm::vec3(0.0f, 0.0f, 1.0f)); // Then rotate
model = glm::translate(model, glm::vec3(-0.5f * size.x, -0.5f * size.y, 0.0f)); // Move origin back
model = glm::scale(model, glm::vec3(size, 1.0f)); // Last scale
this->shader.SetMatrix4("model", model);
// Render textured quad
this->shader.SetVector3f("spriteColor", color);
glActiveTexture(GL_TEXTURE0);
GLuint VBO;
GLfloat vertices[] = {
// Pos // Tex
0.0f, 1.0f, sheet.minu[frame], sheet.maxv[frame],
1.0f, 0.0f, sheet.maxu[frame], sheet.minv[frame],
0.0f, 0.0f, sheet.minu[frame], sheet.minv[frame],
0.0f, 1.0f, sheet.minu[frame], sheet.maxv[frame],
1.0f, 1.0f, sheet.maxu[frame], sheet.maxv[frame],
1.0f, 0.0f, sheet.maxu[frame], sheet.minv[frame]
};
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
sheet.Bind();
glBindVertexArray(this->quadVAO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0);
glDrawArrays(GL_TRIANGLES, 0, 6);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindVertexArray(0);
}
Player::Player(PlatformState& platformState, BoxWorld* world, sf::Vector2f& size, sf::Vector2f& position, ResourceCollection& resource, LightSolver* lightSolver, StatManager& stats)
: Entity(world, size, position)
, mPlatformState(platformState)
, groundCallBack(nullptr)
, leftButton(false)
, rightButton(false)
, downButton(false)
, mResource(resource)
, flashLight(lightSolver->createLight(FLASHLIGHT_SIZE.x, FLASHLIGHT_SIZE.y))
, maskRight(&resource.getTexture("Assets/Shader/mask.png"))
, maskLeft(flipTexture(maskRight))
, activeStreetLight(nullptr)
, collisionFixture(body->GetFixtureList())
, mStats(stats)
, flashLightBody(world->createEntityBody(sf::Vector2f(0.0f, 0.0f), static_cast<sf::Vector2f>(FLASHLIGHT_SIZE), false))
{
flashLight->setColor(sf::Color(255, 255, 0, 150));
int group = flashLight->getFilterGroup();
group |= (1 << 8);
flashLight->setFilterGroup(group);
setFilterGroup(getFilterGroup() | (1 << 8));
setState(PLAYER_STATE::NORMAL);
/* Walking/run animation */
auto &walking = mResource.getTexture("Assets/Characters/Stella Left.png");
sf::Vector2i walkingSize = static_cast<sf::Vector2i>(walking.getSize());
sf::Vector2i frameSize(256, 256);
SpriteSheet spritesheet1(frameSize, walkingSize);
std::vector<sf::IntRect> frames = spritesheet1.getAllFrames();
mWalking = new Animation(frames,walking);
/* Idle animation */
auto &idle = mResource.getTexture("Assets/Characters/Stella idle.png");
sf::Vector2i idleSize = static_cast<sf::Vector2i>(idle.getSize());
SpriteSheet idleSheet(frameSize,idleSize);
std::vector<sf::IntRect> idleFrames = idleSheet.getAllFrames();
mIdle = new Animation(idleFrames,idle);
/* Jump animation */
auto &jump = mResource.getTexture("Assets/Characters/Stella jump.png");
sf::Vector2i jumpSize = static_cast<sf::Vector2i>(jump.getSize());
SpriteSheet jumpSheet(frameSize,jumpSize);
std::vector<sf::IntRect> jumpFrames = jumpSheet.getAllFrames();
mJump = new Animation(jumpFrames,jump);
/* Grab animation */
auto &grab = mResource.getTexture("Assets/Characters/Stella grab.png");
sf::Vector2i grabSize = static_cast<sf::Vector2i>(grab.getSize());
SpriteSheet grabSheet (frameSize, grabSize);
std::vector<sf::IntRect> grabFrames = grabSheet.getAllFrames();
mGrab = new Animation(grabFrames,grab);
/* Fall Animation*/
auto &fall = mResource.getTexture("Assets/Characters/Stella fall.png");
sf::Vector2i fallSize = static_cast<sf::Vector2i>(fall.getSize());
SpriteSheet fallSheet(frameSize, fallSize);
std::vector<sf::IntRect> fallFrames = jumpSheet.getAllFrames();
mFall = new Animation(fallFrames,fall);
/* Hit Animation*/
auto &hit = mResource.getTexture("Assets/Characters/Stella hit.png");
sf::Vector2i hitSize = static_cast<sf::Vector2i>(hit.getSize());
SpriteSheet hitSheet(frameSize, hitSize);
std::vector<sf::IntRect> hitFrames = hitSheet.getAllFrames();
mHit = new Animation(hitFrames,hit);
anime.setAnimation(*mIdle);
updateSpriteOrigin();
mJumpSound = new sf::Sound;
mJumpSound->setBuffer(*mResource.getSound("Assets/Sound/Jump.wav"));
mWalkSound = new sf::Sound;
mWalkSound->setBuffer(*mResource.getSound("Assets/Sound/Stella_Run_Loop_1.wav"));
mWalkSound->setVolume(40);
mHurtSound = new sf::Sound;
mHurtSound->setBuffer(*mResource.getSound("Assets/Sound/Stella get hurt.wav"));
setupSensors(position, size);
body->SetLinearDamping(1.0f);
/* Set filter for collisions */
b2Filter filter = collisionFixture->GetFilterData();
filter.categoryBits = PLAYER;
//filter.maskBits =ALL, ENEMY_CHASE, ENEMY_ATTACK;
filter.groupIndex = ALL, ENEMY_CHASE, ENEMY_ATTACK;
collisionFixture->SetFilterData(filter);
knockForce = 35;
toggle = false;
}
void SpriteImporter::import(const ImportingAsset& asset, IAssetCollector& collector)
{
String atlasName = asset.assetId;
String spriteSheetName = Path(asset.assetId).replaceExtension("").string();
std::vector<ImageData> totalFrames;
Maybe<Metadata> startMeta;
Maybe<String> palette;
for (auto& inputFile: asset.inputFiles) {
auto fileInputId = Path(inputFile.name).dropFront(1);
const String spriteName = fileInputId.replaceExtension("").string();
// Meta
Metadata meta = inputFile.metadata;
if (!startMeta) {
startMeta = meta;
}
Vector2i pivot;
pivot.x = meta.getInt("pivotX", 0);
pivot.y = meta.getInt("pivotY", 0);
Vector4s slices;
slices.x = gsl::narrow<short, int>(meta.getInt("slice_left", 0));
slices.y = gsl::narrow<short, int>(meta.getInt("slice_top", 0));
slices.z = gsl::narrow<short, int>(meta.getInt("slice_right", 0));
slices.w = gsl::narrow<short, int>(meta.getInt("slice_bottom", 0));
bool trim = meta.getBool("trim", true);
// Palette
auto thisPalette = meta.getString("palette", "");
if (palette) {
if (thisPalette != palette.get()) {
throw Exception("Incompatible palettes in atlas \"" + atlasName + "\". Previously using \"" + palette.get() + "\", now trying to use \"" + thisPalette + "\"", HalleyExceptions::Tools);
}
} else {
palette = thisPalette;
}
// Import image data
std::vector<ImageData> frames;
if (inputFile.name.getExtension() == ".ase" || inputFile.name.getExtension() == ".aseprite") {
// Import Aseprite file
frames = AsepriteReader::importAseprite(spriteName, gsl::as_bytes(gsl::span<const Byte>(inputFile.data)), trim);
} else {
// Bitmap
auto span = gsl::as_bytes(gsl::span<const Byte>(inputFile.data));
auto image = std::make_unique<Image>(span, fromString<Image::Format>(meta.getString("format", "undefined")));
frames.emplace_back();
auto& imgData = frames.back();
imgData.clip = trim ? image->getTrimRect() : image->getRect(); // Be careful, make sure this is done before the std::move() below
imgData.img = std::move(image);
imgData.duration = 100;
imgData.filenames.emplace_back(":img:" + fileInputId.toString());
imgData.frameNumber = 0;
imgData.sequenceName = "";
}
// Update frames with pivot and slices
for (auto& f: frames) {
f.pivot = pivot;
f.slices = slices;
}
// Split into a grid
const Vector2i grid(meta.getInt("tileWidth", 0), meta.getInt("tileHeight", 0));
if (grid.x > 0 && grid.y > 0) {
frames = splitImagesInGrid(frames, grid);
}
// Write animation
Animation animation = generateAnimation(spriteName, spriteSheetName, meta.getString("material", "Halley/Sprite"), frames);
collector.output(spriteName, AssetType::Animation, Serializer::toBytes(animation));
std::move(frames.begin(), frames.end(), std::back_inserter(totalFrames));
}
// Generate atlas + spritesheet
SpriteSheet spriteSheet;
auto atlasImage = generateAtlas(atlasName, totalFrames, spriteSheet);
spriteSheet.setTextureName(atlasName);
// Image metafile
auto size = atlasImage->getSize();
Metadata meta;
if (startMeta) {
meta = startMeta.get();
}
if (palette) {
meta.set("palette", palette.get());
}
meta.set("width", size.x);
meta.set("height", size.y);
meta.set("compression", "raw_image");
// Write atlas image
ImportingAsset image;
image.assetId = atlasName;
image.assetType = ImportAssetType::Image;
image.inputFiles.emplace_back(ImportingAssetFile(atlasName, Serializer::toBytes(*atlasImage), meta));
collector.addAdditionalAsset(std::move(image));
// Write spritesheet
collector.output(spriteSheetName, AssetType::SpriteSheet, Serializer::toBytes(spriteSheet));
}
void Entity::Draw(ShaderProgram* program, Matrix& gameMatrix, SpriteSheet& sprite) {
sprite.Draw(program, gameMatrix, x, y);
}
// TODO: find a cleaner way that this massive mess ?
SpriteSheet* SpriteSheetManager::load(const std::string& textureName)
{
sf::Texture* t = new sf::Texture();
if (!t->loadFromFile(textureName))
{
// BAD!
}
SpriteSheet* s = new SpriteSheet(*t);
if (textureName == "Castle2.png")
{
}
else if (textureName == "wood_tileset_3.png")
{
sf::Sprite* sprite;
sprite = new sf::Sprite(*t, sf::IntRect(0,0,32,32)); // only grass
tiles[TileGame::Grass][TileGame::Grass][TileGame::Grass][TileGame::Grass] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(64,0,32,32));// grass top left
tiles[TileGame::Grass][TileGame::Grass][TileGame::Earth][TileGame::Grass] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(64,32,32,32)); // horizontal separation (grass left)
tiles[TileGame::Grass][TileGame::Grass][TileGame::Earth][TileGame::Earth] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(64,64,32,32)); // grass bottom left
tiles[TileGame::Grass][TileGame::Grass][TileGame::Grass][TileGame::Earth] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(96,0,32,32)); // vertical separation (grass top)
tiles[TileGame::Grass][TileGame::Earth][TileGame::Earth][TileGame::Grass] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(96,32,32,32));// only earth
tiles[TileGame::Earth][TileGame::Earth][TileGame::Earth][TileGame::Earth] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(96,64,32,32));// vertical separation (grass bottom)
tiles[TileGame::Earth][TileGame::Grass][TileGame::Grass][TileGame::Earth] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(128,0,32,32));// grass right top
tiles[TileGame::Grass][TileGame::Earth][TileGame::Grass][TileGame::Grass] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(128,32,32,32));// horizontal separation (grass right)
tiles[TileGame::Earth][TileGame::Earth][TileGame::Grass][TileGame::Grass] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(128,64,32,32)); // grass bottom right
tiles[TileGame::Earth][TileGame::Grass][TileGame::Grass][TileGame::Grass] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(256,192,32,32)); // grass bottom left, top right
tiles[TileGame::Earth][TileGame::Grass][TileGame::Earth][TileGame::Grass] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(160,224,32,32)); // grass top left, bottom right
tiles[TileGame::Grass][TileGame::Earth][TileGame::Grass][TileGame::Earth] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(192,224,32,32)); // minimum grass bottom right
tiles[TileGame::Earth][TileGame::Earth][TileGame::Grass][TileGame::Earth] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(224,224,32,32)); // minimum grass bottom left
tiles[TileGame::Earth][TileGame::Grass][TileGame::Earth][TileGame::Earth] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(192,256,32,32)); // minimum grass top right
tiles[TileGame::Earth][TileGame::Earth][TileGame::Earth][TileGame::Grass] = sprite;
sprite = new sf::Sprite(*t, sf::IntRect(224,256,32,32)); // minimum grass top left
tiles[TileGame::Grass][TileGame::Earth][TileGame::Earth][TileGame::Earth] = sprite;
}
else if (textureName == "BODY_male.png")
{
Animation* anim = new Animation();
anim->setSpriteSheet(*t);
anim->addFrame(sf::IntRect(0,0,64,64));
s->addAnimation("idleUp",anim);
anim = new Animation();
anim->setSpriteSheet(*t);
anim->addFrame(sf::IntRect(0,64,64,64));
s->addAnimation("idleLeft",anim);
anim = new Animation();
anim->setSpriteSheet(*t);
anim->addFrame(sf::IntRect(0,128,64,64));
s->addAnimation("idleDown",anim);
anim = new Animation();
anim->setSpriteSheet(*t);
anim->addFrame(sf::IntRect(0,192,64,64));
s->addAnimation("idleRight",anim);
anim = new Animation();
anim->setSpriteSheet(*t);
for (int i = 1; i < 8; ++i)
anim->addFrame(sf::IntRect(i * 64,0,64,64));
s->addAnimation("walkUp",anim);
anim = new Animation();
anim->setSpriteSheet(*t);
for (int i = 1; i < 8; ++i)
anim->addFrame(sf::IntRect(i * 64,64,64,64));
s->addAnimation("walkLeft",anim);
anim = new Animation();
anim->setSpriteSheet(*t);
for (int i = 1; i < 8; ++i)
anim->addFrame(sf::IntRect(i * 64,128,64,64));
s->addAnimation("walkDown",anim);
anim = new Animation();
anim->setSpriteSheet(*t);
for (int i = 1; i < 8; ++i)
anim->addFrame(sf::IntRect(i * 64,192,64,64));
s->addAnimation("walkRight",anim);
}
textures[textureName] = s;
return s;
}
void TextTestApp::setup()
{
hideBackground = false;
activeUserPresent = false;
// SET UP BLUR STUFF
// setup our scene Fbo
mFboScene = gl::Fbo( getWindowWidth(), getWindowHeight() );
// setup our blur Fbo's, smaller ones will generate a bigger blur
mFboBlur1 = gl::Fbo(getWindowWidth()/8, getWindowHeight()/8);
mFboBlur2 = gl::Fbo(getWindowWidth()/8, getWindowHeight()/8);
OutlineParams::getInstance()->init();
// load and compile the shaders
try {
mShaderBlur = gl::GlslProg(
loadFile("../shaders/blur_vert.glsl"),
loadFile("../shaders/blur_frag.glsl"));
} catch(...) {
console() << "Can't load/compile blur shader" << endl;
quit();
}
try {
mShaderPhong = gl::GlslProg(
loadFile("../shaders/phong_vert.glsl"),
loadFile("../shaders/phong_frag.glsl"));
} catch(...) {
console() << "Can't load/compile phong shader" << endl;
quit();
}
mTransform.setToIdentity();
gestureTracker = GestureTracker::getInstance();
gl::Texture::Format format;
format.enableMipmapping(true);
mCamera.setEyePoint( Vec3f(2.5f, 5.0f, 5.0f) );
mCamera.setCenterOfInterestPoint( Vec3f(0.0f, 2.0f, 0.0f) );
mCamera.setPerspective( 60.0f, getWindowAspectRatio(), 1.0f, 1000.0f );
for (int i=0; i<40; i++)
{
CinderClip cinderClip = CinderClip();
cinderClip.x = -200;
cinderClip.y = -200;
repelClips.push_back(cinderClip);
////
// TweenParticle userParticle = TweenParticle(cinderClip.x, cinderClip.y,10,true);
//userParticles.push_back(userParticle);
}
mbackground.setup();
mbackground.setRepelClips( repelClips ); // I KNOW THEY ON SCREEN
//load store config
cinder::XmlTree configXml(ci::app::loadAsset( "shopconfig.xml" ) );
ShopConfig::getInstance()->parseConfig(configXml);
ci::gl::Texture bubbleManWaveTexture = cinder::loadImage(ci::app::loadResource(BUBBLEMAN_WAVE));
mBubbleManWave = new SpriteSheet();
mBubbleManWave->init(bubbleManWaveTexture, "./spritesheetdata/bubbleman_wave.xml", SpriteSheet::FORMAT_TEXTUREPACKER_GENERIC_XML);
ci::gl::Texture bubbleManRunTexture = cinder::loadImage(ci::app::loadResource(BUBBLEMAN_RUN));
mBubbleManRun = new SpriteSheet();
mBubbleManRun->init(bubbleManRunTexture, "./spritesheetdata/bubbleman_run.xml", SpriteSheet::FORMAT_TEXTUREPACKER_GENERIC_XML);
TextureGlobals::getInstance()->setSpriteSheet(mBubbleManRun,TextureGlobals::SPRITE_BUBBLEMAN_RUN);
TextureGlobals::getInstance()->setSpriteSheet(mBubbleManWave,TextureGlobals::SPRITE_BUBBLEMAN_WAVE);
gl::Texture particleTexture0 = loadImage(loadAsset( "ParticleFullON.png" ) );
TextureGlobals::getInstance()->setParticleTexture(particleTexture0,0);
gl::Texture particleTexture1 = loadImage(loadAsset( "ParticlePatial01.png" ) );
TextureGlobals::getInstance()->setParticleTexture(particleTexture1,1);
gl::Texture particleTexture2 = loadImage(loadAsset( "ParticlePatial02.png" ) );
TextureGlobals::getInstance()->setParticleTexture(particleTexture2,2);
gl::Texture particleTexture3 = loadImage(loadAsset( "ParticlePatial03.png" ) );
TextureGlobals::getInstance()->setParticleTexture(particleTexture3,3);
gl::Texture particleTexture4 = loadImage(loadAsset( "ParticlePatial04.png" ) );
TextureGlobals::getInstance()->setParticleTexture(particleTexture4,4);
gl::Texture particleTexture5 = loadImage(loadAsset( "ParticlePatial05.png" ) );
TextureGlobals::getInstance()->setParticleTexture(particleTexture5,5);
gl::Texture particleTexture6 = loadImage(loadAsset( "background-particle.png" ) );
TextureGlobals::getInstance()->setParticleTexture(particleTexture6,6);
gl::Texture particleTexture7 = loadImage(loadAsset( "ParticleFullONYellow.png" ) );
TextureGlobals::getInstance()->setParticleTexture(particleTexture6,7);
gl::Texture terms1Texture = loadImage(loadAsset( "terms1.png" ) );
TextureGlobals::getInstance()->setParticleTexture(terms1Texture,8);
gl::Texture terms2Texture = loadImage(loadAsset( "terms2.png" ) );
TextureGlobals::getInstance()->setParticleTexture(terms2Texture,9);
//gl::Texture terms2Texture = loadImage(loadAsset( "terms2.png" ) );
//TextureGlobals::getInstance()->setParticleTexture(particleTexture6,9);
myFont = FontRenderer();
fgParticles.setup( 100 );
fgParticles.setRepelClips(repelClips);
// TO VIEW ACTIVE SCENE
//currentScene = new ActiveScene1();
//currentScene->getSignal()->connect( boost::bind(&TextTestApp::onPassiveSceneComplete, this, ::_1 ));
//currentScene->setup( myFont, iconFactory, fgParticles );
currentScene = new PassiveScene1();
currentScene->getSignal()->connect( boost::bind(&TextTestApp::onPassiveSceneComplete, this ));
currentScene->setup( myFont, iconFactory, fgParticles, mbackground.gridLayer1 );
iconFactory.init();
bgAnimationTimer = Timer();
significantInteractionTimer = Timer();
setupSkeletonTracker();
}