Forum du club des développeurs et IT Pro - OpenGL https://www.developpez.net/forums/ FAQ OpenGL]]> fr Sat, 13 Jun 2026 08:27:39 GMT vBulletin 15 https://forum.developpez.be/images/misc/rss.png Forum du club des développeurs et IT Pro - OpenGL https://www.developpez.net/forums/ <![CDATA[fragment shader & decal]]> https://www.developpez.net/forums/showthread.php?t=2183876&goto=newpost Mon, 25 May 2026 21:28:07 GMT Bonjour, Le shader fragment... Bonjour,
Le shader fragment affichant le decals ne fonctionne pas ! ChatGPT ne peux pas m'aider :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
$input  v_texCoord
 
#include "common.sh"
 
SAMPLER2D(u_decalTex,  0);
SAMPLER2D(u_depthTex,  1);
//uniform mat4 u_decalProjMtx;  // Matrice de projection du decal
//uniform mat4 u_decalViewMtx;  // Matrice de vue du decal
uniform mat4 u_decalInvMatrix;
uniform mat4 u_custominvViewProj;
uniform vec4 u_scr;
void main()
{
 
	/*gl_FragColor =
    vec4(normalize(v_worldPos * 0.0001), 1.0);
	return;*/
 
	//le cube rouge s'affiche si decommente
	//gl_FragColor=vec4(1.0,0.0,0.0,1.0);
	//return;
	 // 1. Calculer la position du pixel dans l'espace du decal
 
	 float fx=gl_FragCoord.x;
	 float fy=gl_FragCoord.y;
	 fx/=u_scr[0];
	 fy/=u_scr[1];
	 //fx-=1;
	 //fy-=1;
 
  //  vec4 decalSpacePos = mul(u_decalViewMtx , vec4(v_worldPos, 1.0));
 vec2 uv =  vec2(fx,fy);//gl_FragCoord.xy / vec2(878,716);
 //float depth = gl_FragCoord.z; //texture2D(u_depthTex, uv).r;
 float depth = texture2D(u_depthTex, uv).r;
 //depth*=1;
 //depth=0.9f;
  //gl_FragColor = vec4(depth, depth, depth, 1.0);
 	//return;
 
 //vec4 clip = vec4(uv * 2.0 - 1.0, depth, 1.0);
 /*vec4 clip = vec4(
    uv * 2.0 - 1.0,
    depth * 2.0 - 1.0,
    1.0
);*/
 
	 /*vec4 clip;
 
    clip.x = uv.x * 2.0 - 1.0;
 
    // flip Y bgfx
    clip.y = (1.0 - uv.y) * 2.0 - 1.0;
 
    // IMPORTANT :
    // selon backend bgfx :
    // essayer depth OU depth*2-1
    clip.z = depth;
 
    clip.w = 1.0;*/
	//uv=mul(uv,-1);
	//uv.x=1.0-uv.x;
	//uv=mul(uv,2);
	uv.x=(uv.x*2.0)-1.0;
	uv.y=(uv.y*2.0)-1.0;
    vec4 world = mul(u_custominvViewProj, vec4(uv.x,uv.y,depth,1.0));
    world.xyz /= world.w;
 
	/*gl_FragColor =
    vec4(world.xyz * 0.5 + 0.5, 1.0);
	return;
*/
    vec4 local = mul(u_decalInvMatrix, vec4(world.xyz, 1.0));
	local.xyz/=local.w;
 
	/*gl_FragColor =
    vec4(local.xyz * 0.5 + 0.5, 1.0);
	return;*/
    if (abs(local.x) > 1.0 ||
        abs(local.y) > 1.0 )
        //abs(local.z) > 1.0)
 
    {
 
        discard;
    }
	/*if (local.w<1)
	{
	}*/
 
    vec2 decalUV = local.xy * 0.5 + 0.5;
 
    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
	return;
 
 
}
Shader vertex :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
$input a_position, a_color0, a_texcoord0, a_normal
$output v_texCoord
 
 
#include "common.sh"
 
 
void main()
{
 
	gl_Position = mul(u_modelViewProj, vec4(a_position, 1.0));
 
    v_texCoord = a_texcoord0;
 
}
Demuni ! Ca devrait fonctionner mais non !
Avant d'afficher la texture du decals j'affiche rouge pour debugger ]]> OpenGL yann458 https://www.developpez.net/forums/d2183876/applications/developpement-2d-3d-jeux/api-graphiques/opengl/fragment-shader-decal/ shader fragment éclairage https://www.developpez.net/forums/showthread.php?t=2183462&goto=newpost Tue, 28 Apr 2026 19:06:41 GMT Bonjour, Je voudrais ajouter... Bonjour,
Je voudrais ajouter de l'éclairage dans mon shader et ca ne fonctionne pas sur des directions donnée.
Shader fragment BGFX :

Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
vec4 dcolor = texture2D(s_texColor, v_texcoord0);
 
	vec3 albedo=dcolor.rgb;
 
		vec3 gDirectionalLight_Color=vec3(1.0,1.0,1.0);
		vec4 AmbiantColor = vec4(gDirectionalLight_Color, 1.0f) *                       
                        0.9;                         
 
    float DiffuseFactor0 = dot(normalize(v_normal.xyz), u_viewDir.xyz);    
	float DiffuseFactor1= dot(normalize(v_normal.xyz), -u_viewDir.xyz);    
	float DiffuseFactor=max(DiffuseFactor0,DiffuseFactor1); //pour prendre tous les directions de la caméra
 
    vec4 DiffuseColor;                                                              
 
    if (DiffuseFactor > 0) {                                                        
	//if (true) {
        DiffuseColor = vec4(gDirectionalLight_Color, 1.0f) *                        
                       0.9 *                         
                       DiffuseFactor;                                               
    }                                                                               
    else {                                                                          
        DiffuseColor = vec4(0, 0, 0, 0);                                            
    }                                                                               
 
 
				albedo=albedo*AmbiantColor+DiffuseColor;
				dcolor=vec4(albedo,dcolor[3]);
  gl_FragColor=dcolor;
