Vermischtes

GLSL Material created.

GLSL DefMaterial created.
Compiled with Python version 2.5.
'import site' failed; use -v for traceback
Checking for installed Python... No installed Python found.
Only built-in modules are available. Some scripts may not run.
Continuing happily.

GLSL Supported

GLSL MaterialTree removed.

GLSL Light created.

GLSL Material created.

GLSL DefMaterial created.

GLSL Material created.

GLSL Program created.

GLSL Shader code writing...
Memoryblock GLSL Node Code: end corrupt

Code:
struct light{
vec3 loc;
vec3 vec;
vec3 color;
float dist;
float energy;
float att1;
float att2;
float att3;
float att4;
float gamma;
float area_x;
float area_y;
int sphere;
int square;
int area_type;
int layer;
mat4 mat;
};
varying vec3 vert_color;
varying vec3 normal, pos;
varying vec4 realcolor;
uniform vec3 eye;
uniform vec3 amb_color;
uniform float amb_exp, amb_range;uniform vec3 u_mat_0_diff_color;
uniform vec3 u_mat_0_spec_color;
uniform vec3 u_mat_0_normal;
uniform float u_mat_0_alpha;
uniform float u_mat_0_diff1;
uniform float u_mat_0_diff2;
uniform float u_mat_0_diff3;
uniform float u_mat_0_spec1;
uniform float u_mat_0_spec2;
uniform float u_mat_0_spec3;
uniform float u_mat_0_amb_fac;
uniform float u_mat_0_emit;
uniform int u_mat_0_hard;
uniform light lights[2];
vec3 lambertdef(light l, vec3 vnormal, vec3 diff_color, float ref, float unused1
, float unused2){
vec3 lightVec = normalize(l.loc - pos);
return(max(dot(lightVec, vnormal) * ref * vec3(l.color + vert_color) * d
iff_color, 0.0));
}
vec3 lambertsun(light l, vec3 vnormal, vec3 diff_color, float ref, float unused1
, float unused2){
vec3 lightVec = normalize(l.vec);
return(max(dot(lightVec, vnormal) * ref * vec3(l.color + vert_color) * d
iff_color, 0.0));
}vec3 lamberthemi(light l, vec3 vnormal, vec3 diff_color, float ref){
vec3 lightVec = normalize(l.vec);
return((0.5 * dot(lightVec, vnormal) + 0.5) * ref * vec3(l.color + vert_
color) * diff_color);
}vec3 cooktorrdef(light l, vec3 vnormal, vec3 spec_color, float spec, float hard
, float unused){
vec3 view = normalize(eye - pos);
vec3 h = normalize((eye - pos) + (l.loc - pos));
float nh = max(dot(vnormal, h), 0.0);
float nv = max(dot(vnormal, view), 0.0);
return((spec * pow(nh, hard) * spec_color / (0.1 + nv)) * vec3(l.color +
vert_color));
}
vec3 cooktorrsun(light l, vec3 vnormal, vec3 spec_color, float spec, float hard,
float unused){
vec3 view = normalize(eye - pos);
vec3 h = normalize((eye - pos) + l.vec);
float nh = max(dot(vnormal, h), 0.0);
float nv = max(dot(vnormal, view), 0.0);
return(spec * pow(nh, hard) * vec3(l.color + vert_color) * spec_color /
(0.1 + nv));
}
vec3 cooktorrhemi(light l, vec3 vnormal, vec3 spec_color, float spec, float hard
){
vec3 view = normalize(eye - pos);
vec3 h = normalize((eye - pos) + l.vec);
float nh = 0.5 * (max(dot(vnormal, h), 0.0)) + 0.5;
return(spec * nh * pow(nh, hard) * vec3(l.color + vert_color) * spec_col
or);
}
float visibility_lamp(light l){
float visifac = 1.0;
vec3 lv = (pos - l.loc);
float dist = sqrt(dot(lv, lv));
visifac = l.dist / (l.dist + (l.att1 * dist));
visifac *= (l.dist * l.dist) / ( l.dist * l.dist + (l.att2 * dist * dist
));
visifac = max(visifac * l.att3, l.dist / (l.dist + dist) * l.att4);
float m = max(l.dist - dist, 0.0);
return(visifac * max(m / l.dist, l.sphere));
}

