découper une sprite

[mazertys17]

Bonjour.

Je cherche a découper une sprite, et , avant de me lancer dans des concepts compliqués , j'aimerais savoir si vous connaissez une solution simple, adapté ?

mon objectif : transformé une texture sprite en une texture ne comprenant qu'une partie de l'image . ex :

    _vertex[0].position = sf::Vector2f( x                              , y ) ;
    _vertex[1].position = sf::Vector2f( x + _imageSizeX                , y ) ;
    _vertex[2].position = sf::Vector2f( x + _imageSizeX                , y + _imageSizeY ) ;
    _vertex[3].position = sf::Vector2f( x                              , y + _imageSizeY ) ;

    _vertex[0].texCoords = sf::Vector2f( _counterX  * _imageSizeX                      , _counterY  * _imageSizeY ) ;
    _vertex[1].texCoords = sf::Vector2f( _counterX  * _imageSizeX   + _imageSizeX      , _counterY  * _imageSizeY ) ;
    _vertex[2].texCoords = sf::Vector2f( _counterX  * _imageSizeX   + _imageSizeX      , _counterY  * _imageSizeY +  _imageSizeY ) ;
    _vertex[3].texCoords = sf::Vector2f( _counterX  * _imageSizeX                      , _counterY  * _imageSizeY +  _imageSizeY ) ;

        _transfomableTexture.iDontKnowWhat( ??! , _vertex , ??!! ) ; // découpage de la texture ?!

        myFonction.setTransformableTexture ( _transformableTexture ) ; // la j'envoi la nouvelle texture où j'ai besoin


 

Et obtenir ainsi une texture n'ayant pour dimention les " texCoords " de l'anciène texture. L'objectif est, naturellement , que se soit le plus légers possible afin de réaliser l'opération à chaque frame d'animation.

Merci si vous pouvez m'aider .

[Laurent]

Ton objectif n'est pas très clair. Mais si ce n'est que pour l'affichage, pas besoin de découper quoique ce soit. Il te suffit d'ajuster les coordonnées de texture (si tu utilises sf::Vertex) ou le textureRect (si tu utilises sf::Sprite).

[mazertys17]

Merci pour ta réponse.

En effet, pour l'affichage de l'animation, il suffit de faire ce qui est montré dans mon code simplement, et ca marche. mais pour ce que je voudrais faire, il me faut également l'image découpée "sans rien autour". ( c'est un peu long à expliquer, mais les besoins de mon programme le justifient ). 
J'ai pensé à un sf::renderTexture, mais ça me parait inutile, et surement trop lourd, alors que la texture existe déjà.

[Laurent]

Attention au problème XY

Donc, même si c'est long à expliquer, dis nous plutôt ce que tu cherches réellement à faire, plutôt que de décrire ce que tu crois être la solution.

[mazertys17]

OK.

J'ai besoin d'utiliser l'image en tant que support de lumière. Cela fonctionne pour les objets ne contenant pas d'animation, car leur texture est de la même taille que leur image réel, contrairement à une animation, où la texture est plus grande que l'image réel.

Donc si j'utilise une sprite animé en tant que support lumière, n'importe quel objet lumineux s'approchant éclairera également les autres parties de la sprite. Chose évidement indésirable. Je pourrais bien sur charger plusieurs images, mais c'est de la mémoire gâché.

Dans mon cas, l'idéal serait donc de pouvoir découper la partie de la sprite, qui correspond à l'image animé, pour la remplacer en tant que support lumineux pour l'affichage.

Je sais, ce n'est probablement pas un système conventionnel. On en avais déjà parlé, et j'avais étudié et essayé le système de rendu final avec un bend multiply dont on m'avait parlé. Mais ce résultat ne me satisfaisait pas. J'ai donc construit un système fonctionnant comme décrit ci-dessus. (qui lui en terme de graphisme, d'utilisation, me convient pour l'instant ).

[Laurent]

J'ai rien compris à ton truc

[mazertys17]

Je me doutais que ca ne serait pas très clair. 

Je crois qu'il va être temps pour moi de présenter mon projet...rendez vous dans la section aproprié 

[mazertys17]

Ok, je vais essayer de préciser mon système, au cas où on puisse m'aider à trouver une solution peu couteuse en perf.

Mon objectif n'étant pas de faire le programme de la naza, mais simplement un petit jeu ludique, j'ai crée un petit moteur de light qui ne fait que produire des halos de lumières de taille et couleur différentes.

voici un exemple de ce que cela donne :