Merci ]]> OpenGL yann458 https://www.developpez.net/forums/d2183462/applications/developpement-2d-3d-jeux/api-graphiques/opengl/shader-fragment-eclairage/ Normalization des faces https://www.developpez.net/forums/showthread.php?t=2183395&goto=newpost Fri, 24 Apr 2026 22:12:15 GMT Bonjour, Je travaille avec... Bonjour,

Je travaille avec l'API bgfx et le glmnet.
Je n'ai pas trouver de forum opengl c#.

Je voudrais savoir si la méthode pour calculer la normale est bonne ? je vous joint l'image

Déjà pour dessiner une face : est ce bon :
Code:
1
2
3
4
5
6
7
 lvbuild.Add(new vertex(ax, ay, az, u0, v0, r, g, b, txtc));
 lvbuild.Add(new vertex(bx, by, bz, u1, v0, r, g, b, txtc));
 lvbuild.Add(new vertex(cx, cy, cz, u1, v1, r, g, b, txtc));
 
 lvbuild.Add(new vertex(ax, ay, az, u0, v0, r, g, b, txtc)); 
 lvbuild.Add(new vertex(cx, cy, cz, u1, v1, r, g, b, txtc));              
 lvbuild.Add(new vertex(dx, dy, dz, u0, v1, r, g, b, txtc));
Sachant que le Y est la hauteur est X,Z sont les coordonnées carte.

Voici la méthode pour normaliser :

