Sujets

1

Discussions générales / SFML est lente sur de gros projets.

« le: Juillet 15, 2021, 12:59:55 pm »

Salut, j'ai commencé à utiliser la SFML il y a bien longtemps et mon projet s'agrandissant, je me suis rendu compte que la SFML est lente et on m'a clairement dit que la SFML n'était pas une référence pour faire de gros projets avec opengl.

Les appels à glDraw sont lents surtout lorsqu'on utilise pas mal de textures de rendu, SFML n'utilises aucune technique moderne, que ça soit les buffers (UBO,  bindless textures, etc...), j'ai donc tenté de changer les classes de la SFML pour faire tout ça, mais ça reste lent, à cause des appels à glDraw à chaque rendertexture, j'ai pensé à utiliser des threads pour faire plusieurs appels à draw simultanément en espérant que ça n'altère pas le rendu final (normalement non car c'est opengl qui se charge de faire la synchronisation au niveau de la mise à jour de l'affichage) et que je n'aie pas trop de crash à cause des accès concurrents, on m'a même carrément conseillé d'utiliser VULKAN plutôt qu'opengl pour faire du multithreading, cependant, SFML ne possède actuellement pas d'implémentation pour VULKAN, je n'en ai pas trouver du moins.

Mais il n'y a pas que ça, j'ai remarqué que plus le CPU est lent à l'exécution, plus le GPU l'est aussi, j'ai remarqué que les fonctions virtuelles (SFML en utilise) sont lentes sur de plus gros projets, parce que, la recherche de la bonne fonction à appeler se fait à l'exécution et non pas en compilation.

J'ai pensé alors à un système de type ECS qui utilise la composition plutôt que l'héritage cependant cela est lourd pour gérer des noeuds (Récupérer les composants de tout les noeuds enfants et calculer la transformation finale) comme c'est illustré dans l'exemple de l'un des tutoriels de la SFML d'ailleurs.

J'ai donc pensé aux nouvelles fonctionnalités du c++ moderne c'est à dire aux templates variadiques et au polymorphisme d'inclusion qui est beaucoup plus rapide d'après mes tests (Malgré le fait qu'il faille rechercher le bon type dérivé à l'exécution mais je le fait à coup de "if" générés en compilation ce qui est rapide) et j'ai implémenté cette solution.

Pourquoi la SFML, n'utilise t'elle pas des fonctionnalités du c++ moderne ? (Et il n'y a pas que la SFML, beaucoup d'ancienne bibliothèque ne le font pas)
Est ce que cela va changer à l'avenir ?

Je pense que si les nouvelles technologies existent, c'est pour certaines raisons, des questions de performance la plupart du temps.


 

2

Suggestions de nouvelles fonctionnalités / Un support pour vulkan de prévu ?

« le: Janvier 18, 2021, 07:59:41 pm »

Salut, je ne sais pas si opengl va persister on m'a conseillé de passer à vulkan mais je la trouve, comment dire, pas du tout adaptée pour SFML déjà que SFML utilise les anciennes versions de opengl et que vulkan fonctionne à peut prêt comme l'opengl moderne, en plus le module fenêtre de la SFML crée un contexte opengl je ne pense pas qu'on puisse créer une fenêtre SFML sans contexte opengl et utiliser vulkan comme on pourrait le faire avec la SDL et glfw.

Et si opengl disparait SFML disparait aussi à moins de la recoder pour vulkan et j'aurai bien aimé avoir un code source de référence pour encapsuler vulkan dans des classes textures, shader, rendertexture comme le fait la SFML histoire d'être sûr de faire ça correctement pour mon framework.

3

Système / undefined references errors.

« le: Janvier 12, 2021, 12:02:33 am »

Salut! je voudrais essayer de compiler une lib en shared qui utilise SFML mais j'ai des messages d'erreurs :

