JME 3.8.0-alpha4

yaRnMcDonuts · March 5, 2025, 7:38am

JME v3.8.0-alpha4 is now available for testing:

project.ext {
  jmeVer = '3.8.0-alpha4' 
}
dependencies {
    implementation "org.jmonkeyengine:jme3-core:$jmeVer"
    ...
}

Full Release Notes Here

The most notable changes since the last alpha3 release:

I’ve finally finished modularizing jme’s pbr shader system and eliminated most bugs. The only remaining issue is that light probe blending is still broken, but it should be an easy fix that I’ll be submitting a pr for soon.
Upgraded the versions of some libraries that the engine uses including lwgl, lwjglx-awt, and groovy.
Added a new convenience class (RawInputListenerAdapter) that should make it easier to setup and work with jme’s RawInputListener
OSVR has been removed, as it is very outdated and jme offers better alternatives
A few other bug fixes and minor changes

Big thanks to all of the contributors and testers that have helped with 3.8.0 so far!

xuan · March 5, 2025, 5:34pm

Seems convenient but why not make default implementations in the interface?

pspeed · March 5, 2025, 5:42pm

The down side of an interface with all defaults is that if you really DO want to implement all of the methods you have no options. If you implement the interface with no defaults then the compiler will tell you when you are missing something.

The interface + adapter is an old well-established pattern in Java. The “default” methods are nice when you have to update an interface and want to maintain backwards compatibility. In my experience, many of the cases where an interface starts off with defaults is a code smell… and certainly an interface of all defaults is weird.

ndebruyn · March 5, 2025, 5:54pm

Probably a stupid question, but was the jme3-lwjgl3 removed from this version?
I am not seeing it anymore.

pspeed · March 5, 2025, 6:16pm

Where are you looking?

It seems to be in maven central: Maven Central: org.jmonkeyengine:jme3-lwjgl3

ndebruyn · March 5, 2025, 6:42pm

In the zip file we download.

pspeed · March 5, 2025, 7:16pm

I wonder how many are in that “we”. I think it is not the normal way.

…but yeah, maybe an uploaded jar was missed when cutting the release for bitbucket.

ndebruyn · March 5, 2025, 7:20pm

That might be, however it is still an option.

sgold · March 5, 2025, 7:39pm

@yarnMcDonuts:
I’m very grateful for the new alpha release. Please take a look at this recent regression:

github.com/jMonkeyEngine/jmonkeyengine

implicit cast from "vec4" to "vec3" in PBRLighting.frag

opened 07:36PM - 05 Mar 25 UTC

stephengold