modeindicevertex = indiceall
indtxt est le numéro de texture, pour le moment c'est la même valeur

Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
 
 
 internal class vertex
 {
     internal Modeindicevertex modeindicevertex;
 
     internal float x, y, z, u, v, r, g, b; // On ajoute la couleur (RGB)
     internal float nx, ny, nz;
     internal int indtxt;
 
     public override string ToString()
     {
         return $"x:{x.ToString("F2")},y:{y.ToString("F2")},z:{z.ToString("F2")},u:{u.ToString("F2")},v:{v.ToString("F2")} txt:{indtxt} nx:{nx.ToString("F2")},ny:{ny.ToString("F2")},nz:{nz.ToString("F2")}";
     }
 
     // Constructeur mis à jour
     internal vertex(float _x, float _y, float _z, float _u, float _v, float _r, float _g, float _b, int _indtxt)
     {
         x = _x; y = _y; z = _z; u = _u; v = _v;
         r = _r; g = _g; b = _b; // Définit la teinte
         nx = ny = nz = 0;
         indtxt = _indtxt;
         modeindicevertex = Modeindicevertex.indicecall;
     }
 
     internal vertex()
     {
 
     }
 
     public override bool Equals(object obj)
     {
         if (!(obj is vertex other)) return false;
         if (modeindicevertex == Modeindicevertex.indicecall)
         {
             return x == other.x && y == other.y && z == other.z &&
                    u == other.u && v == other.v &&
                    r == other.r && g == other.g && b == other.b &&
                     nx == other.nx && ny == other.ny && nz == other.nz &&
                    indtxt == other.indtxt;
         }
         else
         {
             return x == other.x && y == other.y && z == other.z;
 
 
         }
     }
 
     public override int GetHashCode()
     {
         unchecked // Permet l'overflow sans erreur
         {
             int hash = 17;
             hash = hash * 23 + x.GetHashCode();
             hash = hash * 23 + y.GetHashCode();
             hash = hash * 23 + z.GetHashCode();
             if (modeindicevertex == Modeindicevertex.indicecall)
             {
                 hash = hash * 23 + nx.GetHashCode();
                 hash = hash * 23 + ny.GetHashCode();
                 hash = hash * 23 + nz.GetHashCode();
                 hash = hash * 23 + u.GetHashCode();
                 hash = hash * 23 + v.GetHashCode();
                 hash = hash * 23 + r.GetHashCode();
                 hash = hash * 23 + g.GetHashCode();
                 hash = hash * 23 + b.GetHashCode();
                 hash = hash * 23 + indtxt.GetHashCode();
             }
             return hash;
         }
     }
 }
  private void ProcessNormal(List<int> indices, List<vertex> ltx)
  {
      // 1. Initialiser les normales à zéro
      foreach (var v in ltx)
      {
          v.nx = 0;
          v.ny = 0;
          v.nz = 0;
      }
 
      // 2. Calculer les normales par face et les accumuler
      int nt3 = indices.Count / 3;
      for (int fnt3 = 0; fnt3 < nt3; fnt3++)
      {
          int ip1 = indices[0 + fnt3 * 3];
          int ip2 = indices[1 + fnt3 * 3];
          int ip3 = indices[2 + fnt3 * 3];
 
          vertex p1 = ltx[ip1];
          vertex p2 = ltx[ip2];
          vertex p3 = ltx[ip3];
 
          vec3 vp1 = new vec3(p1.x, p1.y, p1.z);
          vec3 vp2 = new vec3(p2.x, p2.y, p2.z);
          vec3 vp3 = new vec3(p3.x, p3.y, p3.z);
 
          vec3 edge1 = vp2 - vp1;
          vec3 edge2 = vp3 - vp1;
 
          // Vérifier si les arêtes sont non nulles
          float edge1LengthSq = edge1.x * edge1.x + edge1.y * edge1.y + edge1.z * edge1.z;
          float edge2LengthSq = edge2.x * edge2.x + edge2.y * edge2.y + edge2.z * edge2.z;
 
          if (edge1LengthSq > 0.000001f && edge2LengthSq > 0.000001f)
          {
              var facenormal = glm.normalize(glm.cross(edge1, edge2));
 
              // Accumuler sur les sommets (OK car vertex est une classe)
              p1.nx += facenormal.x;
              p1.ny += facenormal.y;
              p1.nz += facenormal.z;
 
              p2.nx += facenormal.x;
              p2.ny += facenormal.y;
              p2.nz += facenormal.z;
 
              p3.nx += facenormal.x;
              p3.ny += facenormal.y;
              p3.nz += facenormal.z;
          }
          else
              edge1LengthSq = edge1LengthSq;
      }
 
      // 3. Normaliser les normales finales (avec vérification)
      foreach (var fltx in ltx)
      {
          vec3 normal = new vec3(fltx.nx, fltx.ny, fltx.nz);
          float lengthSq = normal.x * normal.x + normal.y * normal.y + normal.z * normal.z;
          if (lengthSq > 0.000001f)
          {
              normal = glm.normalize(normal);
              fltx.nx = normal.x;
              fltx.ny = normal.y;
              fltx.nz = normal.z;
          }
          else
          {
              // Normale par défaut si nulle
              fltx.nx = 0;
              fltx.ny = 0;
              fltx.nz = 1;
          }
      }
  }
