Bienvenue, Invité. Merci de vous connecter ou de vous inscrire. Avez-vous oublié d'activer ?

Voir les contributions

Cette section vous permet de consulter les contributions (messages, sujets et fichiers joints) d'un utilisateur. Vous ne pourrez voir que les contributions des zones auxquelles vous avez accès.


Messages - Slash94

Pages: [1] 2 3 ... 6 Suivante »
1
Graphique / Re: Comment modifier un sprite pixel par pixel ?
« le: Octobre 27, 2017, 02:52:42 pm »
Salut l'ami,

J'ai réussi à faire ce que je voulais faire ! Récupérer les pixels un par un selon l'orientation d'un rayon qui parcourt un scanline ! :-D

https://gyazo.com/792b4c053fe375425900b7316cb9fbab

Le GIF est de mauvaise qualité mais je te laisse voir le résultat sur le screenshot ici, on voit bien mieux :

https://image.noelshack.com/fichiers/2017/43/5/1509108663-yes.png

En gros je récupère pixel par pixel le long du parcours du rayon :

        ///RECUPERATION DU TRAIT DE PIXELS AU FUR ET A MESURE///
        if (line[1].position.x >= 0 && line[1].position.x <= texture.getSize().x &&
            line[1].position.y >= 0 && line[1].position.y <= texture.getSize().y)
        {
            redLine[1].position = {line[1].position.x, line[1].position.y};
            sf::Color c = sf ::Color(img.getPixel((int)line[1].position.x, (int)line[1].position.y).r,
                                     img.getPixel((int)line[1].position.x, (int)line[1].position.y).g,
                                     img.getPixel((int)line[1].position.x, (int)line[1].position.y).b);
            vecColors.push_back(c);
        }

Et ensuite ma fonction d'assignation des pixels :

            texStripe.create(1, vecColors.size());

            sf::Uint8 pixels[vecColors.size()*4];

            stripe[0].texCoords = {0,0};
            stripe[1].texCoords = {0, vecColors.size()};
            stripe[1].position = {stripe[0].position.x, vecColors.size()};

            for (unsigned int i = 0 ; i < vecColors.size() ; i++)
            {
                pixels[(i)*4+0] = vecColors[i].r;
                pixels[(i)*4+1] = vecColors[i].g;
                pixels[(i)*4+2] = vecColors[i].b;
                pixels[(i)*4+3] = vecColors[i].a;
            }

            texStripe.update(pixels);

Merci infiniment à toi !!

2
Graphique / Re: Comment modifier un sprite pixel par pixel ?
« le: Octobre 26, 2017, 05:41:13 pm »
Grâce à toi je commence à avoir un rendu mais l'affichage est saturé lorsque je suis trop près... si je galère encore d'ici quelques heures, je te solliciterais à nouveau avec mon code source.. :-D

https://gyazo.com/c177f8c8abef90d185ea366dcc733f84

Je balance un rayon la largeur de mon FOV ( donc 800 rayons sur un champ de 60 degrés car ma fenêtre de rendu est en 800*600 ) et dés que mon rayon est dans la texture, je récupère le pixel et l'affiche, malheureusement, plus la texture est grande plus c'est slow... donc si tu connais une méthode plus optimisée que ça pour faire un Mode 7-like, je suis preneur ;)

3
Graphique / Re: Comment modifier un sprite pixel par pixel ?
« le: Octobre 25, 2017, 05:19:13 pm »
Merci beaucoup Laurent, tu es un homme fantastique !

4
Graphique / Re: Comment modifier un sprite pixel par pixel ?
« le: Octobre 25, 2017, 01:15:55 pm »
Ben je n'arrive pas à comprendre le principe de la modification via un array de sf::Uint8..

J'aimerais vraiment avoir un exemple tangible, ça me ferait probablement un coup de déclic :-)

5
Graphique / Re: Comment modifier un sprite pixel par pixel ?
« le: Octobre 24, 2017, 07:16:04 pm »
Salut à toi Laurent !
Je dois t'avouer que je suis un peu paumé... Si tu as du temps , tu pourrais me confectionner un mini exemple afin de jouer avec les pixels d'une rendertexture pour lui donner une autre forme ? ( exemple , faire une rotation de la texture ) ?

Je ne veux pas utiliser de sprite , c'est pour pouvoir dessiner un effet de perspective ensuite avec des lignes en faisant un scanline vertical  de mon écran par rapport aux pixels de la texture .. Merci :-)

