HELP material file is playing up

Troubleshooting SDK
1

Hi guys, I have been struggling for weeks with this texture problem and am still unable to solve it. From 3ds max I have created and UV mapped a model, according to jme3, this 3ds max object and material is to be exported to jme3 via blender. To get to blender I used the .obj + .mat formats, to export to jme3 I used the ogretoblender addon. This left me with two files: house.mesh.xml and blendertoogre.material, these I put together in a folder called ‘/house’ within my ‘Assets > Models’ folder. With these two files I also added the image texture file called ‘houseimg.jpg’. All as per JME3 guidance.

Below is my jme3 source code, when ran with the file structure above, the program launches, a blue square loads, my model loads but my model is red and has lost its original exported material. Why is this happening?

Even stranger, the jme3 guidance says that I should rename the material file the same as the model name (house.mesh.xml & house.material), but when this is changed the program launches, shuts down and spits out the error message at the bottom of this post, I hate giving things up, but jme3, blendertoogre or my own stupidity is really starting to piss me off. I was hoping somebody could tell me where Im going wrong? Thanks.

///SETUP

Win XP - sp3
3ds max 9
blender 2.68
jme3
Nvidia Geforce FX5200
…Dunno what else is important?

///SOURCE CODE

package HelloAssets;

import com.jme3.app.SimpleApplication;
import com.jme3.light.DirectionalLight;
import com.jme3.material.Material;
import com.jme3.math.ColorRGBA;
import com.jme3.math.Vector3f;
import com.jme3.scene.Geometry;
import com.jme3.scene.Spatial;
import com.jme3.scene.shape.Box;

public class HelloAssets extends SimpleApplication {

    public static void main(String[] args){
        HelloAssets app = new HelloAssets();
        app.start();
    }

    @Override
    public void simpleInitApp(){
        Box box1 = new Box(1,1,1);
        Geometry blue = new Geometry("Box", box1);
        blue.setLocalTranslation(new Vector3f(1,-1,1));
        Material mat1 = new Material(assetManager, "Common/MatDefs/Misc/Unshaded.j3md");
        mat1.setColor("Color", ColorRGBA.Blue);
        blue.setMaterial(mat1);
        rootNode.attachChild(blue);
    
        Spatial env = assetManager.loadModel("Models/house/house.mesh.xml");
        env.setLocalTranslation(0.0f, 0.0f, 0.0f);
        env.scale(0.1f, 0.1f, 0.1f);
        rootNode.attachChild(env);
    
        DirectionalLight sun = new DirectionalLight();
        sun.setDirection(new Vector3f(20.0f, 20.0f, 20.0f));
        rootNode.addLight(sun);
    }
}

/// ERROR MESSGE