Partie shader :
Une partie du shader vertex :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
$input a_position, a_color0, a_texcoord0,a_normal
$output v_color0, v_texcoord0 ,v_fragPos ,v_pos, v_normal, viewPos
 
 
#include "common.sh"
 
//SAMPLER2D(s_texColor, 0);
//uniform mat4 matview;
uniform vec4 fogcolor;
uniform vec4 fp;
uniform vec4 eBias;
//uniform vec4 u_viewPos;
//uniform mat4 modelu;
 
//out vec2 OutTexCoord0;
//out vec4 vertexColor; // Remplace l'ancien gl_BackColor
 
void main()
{
   // vec4 a = InVertex;
    //v_texcoord0 = a_texcoord0 * fp[0];
	 v_texcoord0 = a_texcoord0;
	 v_color0=a_color0;
	 //v_normal=mul(modelu, vec4(a_normal, 0.0)).xyz;//a_normal;
 
	 //v_normal = normalize(mul(u_model[0], vec4(a_normal, 0.0)));
 
 
	 vec3 worldNormal = mul(u_model[0], float4(a_normal, 0.0)).xyz;
	 v_normal = normalize(worldNormal); //mul(u_view, vec4(worldNormal,0.0)).xyz;
 ....
....
}
Une partie du shader fragment pour uniquement afficher la normal (pour debugger) :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
$input v_color0, v_texcoord0, v_fragPos, v_pos ,v_normal ,viewPos
 
#include "common.sh"
SAMPLER2D(s_texColor,  0);
SAMPLER3D(lightMap,  1);
 
//uniform sampler2D myTexture;
//varying vec2 vTexCoord;
//uniform mat4 matview;
uniform vec4 fp;  //float
uniform vec4 fogdensity; //float
uniform vec4 fogcolor;
uniform vec4 lumdensitycolor;
uniform vec4 mixcolor;
uniform vec4 valmixcolor; //float
uniform vec4 modeprogram; //int
uniform vec4 u_viewPos;
uniform vec4 roomSize;
uniform vec4 dectxt3dli;
 
uniform vec4 u_lightPos;
uniform vec4 u_lightColor;
 
//uniform mat4 modelu;
uniform vec4 u_viewDir;
//uniform vec4 eBias; //float
//varying vec2 OutTexCoord0;
void main()
{
vec4 dcolor = texture2D(s_texColor, v_texcoord0);
 
	vec3 albedo=dcolor.rgb;
gl_FragColor = vec4(normalize(v_normal) * 0.5 + 0.5, 1.0);
		return;
}
L'un ou l'autre qui est correcte ou aucun ? NE VOUS PRÉOCCUPER PAS DES zone noir
Nom : an.png Affichages : 72 Taille : 12,6 Ko
Nom : an2.png Affichages : 70 Taille : 22,2 Ko

Merci
Images attachées
  
]]> OpenGL yann458 https://www.developpez.net/forums/d2183395/applications/developpement-2d-3d-jeux/api-graphiques/opengl/normalization-faces/ <![CDATA[[OpenGL 4.x] [GLSL] Problème d'affichage de ligne avec l'utilisation de l'opérateur mod() et dFdx/dFdy]]> https://www.developpez.net/forums/showthread.php?t=2181445&goto=newpost Mon, 12 Jan 2026 21:54:03 GMT Bonjour à vous :D, ... Bonjour à vous :D,

Dernièrement, j’ai voulu me replonger dans les shaders, notamment via GLSL, et j’ai tenté de suivre une vidéo de OGLDev :

J’ai donc essayé de reprendre son vertex shader et son fragment shader :

Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#version 420 core
 
out vec3 WorldPos;
uniform mat4 viewMatrix;
uniform mat4 projectionMatrix;
 
