SFML C++ drawing a vector of shapes - c++

Question

I just got back into coding. Trying to make a simple breakout game, I did start of just making a simple 'pong' game but found it quite easy so I am trying to expand it to a breakout game (image attached for those who do not know what it is).
To handle the blocks at the top of the screen I have used a vector of blocks, from which right now I am trying to draw them onto the screen. I am unable to do this as I am getting an error:
error C2664: 'void sf::RenderTarget::draw(const sf::Vertex
*,size_t,sf::PrimitiveType,const sf::RenderStates &)' : cannot convert argument 1 from 'Block' to 'const sf::Drawable &'
which is inside the block.cpp file
Here is the relevant code, there are more functions but they do not apply to this. Sorry for any bad code in there :)
block.cpp
Block::Block(float startX, float startY)
{
position.x = startX;
position.y = startY;
colour = sf::Color::White;
block.setSize(sf::Vector2f(width, height));
block.setFillColor(colour);
block.setPosition(position);
}
void Block::draw(Block block, sf::RenderWindow& window)
{
window.draw(block);
}
blockContainer.cpp
#pragma once
class ContainerOfBlocks
{
public:
ContainerOfBlocks(int useless);
~ContainerOfBlocks();
std::vector<Block> getContainer();
void drawContainer(sf::RenderWindow& window);
private:
std::vector<Block> blockContainer;
};
blockContainer.h
#pragma once
class ContainerOfBlocks
{
public:
ContainerOfBlocks(int useless);
~ContainerOfBlocks();
std::vector<Block> getContainer();
void drawContainer(sf::RenderWindow& window);
private:
std::vector<Block> blockContainer;
};
Thank you for any help :)

Answer 1

(I'll have to put it here because I don't have enough reputation yet to comment)
some things
I don't understand why you have this code void Block::draw(Block block, sf::RenderWindow &window). It should be void Block::draw(sf::RenderWindow &window) and then just draw block (which is a class member) OR pass block by reference if you want to draw the block from somewhere else
In any case, Block should inherit from sf::Drawable and use its function to draw. I think that's what the error message is saying. For example class Block : public sf::Drawable { ... }; and the function to draw would be virtual void draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const; in the header and void draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const { renderTarget.draw(block); } in your .cpp. Then you can iterate over the vector of blocks you already have and draw each block
the function std::vector<Block> getContainer() should return a reference to the vector (std::vector<Block> &getContainer())
it's not an error but I prefer using #ifndef ... #define... #endif header guard instead of #pragma once
edit (regarding your replies below):
I made a quick project that uses most of your code.
(Also make sure to read my notes below the code)
Here's a picture of what it looks like compiled:
Code:
block.h
#ifndef BLOCK_H_INCLUDED
#define BLOCK_H_INCLUDED
#include <SFML/Graphics.hpp>
class Block : public sf::Drawable {
public:
Block();
Block::Block(float startX, float startY);
virtual ~Block();
private:
virtual void draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const;
sf::RectangleShape block;
sf::Vector2f position;
float width;
float height;
sf::Color colour;
};
#endif
block.cpp
#include "block.h"
Block::Block() :
position(sf::Vector2f()),
width(40.0f),
height(20.0f),
colour(sf::Color())
{
}
Block::Block(float startX, float startY) :
width(40.0f),
height(20.0f)
{
position.x = startX;
position.y = startY;
colour = sf::Color::White;
block.setSize(sf::Vector2f(width, height));
block.setFillColor(colour);
block.setPosition(position);
}
Block::~Block() {
}
void Block::draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const {
renderTarget.draw(block);
}
blockContainer.h
#ifndef BLOCKCONTAINER_H_INCLUDED
#define BLOCKCONTAINER_H_INCLUDED
#include "block.h"
class ContainerOfBlocks : public sf::Drawable {
public:
ContainerOfBlocks();
ContainerOfBlocks(int useless, const sf::Vector2f pos);
~ContainerOfBlocks();
std::vector<Block> &getContainer();
void drawContainer(sf::RenderWindow &window);
private:
virtual void draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const;
std::vector<Block> blockContainer;
};
#endif
blockContainer.cpp
#include "blockContainer.h"
ContainerOfBlocks::ContainerOfBlocks() {
}
ContainerOfBlocks::ContainerOfBlocks(int useless, const sf::Vector2f pos) {
if (useless > 0) {
float x = pos.x;
float y = pos.y;
for (std::size_t i = 0; i < static_cast<std::size_t>(useless); ++i) {
blockContainer.push_back(Block(x, y));
x += 50.0f;
}
}
}
ContainerOfBlocks::~ContainerOfBlocks() {
}
std::vector<Block> &ContainerOfBlocks::getContainer() {
return blockContainer;
}
void ContainerOfBlocks::drawContainer(sf::RenderWindow &window) {
for (std::size_t i = 0; i < blockContainer.size(); ++i) {
window.draw(blockContainer[i]);
}
}
void ContainerOfBlocks::draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const {
for (std::size_t i = 0; i < blockContainer.size(); ++i) {
renderTarget.draw(blockContainer[i]);
}
}
main.cpp
#include <SFML/Graphics.hpp>
#include "block.h"
#include "blockContainer.h"
int main() {
sf::RenderWindow window(sf::VideoMode(400, 200), "SFML works!");
window.setFramerateLimit(30);
window.setVerticalSyncEnabled(false);
// create container with 5 blocks in it, starting at pos 10/10
// this container will be drawn using ContainerOfBlocks' void drawContainer(sf::RenderWindow &window)
ContainerOfBlocks testBlocks(5, sf::Vector2f(10.0f, 10.0f));
// create another container, starting at pos 10/50
// this one will be drawn using sf::Drawable's function to draw
ContainerOfBlocks testBlocks2(5, sf::Vector2f(10.0f, 50.0f));
while (window.isOpen()) {
sf::Event evt;
while (window.pollEvent(evt)) {
if (evt.type == sf::Event::Closed) {
window.close();
}
}
window.clear();
testBlocks.drawContainer(window);
window.draw(testBlocks2);
window.display();
}
return 0;
}
As you can see Block now inherits from sf::Drawable and can be drawn with xxx.draw(block).
BlockContainer now has two different functions to draw its contents (this is only for demonstrating purposes, you only need one function to draw depending on what you like better). If you want to keep your own drawing function, you can remove the : public sf::Drawable from BlockContainer.
In main() two block containers are created, one (testBlocks) will be drawn using BlockContainer's void drawContainer(sf::RenderWindow &window) draw function from your original code, the other (testBlocks2) using sf::Drawable's.
Also note how &getContainer() now returns a reference to the vector of blocks. If you don't return a reference the original vector won't be affected by whatever you want to do to it from the outside.