#define MATERIAL_ID 0

#define MATERIAL_FUNC material_ ## 0
vec3 MATERIAL_FUNC(inout vec3 diff_color, inout vec3 spec_color, inout vec3 norm
al, inout float alpha, float diff1, float diff2, float diff3, float spec1, float
spec2, float spec3, float amb_fac, float emit, int hard){
vec3 diff_rslt = vec3(0.0, 0.0, 0.0);
vec3 spec_rslt = vec3(0.0, 0.0, 0.0);
vec3 amb_rslt = amb_color * amb_fac;
float vis = 0.0;

#define LIGHT_CALCULATIONS 1

#define LIGHT_ID 0

#define VISIBILITY visibility_ ## lamp

#define CALC_DIFFUSE 1

#define DIFF_SHADER_ID lambert ## def

#define CALC_SPECULAR 1

#define SPEC_SHADER_ID cooktorr ## def
#ifdef LIGHT_ID
vis = VISIBILITY(lights[LIGHT_ID]);
#endif

#ifdef CALC_DIFFUSE
#ifdef LIGHT_ID
#ifdef HEMI
diff_rslt+= amb_exp * (1.0 - exp(DIFF_SHADER_ID(lights[LIGHT_ID], normal, diff_c
olor, diff1) * lights[LIGHT_ID].layer * lights[LIGHT_ID].energy * vis * amb_rang
e));
#else
diff_rslt+= DIFF_SHADER_ID(lights[LIGHT_ID], normal, diff_color, diff1, diff2, d
iff3) * lights[LIGHT_ID].layer * lights[LIGHT_ID].energy * vis;
#endif
#endif
#endif

#ifdef CALC_SPECULAR
#ifdef LIGHT_ID
#ifdef HEMI
spec_rslt+= SPEC_SHADER_ID(lights[LIGHT_ID], normal, spec_color, spec1, hard) *
lights[LIGHT_ID].layer * lights[LIGHT_ID].energy * vis;
#else
spec_rslt+= SPEC_SHADER_ID(lights[LIGHT_ID], normal, spec_color, spec1, spec2, s
pec3) * lights[LIGHT_ID].layer * lights[LIGHT_ID].energy * vis;
#endif
#endif
#endif

#undef VISIBILITY
#undef LIGHT_ID
#undef CALC_DIFFUSE
#undef CALC_SPECULAR
#undef DIFF_SHADER_ID
#undef SPEC_SHADER_ID
#undef HEMI
#ifdef LIGHT_CALCULATIONS
return(amb_exp * (1.0 - exp(diff_rslt * amb_range)) + spec_rslt + amb_rslt);
#else
return(vec3(0.0, 0.0, 0.0));
#endif
}

#undef MATERIAL_ID
#undef MATERIAL_FUNC
void main(void){ vec3 norm = normalize(normal); vec3 diff_color = realcolor.xyz
; vec3 spec_color = u_mat_0_spec_color; float alpha = realcolor.a; float diff1 =
u_mat_0_diff1; float diff2 = u_mat_0_diff2; float diff3 = u_mat_0_diff3; float
spec1 = u_mat_0_spec1; float spec2 = u_mat_0_spec2; float spec3 = u_mat_0_spec3;
float amb_fac = u_mat_0_amb_fac; float emit = u_mat_0_emit; int hard = u_mat_0_
hard; vec3 result = material_0(diff_color, spec_color, norm, alpha, diff1, diff2
, diff3, spec1, spec2, spec3, amb_fac, emit, hard); gl_FragColor = vec4(result,
alpha);}

END OF CODE

╚n▄♀på▄♀DATA°

GLSL Shader Compile Error
Memoryblock GLSL Node Code: end corrupt

GLSL Material removed.

GLSL MaterialTree removed.

GLSL Light removed.

GLSL MaterialTree removed.

GLSL deactivated.

GLSL MaterialTree created.