const vec3 positions[4] = vec3[4](
        vec3(-1.0, 0.0, -1.0), // TL
        vec3(1.0, 0.0, -1.0), // BL
        vec3(1.0, 0.0, 1.0), // BR
        vec3(-1.0, 0.0, 1.0) // TL
    );
 
const int indices[6] = int[6](0, 2, 1, 2, 0, 3);
 
void main() {
    // gl_VertexID [0 : 5] because the shader is use a gldraw with 6 as parameters
    WorldPos = positions[indices[gl_VertexID]];
    vec4 Pos = projectionMatrix * viewMatrix * vec4(WorldPos, 1.0);
    gl_Position = Pos;
}
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#version 420 core
in vec3 WorldPos;
out vec4 FragColor;
 
void main()
{
    float gridCellSize = 0.25;
    vec4 blackColor = vec4(0.0f, 0.0f, 0.0f, 1.0f);
 
    float lx = length(vec2(dFdx(WorldPos.x), dFdy(WorldPos.x)));
    float ly = length(vec2(dFdx(WorldPos.z), dFdy(WorldPos.z)));
    vec2 dxdy = vec2(lx, ly);
 
    float d = mod(WorldPos.z, gridCellSize);
    float lod0a = 1.0f - d / ly;
 
    FragColor = blackColor;
    FragColor.a *= lod0a;
}
Je place ma camera de sorte a ce qu'elle soit parfaite en face du plan crée. Il se trouve que certaines ligne sont plus transparente que d'autre :
Nom : faded lines 2.png Affichages : 125 Taille : 3,9 Ko

J’ai tenté de chercher une cause par moi-même ainsi qu’en utilisant ce bon vieux ChatGPT, mais malheureusement aucune des réponses qu’il m’a données ne m’a convaincu.
Je pense bien évidemment que cela est lié à l’utilisation de dFdx / dFdy, mais je trouve cela étrange que certaines lignes verticales au centre soient plus transparentes que celles situées aux extrémités,
puisque la taille projetée sur un pixel devrait normalement être plus grande aux extrémités du plan qu’en son centre, du fait de la projection perspective et donc en utilisant la fonction lod0a du fragment shader, les lignes les
plus aux extrémité du plan devrait être transparente. Si quelqu'un a une réponse a ce problème je suis fort intéressé :aie: .