CMakeFiles\odfaeg-math.dir/objects.a(distribution.cpp.obj):distribution.cpp:(.text+0x15d): undefined reference to `_imp___ZN2sf7secondsEf'
CMakeFiles\odfaeg-math.dir/objects.a(distribution.cpp.obj):distribution.cpp:(.text+0x350): undefined reference to `_imp___ZN2sf5ColorC1Ev'
CMakeFiles\odfaeg-math.dir/objects.a(distribution.cpp.obj):distribution.cpp:(.text+0x917): undefined reference to `_imp___ZNK2sf4Time9asSecondsEv'
C:/PROGRA~2/CODEBL~1/MinGW/bin/../lib/gcc/mingw32/5.1.0/../../../../mingw32/bin/ld.exe: CMakeFiles\odfaeg-math.dir/objects.a(distribution.cpp.obj): bad reloc address 0x4 in section `.text.startup'
collect2.exe: error: ld returned 1 exit status
src\odfaeg\Math\CMakeFiles\odfaeg-math.dir\build.make:246: recipe for target 'lib/odfaeg-math-1.dll' failed
mingw32-make[2]: *** [lib/odfaeg-math-1.dll] Error 1
CMakeFiles\Makefile2:263: recipe for target 'src/odfaeg/Math/CMakeFiles/odfaeg-math.dir/all' failed
mingw32-make[1]: *** [src/odfaeg/Math/CMakeFiles/odfaeg-math.dir/all] Error 2
Makefile:128: recipe for target 'all' failed
mingw32-make: *** [all] Error 2
 

J'ai des undefined references de sf::seconds, sf::Color et sf::Time :

/////////////////////////////////////////////////////////////////////////////////
//
// Thor C++ Library
// Copyright (c) 2011-2014 Jan Haller
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
/////////////////////////////////////////////////////////////////////////////////

#include "../../../include/odfaeg/Math/distributions.h"

#include <cassert>


namespace odfaeg
{
    namespace math {
        namespace Distributions
        {
            namespace
            {
                template <typename T>
                Distribution<T> uniformT(T min, T max)
                {
                    assert(min <= max);

                    return [=] () -> T
                    {
                        return Math::random(min, max);
                    };
                }
            }
            // ---------------------------------------------------------------------------------------------------------------------------


            Distribution<int> uniformi(int min, int max)
            {
                return uniformT(min, max);
            }

            Distribution<unsigned int> uniformui(unsigned int min, unsigned int max)
            {
                return uniformT(min, max);
            }

            Distribution<float> uniform(float min, float max)
            {
                return uniformT(min, max);
            }

            Distribution<sf::Time> uniform(sf::Time min, sf::Time max)
            {
                assert(min <= max);

                const float floatMin = min.asSeconds();
                const float floatMax = max.asSeconds();

                return [=] () -> sf::Time
                {
                    return sf::seconds(Math::random(floatMin, floatMax));
                };
            }

            Distribution<sf::Vector3f> rect(sf::Vector3f center, sf::Vector3f halfSize)
            {
                assert(halfSize.x >= 0.f && halfSize.y >= 0.f);

                return [=] () -> sf::Vector3f
                {
                    return sf::Vector3f(
                    Math::random(center.x - halfSize.x, center.x + halfSize.x),
                    Math::random(center.y - halfSize.y, center.y + halfSize.y),
                    Math::random(center.z - halfSize.z, center.z + halfSize.z));
                };
            }

            Distribution<sf::Vector3f> circle(sf::Vector3f center, float radius)
            {
                assert(radius >= 0.f);

                return [=] () -> sf::Vector3f
                {
                    //sf::Vector3f radiusVector = sf::Vector3f(radius * std::sqrt(Math::random(0.f, 1.f)), Math::random(0.f, 360.f), 0);
                    sf::Vector3f radiusVector = sf::Vector3f(Math::random(0, radius) * Math::cosinus(Math::random(0, Math::toRadians(360))), Math::random(0, radius) * Math::sinus(Math::random(0, Math::toRadians(360))), 0);
                    return center + radiusVector;
                };
            }