ici mon élémentaire de feu qui éclaire le sol. Chaque petite flamme qui le suit éclaire également le sol. Les lumières peuvent changer de taille et de couleur. ( des triggers d'animation permettent de gérer cela ).

cela fonctionne ainsi :

chaque objet comportant une Light, va envoyer l'adresse de sa light au moteur, qui va s'occuper de l'afficher. Pour se faire, il va vérifier ou elle se trouve et quelle image elle est susceptible d'éclairer.

S'il en trouve une/deux ou plus, il va envoyer à ces images ( ici le sol, par ex ) , a son tour l'adresse(pointeur) de la Light.

L'image va alors elle même créer une/plusieurs nouvelle(s) image(s), avec sa texture de lumière qu'elle a en mémoire ( une texture travaillé sur Photoshop pour donner un effet de lumière ).

Pour se faire, elle va se référer à ses propres coordonnés, pour créer la forme de la lumière a afficher.

Elle ajoutera ainsi à "l'impression", la nouvelle image crée, avec le zOrder approprié, ayant pour texCoord les caractéristiques de la Light de l'objet initial ( couleur et taille ).

Toutes les lights sont identiques en terme de forme, par contre ( un cercle dégradé de 36 vertex ).

Voilà. C'est plutôt simple en fait. Cela me permet de pouvoir avoir des light en grand nombre sans que cela implique des calculs trop lourds. Cela fonctionne bien ( du moins avec ma bécane ).

Maintenant, ça se complique légèrement dès que je demande à un objet animé/quiChangeDeForme d'être " éclairable ". Ce n'est pas le cas, par ex, avec mes animations de feu, puisqu'elles n'ont pas à être éclairées.

Mais pour un élément de glace, par ex, qui fond au contact du feu, c'est nécessaire: le feu fait rougeoyer la glace, et celle si change de forme, donc est animée.

J'espère que c'est plus clair maintenant.

En somme, j'ai besoin d'isoler une partie de la texture de lumière pour faire tranquillement les calculs du cercle de vertex afin que ne soit affiché que la partie du cercle qui est a l'intérieur de ce bout de texture. Sans avoir a faire de pénibles calcul sur chaque vertex pour essayer de garder une forme ronde sans empiéter sur les images voisines...



 




 

[Laurent]

Je comprend un peu mieux, mais les détails sont encore un peu flous. En terme de dessin SFML, ça donne quoi ? Quelles classes sont impliquées et de quelle manière ?

Et une image un peu plus grande ce serait pas du luxe.

[mazertys17]

j'ai 2 type d'Image Entity :

- une normale, public de sf::drawable, qui prend en compte qu'un rectangle de vertex, _vertex[4]

- une IE_Light, qui prend en compte 36 vertex, _vertex[36]. Elle est contenue dans un vector , lui même contenue dans une IE normal.

Quand/si l'IE normale contiend une IE_Light, au moment de s'afficher lui même, il affiche également toutes ses IE_Light, après leur avoir demandé de se recalculer leurs position :

allé, pour le style, je met le code complet de la fonction

là mon IE normale :

void IE::draw ( sf::RenderWindow &window )
{


    window.draw ( *this ) ;

    for ( std::vector < IE_Light  > :: iterator it = _IE_Light.begin() ; it != _IE_Light.end() ; )
    {
        if( ! it -> setLightPosition ( _vertex[0] ) )
        {
            it = _IE_Light.erase( it ) ;

        }
        else
        {
            window.draw ( *it ) ;
            it ++ ;
        }
    }

}
 

et là une des IE_Light contenue dans l'IE normale :

bool IE_Light::setLightPosition ( sf::Vertex &vertex )
{

    sf::Vector2f position = vertex.position ;

    float x = _light -> getPosition().x ;
    float y = _light -> getPosition().y ;

    int sizeLight = _light -> getSize () ;

    sf::Color color = _light -> getColor () ;



    bool condition = true ;

    if (  x + sizeLight/2 < position.x
       || x - sizeLight/2 > position.x + _texture -> getSize().x
       || y + sizeLight/2 < position.y
       || y - sizeLight/2 > position.y + _texture -> getSize().y )
    {
        condition = false ;
    }
    if( condition )
    {

        _vertex[0] = sf::Vector2f( x                                                                                                       , y );
        _vertex[1] = sf::Vector2f( x                                                                                                       , y - sizeLight );
        _vertex[2] = sf::Vector2f( x  + sizeLight/2                                                                                  , y - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );

        _vertex[3] = sf::Vector2f( x                                                                                                       , y );
        _vertex[4] = sf::Vector2f( x  + sizeLight/2                                                                                  , y - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );
        _vertex[5] = sf::Vector2f( x  + sqrt ( -( (sizeLight/2) * (sizeLight/2)) + (sizeLight * sizeLight)  )     , y - sizeLight/2 );

        _vertex[6] = sf::Vector2f( x                                                                                                       , y );
        _vertex[7] = sf::Vector2f( x  + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y - sizeLight/2 );
        _vertex[8] = sf::Vector2f( x  + sizeLight                                                                                    , y );



        _vertex[9] = sf::Vector2f( x                                                                                                       , y );
        _vertex[10] = sf::Vector2f( x  + sizeLight                                                                                   , y );
        _vertex[11] = sf::Vector2f( x  + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )    , y + sizeLight/2 );

        _vertex[12] = sf::Vector2f( x                                                                                                      , y );
        _vertex[13] = sf::Vector2f( x  + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )    , y + sizeLight/2 );
        _vertex[14] = sf::Vector2f( x  + sizeLight/2                                                                                 , y + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )  );

        _vertex[15] = sf::Vector2f( x                                                                                                       , y );
        _vertex[16] = sf::Vector2f( x  + sizeLight/2                                                                                 , y + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )  );
        _vertex[17] = sf::Vector2f( x                                                                                                       , y + sizeLight );


        _vertex[18] = sf::Vector2f( x                                                                                                       , y );
        _vertex[19] = sf::Vector2f( x                                                                                                       , y + sizeLight );
        _vertex[20] = sf::Vector2f( x  - sizeLight/2                                                                                  , y + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );

        _vertex[21] = sf::Vector2f( x                                                                                                       , y );
        _vertex[22] = sf::Vector2f( x  - sizeLight/2                                                                                  , y + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );
        _vertex[23] = sf::Vector2f( x  - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y + sizeLight/2 );

        _vertex[24] = sf::Vector2f( x                                                                                                       , y );
        _vertex[25] = sf::Vector2f( x  - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y + sizeLight/2 );
        _vertex[26] = sf::Vector2f( x  - sizeLight                                                                                    , y );



        _vertex[27] = sf::Vector2f( x                                                                                                       , y );
        _vertex[28] = sf::Vector2f( x  - sizeLight                                                                                    , y );
        _vertex[29] = sf::Vector2f( x  - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y - sizeLight/2 );


        _vertex[30] = sf::Vector2f( x                                                                                                       , y );
        _vertex[31] = sf::Vector2f( x  - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y - sizeLight/2 );
        _vertex[32] = sf::Vector2f( x  - sizeLight/2                                                                                  , y - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );


        _vertex[33] = sf::Vector2f( x                                                                                                       , y );
        _vertex[34] = sf::Vector2f( x  - sizeLight/2                                                                                  , y - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );
        _vertex[35] = sf::Vector2f( x                                                                                                       , y - sizeLight );


        x = _light -> getPosition().x - position.x + vertex.texCoords.x ;
        y = _light -> getPosition().y - position.y + vertex.texCoords.y ;


        _vertex[0].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[1].texCoords = sf::Vector2f( x                                                                                                       , y - sizeLight );
        _vertex[2].texCoords = sf::Vector2f( x  + sizeLight/2                                                                                  , y - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );

        _vertex[3].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[4].texCoords = sf::Vector2f( x  + sizeLight/2                                                                                  , y - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );
        _vertex[5].texCoords = sf::Vector2f( x  + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y - sizeLight/2 );

        _vertex[6].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[7].texCoords = sf::Vector2f( x  + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y - sizeLight/2 );
        _vertex[8].texCoords = sf::Vector2f( x  + sizeLight                                                                                    , y );



        _vertex[9].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[10].texCoords = sf::Vector2f( x  + sizeLight                                                                                   , y );
        _vertex[11].texCoords = sf::Vector2f( x  + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )    , y + sizeLight/2 );

        _vertex[12].texCoords = sf::Vector2f( x                                                                                                      , y );
        _vertex[13].texCoords = sf::Vector2f( x  + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )    , y + sizeLight/2 );
        _vertex[14].texCoords = sf::Vector2f( x  + sizeLight/2                                                                                 , y + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )  );

        _vertex[15].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[16].texCoords = sf::Vector2f( x  + sizeLight/2                                                                                 , y + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )  );
        _vertex[17].texCoords = sf::Vector2f( x                                                                                                       , y + sizeLight );


        _vertex[18].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[19].texCoords = sf::Vector2f( x                                                                                                       , y + sizeLight );
        _vertex[20].texCoords = sf::Vector2f( x  - sizeLight/2                                                                                  , y + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );

        _vertex[21].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[22].texCoords = sf::Vector2f( x  - sizeLight/2                                                                                  , y + sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );
        _vertex[23].texCoords = sf::Vector2f( x  - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y + sizeLight/2 );

        _vertex[24].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[25].texCoords = sf::Vector2f( x  - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y + sizeLight/2 );
        _vertex[26].texCoords = sf::Vector2f( x  - sizeLight                                                                                    , y );



        _vertex[27].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[28].texCoords = sf::Vector2f( x  - sizeLight                                                                                    , y );
        _vertex[29].texCoords = sf::Vector2f( x  - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y - sizeLight/2 );


        _vertex[30].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[31].texCoords = sf::Vector2f( x  - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  )     , y - sizeLight/2 );
        _vertex[32].texCoords = sf::Vector2f( x  - sizeLight/2                                                                                  , y - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );


        _vertex[33].texCoords = sf::Vector2f( x                                                                                                       , y );
        _vertex[34].texCoords = sf::Vector2f( x  - sizeLight/2                                                                                  , y - sqrt ( -( (sizeLight/2) * (sizeLight/2) ) + (sizeLight * sizeLight)  ) );
        _vertex[35].texCoords = sf::Vector2f( x                                                                                                       , y - sizeLight );





        _vertex[0].color = sf::Color( color );
        _vertex[1].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[2].color = sf::Color( 0 , 0 , 0 , 0 );

        _vertex[3].color = sf::Color( color );
        _vertex[4].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[5].color = sf::Color( 0 , 0 , 0 , 0 );

        _vertex[6].color = sf::Color( color );
        _vertex[7].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[8].color = sf::Color( 0 , 0 , 0 , 0 );


        _vertex[9].color = sf::Color( color );
        _vertex[10].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[11].color = sf::Color( 0 , 0 , 0 , 0 );

        _vertex[12].color = sf::Color( color );
        _vertex[13].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[14].color = sf::Color( 0 , 0 , 0 , 0 );

        _vertex[15].color = sf::Color( color );
        _vertex[16].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[17].color = sf::Color( 0 , 0 , 0 , 0 );



        _vertex[18].color = sf::Color( color );
        _vertex[19].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[20].color = sf::Color( 0 , 0 , 0 , 0 );

        _vertex[21].color = sf::Color( color );
        _vertex[22].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[23].color = sf::Color( 0 , 0 , 0 , 0 );

        _vertex[24].color = sf::Color( color );
        _vertex[25].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[26].color = sf::Color( 0 , 0 , 0 , 0 );



        _vertex[27].color = sf::Color( color );
        _vertex[28].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[29].color = sf::Color( 0 , 0 , 0 , 0 );

        _vertex[30].color = sf::Color( color );
        _vertex[31].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[32].color = sf::Color( 0 , 0 , 0 , 0 );

        _vertex[33].color = sf::Color( color );
        _vertex[34].color = sf::Color( 0 , 0 , 0 , 0 );
        _vertex[35].color = sf::Color( 0 , 0 , 0 , 0 );

    }
    return condition ;

}


 