Shortly after loading the "SpecGlossVsMetalRough" model from glTF-Sample-Assets,… my CompareLoaders app crashes with a bad shader compile. This crash is reproducible with JME v3.8.0-alpha4 and -alpha3 but not -alpha2, so I think it's a recent regression. The test model can be found online: https://github.com/KhronosGroup/glTF-Sample-Assets/tree/main/Models/SpecGlossVsMetalRough ```console Successfully loaded "SpecGlossVsMetalRough" from the gltf-sample-assets group using the Default loader(s). ====== Mar 05, 2025 11:19:00 AM com.jme3.renderer.opengl.GLRenderer updateShaderSourceData WARNING: Bad compile of: 1 #version 150 core 2 #define SRGB 1 3 #define FRAGMENT_SHADER 1 4 #define BOUND_DRAW_BUFFER 0 5 #define BASECOLORMAP 1 6 #define EMISSIVE 1 7 #define SPECGLOSSPIPELINE 1 8 #define SPECULAR_AA 1 9 #define NORMAL_TYPE -1.0 10 #define SINGLE_PASS_LIGHTING 1 11 #define NB_LIGHTS 3 12 #define NB_PROBES 1 13 #define USE_AMBIENT_LIGHT 1 14 #extension GL_ARB_shader_texture_lod : enable 15 // -- begin import Common/ShaderLib/GLSLCompat.glsllib -- 16 #ifdef GL_ES 17 #ifdef FRAGMENT_SHADER 18 precision highp float; 19 precision highp int; 20 #if __VERSION__ >= 130 21 precision highp sampler2DArray; 22 #endif 23 precision highp sampler2DArray; 24 precision highp sampler2DShadow; 25 precision highp samplerCube; 26 precision highp sampler3D; 27 precision highp sampler2D; 28 #if __VERSION__ >= 310 29 precision highp sampler2DMS; 30 #endif 31 #endif 32 #endif 33 34 #if defined GL_ES 35 # define hfloat highp float 36 # define hvec2 highp vec2 37 # define hvec3 highp vec3 38 # define hvec4 highp vec4 39 # define lfloat lowp float 40 # define lvec2 lowp vec2 41 # define lvec3 lowp vec3 42 # define lvec4 lowp vec4 43 #else 44 # define hfloat float 45 # define hvec2 vec2 46 # define hvec3 vec3 47 # define hvec4 vec4 48 # define lfloat float 49 # define lvec2 vec2 50 # define lvec3 vec3 51 # define lvec4 vec4 52 #endif 53 54 #if __VERSION__ >= 130 55 56 #ifdef FRAGMENT_SHADER 57 #ifdef GL_ES 58 #ifdef BOUND_DRAW_BUFFER 59 60 #if 0<=BOUND_DRAW_BUFFER 61 #if BOUND_DRAW_BUFFER == 0 62 layout( location = 0 ) out highp vec4 outFragColor; 63 #else 64 layout( location = 0 ) out highp vec4 outNOP0; 65 #endif 66 #endif 67 68 #if 1<=BOUND_DRAW_BUFFER 69 #if BOUND_DRAW_BUFFER == 1 70 layout( location = 1 ) out highp vec4 outFragColor; 71 #else 72 layout( location = 1 ) out highp vec4 outNOP1; 73 #endif 74 #endif 75 76 #if 2<=BOUND_DRAW_BUFFER 77 #if BOUND_DRAW_BUFFER == 2 78 layout( location = 2 ) out highp vec4 outFragColor; 79 #else 80 layout( location = 2 ) out highp vec4 outNOP2; 81 #endif 82 #endif 83 84 #if 3<=BOUND_DRAW_BUFFER 85 #if BOUND_DRAW_BUFFER == 3 86 layout( location = 3 ) out highp vec4 outFragColor; 87 #else 88 layout( location = 3 ) out highp vec4 outNOP3; 89 #endif 90 #endif 91 92 #if 4<=BOUND_DRAW_BUFFER 93 #if BOUND_DRAW_BUFFER == 4 94 layout( location = 4 ) out highp vec4 outFragColor; 95 #else 96 layout( location = 4 ) out highp vec4 outNOP4; 97 #endif 98 #endif 99 100 #if 5<=BOUND_DRAW_BUFFER 101 #if BOUND_DRAW_BUFFER == 5 102 layout( location = 5 ) out highp vec4 outFragColor; 103 #else 104 layout( location = 5 ) out highp vec4 outNOP5; 105 #endif 106 #endif 107 108 #if 6<=BOUND_DRAW_BUFFER 109 #if BOUND_DRAW_BUFFER == 6 110 layout( location = 6 ) out highp vec4 outFragColor; 111 #else 112 layout( location = 6 ) out highp vec4 outNOP6; 113 #endif 114 #endif 115 116 #if 7<=BOUND_DRAW_BUFFER 117 #if BOUND_DRAW_BUFFER == 7 118 layout( location = 7 ) out highp vec4 outFragColor; 119 #else 120 layout( location = 7 ) out highp vec4 outNOP7; 121 #endif 122 #endif 123 124 #if 8<=BOUND_DRAW_BUFFER 125 #if BOUND_DRAW_BUFFER == 8 126 layout( location = 8 ) out highp vec4 outFragColor; 127 #else 128 layout( location = 8 ) out highp vec4 outNOP8; 129 #endif 130 #endif 131 132 #if 9<=BOUND_DRAW_BUFFER 133 #if BOUND_DRAW_BUFFER == 9 134 layout( location = 9 ) out highp vec4 outFragColor; 135 #else 136 layout( location = 9 ) out highp vec4 outNOP9; 137 #endif 138 #endif 139 140 #if 10<=BOUND_DRAW_BUFFER 141 #if BOUND_DRAW_BUFFER == 10 142 layout( location = 10 ) out highp vec4 outFragColor; 143 #else 144 layout( location = 10 ) out highp vec4 outNOP10; 145 #endif 146 #endif 147 148 #if 11<=BOUND_DRAW_BUFFER 149 #if BOUND_DRAW_BUFFER == 11 150 layout( location = 11 ) out highp vec4 outFragColor; 151 #else 152 layout( location = 11 ) out highp vec4 outNOP11; 153 #endif 154 #endif 155 156 #if 12<=BOUND_DRAW_BUFFER 157 #if BOUND_DRAW_BUFFER == 12 158 layout( location = 12 ) out highp vec4 outFragColor; 159 #else 160 layout( location = 12 ) out highp vec4 outNOP12; 161 #endif 162 #endif 163 164 #if 13<=BOUND_DRAW_BUFFER 165 #if BOUND_DRAW_BUFFER == 13 166 layout( location = 13 ) out highp vec4 outFragColor; 167 #else 168 layout( location = 13 ) out highp vec4 outNOP13; 169 #endif 170 #endif 171 172 #if 14<=BOUND_DRAW_BUFFER 173 #if BOUND_DRAW_BUFFER == 14 174 layout( location = 14 ) out highp vec4 outFragColor; 175 #else 176 layout( location = 14 ) out highp vec4 outNOP14; 177 #endif 178 #endif 179 #else 180 out highp vec4 outFragColor; 181 #endif 182 #else 183 out vec4 outFragColor; 184 #endif 185 #endif 186 187 # define texture1D texture 188 # define texture2D texture 189 # define texture3D texture 190 # define textureCube texture 191 # define texture2DLod textureLod 192 # define textureCubeLod textureLod 193 # define texture2DArray texture 194 # if defined VERTEX_SHADER 195 # define varying out 196 # define attribute in 197 # elif defined FRAGMENT_SHADER 198 # define varying in 199 # define gl_FragColor outFragColor 200 # endif 201 #else 202 # define isnan(val) !(val<0.0||val>0.0||val==0.0) 203 #endif 204 205 #if __VERSION__ == 110 206 mat3 mat3_sub(mat4 m) { 207 return mat3(m[0].xyz, m[1].xyz, m[2].xyz); 208 } 209 #else 210 #define mat3_sub mat3 211 #endif 212 213 #if __VERSION__ <= 140 214 float determinant(mat2 m) { 215 return m[0][0] * m[1][1] - m[1][0] * m[0][1]; 216 } 217 218 float determinant(mat3 m) { 219 return + m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) 220 - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) 221 + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]); 222 } 223 #endif 224 225 #if __VERSION__ <= 130 226 mat2 inverse(mat2 m) { 227 return mat2(m[1][1], -m[0][1], -m[1][0], m[0][0]) / determinant(m); 228 } 229 230 mat3 inverse(mat3 m) { 231 return mat3( 232 + (m[1][1] * m[2][2] - m[2][1] * m[1][2]), 233 - (m[1][0] * m[2][2] - m[2][0] * m[1][2]), 234 + (m[1][0] * m[2][1] - m[2][0] * m[1][1]), 235 - (m[0][1] * m[2][2] - m[2][1] * m[0][2]), 236 + (m[0][0] * m[2][2] - m[2][0] * m[0][2]), 237 - (m[0][0] * m[2][1] - m[2][0] * m[0][1]), 238 + (m[0][1] * m[1][2] - m[1][1] * m[0][2]), 239 - (m[0][0] * m[1][2] - m[1][0] * m[0][2]), 240 + (m[0][0] * m[1][1] - m[1][0] * m[0][1])) / determinant(m); 241 } 242 #endif 243 // -- end import Common/ShaderLib/GLSLCompat.glsllib -- 244 245 // enable apis and import PBRLightingUtils 246 #define ENABLE_PBRLightingUtils_getWorldPosition 1 247 //#define ENABLE_PBRLightingUtils_getLocalPosition 1 248 #define ENABLE_PBRLightingUtils_getWorldNormal 1 249 #define ENABLE_PBRLightingUtils_getWorldTangent 1 250 #define ENABLE_PBRLightingUtils_getTexCoord 1 251 #define ENABLE_PBRLightingUtils_readPBRSurface 1 252 #define ENABLE_PBRLightingUtils_computeDirectLightContribution 1 253 #define ENABLE_PBRLightingUtils_computeProbesContribution 1 254 255 // -- begin import Common/ShaderLib/module/pbrlighting/PBRLightingUtils.glsllib -- 256 #ifndef __PBR_LIGHT_UTILS_MODULE__ 257 #define __PBR_LIGHT_UTILS_MODULE__ 258 259 // -- begin import Common/ShaderLib/Math.glsllib -- 260 #ifndef __MATH_GLSLLIB__ 261 #define __MATH_GLSLLIB__ 262 263 /// Multiplies the vector by the quaternion, then returns the resultant vector. 264 vec3 Math_QuaternionMult(in vec4 quat, in vec3 vec){ 265 return vec + 2.0 * cross(quat.xyz, cross(quat.xyz, vec) + quat.w * vec); 266 } 267 268 void Math_lengthAndNormalize(in vec3 vec,out float outLength,out vec3 outNormal){ 269 float dotv=dot(vec,vec); 270 float invl=inversesqrt(dotv); 271 outNormal=vec*invl; 272 outLength=invl*dotv; 273 } 274 275 276 #endif 277 // -- end import Common/ShaderLib/Math.glsllib -- 278 // -- begin import Common/ShaderLib/PBR.glsllib -- 279 #ifndef PI 280 #define PI 3.14159265358979323846264 281 #endif 282 #ifndef NB_PROBES 283 #define NB_PROBES 0 284 #endif 285 286 // BEGIN-@jhonkkk,Specular AA -------------------------------------------------------------- 287 // see:http://www.jp.square-enix.com/tech/library/pdf/ImprovedGeometricSpecularAA(slides).pdf 288 // https://docs.unity3d.com/Packages/com.unity.render-pipelines.high-definition@15.0/manual/Geometric-Specular-Anti-Aliasing.html 289 float Specular_Anti_Aliasing(in vec3 normal, in vec3 half_vector, 290 float alpha, in float sigma, in float kappa) 291 { 292 293 vec3 dndu = dFdx(normal); 294 vec3 dndv = dFdy(normal); 295 float variance = sigma*sigma*(dot(dndu, dndu) + dot(dndv, dndv)); 296 float kernel_roughness = min(kappa, variance); 297 return sqrt(alpha*alpha + kernel_roughness); 298 } 299 // END-@jhonkkk 300 301 302 //Specular fresnel computation 303 vec3 F_Shlick(float vh, vec3 F0){ 304 float fresnelFact = pow(2.0, (-5.55473*vh - 6.98316) * vh); 305 return mix(F0, vec3(1.0, 1.0, 1.0), fresnelFact); 306 } 307 308 vec3 sphericalHarmonics( const in vec3 normal, const vec3 sph[9] ){ 309 float x = normal.x; 310 float y = normal.y; 311 float z = normal.z; 312 313 vec3 result = ( 314 sph[0] + 315 316 sph[1] * y + 317 sph[2] * z + 318 sph[3] * x + 319 320 sph[4] * y * x + 321 sph[5] * y * z + 322 sph[6] * (3.0 * z * z - 1.0) + 323 sph[7] * (z * x) + 324 sph[8] * (x*x - y*y) 325 ); 326 327 return max(result, vec3(0.0)); 328 } 329 330 // BEGIN-@jhonkkk,todo:Keeping the original PBR_ComputeDirectLight function signature is for backwards compatibility, but this adds an extra internal function call, theoretically here we should use a macro to define Inner_PBR_ComputeDirectLight, or best to calculate alpha externally and directly call the Inner_PBR_ComputeDirectLight function. 331 float Inner_PBR_ComputeDirectLight( 332 vec3 normal, vec3 halfVec, vec3 lightDir, vec3 viewDir, 333 vec3 lightColor, vec3 fZero, float alpha, float ndotv, 334 out vec3 outDiffuse, out vec3 outSpecular){ 335 336 // Compute ndotl, ndoth, vdoth terms which are needed later. 337 float ndotl = max( dot(normal, lightDir), 0.0); 338 float ndoth = max( dot(normal, halfVec), 0.0); 339 float hdotv = max( dot(viewDir, halfVec), 0.0); 340 341 // Compute diffuse using energy-conserving Lambert. 342 // Alternatively, use Oren-Nayar for really rough 343 // materials or if you have lots of processing power ... 344 outDiffuse = vec3(ndotl) * lightColor; 345 346 //cook-torrence, microfacet BRDF : http://blog.selfshadow.com/publications/s2013-shading-course/karis/s2013_pbs_epic_notes_v2.pdf 347 348 //D, GGX normal Distribution function 349 float alpha2 = alpha * alpha; 350 float sum = ((ndoth * ndoth) * (alpha2 - 1.0) + 1.0); 351 float denom = PI * sum * sum; 352 float D = alpha2 / denom; 353 354 // Compute Fresnel function via Schlick's approximation. 355 vec3 fresnel = F_Shlick(hdotv, fZero); 356 357 //G Schlick GGX Geometry shadowing term, k = alpha/2 358 float k = alpha * 0.5; 359 360 /* 361 //classic Schlick ggx 362 float G_V = ndotv / (ndotv * (1.0 - k) + k); 363 float G_L = ndotl / (ndotl * (1.0 - k) + k); 364 float G = ( G_V * G_L ); 365 366 float specular =(D* fresnel * G) /(4 * ndotv); 367 */ 368 369 // UE4 way to optimise Schlick GGX Geometry shadowing term 370 //http://graphicrants.blogspot.co.uk/2013/08/specular-brdf-reference.html 371 float G_V = ndotv + sqrt( (ndotv - ndotv * k) * ndotv + k ); 372 float G_L = ndotl + sqrt( (ndotl - ndotl * k) * ndotl + k ); 373 // the max here is to avoid division by 0 that may cause some small glitches. 374 float G = 1.0/max( G_V * G_L ,0.01); 375 376 float specular = D * G * ndotl; 377 378 outSpecular = vec3(specular) * fresnel * lightColor; 379 return hdotv; 380 } 381 382 float PBR_ComputeDirectLight( 383 vec3 normal, vec3 lightDir, vec3 viewDir, 384 vec3 lightColor, vec3 fZero, float roughness, float ndotv, 385 out vec3 outDiffuse, out vec3 outSpecular){ 386 // Compute halfway vector. 387 vec3 halfVec = normalize(lightDir + viewDir); 388 return Inner_PBR_ComputeDirectLight(normal, halfVec, lightDir, viewDir, 389 lightColor, fZero, roughness * roughness, ndotv, 390 outDiffuse, outSpecular); 391 } 392 393 float PBR_ComputeDirectLightWithSpecularAA( 394 vec3 normal, vec3 lightDir, vec3 viewDir, 395 vec3 lightColor, vec3 fZero, float roughness, float sigma, float kappa, float ndotv, 396 out vec3 outDiffuse, out vec3 outSpecular){ 397 // Compute halfway vector. 398 vec3 halfVec = normalize(lightDir + viewDir); 399 // Specular-AA 400 float alpha = Specular_Anti_Aliasing(normal, halfVec, roughness * roughness, sigma, kappa); 401 return Inner_PBR_ComputeDirectLight(normal, halfVec, lightDir, viewDir, 402 lightColor, fZero, alpha, ndotv, 403 outDiffuse, outSpecular); 404 } 405 // END-@jhonkkk 406 407 vec3 integrateBRDFApprox( const in vec3 specular, float roughness, float NoV ){ 408 const vec4 c0 = vec4( -1, -0.0275, -0.572, 0.022 ); 409 const vec4 c1 = vec4( 1, 0.0425, 1.04, -0.04 ); 410 vec4 r = roughness * c0 + c1; 411 float a004 = min( r.x * r.x, exp2( -9.28 * NoV ) ) * r.x + r.y; 412 vec2 AB = vec2( -1.04, 1.04 ) * a004 + r.zw; 413 return specular * AB.x + AB.y; 414 } 415 416 // from Sebastien Lagarde https://seblagarde.files.wordpress.com/2015/07/course_notes_moving_frostbite_to_pbr_v32.pdf page 69 417 vec3 getSpecularDominantDir(const in vec3 N, const in vec3 R, const in float realRoughness){ 418 vec3 dominant; 419 420 float smoothness = 1.0 - realRoughness; 421 float lerpFactor = smoothness * (sqrt(smoothness) + realRoughness); 422 // The result is not normalized as we fetch in a cubemap 423 dominant = mix(N, R, lerpFactor); 424 425 return dominant; 426 } 427 428 vec3 ApproximateSpecularIBL(samplerCube envMap,sampler2D integrateBRDF, vec3 SpecularColor , float Roughness, float ndotv, vec3 refVec, float nbMipMaps){ 429 float Lod = sqrt( Roughness ) * (nbMipMaps - 1.0); 430 vec3 PrefilteredColor = textureCubeLod(envMap, refVec.xyz,Lod).rgb; 431 vec2 EnvBRDF = texture2D(integrateBRDF,vec2(Roughness, ndotv)).rg; 432 return PrefilteredColor * ( SpecularColor * EnvBRDF.x+ EnvBRDF.y ); 433 } 434 435 vec3 ApproximateSpecularIBLPolynomial(samplerCube envMap, vec3 SpecularColor , float Roughness, float ndotv, vec3 refVec, float nbMipMaps){ 436 float Lod = sqrt( Roughness ) * (nbMipMaps - 1.0); 437 vec3 PrefilteredColor = textureCubeLod(envMap, refVec.xyz, Lod).rgb; 438 return PrefilteredColor * integrateBRDFApprox(SpecularColor, Roughness, ndotv); 439 } 440 441 442 float renderProbe(vec3 viewDir, vec3 worldPos, vec3 normal, vec3 norm, float Roughness, vec4 diffuseColor, vec4 specularColor, float ndotv, vec3 ao, mat4 lightProbeData,vec3 shCoeffs[9],samplerCube prefEnvMap, inout vec3 color ){ 443 444 // lightProbeData is a mat4 with this layout 445 // 3x3 rot mat| 446 // 0 1 2 | 3 447 // 0 | ax bx cx | px | ) 448 // 1 | ay by cy | py | probe position 449 // 2 | az bz cz | pz | ) 450 // --|----------| 451 // 3 | sx sy sz sp | -> 1/probe radius + nbMipMaps 452 // --scale-- 453 // parallax fix for spherical / obb bounds and probe blending from 454 // from https://seblagarde.wordpress.com/2012/09/29/image-based-lighting-approaches-and-parallax-corrected-cubemap/ 455 vec3 rv = reflect(-viewDir, normal); 456 vec4 probePos = lightProbeData[3]; 457 float invRadius = fract( probePos.w); 458 float nbMipMaps = probePos.w - invRadius; 459 vec3 direction = worldPos - probePos.xyz; 460 float ndf = 0.0; 461 462 if(lightProbeData[0][3] != 0.0){ 463 // oriented box probe 464 // mat3_sub our compat wrapper for mat3(mat4) 465 mat3 wToLocalRot = inverse(mat3_sub(lightProbeData)); 466 467 vec3 scale = vec3(lightProbeData[0][3], lightProbeData[1][3], lightProbeData[2][3]); 468 #if NB_PROBES >= 2 469 // probe blending 470 // compute fragment position in probe local space 471 vec3 localPos = wToLocalRot * worldPos; 472 localPos -= probePos.xyz; 473 // compute normalized distance field 474 vec3 localDir = abs(localPos); 475 localDir /= scale; 476 ndf = max(max(localDir.x, localDir.y), localDir.z); 477 #endif 478 // parallax fix 479 vec3 rayLs = wToLocalRot * rv; 480 rayLs /= scale; 481 482 vec3 positionLs = worldPos - probePos.xyz; 483 positionLs = wToLocalRot * positionLs; 484 positionLs /= scale; 485 486 vec3 unit = vec3(1.0); 487 vec3 firstPlaneIntersect = (unit - positionLs) / rayLs; 488 vec3 secondPlaneIntersect = (-unit - positionLs) / rayLs; 489 vec3 furthestPlane = max(firstPlaneIntersect, secondPlaneIntersect); 490 float distance = min(min(furthestPlane.x, furthestPlane.y), furthestPlane.z); 491 492 vec3 intersectPositionWs = worldPos + rv * distance; 493 rv = intersectPositionWs - probePos.xyz; 494 495 } else { 496 // spherical probe 497 // parallax fix 498 rv = invRadius * direction + rv; 499 500 #if NB_PROBES >= 2 501 // probe blending 502 float dist = sqrt(dot(direction, direction)); 503 ndf = dist * invRadius; 504 #endif 505 } 506 507 vec3 indirectDiffuse = vec3(0.0); 508 vec3 indirectSpecular = vec3(0.0); 509 indirectDiffuse = sphericalHarmonics(normal.xyz, shCoeffs) * diffuseColor.rgb; 510 vec3 dominantR = getSpecularDominantDir( normal, rv.xyz, Roughness * Roughness ); 511 indirectSpecular = ApproximateSpecularIBLPolynomial(prefEnvMap, specularColor.rgb, Roughness, ndotv, dominantR, nbMipMaps); 512 513 #ifdef HORIZON_FADE 514 //horizon fade from http://marmosetco.tumblr.com/post/81245981087 515 float horiz = dot(rv, norm); 516 float horizFadePower = 1.0 - Roughness; 517 horiz = clamp( 1.0 + horizFadePower * horiz, 0.0, 1.0 ); 518 horiz *= horiz; 519 indirectSpecular *= vec3(horiz); 520 #endif 521 522 vec3 indirectLighting = (indirectDiffuse + indirectSpecular) * ao; 523 524 color = indirectLighting * step( 0.0, probePos.w); 525 return ndf; 526 } 527 // -- end import Common/ShaderLib/PBR.glsllib -- 528 // -- begin import Common/ShaderLib/Parallax.glsllib -- 529 #if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP))) && !defined(VERTEX_LIGHTING) 530 vec2 steepParallaxOffset(sampler2D parallaxMap, vec3 vViewDir,vec2 texCoord,float parallaxScale){ 531 vec2 vParallaxDirection = normalize( vViewDir.xy ); 532 533 // The length of this vector determines the furthest amount of displacement: (Ati's comment) 534 float fLength = length( vViewDir ); 535 float fParallaxLength = sqrt( fLength * fLength - vViewDir.z * vViewDir.z ) / vViewDir.z; 536 537 // Compute the actual reverse parallax displacement vector: (Ati's comment) 538 vec2 vParallaxOffsetTS = vParallaxDirection * fParallaxLength; 539 540 // Need to scale the amount of displacement to account for different height ranges 541 // in height maps. This is controlled by an artist-editable parameter: (Ati's comment) 542 parallaxScale *=0.3; 543 vParallaxOffsetTS *= parallaxScale; 544 545 vec3 eyeDir = normalize(vViewDir).xyz; 546 547 float nMinSamples = 6.0; 548 float nMaxSamples = 1000.0 * parallaxScale; 549 float nNumSamples = mix( nMinSamples, nMaxSamples, 1.0 - eyeDir.z ); //In reference shader: int nNumSamples = (int)(lerp( nMinSamples, nMaxSamples, dot( eyeDirWS, N ) )); 550 float fStepSize = 1.0 / nNumSamples; 551 float fCurrHeight = 0.0; 552 float fPrevHeight = 1.0; 553 float fNextHeight = 0.0; 554 float nStepIndex = 0.0; 555 vec2 vTexOffsetPerStep = fStepSize * vParallaxOffsetTS; 556 vec2 vTexCurrentOffset = texCoord; 557 float fCurrentBound = 1.0; 558 float fParallaxAmount = 0.0; 559 560 while ( nStepIndex < nNumSamples && fCurrHeight <= fCurrentBound ) { 561 vTexCurrentOffset -= vTexOffsetPerStep; 562 fPrevHeight = fCurrHeight; 563 564 565 #ifdef NORMALMAP_PARALLAX 566 //parallax map is stored in the alpha channel of the normal map 567 fCurrHeight = texture2D( parallaxMap, vTexCurrentOffset).a; 568 #else 569 //parallax map is a texture 570 fCurrHeight = texture2D( parallaxMap, vTexCurrentOffset).r; 571 #endif 572 573 fCurrentBound -= fStepSize; 574 nStepIndex+=1.0; 575 } 576 vec2 pt1 = vec2( fCurrentBound, fCurrHeight ); 577 vec2 pt2 = vec2( fCurrentBound + fStepSize, fPrevHeight ); 578 579 float fDelta2 = pt2.x - pt2.y; 580 float fDelta1 = pt1.x - pt1.y; 581 582 float fDenominator = fDelta2 - fDelta1; 583 584 fParallaxAmount = (pt1.x * fDelta2 - pt2.x * fDelta1 ) / fDenominator; 585 586 vec2 vParallaxOffset = vParallaxOffsetTS * (1.0 - fParallaxAmount ); 587 return texCoord - vParallaxOffset; 588 } 589 590 vec2 classicParallaxOffset(sampler2D parallaxMap, vec3 vViewDir,vec2 texCoord,float parallaxScale){ 591 float h; 592 #ifdef NORMALMAP_PARALLAX 593 //parallax map is stored in the alpha channel of the normal map 594 h = texture2D(parallaxMap, texCoord).a; 595 #else 596 //parallax map is a texture 597 h = texture2D(parallaxMap, texCoord).r; 598 #endif 599 float heightScale = parallaxScale; 600 float heightBias = heightScale* -0.6; 601 vec3 normView = normalize(vViewDir); 602 h = (h * heightScale + heightBias) * normView.z; 603 return texCoord + (h * normView.xy); 604 } 605 #endif 606 // -- end import Common/ShaderLib/Parallax.glsllib -- 607 608 // -- begin import Common/ShaderLib/module/Light.glsl -- 609 #ifndef __LIGHT_MODULE__ 610 #define __LIGHT_MODULE__ 611 612 /** 613 * Defines a light 614 */ 615 616 617 #ifndef Light 618 #define STRUCT_StdLight \ 619 vec4 color; \ 620 vec3 position; \ 621 float type; \ 622 float invRadius; \ 623 float spotAngleCos; \ 624 vec3 spotDirection; \ 625 bool ready; \ 626 float NdotL; \ 627 float NdotH; \ 628 float LdotH; \ 629 float HdotV; \ 630 vec3 vector; \ 631 vec3 dir; \ 632 float fallOff; 633 struct StdLight { 634 STRUCT_StdLight 635 }; 636 #define Light StdLight 637 #endif 638 639 640 641 #endif 642 // -- end import Common/ShaderLib/module/Light.glsl -- 643 // -- begin import Common/ShaderLib/module/PBRSurface.glsl -- 644 #ifndef __SURFACE_MODULE__ 645 #define __SURFACE_MODULE__ 646 647 #ifndef PBRSurface 648 #define STRUCT_StdPBRSurface \ 649 \ 650 vec3 position; \ 651 vec3 viewDir; \ 652 vec3 geometryNormal; \ 653 vec3 normal; \ 654 bool frontFacing; \ 655 float depth; \ 656 mat3 tbnMat; \ 657 bool hasTangents; \ 658 \ 659 vec3 albedo; \ 660 float alpha; \ 661 float metallic; \ 662 float roughness; \ 663 vec3 ao; \ 664 vec3 lightMapColor; \ 665 bool hasBasicLightMap; \ 666 float exposure; \ 667 vec3 emission; \ 668 \ 669 vec3 diffuseColor; \ 670 vec3 specularColor; \ 671 vec3 fZero; \ 672 \ 673 float NdotV; \ 674 \ 675 vec3 bakedLightContribution; \ 676 vec3 directLightContribution; \ 677 vec3 envLightContribution; \ 678 float brightestNonGlobalLightStrength; 679 struct StdPBRSurface { 680 STRUCT_StdPBRSurface 681 }; 682 #define PBRSurface StdPBRSurface 683 #endif 684 #endif 685 // -- end import Common/ShaderLib/module/PBRSurface.glsl -- 686 687 // enable all apis 688 // #define ENABLE_PBRLightingUtils_getWorldPosition 1 689 // #define ENABLE_PBRLightingUtils_getLocalPosition 1 690 // #define ENABLE_PBRLightingUtils_getWorldNormal 1 691 // #define ENABLE_PBRLightingUtils_getWorldTangent 1 692 // #define ENABLE_PBRLightingUtils_getTexCoord 1 693 // #define ENABLE_PBRLightingUtils_newLight 1 694 // #define ENABLE_PBRLightingUtils_computeLightInWorldSpace 1 695 // #define ENABLE_PBRLightingUtils_readPBRSurface 1 696 // #define ENABLE_PBRLightingUtils_computeDirectLight 1 697 // #define ENABLE_PBRLightingUtils_computeDirectLightContribution 1 698 // #define ENABLE_PBRLightingUtils_computeProbesContribution 1 699 700 #if defined(ENABLE_PBRLightingUtils_readPBRSurface)||defined(ENABLE_PBRLightingUtils_getWorldPosition) 701 varying vec3 wPosition; 702 #endif 703 704 #if defined(ENABLE_PBRLightingUtils_readPBRSurface)||defined(ENABLE_PBRLightingUtils_getWorldNormal) 705 varying vec3 wNormal; 706 #endif 707 708 #if (defined(ENABLE_PBRLightingUtils_readPBRSurface)&&(defined(NORMALMAP)||defined(PARALLAXMAP)))||defined(ENABLE_PBRLightingUtils_getWorldTangent) 709 varying vec4 wTangent; 710 #endif 711 712 #if defined(ENABLE_PBRLightingUtils_readPBRSurface)||defined(ENABLE_PBRLightingUtils_getTexCoord) 713 varying vec2 texCoord; 714 #ifdef SEPARATE_TEXCOORD 715 varying vec2 texCoord2; 716 #endif 717 #endif 718 719 #if defined(ENABLE_PBRLightingUtils_getLocalPosition) 720 varying vec3 lPosition; 721 #endif 722 723 724 725 #ifdef ENABLE_PBRLightingUtils_readPBRSurface 726 varying vec4 Color; 727 728 uniform float m_Roughness; 729 uniform float m_Metallic; 730 731 732 #ifdef BASECOLORMAP 733 uniform sampler2D m_BaseColorMap; 734 #endif 735 736 #ifdef USE_PACKED_MR 737 uniform sampler2D m_MetallicRoughnessMap; 738 #else 739 #ifdef METALLICMAP 740 uniform sampler2D m_MetallicMap; 741 #endif 742 #ifdef ROUGHNESSMAP 743 uniform sampler2D m_RoughnessMap; 744 #endif 745 #endif 746 747 #ifdef EMISSIVE 748 uniform vec4 m_Emissive; 749 #endif 750 #ifdef EMISSIVEMAP 751 uniform sampler2D m_EmissiveMap; 752 #endif 753 #if defined(EMISSIVE) || defined(EMISSIVEMAP) 754 uniform float m_EmissivePower; 755 uniform float m_EmissiveIntensity; 756 #endif 757 758 759 760 #ifdef SPECGLOSSPIPELINE 761 uniform vec4 m_Specular; 762 uniform float m_Glossiness; 763 #ifdef USE_PACKED_SG 764 uniform sampler2D m_SpecularGlossinessMap; 765 #else 766 uniform sampler2D m_SpecularMap; 767 uniform sampler2D m_GlossinessMap; 768 #endif 769 #endif 770 771 #ifdef PARALLAXMAP 772 uniform sampler2D m_ParallaxMap; 773 #endif 774 #if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP))) 775 uniform float m_ParallaxHeight; 776 #endif 777 778 #ifdef LIGHTMAP 779 uniform sampler2D m_LightMap; 780 #endif 781 782 #ifdef AO_STRENGTH 783 uniform float m_AoStrength; 784 #endif 785 786 #if defined(NORMALMAP) || defined(PARALLAXMAP) 787 uniform sampler2D m_NormalMap; 788 #endif 789 #ifdef NORMALSCALE 790 uniform float m_NormalScale; 791 #endif 792 793 #ifdef DISCARD_ALPHA 794 uniform float m_AlphaDiscardThreshold; 795 #endif 796 #endif 797 798 #if defined(ENABLE_PBRLightingUtils_computeDirectLight) || defined(ENABLE_PBRLightingUtils_computeDirectLightContribution) 799 800 // Specular-AA 801 #ifdef SPECULAR_AA_SCREEN_SPACE_VARIANCE 802 uniform float m_SpecularAASigma; 803 #endif 804 #ifdef SPECULAR_AA_THRESHOLD 805 uniform float m_SpecularAAKappa; 806 #endif 807 808 // DirectionalLight Exposure 809 #if defined(EXPOSUREMAP) 810 uniform sampler2D m_SunLightExposureMap; 811 #endif 812 #if defined(USE_VERTEX_COLORS_AS_SUN_EXPOSURE) 813 varying vec4 vertColors; 814 #endif 815 #ifdef STATIC_SUN_EXPOSURE 816 uniform float m_StaticSunIntensity; 817 #endif 818 819 void PBRLightingUtils_readSunLightExposureParams(inout PBRSurface surface){ 820 821 surface.exposure = 1.0; //default value 822 #ifdef EXPOSUREMAP 823 surface.exposure *= texture2D(m_SunLightExposureMap, newTexCoord; 824 #endif 825 #ifdef STATIC_SUN_EXPOSURE 826 surface.exposure *= m_StaticSunIntensity; //single float value to indicate percentage of sunlight hitting the model (only suitable for small models or models with equal sunlight exposure accross the entire model 827 #endif 828 #ifdef USE_VERTEX_COLORS_AS_SUN_EXPOSURE 829 surface.exposure *= vertColors.r; // use red channel of vertexColors for non-uniform sunlighting accross a single model 830 #endif 831 } 832 833 #endif 834 835 836 837 #ifdef ENABLE_PBRLightingUtils_computeProbesContribution 838 #if NB_PROBES >= 1 839 uniform samplerCube g_PrefEnvMap; 840 uniform vec3 g_ShCoeffs[9]; 841 uniform mat4 g_LightProbeData; 842 #endif 843 #if NB_PROBES >= 2 844 uniform samplerCube g_PrefEnvMap2; 845 uniform vec3 g_ShCoeffs2[9]; 846 uniform mat4 g_LightProbeData2; 847 #endif 848 #if NB_PROBES == 3 849 uniform samplerCube g_PrefEnvMap3; 850 uniform vec3 g_ShCoeffs3[9]; 851 uniform mat4 g_LightProbeData3; 852 #endif 853 #endif 854 855 #ifdef ENABLE_PBRLightingUtils_getWorldPosition 856 vec3 PBRLightingUtils_getWorldPosition(){ 857 return wPosition.xyz; 858 } 859 #endif 860 861 #ifdef ENABLE_PBRLightingUtils_getWorldNormal 862 vec3 PBRLightingUtils_getWorldNormal(){ 863 return normalize(wNormal.xyz); 864 } 865 #endif 866 867 #ifdef ENABLE_PBRLightingUtils_getWorldTangent 868 vec4 PBRLightingUtils_getWorldTangent(){ 869 return wTangent; 870 } 871 #endif 872 873 #ifdef ENABLE_PBRLightingUtils_getTexCoord 874 vec2 PBRLightingUtils_getTexCoord(){ 875 return texCoord; 876 } 877 878 #ifdef SEPARATE_TEXCOORD 879 vec2 PBRLightingUtils_getTexCoord2(){ 880 return texCoord2; 881 } 882 #endif 883 #endif 884 885 886 887 #if defined(ENABLE_PBRLightingUtils_computeDirectLightContribution) || defined(ENABLE_PBRLightingUtils_newLight) 888 Light PBRLightingUtils_newLight(vec4 color, vec3 position, float type, float invRadius, float spotAngleCos, vec3 spotDirection){ 889 Light l; 890 l.color = color; 891 l.position = position; 892 l.type = type; 893 l.invRadius = invRadius; 894 l.spotAngleCos = spotAngleCos; 895 l.spotDirection = spotDirection; 896 l.ready = false; 897 return l; 898 } 899 #endif 900 901 902 #if defined(ENABLE_PBRLightingUtils_computeDirectLightContribution) || defined(ENABLE_PBRLightingUtils_computeLightInWorldSpace) 903 void PBRLightingUtils_computeLightInWorldSpace(vec3 worldPos,vec3 worldNormal, vec3 viewDir, inout Light light){ 904 if(light.ready) return; 905 906 // lightComputeDir 907 float posLight = step(0.5, light.type); 908 light.vector = light.position.xyz * sign(posLight - 0.5) - (worldPos * posLight); //tempVec lightVec 909 910 vec3 L; // lightDir 911 float dist; 912 Math_lengthAndNormalize(light.vector,dist,L); 913 914 float invRange=light.invRadius; // position.w 915 const float light_threshold = 0.01; 916 917 #ifdef SRGB 918 light.fallOff = (1.0 - invRange * dist) / (1.0 + invRange * dist * dist); // lightDir.w 919 light.fallOff = clamp(light.fallOff, 1.0 - posLight, 1.0); 920 #else 921 light.fallOff = clamp(1.0 - invRange * dist * posLight, 0.0, 1.0); 922 #endif 923 924 // computeSpotFalloff 925 if(light.type>1.){ 926 vec3 spotdir = normalize(light.spotDirection); 927 float curAngleCos = dot(-L, spotdir); 928 float innerAngleCos = floor(light.spotAngleCos) * 0.001; 929 float outerAngleCos = fract(light.spotAngleCos); 930 float innerMinusOuter = innerAngleCos - outerAngleCos; 931 float falloff = clamp((curAngleCos - outerAngleCos) / innerMinusOuter, 0.0, 1.0); 932 #ifdef SRGB 933 // Use quadratic falloff (notice the ^4) 934 falloff = pow(clamp((curAngleCos - outerAngleCos) / innerMinusOuter, 0.0, 1.0), 4.0); 935 #endif 936 light.fallOff*=falloff; 937 } 938 939 940 vec3 h=normalize(L+viewDir); 941 light.dir=L; 942 light.NdotL = max(dot(worldNormal, L), 0.0); 943 light.NdotH = max(dot(worldNormal, h), 0.0); 944 light.LdotH = max(dot(L, h), 0.0); 945 light.HdotV = max(dot(viewDir,h), 0.); 946 } 947 #endif 948 949 PBRSurface PBRLightingUtils_createPBRSurface(in vec3 wViewDir){ 950 951 PBRSurface surface; //creates a new PBRSurface 952 953 surface.position = wPosition; 954 surface.viewDir = wViewDir; 955 surface.geometryNormal = normalize(wNormal); 956 957 //set default values 958 surface.hasTangents = false; 959 surface.hasBasicLightMap = false; 960 surface.albedo = vec3(1.0); 961 surface.normal = surface.geometryNormal; 962 surface.emission = vec3(0.0); 963 surface.ao = vec3(1.0); 964 surface.lightMapColor = vec3(0.0); 965 surface.alpha = 1.0; 966 surface.roughness = 1.0; 967 surface.metallic = 0.0; 968 surface.alpha = 1.0; 969 surface.exposure = 1.0; 970 971 return surface; 972 } 973 974 #ifdef ENABLE_PBRLightingUtils_readPBRSurface 975 vec2 newTexCoord; 976 977 void PBRLightingUtils_readPBRSurface(inout PBRSurface surface){ 978 979 surface.bakedLightContribution = vec3(0.0); 980 surface.directLightContribution = vec3(0.0); 981 surface.envLightContribution = vec3(0.0); 982 983 #ifdef ENABLE_PBRLightingUtils_getWorldTangent 984 vec3 tan = normalize(wTangent.xyz); 985 surface.tbnMat = mat3(tan, wTangent.w * cross( surface.geometryNormal, tan), surface.geometryNormal); 986 surface.hasTangents = true; 987 #endif 988 989 990 #if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP))) 991 vec3 vViewDir = surface.viewDir * surface.tbnMat; 992 #ifdef STEEP_PARALLAX 993 #ifdef NORMALMAP_PARALLAX 994 //parallax map is stored in the alpha channel of the normal map 995 newTexCoord = steepParallaxOffset(m_NormalMap, vViewDir, texCoord, m_ParallaxHeight); 996 #else 997 //parallax map is a texture 998 newTexCoord = steepParallaxOffset(m_ParallaxMap, vViewDir, texCoord, m_ParallaxHeight); 999 #endif 1000 #else 1001 #ifdef NORMALMAP_PARALLAX 1002 //parallax map is stored in the alpha channel of the normal map 1003 newTexCoord = classicParallaxOffset(m_NormalMap, vViewDir, texCoord, m_ParallaxHeight); 1004 #else 1005 //parallax map is a texture 1006 newTexCoord = classicParallaxOffset(m_ParallaxMap, vViewDir, texCoord, m_ParallaxHeight); 1007 #endif 1008 #endif 1009 #else 1010 newTexCoord = texCoord; 1011 #endif 1012 1013 #ifdef BASECOLORMAP 1014 vec4 baseColor = texture2D(m_BaseColorMap, newTexCoord) * Color; 1015 #else 1016 vec4 baseColor = Color; 1017 #endif 1018 1019 #ifdef DISCARD_ALPHA 1020 if( baseColor.a < m_AlphaDiscardThreshold) discard; 1021 #endif 1022 1023 surface.albedo = baseColor.rgb; 1024 surface.alpha = baseColor.a; 1025 1026 //ao in r channel, roughness in green channel, metallic in blue channel! 1027 vec3 aoRoughnessMetallicValue = vec3(1.0, 1.0, 0.0); 1028 #ifdef USE_PACKED_MR 1029 aoRoughnessMetallicValue = texture2D(m_MetallicRoughnessMap, newTexCoord).rgb; 1030 surface.roughness = aoRoughnessMetallicValue.g * max(m_Roughness, 1e-4); 1031 surface.metallic = aoRoughnessMetallicValue.b * max(m_Metallic, 0.0); 1032 #else 1033 #ifdef ROUGHNESSMAP 1034 surface.roughness = texture2D(m_RoughnessMap, newTexCoord).r * max(m_Roughness, 1e-4); 1035 #else 1036 surface.roughness = max(m_Roughness, 1e-4); 1037 #endif 1038 #ifdef METALLICMAP 1039 surface.metallic = texture2D(m_MetallicMap, newTexCoord).r * max(m_Metallic, 0.0); 1040 #else 1041 surface.metallic = max(m_Metallic, 0.0); 1042 #endif 1043 #endif 1044 1045 1046 1047 #if defined(NORMALMAP) 1048 vec4 normalHeight = texture2D(m_NormalMap, newTexCoord); 1049 // Note we invert directx style normal maps to opengl style 1050 #ifdef NORMALSCALE 1051 vec3 normal = normalize((normalHeight.xyz * vec3(2.0, NORMAL_TYPE * 2.0, 2.0) - vec3(1.0, NORMAL_TYPE * 1.0, 1.0)) * vec3(m_NormalScale, m_NormalScale, 1.0)); 1052 #else 1053 vec3 normal = normalize((normalHeight.xyz * vec3(2.0, NORMAL_TYPE * 2.0, 2.0) - vec3(1.0, NORMAL_TYPE * 1.0, 1.0))); 1054 #endif 1055 surface.normal = normalize(surface.tbnMat * normal); 1056 #else 1057 surface.normal = surface.geometryNormal; 1058 #endif 1059 1060 //spec gloss tex reads: 1061 1062 #ifdef SPECGLOSSPIPELINE 1063 #ifdef USE_PACKED_SG 1064 vec4 specularColor = texture2D(m_SpecularGlossinessMap, newTexCoord); 1065 float glossiness = specularColor.a * m_Glossiness; 1066 specularColor *= m_Specular; 1067 #else 1068 #ifdef SPECULARMAP 1069 vec4 specularColor = texture2D(m_SpecularMap, newTexCoord); 1070 #else 1071 vec4 specularColor = vec4(1.0); 1072 #endif 1073 #ifdef GLOSSINESSMAP 1074 float glossiness = texture2D(m_GlossinesMap, newTexCoord).r * m_Glossiness; 1075 #else 1076 float glossiness = m_Glossiness; 1077 #endif 1078 specularColor *= m_Specular; 1079 surface.specularColor = specularColor; 1080 #endif 1081 #endif [...470 lines deleted ...] 1552 gl_FragColor = PBRLightingUtils_getColorOutputForDebugMode(m_DebugValuesMode, vec4(gl_FragColor.rgba), surface); 1553 #endif 1554 } Mar 05, 2025 11:19:00 AM com.jme3.app.LegacyApplication handleError SEVERE: Uncaught exception thrown in Thread[jME3 Main,5,main] com.jme3.renderer.RendererException: compile error in: ShaderSource[name=Common/MatDefs/Light/PBRLighting.frag, defines, type=Fragment, language=GLSL150] 0(1079) : error C7011: implicit cast from "vec4" to "vec3" at com.jme3.renderer.opengl.GLRenderer.updateShaderSourceData(GLRenderer.java:1659) at com.jme3.renderer.opengl.GLRenderer.updateShaderData(GLRenderer.java:1686) at com.jme3.renderer.opengl.GLRenderer.setShader(GLRenderer.java:1751) at com.jme3.material.logic.SinglePassAndImageBasedLightingLogic.render(SinglePassAndImageBasedLightingLogic.java:277) at com.jme3.material.Technique.render(Technique.java:168) at com.jme3.material.Material.render(Material.java:1099) at com.jme3.renderer.RenderManager.renderGeometry(RenderManager.java:842) at com.jme3.renderer.RenderManager.renderGeometry(RenderManager.java:772) at com.jme3.renderer.queue.RenderQueue.renderGeometryList(RenderQueue.java:273) at com.jme3.renderer.queue.RenderQueue.renderQueue(RenderQueue.java:315) at com.jme3.renderer.RenderManager.renderViewPortQueues(RenderManager.java:1117) at com.jme3.renderer.RenderManager.flushQueue(RenderManager.java:1012) at com.jme3.renderer.pipeline.ForwardPipeline.pipelineRender(ForwardPipeline.java:117) at com.jme3.renderer.RenderManager.renderViewPort(RenderManager.java:1313) at com.jme3.renderer.RenderManager.render(RenderManager.java:1355) at com.jme3.app.SimpleApplication.update(SimpleApplication.java:283) at com.jme3.system.lwjgl.LwjglWindow.runLoop(LwjglWindow.java:707) at com.jme3.system.lwjgl.LwjglWindow.run(LwjglWindow.java:797) at java.base/java.lang.Thread.run(Thread.java:840) Mar 05, 2025 11:19:00 AM com.jme3.system.JmeSystemDelegate lambda$new$0 WARNING: JmeDialogsFactory implementation not found. Uncaught exception thrown in Thread[jME3 Main,5,main] RendererException: compile error in: ShaderSource[name=Common/MatDefs/Light/PBRLighting.frag, defines, type=Fragment, language=GLSL150] 0(1079) : error C7011: implicit cast from "vec4" to "vec3" ```