Note : J'ai deja pu résoudre mon soucis en changeant de formule mais je n'arrive toujours pas à expliquer le problème dont j'ai parlé...
Images attachées
 
]]> OpenGL Benzaikill https://www.developpez.net/forums/d2181445/applications/developpement-2d-3d-jeux/api-graphiques/opengl/glsl-probleme-d-affichage-ligne-l-utilisation-l-operateur-mod-dfdx-dfdy/ <![CDATA[[OpenGL 4.x] Deplacement d'un objet avec la souris]]> https://www.developpez.net/forums/showthread.php?t=2180764&goto=newpost Wed, 03 Dec 2025 16:57:20 GMT Bonjour, dans le cadre de mon... Bonjour, dans le cadre de mon projet de recreer un 3dEngine basic, je me suis donne pour objectif de pouvoir deplacer mes objets rendus en les selectionnant, puis en faisant apparaitre les axes correspondant a mon objet representes sous forme de fleches.
J'ai compris la (ou une des) maniere(s) de proceder, qui est de projetter mes coordonees de ma souris dans mon espace 3d, puis de recuperer le point d'intersection avec le plan selon lequel je vais travailler (deplacer mon objet selon son axe X -> plan XY).
Je repete l'operation "2 fois" avec les coordonees precedentes de ma souris et celle actuelles pour obtenir un delta et avoir un deplacement a peu pres proportionnel avec celui de ma souris.
Mon probleme etant que meme en sachant cela (si c'est la bonne methode) je n'arrive pas a arriver a un resultat coherent.
Quelques specificite de mes parametres :
- j'ai une camera fixe, avec un lookAt = eye = {0, 0, 0}, center = {0, 0, -1} et up = {0, 1, 0}, ce qui veux dire que mon monde translate et tourne,
- je n'utilise aucune lib externe autre que <GLFW/glfw3.h> qui est nécessaire pour avoir un opengl minimal.
Le deroulement de mon code :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
void Render::moveGizmo(double &lastX, double &lastY)
{
    double mouseX, mouseY;
    Entity *obj = Gizmo::getObj();
    auto pos = obj->getMesh().getPos();
    auto vert = Gizmo::getGizmo()[3].getMesh().getVertices();
    std::array<double,3> axis = {0, 0, 0}, plane = {0, 0, 0}, axisWorld, planeWorld;
    int index = Gizmo::getArrPos()[3];
 
    if (index-- == 0)
        return ;
    axis[index] = 1.0;
    if (axis[0] == 1.0) plane = {0,0,1}; // X → plan XY
    if (axis[1] == 1.0) plane = {0,0,1}; // Y → plan XY
    if (axis[2] == 1.0) plane = {0,1,0}; // Z → plan XZ
    obj->turnAxis(axis, axisWorld);
    obj->turnAxis(plane, planeWorld);
    glfwGetCursorPos(Opengl::getWindow(), &mouseX, &mouseY);
    std::array<double, 3> dirLast, originLast, dirM, originM, interLast, interMouse;
 
    if (!unprojectMouse(lastX, lastY, dirLast[0], dirLast[1], dirLast[2], originLast))
        return ;
    if (!unprojectMouse(mouseX, mouseY, dirM[0], dirM[1], dirM[2], originM))
        return ;
    if (!getIntersection(planeWorld, originLast, dirLast, interLast))
        return ;
    if (!getIntersection(planeWorld, originM, dirM, interMouse))
        return ;
    std::array<double, 3> delta = {interMouse[0] - interLast[0], interMouse[1] - interLast[1], interMouse[2] - interLast[2]};
    double dot = delta[0]*axisWorld[0] + delta[1]*axisWorld[1] + delta[2]*axisWorld[2];
    std::array<double, 3> deltaAxis = {dot * axisWorld[0], dot * axisWorld[1], dot * axisWorld[2]};
    obj->setPos(pos[0] + deltaAxis[0],
                pos[1] + deltaAxis[1],
                pos[2] + deltaAxis[2]);
 
    lastX = mouseX;
    lastY = mouseY;
}
avec turnAxis qui prends l'origine de base et qui applique les matrices de rotations de mon objet pour bien tourner pour correspondre a mon objet selectionne,
avec unprojectMouse qui va projeter selon le sens inverse les coordonees de ma souris (fait pixel -> ndc, avec z = -1 puis z = 1 pour near/far) puis multiplie ces coordonees par l'inverse de cette matrice: projection * view * wTranslate * wRotZ * wRotY * wRotX, puis divise par w fait le vecteur far - near et normalise,
avec getIntersection qui renvoit le point d'intersection de mon rayon souris et mon plan.
C'est a peu pres tout, si vous avez des idees du pourquoi cela ne fonctionne pas je suis prenneur !
Merci d'avance :) ]]> OpenGL Moiu_ https://www.developpez.net/forums/d2180764/applications/developpement-2d-3d-jeux/api-graphiques/opengl/deplacement-d-objet-souris/ <![CDATA[[GLSL] BGFX : shader lighting]]> https://www.developpez.net/forums/showthread.php?t=2178656&goto=newpost Sun, 17 Aug 2025 20:35:08 GMT Bonjour, Je vous joint le... Bonjour,
Je vous joint le shader vertex et fragment mais en version BGFX .

Vertex:
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
$input a_position, a_texcoord0
//$output v_texcoord0
$output v_position
$output v_normal
 
#include "common.sh"
 
//SAMPLER2D(s_texColor, 0);
uniform mat4 matview;
uniform vec4 eBias;
 
//out vec2 OutTexCoord0;
//out vec4 vertexColor; // Remplace l'ancien gl_BackColor
 
void main()
{
 
	// v_texcoord0 = a_texcoord0;
 
 
    gl_Position = mul(matview, vec4(a_position, 1.0) );
 
 
    v_position=a_position;
 
	v_normal = vec3(0,0,1);  // normale arbitraire
	gl_Position=gl_Position+eBias;
 
 
 
}
Fragment :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// fs_spot_lightonly.sc
$input v_normal, v_position
#include "common.sh"
 
// uniforms
uniform vec4 u_lightPos;   // xyz = position du spot, w = cos(cutoffAngle)
uniform vec4 u_lightDir;   // xyz = direction du spot normalisée
uniform vec4 u_lightColor; // rgb = couleur du spot
 
void main()
{
vec3 N = normalize(v_normal);
 
    // vecteur du fragment vers la lumière
    vec3 fragToLight = normalize(u_lightPos.xyz - v_position);
 
    // cos de l’angle entre direction du spot et fragment
    float cosTheta = dot(normalize(u_lightDir.xyz), fragToLight);
 
    // si on veut autoriser demi-angle > 90° (jusqu'à 180°)
    float cutoff = clamp(u_lightPos.w, -1.0, 1.0); // cos(demi-angle) peut être négatif
    float spot = smoothstep(cutoff, 1.0, cosTheta);
 
    // Lambert
    float ndotl = max(dot(N, fragToLight), 0.0);
 
    vec3 contrib = u_lightColor.rgb * ndotl * spot;
 
    gl_FragColor = vec4(contrib, 1.0);
}
Les shaders sont t'ils bon ?
Pour information : La valeur eBias est à 0,bref.
Ces shaders qui servent à intégrer la lumière dans la scéne 3d.
La lumiére fonctionne que sur certain angle , c'est à dire quand la lumière est sur un angle de 0 à 120° , cela fonctionne mais partir de 120° la lumiére s'estompe et plus rien à 180°.

Comment faire pour que cela fonctionne sur toutes les angles ????

Merci ]]> OpenGL yann458 https://www.developpez.net/forums/d2178656/applications/developpement-2d-3d-jeux/api-graphiques/opengl/bgfx-shader-lighting/ chargement d un shader depuis un fichier https://www.developpez.net/forums/showthread.php?t=2178355&goto=newpost Thu, 31 Jul 2025 11:54:45 GMT Bonjour ! je viens d... Bonjour !