un exemple en plus grand d'une scène comprenant plusieurs types de Lights :

[Laurent]

C'est quoi le but de tous ces calculs de vertex ? Pourquoi tes lumières ne sont-elles pas simplement des sprites affichés par dessus le sol, en mode blending additif ?

[mazertys17]

Tu penses qu'un blending additif pourrait donner le même résultat au final ?

Mais même si c'est le cas, il faudra fatalement recalculer tous les vertex de la sprite non ? Puisque ceux ci bougent et changent de taille et de couleur constamment ?

Ce qui reviendrait au même ? Avec peut être le calcul du blend en plus ?

[Laurent]

La taille et la couleur de la lumière, c'est juste un setScale et un setColor sur le sprite correspondant. Le blending additif est vite limité en terme d'effet lumineux (ça sature rapidement), mais ça peut le faire pour certains besoins simples. Fais un essai, tu verras bien si ça correspond à ce que tu veux.

[mazertys17]

Ok, merci, je vais essayer. Mais comme je le disais plus haut, il faudrait quoi qu'il arrive faire les même calculs, mais depuis le scale et le setColor, de plus, est-ce possible de faire le dégradé depuis le centre avec cette methode ?

ps : au fait, as tu reçu mes mp ?
Le mieux, si tu veux bien m'aider, ce serait de tester le programme et me dire s'il fonctionne bien.  . c'est pas un jeux de 30 heures, alors ça peu être vite fait.

[Laurent]

Mais comme je le disais plus haut, il faudrait quoi qu'il arrive faire les même calculs

Pourquoi ? Une lumière a une position, un rayon et une couleur, ça se traduit directement en attributs du sprite. En fait je ne sais toujours pas ce que tu calcules avec tes vertex. Un sprite + une texture, ça n'irait pas ? D'autant plus que tu me parles de dégradé et d'effet fait sous Photoshop.

au fait, as tu reçu mes mp ?

Non.