6
Graphique / Re: Comment modifier un sprite pixel par pixel ?
« le: Octobre 23, 2017, 09:37:30 pm »
Merci encore pour ton aide Laurent, néanmoins, penses-tu que sf::image me serait utile pour modifier une texture pixel par pixel ?
Car admettons que j'ai une texture qui fasse 80x80 et que je désire la modifier de manière à lui donner une forme de trapèze tout en prenant le soin de bien "resserrer" les pixels du haut et qui s'élargissent jusqu'en bas du trapèze , cette fonction me serait utile ou bien texture update me suffirait ?
 
( je pose cette question car je suis sur mon téléphone et au boulot donc pas encore pu tester la méthode de ta réponse ! )

Merci !

7
Graphique / Comment modifier un sprite pixel par pixel ?
« le: Octobre 23, 2017, 03:50:54 pm »
Salut à tous ! :-]

Alors voilà, je désirerais modifier un sprite pixel par pixel car je travaille actuellement sur une projection de perspective de type Mode 7 ( dans le même principe que du floor casting, j'ai exploré plusieurs pistes qui étaient plus ou moins fonctionnelles mais toujours soumis à quelques problèmes particulièrement gênants.. ).

Si l'un d'entre vous pourrait m'expliquer comment procéder, j'aurais une excellente idée pour procéder à ma projection tant désirée une fois que j'aurais une idée sur la manière dont je pourrais procéder afin de modifier mes sprites dans les moindres détails.

Merci à vous ;-)

8
Graphique / Re: Comment réaliser une rotation cohérente de plusieurs sprites ?
« le: Octobre 23, 2017, 03:37:03 pm »
Salut Laurent, merci à toi, c'est sympa de m'avoir répondu  ;)
J'ai réussi grâce au sf::RenderTexture ! :-D

9
Graphique / Comment réaliser une rotation cohérente de plusieurs sprites ?
« le: Octobre 22, 2017, 02:26:48 pm »
Salut à tous,

J'aimerais savoir quelle théorie / méthode / algorithme me permettrait de créer un système de rotation de plusieurs sprites comme si ils étaient solidaires les uns des autres ?

Comme cet exemple :



(On s'en fiche du zoom, je parle de la rotation là ).

Car bien évidemment, si je modifie l'angle de chaque sprite dans une boucle, ils tourneront tous depuis leur centre ( leur origin quoi ), ce qui est logique, mais j'aimerais qu'ils tournent tous ensemble telle que sur la vidéo du dessus, une idée de la manière dont je pourrais réaliser ceci ? Merci :-)

10
Graphique / Re: Erreur d'affichage très étrange à cause de math.h
« le: Octobre 15, 2017, 02:45:33 pm »
Nickel, ça marche parfaitement avec <cmath> !

Merci à toi G. :-)

11
Graphique / Erreur d'affichage très étrange à cause de math.h
« le: Octobre 14, 2017, 01:28:41 pm »
Salut à tous,

Je conçois en ce moment un système de projection basé sur le Mode 7.

Lorsque je décide d'inclure la librairie <math.h>, j'ai une erreur d'affichage grotesque, il n'y a que la moitié de mon rendu qui s'affiche :



Alors que lorsque je retire "#include <math.h>", tout se redraw parfaitement..



Je ne comprends absolument pas l'erreur.. Voici mon code :

#include <math.h>
#include <iostream>

#include <SFML/Graphics.hpp>