je viens d implementer un code source c++ :

une fonction renvoyant un pointeur sur char, depuis un fichier.
un fichier lui-meme contenant le code source d un shader, afin de fournir le pointeur en question au code opengl afin de le compiler...

Merci de critiquer mon travail (en bien ou en mal, no souci)...
(j apprend de mes erreurs)

Et si ca peut etre utile a quelqu'un, c est coool !
merci.

Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#include <iostream>
#include <fstream>
#include <string>
 
char* chargement(std::string nom)
{
    char* adresse = nullptr;
    int taille;
 
    std::ifstream flux(nom, std::ios::in);
    if(!flux){std::cout << "fichier " << nom << " introuvable !\n";}
 
    flux.seekg(0, std::ios::end);
    taille = flux.tellg();
 
    flux.seekg(0, std::ios::beg);
    for (int i = 0; i<taille; i++)
    {
        flux.read(adresse+i, sizeof(char));
    }
    // ajouter \0
    adresse[taille] = '\0';
    // fermer le fichier
    flux.close();
    // renvoyer adresse
    return adresse;
 
}
]]> OpenGL GraineDeDev https://www.developpez.net/forums/d2178355/applications/developpement-2d-3d-jeux/api-graphiques/opengl/chargement-d-shader-fichier/ <![CDATA[[GLSL] Vertex Shader : ou placer le code du shader ?]]> https://www.developpez.net/forums/showthread.php?t=2178322&goto=newpost Tue, 29 Jul 2025 22:27:27 GMT Bonsoir !

J'étudie openGL sous Linux... en c++ avec SFML...

Je suis le tutoriel de Joey de Vries - Jean-Michel Fray(traducteur)

Il indique un code simple pour un Vertex Shader... Mais :

_Pas d indication de où placer ce code, surtout que nous sommes sensés le compiler depuis le code source...
_donc :

Je dois faire appel à "glShaderSource(..., ..., ..., ...);
Le 3ème argument est un pointeur vers le code source du Shader... (?)

Et puis, ce code débute avec un "void main()" : autrement dit "surcharge du main" : )

Je nage...
Merci de votre aide. ]]> OpenGL GraineDeDev https://www.developpez.net/forums/d2178322/applications/developpement-2d-3d-jeux/api-graphiques/opengl/vertex-shader-placer-code-shader/