pspeed · March 5, 2025, 7:41pm

Totally… and should be fixed if it’s busted.

I was just joking around because the ‘we’ made me chuckle.

sgold · March 5, 2025, 7:42pm

The ZIP file is intended for execution, so it only includes one of { jme3-lwjgl, jme3-lwjgl3 }. I believe this has always been the case, though which jar is included has changed over time.

pspeed · March 5, 2025, 7:43pm

Ah. Interesting.

I thought it was the zip that bitbucket made for the release… which I’d have expected to have ‘all the things’ in it.

Edit: which shows how long it’s been since I’ve download a jar or a zip related to any open source projects.

xuan · March 5, 2025, 9:30pm

Thanks for clarifying! just glad there was some reasoning behind the decision. I assumed most folks would not need to implement everything.
I only have one implementation of the listener and there most methods are empty so the new adapter would make it cleaner.

yaRnMcDonuts · March 6, 2025, 1:52am

Thanks for the quick work testing and finding this!

I submitted a PR that solves the exception, and it also fixes 2 other logic errors in the spec gloss pipeline. The exception and the first logic error are due to mistakes that must’ve occurred when riccardo implemented the struct approach and then I missed it in testing since my only spec gloss models use packed spec gloss maps (and these issues only occurred when using non packed maps). And the other logic error has likely been around much longer and was ignoring the glossiness value from textures entirely. Everything should be fixed now, but will still need tested to be sure.

