SFML C++ Zeichnen eines Vektors von Formen

Question

Ich bin gerade zurück in die Codierung. Beim Versuch, ein einfaches Breakout-Spiel zu machen, habe ich angefangen, ein einfaches Pong-Spiel zu machen, fand es aber ziemlich einfach, also versuche ich, es zu einem Breakout-Spiel zu erweitern (Bild für diejenigen, die nicht wissen, was es ist).

Um die Blöcke am oberen Rand des Bildschirms zu behandeln, habe ich einen Vektor von Blöcken verwendet, von denen ich gerade versuche, sie auf den Bildschirm zu zeichnen. Ich bin nicht in der Lage, dies zu tun, wie ich eine Störung erhalte:

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 &'

die

Hier in der block.cpp Datei ist, ist der entsprechende Code, gibt es mehr Funktionen, aber sie gelten nicht für diese. Sorry für die schlechten Code drin :)

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; 
}; 

Vielen Dank für jede Hilfe :)

Answer 1

(Ich werde hav e es hier zu setzen, weil ich noch genug Ruf haben nicht

einige Dinge

• Ich verstehe nicht, Kommentar), warum Sie diesen Code void Block::draw(Block block, sf::RenderWindow &window) haben. Es sollte void Block::draw(sf::RenderWindow &window) sein und dann ziehen nur block (das ist ein Klassenmitglied ist) OR block durch Verweis übergeben, wenn Sie von einem anderen Ort, den Block ziehen wollen

• In jedem Fall sollte Block von sf::Drawable erben und seine Funktion verwenden, um zeichnen. Ich denke, das ist was die Fehlermeldung sagt. Zum Beispiel class Block : public sf::Drawable { ... }; und die Funktion zum Zeichnen wäre virtual void draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const; in der Kopfzeile und void draw(sf::RenderTarget &renderTarget, sf::RenderStates renderStates) const { renderTarget.draw(block); } in Ihrer .cpp. Dann können Sie über den Vektor der Blöcke durchlaufen Sie bereits haben und jeden Block zeichnen

• die Funktion std::vector<Block> getContainer() einen Verweis auf den Vektor zurückgeben sollte (std::vector<Block> &getContainer())

• es ist kein Fehler, aber ich ziehe mit #ifndef ... #define... #endif Kopf guard statt #pragma once

bearbeiten (in Bezug auf Ihre Antworten unten):

Ich habe ein schnelles Projekt erstellt, das den Großteil Ihres Codes verwendet.

(auch sicherstellen, dass meine Notizen unter dem Code lesen)

Hier ist ein Bild von dem, was es sieht aus wie zusammengestellt:

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; 
} 

Wie Sie Block jetzt erbt von sf::Drawable sehen und gezogen werden kann, mit xxx.d roh (Block).

BlockContainer hat jetzt zwei verschiedene Funktionen, um seinen Inhalt zu zeichnen (dies dient nur zu Demonstrationszwecken, Sie brauchen nur eine Funktion zum Zeichnen, je nachdem, was Ihnen besser gefällt). Wenn Sie Ihre eigene Zeichenfunktion beibehalten möchten, können Sie die : public sf::Drawable von BlockContainer entfernen.

In main() zwei Block-Containern erstellt werden, ein (testBlocks) wird BlockContainer 's void drawContainer(sf::RenderWindow &window) Zeichenfunktion von Ihrem ursprünglichen Code, die anderen (testBlocks2) mit sf::Drawable' gezogen wird unter Verwendung von s.

Beachten Sie auch, wie &getContainer() jetzt einen Verweis auf den Vektor der Blöcke zurückgibt. Wenn Sie keine Referenz zurückgeben, wird der ursprüngliche Vektor nicht von dem beeinflusst, was Sie von außen tun möchten.