int main()
{
    unsigned int WIDTHSCREEN = 800, HEIGHTSCREEN = 600;

    sf::RenderWindow app(sf::VideoMode(WIDTHSCREEN, HEIGHTSCREEN), "Rotozoom", sf::Style::Titlebar);
    app.setFramerateLimit(60);

    sf::RenderWindow render(sf::VideoMode(WIDTHSCREEN, HEIGHTSCREEN), "Render", sf::Style::Titlebar);
    render.setFramerateLimit(60);

    sf::Clock clock;

    std::vector<sf::VertexArray>vecLines;
    std::vector<sf::VertexArray>vecQuads;

    sf::Vector2f m_position = {100,100};
    float angle = 0.0f;

    double speedMove = 20;

    for (unsigned int i = 0 ; i < HEIGHTSCREEN ; i++)
    {
        sf::VertexArray line(sf::Lines, WIDTHSCREEN);
        for (unsigned int k = 0 ; k < WIDTHSCREEN ; k++)
            line[k].position = {0, i};
        vecLines.push_back(line);
    }

    std::vector<std::vector<unsigned int>>vecMap =
    {
        {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0},
        {0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0}


    };

    unsigned int blocSize = 32;

    for (unsigned int y = 0 ; y < vecMap.size() ; y++)
    {
        for (unsigned int x = 0 ; x < vecMap[y].size() ; x++)
        {
            if (vecMap[y][x])
            {
                sf::VertexArray quad(sf::Quads, 4);
                quad[0].position = {x*blocSize, y*blocSize};
                quad[1].position = {x*blocSize+blocSize, y*blocSize};
                quad[2].position = {x*blocSize+blocSize, y*blocSize+blocSize};
                quad[3].position = {x*blocSize, y*blocSize+blocSize};

                for (unsigned int c = 0 ; c < 4 ; c++)
                    x%2 ? quad[c].color = sf::Color::Red : quad[c].color = sf::Color::Blue;

                vecQuads.push_back(quad);
            }
        }
    }

    double scale = 200;

    while (app.isOpen())
    {
        sf::Event event;
        while (app.pollEvent(event))
        {
            switch(event.type)
            {
                case sf::Event::Closed:
                    app.close();
                break;
                case sf::Event::KeyReleased:
                    if (event.key.code == sf::Keyboard::Escape)
                        app.close();
                break;
            }
        }

        render.clear();

        for (unsigned int y = 0 ; y < HEIGHTSCREEN ; y++)
        {
            unsigned int l = 0;
            for (unsigned int x = 0 ; x < WIDTHSCREEN ; x++)
            {
                for (unsigned int i = 0 ; i < vecQuads.size() ; i++)
                {
                    double xDistance = abs(WIDTHSCREEN/2-x);

                    if (x==vecQuads[i][0].position.x && y>=vecQuads[i][0].position.y && y<= vecQuads[i][3].position.y)
                    {
                        vecLines[y][l].position.x = WIDTHSCREEN/2;
                        vecLines[y][l].position.y = y/2;
                        vecLines[y][l].color = vecQuads[i][0].color;

                        if (x<WIDTHSCREEN/2)
                            vecLines[y][l].position.x = x - (y*xDistance/scale);
                        if (x>WIDTHSCREEN/2)
                            vecLines[y][l].position.x = x + (y*xDistance/scale);
                        l++;
                    }

                    if (x==vecQuads[i][1].position.x && y>=vecQuads[i][0].position.y && y<= vecQuads[i][2].position.y)
                    {
                        vecLines[y][l].color = vecQuads[i][1].color;
                        vecLines[y][l].position.y = y/2;
                        vecLines[y][l].position.x = WIDTHSCREEN/2;

                        if (x<WIDTHSCREEN/2)
                            vecLines[y][l].position.x = x - (y*xDistance/scale);
                        if (x>WIDTHSCREEN/2)
                            vecLines[y][l].position.x = x + (y*xDistance/scale);
                        l++;
                    }
                }
            }
        }

        app.clear();

        for (auto& vvec : vecQuads)
            app.draw(vvec);

        for (auto& vvec : vecLines)
            render.draw(vvec);

        app.display();

        render.display();
    }
}
 

Si je retire le "math.h", ça projette sans problème ma perspective, si je l'inclu, la moitié ne s'affiche plus du tout..

Merci à vous !

12
Projets SFML / Re: Projet en cours de développement : Un Wolfenstein 3D-Like en réseau.
« le: Septembre 30, 2017, 12:06:10 pm »
Bon, le projet est à un stade très avancé !

Je n'utilise pas les balises [IMG] du forum car les images sont trop grandes et n'apparaissent pas dans leur intégralité sinon...