            Distribution<sf::Vector3f> deflect(sf::Vector3f direction, float maxRotation)
            {
                return [=] () -> sf::Vector3f
                {
                    Vec3f v(direction.x, direction.y, direction.z);
                    graphic::TransformMatrix tm;
                    tm.setRotation(Vec3f(0, 0, 1), Math::random(0.f - maxRotation, 0.f + maxRotation));
                    Vec3f t = tm.transform(v);
                    return sf::Vector3f(t.x, t.y, t.z);
                };

            }
            Distribution<sf::Color> color(Vec3f color1, Vec3f color2) {
                return [=] () -> sf::Color {
                    sf::Color color;
                    color.r = Math::clamp(Math::random(color1.x, color2.x), 0, 255);
                    color.g = Math::clamp(Math::random(color1.y, color2.y), 0, 255);
                    color.b = Math::clamp(Math::random(color1.z, color2.z), 0, 255);
                    color.a = Math::clamp(Math::random(color1.w, color2.w), 0, 255);
                    return color;
                };
            }
        }

    } // namespace Distributions
} // namespace thor

 

Je lie SFML dans le fichier CMake :

# include the ODFAEG specific macros
include(${PROJECT_SOURCE_DIR}/cmake/Macros.cmake)

set(INCROOT ${PROJECT_SOURCE_DIR}/include/odfaeg/Math)
set(SRCROOT ${PROJECT_SOURCE_DIR}/src/odfaeg/Math)
set(SRC
        ${INCROOT}/transformMatrix.h
        ${SRCROOT}/transformMatrix.cpp
        ${INCROOT}/export.hpp
        ${INCROOT}/computer.h
        ${SRCROOT}/computer.cpp
        ${INCROOT}/maths.h
        ${SRCROOT}/maths.cpp
        ${INCROOT}/matrix2.h
        ${SRCROOT}/matrix2.cpp
        ${INCROOT}/matrix3.h
        ${SRCROOT}/matrix3.cpp
        ${INCROOT}/matrix4.h
        ${SRCROOT}/matrix4.cpp 
        ${INCROOT}/vec2f.h
        ${SRCROOT}/vec2.cpp
        ${INCROOT}/vec4.h
        ${SRCROOT}/vec4.cpp
        ${INCROOT}/distributions.h
        ${INCROOT}/distribution.h
        ${SRCROOT}/distribution.cpp
        ${INCROOT}/ray.h
        ${SRCROOT}/ray.cpp
        ${INCROOT}/bigInt.hpp
        ${SRCROOT}/bigInt.cpp)
       
include_directories(${CMAKE_INCLUDE_PATH})
link_directories (${CMAKE_LIBRARY_PATH})
find_package (SFML 2 REQUIRED)
sfgl_add_library(odfaeg-math
                                 SOURCES ${SRC}
                                 DEPENDS odfaeg-core)
target_link_libraries (odfaeg-math ${SFML_LIBRARIES})
 

4

Graphique / Quelquee questions sur sf::Text

« le: Décembre 11, 2020, 01:53:12 am »

Salut!

Y a t'il une fonction pour récupérer le rectangle englobant d'un caractère pour faire de la sélection de texte ?
Et lorsque j'appuie sur la touche "enter" ça insère un caractère mais ça ne retourne pas à la ligne.
Apparemment faut récupérer le Glyph :
https://www.sfml-dev.org/tutorials/2.5/graphics-text-fr.php

5

Système / [RESOLU]Erreur de compilation lors de la construction d'un thread.

« le: Décembre 02, 2020, 05:59:18 pm »

Salut, je voudrais appeler un thread mais j'ai un problème en compilation :

Listener(bool useThread=false) : m_thread(&Listener::run) {
                if (useThread) {
                    m_thread.launch();
                }
             }
             void run() {
                 running = true;
                 while (running) {
                    processEvents();
                 }
             }
             void stop() {
                 running = false;
             }
 

