Forum de la communauté SFML

Aide => Graphique => Discussion démarrée par: MyPix le Juin 30, 2015, 03:07:22 pm

Titre: Ombre
Posté par: MyPix le Juin 30, 2015, 03:07:22 pm

Bonjour,

Je développe une petite bibliothèque pour la SFML, mais j'aimerais avoir une ombre diffuse derriere ou à l'interieur de la forme, comme cela :
http://prntscr.com/7n3lya
(Dans l'ordre : Sans Ombre, Ombre porté,Ombre interne)
Mais est ce possible avec la SFML ?

Pour l'ombre portée j'ai une idée de solution barbare, ce serait de dupliquer ma forme, la mettre tout en noir avec une opacité de +- 40% / 50% et d'y appliquer un flou (gaussien?).
Pour l'ombre interne, aucune idée par contre.

La réponse résiderais t-elle dans un shader ?

Merci

Titre: Re : Ombre
Posté par: Xyliaris le Mars 07, 2016, 12:58:25 pm

OpenGl est ton ami :) ou sinon ouai les shaders

Titre: Re : Ombre
Posté par: Cpl.Bator le Mars 08, 2016, 12:02:48 pm

pour une interface de ce type :
(http://img15.hostingpics.net/pics/77232356ui.png)

j'utilise comme shader :

const std::string black_shader ="#version 150\n"
                                                                "void main() {\n"
                                                                "    gl_FragColor = vec4(0.0,0.0,0.0,1.0);\n"
                                                                "}";
                       
const std::string blur_shader = "uniform sampler2D texture;\n"
                                                                "uniform float blur_radius;\n"
                                                                "\n"
                                                                "void main()\n"
                                                                "{\n"
                                                                "    vec2 offx = vec2(blur_radius, 0.0);\n"
                                                                "    vec2 offy = vec2(0.0, blur_radius);\n"
                                                                "\n"
                                                                "    vec4 pixel = texture2D(texture, gl_TexCoord[0].xy)               * 4.0 +\n"
                                                                "                 texture2D(texture, gl_TexCoord[0].xy - offx)        * 2.0 +\n"
                                                                "                 texture2D(texture, gl_TexCoord[0].xy + offx)        * 2.0 +\n"
                                                                "                 texture2D(texture, gl_TexCoord[0].xy - offy)        * 2.0 +\n"
                                                                "                 texture2D(texture, gl_TexCoord[0].xy + offy)        * 2.0 +\n"
                                                                "                 texture2D(texture, gl_TexCoord[0].xy - offx - offy) * 1.0 +\n"
                                                                "                 texture2D(texture, gl_TexCoord[0].xy - offx + offy) * 1.0 +\n"
                                                                "                 texture2D(texture, gl_TexCoord[0].xy + offx - offy) * 1.0 +\n"
                                                                "                 texture2D(texture, gl_TexCoord[0].xy + offx + offy) * 1.0;\n"
                                                                "\n"
                                                                "    gl_FragColor =  gl_Color * (pixel / 16.0);\n"
                                                                "}";                           

 

et pour dessiner mes rectangle arrondi :

http://pastebin.com/nDFHPsc0 (http://pastebin.com/nDFHPsc0)

cela se passe en 3 étapes , je dessine tout ce qui doit être l'ombre , avec le black shader , puis ensuite je blur le resultat avec le shader qui va bien , puis je dessine ma scène "regulière" devant le black/blur.
a toi d'adapté le resultat pour une ombre interne, pour un rectangle, tu peu te passer des shaders et faire un dégradé de couleur avec les vertices.