run:
Sep 19, 2003 5:19:15 AM com.jme3.system.JmeDesktopSystem initialize
INFO: Running on jMonkeyEngine 3.0.5
Sep 19, 2003 5:19:15 AM com.jme3.system.lwjgl.LwjglContext printContextInitInfo
INFO: Lwjgl 2.9.0 context running on thread LWJGL Renderer Thread
Sep 19, 2003 5:19:15 AM com.jme3.system.lwjgl.LwjglContext printContextInitInfo
INFO: Adapter: nv4_disp
Sep 19, 2003 5:19:15 AM com.jme3.system.lwjgl.LwjglContext printContextInitInfo
INFO: Driver Version: 6.14.10.8421
Sep 19, 2003 5:19:15 AM com.jme3.system.lwjgl.LwjglContext printContextInitInfo
INFO: Vendor: NVIDIA Corporation
Sep 19, 2003 5:19:15 AM com.jme3.system.lwjgl.LwjglContext printContextInitInfo
INFO: OpenGL Version: 2.0.1
Sep 19, 2003 5:19:15 AM com.jme3.system.lwjgl.LwjglContext printContextInitInfo
INFO: Renderer: GeForce FX 5200/AGP/SSE2
Sep 19, 2003 5:19:15 AM com.jme3.system.lwjgl.LwjglContext printContextInitInfo
INFO: GLSL Ver: 1.10 NVIDIA via Cg 1.3 compiler
Sep 19, 2003 5:19:16 AM com.jme3.renderer.lwjgl.LwjglRenderer initialize
WARNING: Your graphics card does not support non-power-of-2 textures. Some features might not work.
Sep 19, 2003 5:19:16 AM com.jme3.asset.AssetConfig loadText
WARNING: Cannot find loader com.jme3.scene.plugins.blender.BlenderModelLoader
Sep 19, 2003 5:19:16 AM com.jme3.audio.lwjgl.LwjglAudioRenderer initInThread
INFO: Audio Device: OpenAL Soft
Sep 19, 2003 5:19:16 AM com.jme3.audio.lwjgl.LwjglAudioRenderer initInThread
INFO: Audio Vendor: OpenAL Community
Sep 19, 2003 5:19:16 AM com.jme3.audio.lwjgl.LwjglAudioRenderer initInThread
INFO: Audio Renderer: OpenAL Soft
Sep 19, 2003 5:19:16 AM com.jme3.audio.lwjgl.LwjglAudioRenderer initInThread
INFO: Audio Version: 1.1 ALSOFT 1.15.1
Sep 19, 2003 5:19:16 AM com.jme3.audio.lwjgl.LwjglAudioRenderer initInThread
INFO: AudioRenderer supports 64 channels
Sep 19, 2003 5:19:16 AM com.jme3.audio.lwjgl.LwjglAudioRenderer initInThread
INFO: Audio effect extension version: 1.0
Sep 19, 2003 5:19:16 AM com.jme3.audio.lwjgl.LwjglAudioRenderer initInThread
INFO: Audio max auxilary sends: 4
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: alpha_to_coverage
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: colour_write
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: depth_check
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: depth_func
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: depth_write
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: illumination_stage
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: light_clip_planes
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: light_scissor
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: normalise_normals
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: polygon_mode
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: scene_blend_op
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: shading
Sep 19, 2003 5:19:16 AM com.jme3.scene.plugins.ogre.MaterialLoader readPassStatement
WARNING: Unsupported pass directive: transparent_sorting
Sep 19, 2003 5:19:17 AM com.jme3.scene.plugins.ogre.MaterialLoader readTextureUnitStatement
WARNING: Unsupported texture_unit directive: scale
Sep 19, 2003 5:19:17 AM com.jme3.scene.plugins.ogre.MaterialLoader readTextureUnitStatement
WARNING: Unsupported texture_unit directive: colour_op
Sep 19, 2003 5:19:18 AM com.jme3.renderer.lwjgl.LwjglRenderer updateShaderSourceData
WARNING: Bad compile of:
1 #define DIFFUSEMAP 1
2 #define MATERIAL_COLORS 1
3 #if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP))) && !defined(VERTEX_LIGHTING)
4 vec2 steepParallaxOffset(sampler2D parallaxMap, vec3 vViewDir,vec2 texCoord,float parallaxScale){
5 vec2 vParallaxDirection = normalize( vViewDir.xy );
6
7 // The length of this vector determines the furthest amount of displacement: (Ati’s comment)
8 float fLength = length( vViewDir );
9 float fParallaxLength = sqrt( fLength * fLength - vViewDir.z * vViewDir.z ) / vViewDir.z;
10
11 // Compute the actual reverse parallax displacement vector: (Ati’s comment)
12 vec2 vParallaxOffsetTS = vParallaxDirection * fParallaxLength;
13
14 // Need to scale the amount of displacemen

2

First, generally you import the ogre stuff in the SDK to convert it to a j3o for using in your own program.

Second, the bottom part is a shader error which likely has nothing to do with the ogre import but it’s hard to tell for sure because only the very beginning of the stuff was included (and the actual error message was not included at all).

3

14 // Need to scale the amount of displacement to account for different height ranges
15 // in height maps. This is controlled by an artist-editable parameter: (Ati’s comment)
16 parallaxScale =0.3;
17 vParallaxOffsetTS = parallaxScale;
18
19 vec3 eyeDir = normalize(vViewDir).xyz;
20
21 float nMinSamples = 6.0;
22 float nMaxSamples = 1000.0 * parallaxScale;
23 float nNumSamples = mix( nMinSamples, nMaxSamples, 1.0 - eyeDir.z ); //In reference shader: int nNumSamples = (int)(lerp( nMinSamples, nMaxSamples, dot( eyeDirWS, N ) ));
24 float fStepSize = 1.0 / nNumSamples;
25 float fCurrHeight = 0.0;
26 float fPrevHeight = 1.0;
27 float fNextHeight = 0.0;
28 float nStepIndex = 0.0;
29 vec2 vTexOffsetPerStep = fStepSize * vParallaxOffsetTS;
30 vec2 vTexCurrentOffset = texCoord;
31 float fCurrentBound = 1.0;
32 float fParallaxAmount = 0.0;
33
34 while ( nStepIndex < nNumSamples && fCurrHeight <= fCurrentBound ) {
35 vTexCurrentOffset -= vTexOffsetPerStep;
36 fPrevHeight = fCurrHeight;
37
38
39 #ifdef NORMALMAP_PARALLAX
40 //parallax map is stored in the alpha channel of the normal map
41 fCurrHeight = texture2D( parallaxMap, vTexCurrentOffset).a;
42 #else
43 //parallax map is a texture
44 fCurrHeight = texture2D( parallaxMap, vTexCurrentOffset).r;
45 #endif
46
47 fCurrentBound -= fStepSize;
48 nStepIndex+=1.0;
49 }
50 vec2 pt1 = vec2( fCurrentBound, fCurrHeight );
51 vec2 pt2 = vec2( fCurrentBound + fStepSize, fPrevHeight );
52
53 float fDelta2 = pt2.x - pt2.y;
54 float fDelta1 = pt1.x - pt1.y;
55
56 float fDenominator = fDelta2 - fDelta1;
57
58 fParallaxAmount = (pt1.x * fDelta2 - pt2.x * fDelta1 ) / fDenominator;
59
60 vec2 vParallaxOffset = vParallaxOffsetTS * (1.0 - fParallaxAmount );
61 return texCoord - vParallaxOffset;
62 }
63
64 vec2 classicParallaxOffset(sampler2D parallaxMap, vec3 vViewDir,vec2 texCoord,float parallaxScale){
65 float h;
66 h = texture2D(parallaxMap, texCoord).a;
67 #ifdef NORMALMAP_PARALLAX
68 //parallax map is stored in the alpha channel of the normal map
69 h = texture2D(parallaxMap, texCoord).a;
70 #else
71 //parallax map is a texture
72 h = texture2D(parallaxMap, texCoord).r;
73 #endif
74 float heightScale = parallaxScale;
75 float heightBias = heightScale -0.6;
76 vec3 normView = normalize(vViewDir);
77 h = (h * heightScale + heightBias) * normView.z;
78 return texCoord + (h * normView.xy);
79 }
80 #endif
81 #ifdef SPHERE_MAP
82 #define ENVMAP sampler2D
83 #define TEXENV texture2D
84 #else
85 #define ENVMAP samplerCube
86 #define TEXENV textureCube
87 #endif
88
89 // converts a normalized direction vector
90 // into a texture coordinate for fetching
91 // texel from a sphere map
92 vec2 Optics_SphereCoord(in vec3 dir){
93 float dzplus1 = dir.z + 1.0;
94
95 // compute 1/2p
96 // NOTE: this simplification only works if dir is normalized.
97 float inv_two_p = 1.414 * sqrt(dzplus1);
98 //float inv_two_p = sqrt(dir.x * dir.x + dir.y * dir.y + dzplus1 * dzplus1);
99 inv_two_p = 2.0;
100 inv_two_p = 1.0 / inv_two_p;
101
102 // compute texcoord
103 return (dir.xy * vec2(inv_two_p)) + vec2(0.5);
104 }
105
106 vec4 Optics_GetEnvColor(in ENVMAP envMap, in vec3 dir){
107 #ifdef SPHERE_MAP
108 return texture2D(envMap, Optics_SphereCoord(dir));
109 #else
110 return textureCube(envMap, dir);
111 #endif
112 }
113 #define ATTENUATION
114 //#define HQ_ATTENUATION
115
116 varying vec2 texCoord;
117 #ifdef SEPARATE_TEXCOORD
118 varying vec2 texCoord2;
119 #endif
120
121 varying vec3 AmbientSum;
122 varying vec4 DiffuseSum;
123 varying vec3 SpecularSum;
124
125 #ifndef VERTEX_LIGHTING
126 uniform vec4 g_LightDirection;
127 //varying vec3 vPosition;
128 varying vec3 vViewDir;
129 varying vec4 vLightDir;
130 varying vec3 lightVec;
131 #else
132 varying vec2 vertexLightValues;
133 #endif
134
135 #ifdef DIFFUSEMAP
136 uniform sampler2D m_DiffuseMap;
137 #endif
138
139 #ifdef SPECULARMAP
140 uniform sampler2D m_SpecularMap;
141 #endif
142
143 #ifdef PARALLAXMAP
144 uniform sampler2D m_ParallaxMap;
145 #endif
146 #if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP))) && !defined(VERTEX_LIGHTING)
147 uniform float m_ParallaxHeight;
148 #endif
149
150 #ifdef LIGHTMAP
151 uniform sampler2D m_LightMap;
152 #endif
153
154 #ifdef NORMALMAP
155 uniform sampler2D m_NormalMap;
156 #else
157 varying vec3 vNormal;
158 #endif
159
160 #ifdef ALPHAMAP
161 uniform sampler2D m_AlphaMap;
162 #endif
163
164 #ifdef COLORRAMP
165 uniform sampler2D m_ColorRamp;
166 #endif
167
168 uniform float m_AlphaDiscardThreshold;
169
170 #ifndef VERTEX_LIGHTING
171 uniform float m_Shininess;
172
173 #ifdef HQ_ATTENUATION
174 uniform vec4 g_LightPosition;
175 #endif
176
177 #ifdef USE_REFLECTION
178 uniform float m_ReflectionPower;
179 uniform float m_ReflectionIntensity;
180 varying vec4 refVec;
181
182 uniform ENVMAP m_EnvMap;
183 #endif
184
185 float tangDot(in vec3 v1, in vec3 v2){
186 float d = dot(v1,v2);
187 #ifdef V_TANGENT
188 d = 1.0 - dd;
189 return step(0.0, d) * sqrt(d);
190 #else
191 return d;
192 #endif
193 }
194
195 float lightComputeDiffuse(in vec3 norm, in vec3 lightdir, in vec3 viewdir){
196 #ifdef MINNAERT
197 float NdotL = max(0.0, dot(norm, lightdir));
198 float NdotV = max(0.0, dot(norm, viewdir));
199 return NdotL * pow(max(NdotL * NdotV, 0.1), -1.0) * 0.5;
200 #else
201 return max(0.0, dot(norm, lightdir));
202 #endif
203 }
204
205 float lightComputeSpecular(in vec3 norm, in vec3 viewdir, in vec3 lightdir, in float shiny){
206 // NOTE: check for shiny <= 1 removed since shininess is now
207 // 1.0 by default (uses matdefs default vals)
208 #ifdef LOW_QUALITY
209 // Blinn-Phong
210 // Note: preferably, H should be computed in the vertex shader
211 vec3 H = (viewdir + lightdir) * vec3(0.5);
212 return pow(max(tangDot(H, norm), 0.0), shiny);
213 #elif defined(WARDISO)
214 // Isotropic Ward
215 vec3 halfVec = normalize(viewdir + lightdir);
216 float NdotH = max(0.001, tangDot(norm, halfVec));
217 float NdotV = max(0.001, tangDot(norm, viewdir));
218 float NdotL = max(0.001, tangDot(norm, lightdir));
219 float a = tan(acos(NdotH));
220 float p = max(shiny/128.0, 0.001);
221 return NdotL * (1.0 / (4.03.14159265pp)) * (exp(-(aa)/(pp)) / (sqrt(NdotV * NdotL)));
222 #else
223 // Standard Phong
224 vec3 R = reflect(-lightdir, norm);
225 return pow(max(tangDot(R, viewdir), 0.0), shiny);
226 #endif
227 }
228
229 vec2 computeLighting(in vec3 wvNorm, in vec3 wvViewDir, in vec3 wvLightDir){
230 float diffuseFactor = lightComputeDiffuse(wvNorm, wvLightDir, wvViewDir);
231 float specularFactor = lightComputeSpecular(wvNorm, wvViewDir, wvLightDir, m_Shininess);
232
233 #ifdef HQ_ATTENUATION
234 float att = clamp(1.0 - g_LightPosition.w * length(lightVec), 0.0, 1.0);
235 #else
236 float att = vLightDir.w;
237

4

237 #endif
238
239 if (m_Shininess <= 1.0) {
240 specularFactor = 0.0; // should be one instruction on most cards …
241 }
242
243 specularFactor *= diffuseFactor;
244
245 return vec2(diffuseFactor, specularFactor) * vec2(att);
246 }
247 #endif
248
249 void main(){
250 vec2 newTexCoord;
251
252 #if (defined(PARALLAXMAP) || (defined(NORMALMAP_PARALLAX) && defined(NORMALMAP))) && !defined(VERTEX_LIGHTING)
253
254 #ifdef STEEP_PARALLAX
255 #ifdef NORMALMAP_PARALLAX
256 //parallax map is stored in the alpha channel of the normal map
257 newTexCoord = steepParallaxOffset(m_NormalMap, vViewDir, texCoord, m_ParallaxHeight);
258 #else
259 //parallax map is a texture
260 newTexCoord = steepParallaxOffset(m_ParallaxMap, vViewDir, texCoord, m_ParallaxHeight);
261 #endif
262 #else
263 #ifdef NORMALMAP_PARALLAX
264 //parallax map is stored in the alpha channel of the normal map
265 newTexCoord = classicParallaxOffset(m_NormalMap, vViewDir, texCoord, m_ParallaxHeight);
266 #else
267 //parallax map is a texture
268 newTexCoord = classicParallaxOffset(m_ParallaxMap, vViewDir, texCoord, m_ParallaxHeight);
269 #endif
270 #endif
271 #else
272 newTexCoord = texCoord;
273 #endif
274
275 #ifdef DIFFUSEMAP
276 vec4 diffuseColor = texture2D(m_DiffuseMap, newTexCoord);
277 #else
278 vec4 diffuseColor = vec4(1.0);
279 #endif
280
281 float alpha = DiffuseSum.a * diffuseColor.a;
282 #ifdef ALPHAMAP
283 alpha = alpha * texture2D(m_AlphaMap, newTexCoord).r;
284 #endif
285 if(alpha < m_AlphaDiscardThreshold){
286 discard;
287 }
288
289 #ifndef VERTEX_LIGHTING
290 float spotFallOff = 1.0;
291
292 #if VERSION >= 110
293 // allow use of control flow
294 if(g_LightDirection.w != 0.0){
295 #endif
296
297 vec3 L = normalize(lightVec.xyz);
298 vec3 spotdir = normalize(g_LightDirection.xyz);
299 float curAngleCos = dot(-L, spotdir);
300 float innerAngleCos = floor(g_LightDirection.w) * 0.001;
301 float outerAngleCos = fract(g_LightDirection.w);
302 float innerMinusOuter = innerAngleCos - outerAngleCos;
303 spotFallOff = (curAngleCos - outerAngleCos) / innerMinusOuter;
304
305 #if VERSION >= 110
306 if(spotFallOff <= 0.0){
307 gl_FragColor.rgb = AmbientSum * diffuseColor.rgb;
308 gl_FragColor.a = alpha;
309 return;
310 }else{
311 spotFallOff = clamp(spotFallOff, 0.0, 1.0);
312 }
313 }
314 #else
315 spotFallOff = clamp(spotFallOff, step(g_LightDirection.w, 0.001), 1.0);
316 #endif
317 #endif
318
319 // ***********************
320 // Read from textures
321 // ***********************
322 #if defined(NORMALMAP) && !defined(VERTEX_LIGHTING)
323 vec4 normalHeight = texture2D(m_NormalMap, newTexCoord);
324 vec3 normal = normalize((normalHeight.xyz * vec3(2.0) - vec3(1.0)));
325 #ifdef LATC
326 normal.z = sqrt(1.0 - (normal.x * normal.x) - (normal.y * normal.y));
327 #endif
328 //normal.y = -normal.y;
329 #elif !defined(VERTEX_LIGHTING)
330 vec3 normal = vNormal;
331 #if !defined(LOW_QUALITY) && !defined(V_TANGENT)
332 normal = normalize(normal);
333 #endif
334 #endif
335
336 #ifdef SPECULARMAP
337 vec4 specularColor = texture2D(m_SpecularMap, newTexCoord);
338 #else
339 vec4 specularColor = vec4(1.0);
340 #endif
341
342 #ifdef LIGHTMAP
343 vec3 lightMapColor;
344 #ifdef SEPARATE_TEXCOORD
345 lightMapColor = texture2D(m_LightMap, texCoord2).rgb;
346 #else
347 lightMapColor = texture2D(m_LightMap, texCoord).rgb;
348 #endif
349 specularColor.rgb *= lightMapColor;
350 diffuseColor.rgb *= lightMapColor;
351 #endif
352
353 #ifdef VERTEX_LIGHTING
354 vec2 light = vertexLightValues.xy;
355 #ifdef COLORRAMP
356 light.x = texture2D(m_ColorRamp, vec2(light.x, 0.0)).r;
357 light.y = texture2D(m_ColorRamp, vec2(light.y, 0.0)).r;
358 #endif
359
360 gl_FragColor.rgb = AmbientSum * diffuseColor.rgb +
361 DiffuseSum.rgb * diffuseColor.rgb * vec3(light.x) +
362 SpecularSum * specularColor.rgb * vec3(light.y);
363 #else
364 vec4 lightDir = vLightDir;
365 lightDir.xyz = normalize(lightDir.xyz);
366 vec3 viewDir = normalize(vViewDir);
367
368 vec2 light = computeLighting(normal, viewDir, lightDir.xyz) * spotFallOff;
369 #ifdef COLORRAMP
370 diffuseColor.rgb *= texture2D(m_ColorRamp, vec2(light.x, 0.0)).rgb;
371 specularColor.rgb *= texture2D(m_ColorRamp, vec2(light.y, 0.0)).rgb;
372 #endif
373
374 // Workaround, since it is not possible to modify varying variables
375 vec4 SpecularSum2 = vec4(SpecularSum, 1.0);
376 #ifdef USE_REFLECTION
377 vec4 refColor = Optics_GetEnvColor(m_EnvMap, refVec.xyz);
378
379 // Interpolate light specularity toward reflection color
380 // Multiply result by specular map
381 specularColor = mix(SpecularSum2 * light.y, refColor, refVec.w) * specularColor;
382
383 SpecularSum2 = vec4(1.0);
384 light.y = 1.0;
385 #endif
386
387 gl_FragColor.rgb = AmbientSum * diffuseColor.rgb +
388 DiffuseSum.rgb * diffuseColor.rgb * vec3(light.x) +
389 SpecularSum2.rgb * specularColor.rgb * vec3(light.y);
390 #endif
391 gl_FragColor.a = alpha;
392 }