github.com/jMonkeyEngine/jmonkeyengine

Fix logic errors and exception in SpecGloss pipeline

master ← yaRnMcDonuts-patch-2

opened 01:36AM - 06 Mar 25 UTC

yaRnMcDonuts

+6 -10

This PR addresses this issue: #2386 And then I also found another critical l…ogic error in the spec gloss pipeline that was likely there even before riccardo adapted the shader to use structs: It looks like the specular and glossiness value taken from specularMaps was being totally ignored and the glossiness value was not being accounted for in the final roughness calculation. The code further down in the shader was calculating the roughness solely based on m_Glossiness with no regard for the glossiness scalar read from texture maps, which is incorrect. The logic error and exception should all be fixed in this PR now, but it will need testing from a spec gloss model with packed specularGlossinesMap as well as a model with seperate specular and glossiness maps in order to ensure everything works properly now.

FoxCC · March 7, 2025, 1:28pm

@yaRnMcDonuts
Thank you for the new version!
I just tested the new version (alpha4),
and some exceptions occurred in the scene containing InstancedNode:
error C1503: undefined variable "Use_the_instancing_functions_for_this"
This seems to be a regression! It seems to be the same as this one:

yaRnMcDonuts · March 7, 2025, 10:09pm

Thanks for finding and reporting this!

