intrude import depth_core
intrude import flat
-# Simple material with static colors used for debugging or display abstract objects
-class SmoothMaterial
- super Material
-
+redef class Material
# Get the default blueish material
- init default do init(
+ new do return new SmoothMaterial(
[0.0, 0.0, 0.3, 1.0],
[0.0, 0.0, 0.6, 1.0],
[1.0, 1.0, 1.0, 1.0])
+end
+
+# Simple material with static colors
+class SmoothMaterial
+ super Material
# Ambient color, always visible
- var ambient_color: Array[Float]
+ var ambient_color: Array[Float] is writable
# Diffuse color when covered by a light source
- var diffuse_color: Array[Float]
+ var diffuse_color: Array[Float] is writable
# Specular color affecting reflections
- var specular_color: Array[Float]
+ var specular_color: Array[Float] is writable
redef fun draw(actor, model)
do
var mesh = model.mesh
# Actor specs
- program.translation.uniform(actor.center.x, -actor.center.y, actor.center.z, 0.0)
+ program.translation.uniform(actor.center.x, actor.center.y, actor.center.z, 0.0)
program.scale.uniform actor.scale
- program.rotation.uniform new Matrix.rotation(actor.rotation, 0.0, 1.0, 0.0)
+ program.rotation.uniform new Matrix.gamnit_euler_rotation(actor.pitch, actor.yaw, actor.roll)
# From mesh
program.coord.array_enabled = true
# Execute draw
if mesh.indices.is_empty then
- glDrawArrays(gl_TRIANGLES, 0, mesh.vertices.length/3)
+ glDrawArrays(mesh.draw_mode, 0, mesh.vertices.length/3)
else
- glDrawElements(gl_TRIANGLES, mesh.indices.length, gl_UNSIGNED_SHORT, mesh.indices_c.native_array)
+ glDrawElements(mesh.draw_mode, mesh.indices.length, gl_UNSIGNED_SHORT, mesh.indices_c.native_array)
end
end
end
var program = app.versatile_program
program.use
- var need_tex_coord = false
+ # One of the textures used, if any
+ var sample_used_texture = null
var texture = ambient_texture
if texture != null then
glBindTexture(gl_TEXTURE_2D, texture.gl_texture)
program.use_map_ambient.uniform true
program.map_ambient.uniform 0
- need_tex_coord = true
+ sample_used_texture = texture
else
program.use_map_ambient.uniform false
end
glBindTexture(gl_TEXTURE_2D, texture.gl_texture)
program.use_map_diffuse.uniform true
program.map_diffuse.uniform 1
- need_tex_coord = true
+ sample_used_texture = texture
else
program.use_map_diffuse.uniform false
end
glBindTexture(gl_TEXTURE_2D, texture.gl_texture)
program.use_map_specular.uniform true
program.map_specular.uniform 2
- need_tex_coord = true
+ sample_used_texture = texture
else
program.use_map_specular.uniform false
end
- program.translation.uniform(actor.center.x, -actor.center.y, actor.center.z, 0.0)
+ program.translation.uniform(actor.center.x, actor.center.y, actor.center.z, 0.0)
program.scale.uniform actor.scale
- program.tex_coord.array_enabled = need_tex_coord
- program.tex_coord.array(mesh.texture_coords, 2)
+ # If using a texture, set `texture_coords`
+ program.tex_coord.array_enabled = sample_used_texture != null
+ if sample_used_texture != null then
+ if sample_used_texture isa RootTexture then
+ # Coordinates are directly valid
+ program.tex_coord.array(mesh.texture_coords, 2)
+ else
+ # Correlate texture coordinates from the substexture and the mesh.
+ # This is slow, but should be cached on the GPU.
+ var xa = sample_used_texture.offset_left
+ var xd = sample_used_texture.offset_right - xa
+ var ya = sample_used_texture.offset_top
+ var yd = sample_used_texture.offset_bottom - ya
+ xd *= 0.999
+ yd *= 0.999
+
+ var tex_coords = new Array[Float].with_capacity(mesh.texture_coords.length)
+ for i in [0..mesh.texture_coords.length/2[ do
+ tex_coords[i*2] = xa + xd * mesh.texture_coords[i*2]
+ tex_coords[i*2+1] = 1.0 - (ya + yd * mesh.texture_coords[i*2+1])
+ end
+
+ program.tex_coord.array(tex_coords, 2)
+ end
+ end
program.coord.array_enabled = true
program.coord.array(mesh.vertices, 3)
- program.rotation.uniform new Matrix.rotation(actor.rotation, 0.0, 1.0, 0.0)
+
+ program.rotation.uniform new Matrix.gamnit_euler_rotation(actor.pitch, actor.yaw, actor.roll)
program.ambient_color.uniform(ambient_color[0], ambient_color[1], ambient_color[2], ambient_color[3]*actor.alpha)
program.diffuse_color.uniform(diffuse_color[0], diffuse_color[1], diffuse_color[2], diffuse_color[3]*actor.alpha)
program.camera.uniform(app.world_camera.position.x, app.world_camera.position.y, app.world_camera.position.z)
if mesh.indices.is_empty then
- glDrawArrays(gl_TRIANGLES, 0, mesh.vertices.length/3)
+ glDrawArrays(mesh.draw_mode, 0, mesh.vertices.length/3)
else
- glDrawElements(gl_TRIANGLES, mesh.indices.length, gl_UNSIGNED_SHORT, mesh.indices_c.native_array)
+ glDrawElements(mesh.draw_mode, mesh.indices.length, gl_UNSIGNED_SHORT, mesh.indices_c.native_array)
end
end
end
# TODO apply normal map
- program.translation.uniform(actor.center.x, -actor.center.y, actor.center.z, 0.0)
+ program.translation.uniform(actor.center.x, actor.center.y, actor.center.z, 0.0)
program.scale.uniform actor.scale
program.tex_coord.array_enabled = true
program.coord.array_enabled = true
program.coord.array(mesh.vertices, 3)
- program.rotation.uniform new Matrix.rotation(actor.rotation, 0.0, 1.0, 0.0)
+
+ program.rotation.uniform new Matrix.gamnit_euler_rotation(actor.pitch, actor.yaw, actor.roll)
program.normal.array_enabled = true
program.normal.array(mesh.normals, 3)
if mesh.indices.is_empty then
- glDrawArrays(gl_TRIANGLES, 0, mesh.vertices.length/3)
+ glDrawArrays(mesh.draw_mode, 0, mesh.vertices.length/3)
else
- glDrawElements(gl_TRIANGLES, mesh.indices.length, gl_UNSIGNED_SHORT, mesh.indices_c.native_array)
+ glDrawElements(mesh.draw_mode, mesh.indices.length, gl_UNSIGNED_SHORT, mesh.indices_c.native_array)
end
end
end
attribute vec4 coord;
// Vertex translation
- attribute vec4 translation;
+ uniform vec4 translation;
// Vertex scaling
- attribute float scale;
+ uniform float scale;
// Vertex coordinates on textures
attribute vec2 tex_coord;
float lambert = max(dot(light_dir, v_normal), 0.0);
if (use_map_ambient)
- gl_FragColor = ambient_color + texture2D(map_ambient, v_tex_coord);
+ gl_FragColor = ambient_color * texture2D(map_ambient, v_tex_coord);
else
gl_FragColor = ambient_color;
gl_FragColor += lambert * diffuse_color * texture2D(map_diffuse, v_tex_coord);
else
gl_FragColor += lambert * diffuse_color;
+
+ if (gl_FragColor.a < 0.01) discard;
}
""" @ glsl_fragment_shader
var camera = uniforms["camera"].as(UniformVec3) is lazy
# Translation applied to each vertex
- var translation = attributes["translation"].as(AttributeVec4) is lazy
+ var translation = uniforms["translation"].as(UniformVec4) is lazy
# Rotation matrix
var rotation = uniforms["rotation"].as(UniformMat4) is lazy
# Scaling per vertex
- var scale = attributes["scale"].as(AttributeFloat) is lazy
+ var scale = uniforms["scale"].as(UniformFloat) is lazy
# Model view projection matrix
var mvp = uniforms["mvp"].as(UniformMat4) is lazy