Sep 19, 2003 5:19:18 AM com.jme3.app.Application handleError
SEVERE: Uncaught exception thrown in Thread[LWJGL Renderer Thread,5,main]
com.jme3.renderer.RendererException: compile error in:ShaderSource[name=Common/MatDefs/Light/Lighting.frag, defines, type=Fragment, language=GLSL100] error:(292) : error C0105: Syntax error in #if
(292) : error C0105: Syntax error in #if
(305) : error C0105: Syntax error in #if
(305) : error C0105: Syntax error in #if

5

Did you try importing the 3DS file directly using the SDK?

6

No I havent because jme3 guidance says only ".blend, .obj+.mat or 1 other that I cant think of right now. Why should I actually be importing a .3ds into jme3?

7

Because you can? Blender is used to convert the 3DS file to .blend which is then imported.

8

We already had this issue actually
http://hub.jmonkeyengine.org/forum/topic/tutorial-3-assets-problems-with-rootnode-addlightsun/

Not sure it got solved though
The advice stays the same, maybe update your drivers?

9

@Norman Hansen - Sorry, I though you meant - did I try import 3ds file with jme3 sdk! So to answer you question, yes I did use blender to convert 3ds to blend before importing to jme3, that also failed.

10

Yes I meant using the SDK to directly import 3ds. It uses the bundled bledner to do that automatically without you importing the model manually to blender.

11

@keymaster- When I began learning jme3, I remember being told that intel graphics cards were not really recommrnded for jme3, as you can tell, thas what im running, is that a problem? Further more, I have just noticed that my computer date and time settng is 11 years out, according to my posted log, would that affect the driver update that I tried last week?