I think this regression happened because I didn’t update my local copy of the fog code after that fix to Lighting.vert, and when I recently added fog to the PBR shader I based it on my local version of PBRLighting.vert that was missing those changes.

This PR should fix the issue though:

yaRnMcDonuts · March 8, 2025, 4:24am

I also re-read my original post in this thread and want to clarify some poor word choice on my part:

My last bullet point originally said:

* A few other small bug fixes and minor changes

And I feel like I should not have used the word “small” to describe any bug fixes, as some were actually quite major fixes. Any and all bug fixes are a big deal and are important contributions. Even a seemingly small bug fix that results in only 1 line of code being changed can require a lot of work.

So I hope my choice of words there did not make any contributors feel as though their bug fix or contributions were not valued.

yaRnMcDonuts · March 9, 2025, 8:50am

The following PRs are ready for review, and are all planned to be merged in the next 2-5 days unless any unresolvable issues are found during review:

github.com/jMonkeyEngine/jmonkeyengine

solve issue #2333 (Camera viewport dimensions not checked)

master ← sgold/issue/2333

opened 03:28AM - 06 Mar 25 UTC

stephengold

+267 -13

This PR attempts to address issue #2333 by adding runtime checks to the `Camera`… class. The new checks throw `IllegalArgumentException` and affect 5 setters: + `setViewPort(float, float, float, float)` + `setViewPortBottom(float)` + `setViewPortLeft(float)` + `setViewPortRight(float)` + `setViewPortTop(float)` For ease of maintenance, the checks are actually centralized in `onViewPortChange()`. This assumes `onViewPortChange()` isn't called often enough for this to cause a measurable performance impact. In addition to testing for negative widths and heights, I decided to also test for zero-width viewports and zero-height viewports. I found at one instance of division by height, and I can't think of a use case for a zero-width viewport. Automated tests (using JUnit4) are included in the PR.