Menu principal ( avec également un sous menu d'options fonctionnel ) où on peut constater le nombre de joueurs présents en temps réel.

https://image.noelshack.com/fichiers/2017/39/6/1506765494-1.png

Les interactions visuelles sont coordonnées de manière assez fluide, on voit les impactes de balles provoquées par les autres joueurs sur les murs et les bruits changent en fonction de la matière ( métal bois etc ) ainsi que le volume selon la distance du joueur et de l'impact, pareil pour les pas des joueurs, dont le volume varie selon leur distance, on peut marcher afin d'éviter d'être entendu par les autres.

https://image.noelshack.com/fichiers/2017/39/6/1506765662-2.png

Petit menu interne IN GAME pour modifier des paramètres avec ma GUI maison :

https://image.noelshack.com/fichiers/2017/39/6/1506765868-5.png

Les animations de mouvement et de tirs sont terminées dans toutes les directions ( 8 au total ) ce qui a donné un spritesheeting assez conséquent !

https://image.noelshack.com/fichiers/2017/39/6/1506765731-3.png

Le t'chat est fonctionnel ainsi que les informations relayées par le serveur ( connexion/déconnexion d'un nouveau joueur etc )

https://image.noelshack.com/fichiers/2017/39/6/1506765747-4.png


Il ne me reste plus qu'à gérer :

-les dégats selon l'arme et la distance / la mort d'un joueur
-le système de gestion de scores de l'ensemble des joueurs présent que l'on pourra consulter avec la touche TAB
-quelques petites optimisations ça et là

Dans l'ensemble ça tourne bien, je ferais bientôt une vidéo du projet définitif que l'on testera avec quelques potes :-)

13
Réseau / Re: Détecter la déconnexion d'un client.
« le: Septembre 21, 2017, 08:37:13 pm »
Je suis un imbécile.

J'avais oublié une condition pour un delete...

Autrement-dit :

void Network::pushNewUser()
{
    sf::TcpSocket* socket = new sf::TcpSocket();
    socket->setBlocking(false);

    if (m_listener.accept(*socket) == sf::Socket::Done)
    {
        std::cout << "Connexion detectee : " << socket->getRemoteAddress() << std::endl;
        m_vecTempSocket.push_back(socket);
        sendServerState();
    } else {
        delete socket;
    }
}

Je n'avais pas mis le "else", donc forcément, j'effaçais le socket juste après.. Lol.
Les erreurs les plus stupides sont souvent les plus.... difficiles à déceler x)

Merci à toi Laurent ;-)

14
Réseau / Re: Détecter la déconnexion d'un client.
« le: Septembre 21, 2017, 07:43:01 pm »
Ben c'est un petit programme de test que j'ai fait juste pour tester cette fonction justement... et en effet, c'est sensé fonctionner, d'où mon étonnement.. je n'arrive plus à reproduire cette mini fonction qui fonctionnait parfaitement lorsque je l'avais testé...
De quoi aurais-tu besoin davantage afin de me venir en aide Laurent ? :-)

15
Réseau / Détecter la déconnexion d'un client.
« le: Septembre 21, 2017, 07:20:50 pm »
Salut à tous !

Alors voilà, depuis un bon moment déjà, j'utilise une technique qui fonctionne mais qui n'est pas fiable :

Lorsque le client se déconnecte, il envoi un packet pour en avertir le serveur et celui-ci agit en conséquence, néanmoins... si le client se déconnecte " salement " ( genre il ferme le programme via le processus ou le quitte en fermant la console d'un coup ou encore si sa connexion internet a soudainement un problème ), évidemment, la détection ne se fait pas.

Il y a plusieurs mois de cela, j'avais testé une méthode qui fonctionnait à merveille avec sf::Socket::Status mais impossible de retrouver le lien du topic et depuis une petite heure, j'essaye de retrouver la méthode, en vain.

J'ai essayé comme ceci, mais si je ferme le client d'un coup, le serveur ne détecte rien, hors, je sais que c'est parfaitement possible pour l'avoir expérimenté quelques mois auparavant grâce à la méthode énoncée dans ce fameux topic introuvable..

void Network::receiveData()
{
    ///SI UN CLIENT SE DECONNECTE///
    if (m_vecTempSocket.size()>0)
    {
        for (unsigned int i = 0 ; i < m_vecTempSocket.size() ; i++)
        {
            sf::Packet exitPacket;
            if (m_vecTempSocket[i]->receive(exitPacket) == sf::Socket::Status::Disconnected)
            {
                std::cout << "Le client est parti." << std::endl;
                m_vecTempSocket.erase(m_vecTempSocket.begin()+i);
            }
        }
    }
}
 

Je vous pose donc la question, ayant perdu de vue cette méthode qui était par ailleurs très simple.. c'est très frustrant !

Merci à vous ;-)

Pages: [1] 2 3 ... 6 Suivante »