/// <summary>
/// Initializes a new instance of the <see cref="Powerup"/> class.
/// </summary>
/// <param name="window">The window.</param>
/// <param name="startPoint">The start point.</param>
/// <param name="type">The type.</param>
/// <param name="resourceHandler">The resource handler.</param>
/// <param name="timeStep">The time step.</param>
Powerup::Powerup(
sf::RenderWindow& window,
VectorN startPoint,
int type,
std::shared_ptr<ResourceHandler>& resourceHandler,
const sf::Time& timeStep
) :
resourceHandler(resourceHandler),
type((Powerup::PowerUpType)type),
Object(window),
timeStep(timeStep),
speedX(0),
speedY(150)
{
// Determine which type the poweup is, set the desired texture.
if (type == Powerup::PowerUpType::HEALTH_INCREMENT)
{
sprite = std::unique_ptr<GameShape>(new GameShape(GameShape::ShapeType::CIRCLE, 10, 20));
sprite->setTexture(&resourceHandler->getTexture(ResourceHandler::Texture::HEALTH_KIT));
}
else if (type == Powerup::PowerUpType::PULSATING_GUN)
{
sprite = std::unique_ptr<GameShape>(new GameShape(GameShape::ShapeType::CIRCLE, 20, 20));
sprite->setTexture(&resourceHandler->getTexture(ResourceHandler::Texture::PULSE_GUN));
}
// Set the position of the sprite powerup
sprite->setPosition(startPoint.x, startPoint.y);
}
void VolumeRAM2GLConverter::update(std::shared_ptr<const VolumeRAM> volumeSrc,
std::shared_ptr<VolumeGL> volumeDst) const {
if (volumeSrc->getDimensions() != volumeDst->getDimensions()) {
volumeDst->setDimensions(volumeSrc->getDimensions());
}
volumeDst->getTexture()->upload(volumeSrc->getData());
}
void LayerGL2RAMConverter::update(std::shared_ptr<const LayerGL> layerSrc,
std::shared_ptr<LayerRAM> layerDst) const {
if (layerSrc->getDimensions() != layerDst->getDimensions()) {
layerDst->setDimensions(layerSrc->getDimensions());
}
layerSrc->getTexture()->download(layerDst->getData());
}
void VolumeCLGL2RAMConverter::update(std::shared_ptr<const VolumeCLGL> volumeSrc,
std::shared_ptr<VolumeRAM> volumeDst) const {
if (volumeSrc->getDimensions() != volumeDst->getDimensions()) {
volumeDst->setDimensions(volumeSrc->getDimensions());
}
volumeSrc->getTexture()->download(volumeDst->getData());
if (volumeDst->hasHistograms()) volumeDst->getHistograms()->setValid(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="Bullet"/> class.
/// </summary>
/// <param name="window">The window.</param>
/// <param name="bulletType">Type of the bullet.</param>
/// <param name="timeStep">The time step.</param>
/// <param name="resourceHandler">The resource handler.</param>
Bullet::Bullet(sf::RenderWindow& window, Bullet::Type bulletType, const sf::Time& timeStep, std::shared_ptr<ResourceHandler>& resourceHandler) :
Object(window),
bulletType(bulletType),
timeStep(timeStep),
deg(-1) // Set rotation as -1 while not inited.
{
setDeleted(false);
// Define the bullet texutres as a standard shot
if (Bullet::Type::standardShot == bulletType){
sprite = std::shared_ptr<GameShape>(new GameShape(GameShape::CIRCLE, 3, 10));
sprite->setTexture(&resourceHandler->getTexture(ResourceHandler::Texture::REGULAR_BULLET_1));
}
// Define the bullet textures as a heavy shot
else if (Bullet::Type::heavyShot == bulletType)
{
sprite = std::shared_ptr<GameShape>(new GameShape(GameShape::TRIANGLE, 40.0f));
sprite->setTexture(&resourceHandler->getTexture(ResourceHandler::Texture::HEAVY_SHOT_TEXTURE));
}
}
std::shared_ptr<VolumeRAM> VolumeGL2RAMConverter::createFrom(
std::shared_ptr<const VolumeGL> volumeGL) const {
auto volume = createVolumeRAM(volumeGL->getDimensions(), volumeGL->getDataFormat());
if (volume) {
volumeGL->getTexture()->download(volume->getData());
return volume;
} else {
LogError("Cannot convert format from GL to RAM:" << volumeGL->getDataFormat()->getString());
}
return nullptr;
}
std::shared_ptr<LayerRAM> LayerGL2RAMConverter::createFrom(
std::shared_ptr<const LayerGL> layerGL) const {
auto layerRAM =
createLayerRAM(layerGL->getDimensions(), layerGL->getLayerType(), layerGL->getDataFormat());
if (layerRAM) {
layerGL->getTexture()->download(layerRAM->getData());
return layerRAM;
} else {
LogError("Cannot convert format from GL to RAM:" << layerGL->getDataFormat()->getString());
}
return nullptr;
}
// hard coded test for now
AnimatedSprite::AnimatedSprite(const std::shared_ptr<AnimatedSpriteData>& spriteData, scene::ISceneNode* parent, irr::scene::ISceneManager* mgr, irr::s32 id):
scene::ISceneNode(parent, mgr, id),
spriteData(spriteData),
playing(false),
startTime(0),
startFrame(0),
currentSequence(0),
looping(false),
flipHorizontal(false),
flipVertical(false)
{
core::dimension2du orig = spriteData->getTexture()->getOriginalSize();
setSize(core::dimension2df(orig.Width / spriteData->getWidth(), size.Height = orig.Height / spriteData->getHeight()));
// initialize vertices
material.Lighting = false;
material.setFlag(video::EMF_BILINEAR_FILTER, false);
material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
material.setTexture(0, spriteData->getTexture());
indices[0] = 0;
indices[1] = 2;
indices[2] = 1;
indices[3] = 0;
indices[4] = 3;
indices[5] = 2;
vertices[0].TCoords.set(1.0f, 1.0f);
vertices[1].TCoords.set(1.0f, 0.0f);
vertices[2].TCoords.set(0.0f, 0.0f);
vertices[3].TCoords.set(0.0f, 1.0f);
for (int i = 0; i < 4; i++)
{
vertices[i].Color.set(255,255,255,255);
}
}
std::shared_ptr<VolumeRAM> VolumeCLGL2RAMConverter::createFrom(
std::shared_ptr<const VolumeCLGL> volumeCLGL) const {
const size3_t dimensions{volumeCLGL->getDimensions()};
auto destination = createVolumeRAM(dimensions, volumeCLGL->getDataFormat());
if (destination) {
volumeCLGL->getTexture()->download(destination->getData());
// const cl::CommandQueue& queue = OpenCL::getPtr()->getQueue();
// queue.enqueueReadVolume(volumeCL->get(), true, glm::size3_t(0), glm::size3_t(dimensions,
// 1), 0, 0, volumeRAM->getData());
} else {
LogError("Invalid conversion or not implemented");
}
return destination;
}
/// <summary>
/// Initializes a new instance of the <see cref="Player"/> class.
/// </summary>
/// <param name="window">The window.</param>
/// <param name="pos">The position.</param>
/// <param name="radius">The radius.</param>
/// <param name="bFactory">The b factory.</param>
/// <param name="bullets">The bullets.</param>
/// <param name="resourceHandler">The resource handler.</param>
/// <param name="timeStep">The time step.</param>
/// <param name="hardMode">The hard mode.</param>
Player::Player(sf::RenderWindow& window,
sf::Vector2f pos,
int radius, BulletFactory& bFactory,
std::list<std::unique_ptr<Bullet>>& bullets,
std::shared_ptr<ResourceHandler>& resourceHandler,
const sf::Time& timeStep,
const bool hardMode,
std::list<std::shared_ptr<Shooter>>& objects
)
:
objects(objects),
playerScore(0),
playerKills(0),
pulsateGun(false),
Shooter(window, bFactory, bullets, resourceHandler, timeStep)
{
// Checks if its hardmode, sets the health correspondingly.
if (!hardMode)
{
setHealth(5);
startHealth = 5;
}
else
{
setHealth(1);
startHealth = 1;
}
// Set the shape type
this->shooterType = Shooter::ShooterType::PLAYER;
// Define the shape for the player
sprite = std::shared_ptr<GameShape>(new GameShape(GameShape::ShapeType::PLAYER_SHIP));
sprite->setTexture(&resourceHandler->getTexture(ResourceHandler::Texture::PLAYER_SHIP));
sprite->setOutlineThickness(1);
sprite->setOutlineColor(sf::Color::Cyan);
this->sprite->setPosition(pos);
}
std::shared_ptr<VolumeCLGL> VolumeGL2CLGLConverter::createFrom(
std::shared_ptr<const VolumeGL> volumeGL) const {
return std::make_shared<VolumeCLGL>(volumeGL->getDimensions(), volumeGL->getDataFormat(),
volumeGL->getTexture());
}
std::shared_ptr<VolumeGL> VolumeCLGL2GLConverter::createFrom(
std::shared_ptr<const VolumeCLGL> src) const {
return std::make_shared<VolumeGL>(src->getTexture(), src->getDataFormat());
}
Element::Element(VertexData vertex_data, std::shared_ptr<Skin> skin, const unsigned int layer) : Renderable(vertex_data.generateVertexArrayObject(), vertex_data), skin(skin), anchor_point(glm::vec2(0.0, 0.0)), width(0), height(0), text_padding(0), cursor_within(false), color(glm::vec4(1.0)), layer(layer) {
setShader(skin->getShader());
addTexture(0, "skin0", skin->getTexture());
getTransform()->translate(glm::vec3(0.0, 0.0, -(float)layer));
}
/// <summary>
/// Initializes a new instance of the <see cref="Enemy"/> class.
/// </summary>
/// <param name="window">The window.</param>
/// <param name="path">The path.</param>
/// <param name="emoteQueue">The emote queue specifies the queue of emotes loaded from script.</param>
/// <param name="type">The type.</param>
/// <param name="repeat">The repeat.</param>
/// <param name="bFactory">The b factory.</param>
/// <param name="bullets">The bullets.</param>
/// <param name="resourceHandler">The resource handler.</param>
/// <param name="timeStep">The time step.</param>
Enemy::Enemy(sf::RenderWindow& window,
std::queue<VectorN> path,
std::list<std::pair<int, std::string>> emoteQueue,
int type, int repeat, BulletFactory& bFactory,
std::list<std::unique_ptr<Bullet>>& bullets,
std::shared_ptr<ResourceHandler>& resourceHandler,
const sf::Time& timeStep
) :
pathTemplate(path), // Const, not to be changed (The template is copyed when a path is over in repeat mode)
emoteQueue(emoteQueue),
repeat(repeat),
secondRot(0),
acceleration(0),
speed(sf::Vector2f(50, 50)),
Shooter(window, bFactory, bullets, resourceHandler, timeStep)
{
// Sets the type of the Shooter to enemy
this->shooterType = Shooter::ShooterType::ENEMY;
// Check which type the enemy is, from this we determine, health, total health , score value and textures,
if (type == 1) // REGULAR
{
setHealth(2);
setStartHealth(2);
sprite = std::unique_ptr<GameShape>(new GameShape(GameShape::ShapeType::STARSHIP));
sprite->setTexture(&resourceHandler->getTexture(ResourceHandler::Texture::ENEMY_SHIP));
this->setEnemyType(Enemy::EnemyType::REGULAR);
this->setScoreValue(100);
}
else if (type == 2) // Chubby Mob
{
setHealth(10);
setStartHealth(10);
sprite = std::unique_ptr<GameShape>(new GameShape(GameShape::ShapeType::CIRCLE, 40, 30));
sprite->setTexture(&resourceHandler->getTexture(ResourceHandler::Texture::CHUBBY_SHIP_TEXTURE));
this->setEnemyType(Enemy::EnemyType::CHUBBY);
this->setScoreValue(250);
}
else if (type == 3) // BOSS
{
setHealth(250);
setStartHealth(250);
sprite = std::unique_ptr<GameShape>(new GameShape(GameShape::ShapeType::BOSS));
sprite->setTexture(&resourceHandler->getTexture(ResourceHandler::Texture::BOSS));
this->setEnemyType(Enemy::EnemyType::BOSS);
this->setScoreValue(500);
}
else if (type == 4) // Umbasta boss
{
setHealth(750);
setStartHealth(750);
sprite = std::unique_ptr<GameShape>(new GameShape(GameShape::ShapeType::CIRCLE, 80, 30));
sprite->setTexture(&resourceHandler->getTexture(ResourceHandler::Texture::BOSS_DEATHSTAR_TEXTURE));
this->setEnemyType(Enemy::EnemyType::DEATHSTAR);
this->setScoreValue(12000);
}
#ifdef _DEBUG
sprite->setOutlineThickness(1);
sprite->setOutlineColor(sf::Color::Cyan);
#endif
setInitPath();
}
GUITextureWrapper(const std::shared_ptr<WidgetType>& widget)
: m_widget(widget ? widget : std::make_shared<WidgetType>())
, texture(m_widget->getTexture())
, style(m_widget->m_style) {}