yaRnMcDonuts · March 26, 2025, 7:44am

I fixed the light probe blending regression that broke smooth blending, and I plan to merge this PR in the next 48 hours. Then I’ll be creating the 3.8 beta release shortly after this is merged.

github.com/jMonkeyEngine/jmonkeyengine

Fix LightProbe blending

master ← yaRnMcDonuts-patch-2

opened 07:32AM - 26 Mar 25 UTC

yaRnMcDonuts

+77 -39

Fixes this issue: https://github.com/jMonkeyEngine/jmonkeyengine/issues/2399 by …reverting this block of code to its pre-for-loop state before the regression occurred. I tried fixing it without removing the for loops, but I'm not super comfortable with this light probe code so reverting this section of code seemed like the safest option. I tested the changes and can confirm now that smooth blending between LightProbes is working again in my scenes with more than 1 LightProbe.

There are also 2 remaining animation bugs I did not manage to fix yet, but I’m hoping these can be fixed during the beta phase:

github.com/jMonkeyEngine/jmonkeyengine

armature.saveBindPose() corrupts model

opened 10:59AM - 04 Mar 25 UTC

yaRnMcDonuts

bug

As reported here: https://hub.jmonkeyengine.org/t/issue-calling-armature-savebin…dpose/48046 Essentially, calling saveBindPose() many times will eventually corrupt/distort the model's bind pose. My best guess so far is that the inverseModelBindMatrix value in this class at this line ends up corrupted from repeatedly being modified one way or another: [SeparateJointModelTransform.java#L33](https://github.com/jMonkeyEngine/jmonkeyengine/blob/d0ad7484aa2d0d2fa0c7c3b035309bd431e15a17/jme3-core/src/main/java/com/jme3/anim/SeparateJointModelTransform.java#L33)