C:/Users/Laurent/Windows/ODFAEG/extlibs/headers/SFML/System/Thread.inl: In instantiation of 'void sf::priv::ThreadFunctor<T>::run() [with T = void (odfaeg::core::Listener::*)()]':
C:\Users\Laurent\Windows\ODFAEG\src\odfaeg\Core\application.cpp:8:1:   required from here
C:/Users/Laurent/Windows/ODFAEG/extlibs/headers/SFML/System/Thread.inl:39:25: error: must use '.*' or '->*' to call pointer-to-member function in '((sf::priv::ThreadFunctor<void (odfaeg::core::Listener::*)()>*)this)->sf::priv::ThreadFunctor<void (odfaeg::core::Listener::*)()>::m_functor (...)', e.g. '(... ->* ((sf::priv::ThreadFunctor<void (odfaeg::core::Listener::*)()>*)this)->sf::priv::ThreadFunctor<void (odfaeg::core::Listener::*)()>::m_functor) (...)'
     virtual void run() {m_functor();}
                         ^
src\odfaeg\Core\CMakeFiles\odfaeg-core.dir\build.make:90: recipe for target 'src/odfaeg/Core/CMakeFiles/odfaeg-core.dir/application.cpp.obj' failed
mingw32-make[2]: *** [src/odfaeg/Core/CMakeFiles/odfaeg-core.dir/application.cpp.obj] Error 1
CMakeFiles\Makefile2:236: recipe for target 'src/odfaeg/Core/CMakeFiles/odfaeg-core.dir/all' failed
mingw32-make[1]: *** [src/odfaeg/Core/CMakeFiles/odfaeg-core.dir/all] Error 2
Makefile:128: recipe for target 'all' failed
mingw32-make: *** [all] Error 2

Et avec std::thread j'ai une autre erreur...

6

Graphique / Blending pas fais avec les textures des FBO.

« le: Mars 11, 2020, 04:44:51 pm »

Salut, j'ai fais un code minimal pour reproduire le bug, j'essaie d'afficher un rectangle rouge sur la texture d'un FBO et un rectangle vert et un rectangle bleu sur une autre texture de FBO, mais, le blending alpha ne e faire pas et le rectangle rouge n'est pas affiché et pas de blending non plus à l'intersection du rectangle vert et bleu.

Voici le code :

int main(int argc, char* argv[])
{
    sf::RenderWindow window(sf::VideoMode(800, 600), "test blending", sf::Style::Default,
    sf::ContextSettings(0, 0, 0, 3, 0));
    sf::RenderTexture rt1, rt2;
    rt1.create(800, 600, sf::ContextSettings(0, 0, 0, 3, 0));
    rt2.create(800, 600, sf::ContextSettings(0, 0, 0, 3, 0));
    sf::RectangleShape tile1 (sf::Vector2f(100, 50));
    tile1.setFillColor(sf::Color(255, 0, 0, 50));
    sf::RectangleShape tile2 (sf::Vector2f(100, 50));
    tile2.setPosition(50, 25);
    tile2.setFillColor(sf::Color(0, 255, 0, 50));
    sf::RectangleShape tile3 (sf::Vector2f(100, 50));
    tile3.setPosition(-50, 25);
    tile3.setFillColor(sf::Color(0, 0, 255, 50));
    sf::Sprite trt1(rt1.getTexture());
    sf::Sprite trt2(rt2.getTexture());
    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                window.close();
            }
        }
        window.clear();
        rt1.clear();
        rt2.clear();
        rt1.draw(tile1);
        rt1.display();
        rt2.draw(tile2);
        rt2.draw(tile3);
        rt2.display();
        window.draw(trt1);
        window.draw(trt2);
        window.display();
    }
    return 0;
}
 

Je suis sur windows 10 et ma carte graphique c'est une nvidia.
Lorsque j'essaie sur mon portable avec linux et une carte graphique amd ça marche.
Quelqu'un m'a dit qu'il fallait utiliser des autres paramètres pour le blending avec des FBO mais je ne sais pas lesquels.