def make(context_id, rpasses):
wrd = bpy.data.worlds['Arm']
rpdat = arm.utils.get_rp()
rid = rpdat.rp_renderer
con = {
'name': context_id,
'depth_write': True,
'compare_mode': 'less',
'cull_mode': 'clockwise'
}
# Blend context
mat = mat_state.material
blend = mat.arm_blending
particle = mat_state.material.arm_particle_flag
dprepass = rid == 'Forward' and rpdat.rp_depthprepass
if blend:
con['name'] = 'blend'
con['blend_source'] = mat.arm_blending_source
con['blend_destination'] = mat.arm_blending_destination
con['blend_operation'] = mat.arm_blending_operation
con['alpha_blend_source'] = mat.arm_blending_source_alpha
con['alpha_blend_destination'] = mat.arm_blending_destination_alpha
con['alpha_blend_operation'] = mat.arm_blending_operation_alpha
con['depth_write'] = False
con['compare_mode'] = 'less'
elif particle:
pass
elif dprepass: # Depth prepass was performed
con['depth_write'] = False
con['compare_mode'] = 'equal'
attachment_format = 'RGBA32' if '_LDR' in wrd.world_defs else 'RGBA64'
con['color_attachments'] = [attachment_format, attachment_format]
if '_gbuffer2' in wrd.world_defs:
con['color_attachments'].append(attachment_format)
con_mesh = mat_state.data.add_context(con)
mat_state.con_mesh = con_mesh
if rid == 'Forward' or blend:
if rpdat.arm_material_model == 'Mobile':
make_forward_mobile(con_mesh)
elif rpdat.arm_material_model == 'Solid':
make_forward_solid(con_mesh)
else:
make_forward(con_mesh)
elif rid == 'Deferred':
make_deferred(con_mesh, rpasses)
elif rid == 'Raytracer':
make_raytracer(con_mesh)
make_finalize.make(con_mesh)
assets.vs_equal(con_mesh, assets.shader_cons['mesh_vert'])
return con_mesh
def make(context_id):
con_transluc = mat_state.data.add_context({ 'name': context_id, 'depth_write': False, 'compare_mode': 'less', 'cull_mode': 'clockwise', \
'blend_source': 'blend_one', 'blend_destination': 'blend_one', 'blend_operation': 'add', \
'alpha_blend_source': 'blend_zero', 'alpha_blend_destination': 'inverse_source_alpha', 'alpha_blend_operation': 'add' })
make_mesh.make_forward_base(con_transluc, parse_opacity=True)
vert = con_transluc.vert
frag = con_transluc.frag
tese = con_transluc.tese
frag.add_out('vec4[2] fragColor')
sh = tese if tese != None else vert
sh.add_out('vec4 wvpposition')
sh.write('wvpposition = gl_Position;')
# Remove fragColor = ...;
frag.main = frag.main[:frag.main.rfind('fragColor')]
frag.write('\n')
frag.write('if (opacity == 1.0) discard;')
frag.write('\n')
frag.add_uniform('vec3 lightColor', link='_lightColor')
frag.write('float visibility = 1.0;')
frag.write(
'vec4 premultipliedReflect = vec4(vec3(direct * lightColor * visibility + indirect * occlusion) * opacity, opacity);'
)
frag.write('float fragZ = wvpposition.z / wvpposition.w;')
frag.write(
'float w = clamp(pow(min(1.0, premultipliedReflect.a * 10.0) + 0.01, 3.0) * 1e8 * pow(1.0 - fragZ * 0.9, 3.0), 1e-2, 3e3);'
)
frag.write(
'fragColor[0] = vec4(premultipliedReflect.rgb * w, premultipliedReflect.a);'
)
frag.write(
'fragColor[1] = vec4(premultipliedReflect.a * w, 0.0, 0.0, 1.0);')
make_finalize.make(con_transluc)
# assets.vs_equal(con_transluc, assets.shader_cons['transluc_vert']) # shader_cons has no transluc yet
# assets.fs_equal(con_transluc, assets.shader_cons['transluc_frag'])
return con_transluc
def make(context_id):
con_transluc = mat_state.data.add_context({ 'name': context_id, 'depth_write': False, 'compare_mode': 'less', 'cull_mode': 'clockwise', \
'blend_source': 'blend_one', 'blend_destination': 'blend_one', 'blend_operation': 'add', \
'alpha_blend_source': 'blend_zero', 'alpha_blend_destination': 'inverse_source_alpha', 'alpha_blend_operation': 'add' })
make_mesh.make_forward_base(con_transluc,
parse_opacity=True,
transluc_pass=True)
vert = con_transluc.vert
frag = con_transluc.frag
tese = con_transluc.tese
frag.add_out('vec4 fragColor[2]')
# Remove fragColor = ...;
frag.main = frag.main[:frag.main.rfind('fragColor')]
frag.write('\n')
wrd = bpy.data.worlds['Arm']
if '_VoxelAOvar' in wrd.world_defs:
frag.write('indirect *= 0.25;')
frag.write(
'vec4 premultipliedReflect = vec4(vec3(direct + indirect * 0.5) * opacity, opacity);'
)
frag.write(
'float w = clamp(pow(min(1.0, premultipliedReflect.a * 10.0) + 0.01, 3.0) * 1e8 * pow(1.0 - (gl_FragCoord.z) * 0.9, 3.0), 1e-2, 3e3);'
)
frag.write(
'fragColor[0] = vec4(premultipliedReflect.rgb * w, premultipliedReflect.a);'
)
frag.write(
'fragColor[1] = vec4(premultipliedReflect.a * w, 0.0, 0.0, 1.0);')
make_finalize.make(con_transluc)
# assets.vs_equal(con_transluc, assets.shader_cons['transluc_vert']) # shader_cons has no transluc yet
# assets.fs_equal(con_transluc, assets.shader_cons['transluc_frag'])
return con_transluc
def make(context_id):
con = {
'name': context_id,
'depth_write': True,
'compare_mode': 'less',
'cull_mode': 'clockwise'
}
mat = mat_state.material
blend = mat.arm_blending
if blend:
con['blend_source'] = mat.arm_blending_source
con['blend_destination'] = mat.arm_blending_destination
con['blend_operation'] = mat.arm_blending_operation
con['alpha_blend_source'] = mat.arm_blending_source_alpha
con['alpha_blend_destination'] = mat.arm_blending_destination_alpha
con['alpha_blend_operation'] = mat.arm_blending_operation_alpha
con_overlay = mat_state.data.add_context(con)
arm_discard = mat.arm_discard
is_transluc = mat_utils.is_transluc(mat)
parse_opacity = (blend and is_transluc) or arm_discard
make_mesh.make_base(con_overlay, parse_opacity=parse_opacity)
frag = con_overlay.frag
if arm_discard:
opac = mat.arm_discard_opacity
frag.write('if (opacity < {0}) discard;'.format(opac))
frag.add_out('vec4 fragColor')
if blend and parse_opacity:
frag.write('fragColor = vec4(basecol, opacity);')
else:
frag.write('fragColor = vec4(basecol, 1.0);')
frag.write('fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / 2.2));')
make_finalize.make(con_overlay)
return con_overlay
def make(context_id):
# 'compare_mode': 'less' needs read-only depth view
con_decal = mat_state.data.add_context({
'name': context_id,
'depth_write': False,
'compare_mode': 'always',
'cull_mode': 'clockwise',
'blend_source': 'source_alpha',
'blend_destination': 'inverse_source_alpha',
'blend_operation': 'add',
'color_write_alpha': False
})
vert = con_decal.make_vert()
frag = con_decal.make_frag()
geom = None
tesc = None
tese = None
vert.add_uniform('mat4 WVP', '_worldViewProjectionMatrix')
vert.add_uniform('mat3 N', '_normalMatrix')
vert.add_out('vec4 wvpposition')
vert.add_out('vec3 wnormal')
vert.write('wnormal = N * vec3(0.0, 0.0, 1.0);')
vert.write('wvpposition = WVP * vec4(pos.xyz, 1.0);')
vert.write('gl_Position = wvpposition;')
frag.add_include('compiled.inc')
frag.add_include('std/gbuffer.glsl')
frag.ins = vert.outs
frag.add_uniform('sampler2D gbufferD')
frag.add_uniform('mat4 invVP', '_inverseViewProjectionMatrix')
frag.add_uniform('mat4 invW', '_inverseWorldMatrix')
frag.add_out('vec4[2] fragColor')
frag.write_attrib(' vec3 n = normalize(wnormal);')
frag.write_attrib(
' vec2 screenPosition = wvpposition.xy / wvpposition.w;')
frag.write_attrib(' vec2 depthCoord = screenPosition * 0.5 + 0.5;')
frag.write_attrib('#ifdef HLSL')
frag.write_attrib(' depthCoord.y = 1.0 - depthCoord.y;')
frag.write_attrib('#endif')
frag.write_attrib(
' float depth = texture(gbufferD, depthCoord).r * 2.0 - 1.0;')
frag.write_attrib(' vec3 wpos = getPos2(invVP, depth, depthCoord);')
frag.write_attrib(' vec4 mpos = invW * vec4(wpos, 1.0);')
frag.write_attrib(' if (abs(mpos.x) > 1.0) discard;')
frag.write_attrib(' if (abs(mpos.y) > 1.0) discard;')
frag.write_attrib(' if (abs(mpos.z) > 1.0) discard;')
frag.write_attrib(' vec2 texCoord = mpos.xy * 0.5 + 0.5;')
frag.write('vec3 basecol;')
frag.write('float roughness;')
frag.write('float metallic;')
frag.write('float occlusion;')
frag.write('float specular;')
frag.write('float opacity;')
cycles.parse(mat_state.nodes, con_decal, vert, frag, geom, tesc, tese)
frag.write('n /= (abs(n.x) + abs(n.y) + abs(n.z));')
frag.write('n.xy = n.z >= 0.0 ? n.xy : octahedronWrap(n.xy);')
frag.write(
'fragColor[0] = vec4(n.xy, packFloat(metallic, roughness), opacity);')
frag.write('fragColor[1] = vec4(basecol.rgb, opacity);')
make_finalize.make(con_decal)
return con_decal
def make_mesh_pass(rpass):
con = { 'name': rpass, 'depth_write': True, 'compare_mode': 'less', 'cull_mode': 'clockwise' }
con_mesh = mat_state.data.add_context(con)
mat_state.con_mesh = con_mesh
wrd = bpy.data.worlds['Arm']
vert = con_mesh.make_vert()
frag = con_mesh.make_frag()
geom = None
tesc = None
tese = None
vert.add_uniform('mat3 N', '_normalMatrix')
vert.write_attrib('vec4 spos = vec4(pos.xyz, 1.0);')
frag.ins = vert.outs
frag.add_include('compiled.glsl')
frag.add_uniform('vec3 lightDir', '_lightDirection')
frag.add_uniform('vec3 lightColor', '_lightColor')
frag.add_uniform('float envmapStrength', link='_envmapStrength')
frag.write('float visibility = 1.0;')
frag.write('float dotNL = max(dot(n, lightDir), 0.0);')
is_shadows = '_ShadowMap' in wrd.world_defs
if is_shadows:
vert.add_out('vec4 lightPos')
vert.add_uniform('mat4 LWVP', '_biasLightWorldViewProjectionMatrix')
vert.write('lightPos = LWVP * spos;')
frag.add_include('std/shadows.glsl')
frag.add_uniform('sampler2DShadow shadowMap')
frag.add_uniform('float shadowsBias', '_lightShadowsBias')
frag.write('if (lightPos.w > 0.0) {')
frag.write('vec3 lPos = lightPos.xyz / lightPos.w;')
frag.write('const vec2 smSize = shadowmapSize;')
frag.write('visibility *= PCF(shadowMap, lPos.xy, lPos.z - shadowsBias, smSize);')
frag.write('}')
frag.write('vec3 basecol;')
frag.write('float roughness;')
frag.write('float metallic;')
frag.write('float occlusion;')
frag.write('float specular;')
is_displacement = mat_utils.disp_linked(mat_state.output_node)
arm_discard = mat_state.material.arm_discard
if arm_discard:
frag.write('float opacity;')
cycles.parse(mat_state.nodes, con_mesh, vert, frag, geom, tesc, tese, parse_opacity=arm_discard, parse_displacement=is_displacement)
if is_displacement:
vert.add_uniform('mat4 W', link='_worldMatrix')
vert.add_uniform('mat4 VP', link='_viewProjectionMatrix')
vert.write('vec4 wpos = W * spos;')
vert.write('wpos.xyz += wnormal * disp * 0.1;')
vert.write('gl_Position = VP * wpos;')
else:
make_attrib.write_vertpos(vert)
if arm_discard:
opac = mat_state.material.arm_discard_opacity
frag.write('if (opacity < {0}) discard;'.format(opac))
if con_mesh.is_elem('tex'):
vert.add_out('vec2 texCoord')
vert.add_uniform('float texUnpack', link='_texUnpack')
vert.write_attrib('texCoord = tex * texUnpack;')
if con_mesh.is_elem('col'):
vert.add_out('vec3 vcolor')
vert.write_attrib('vcolor = col;')
if con_mesh.is_elem('tang'):
vert.add_out('mat3 TBN')
make_attrib.write_norpos(con_mesh, vert, declare=True)
vert.write('vec3 tangent = normalize(N * tang.xyz);')
vert.write('vec3 bitangent = normalize(cross(wnormal, tangent));')
vert.write('TBN = mat3(tangent, bitangent, wnormal);')
else:
vert.add_out('vec3 wnormal')
make_attrib.write_norpos(con_mesh, vert)
frag.write_attrib('vec3 n = normalize(wnormal);')
frag.add_out('vec4 fragColor')
frag.write('vec3 direct = basecol * step(0.5, dotNL) * visibility * lightColor;')
frag.write('vec3 indirect = basecol * envmapStrength;')
frag.write('fragColor = vec4(direct + indirect, 1.0);')
if '_LDR' in wrd.world_defs:
frag.write('fragColor.rgb = pow(fragColor.rgb, vec3(1.0 / 2.2));')
assets.vs_equal(con_mesh, assets.shader_cons['mesh_vert'])
make_finalize.make(con_mesh)
return con_mesh
def make(context_id, rpasses, shadowmap=False):
is_disp = mat_utils.disp_linked(mat_state.output_node)
vs = [{'name': 'pos', 'data': 'short4norm'}]
if is_disp:
vs.append({'name': 'nor', 'data': 'short2norm'})
con_depth = mat_state.data.add_context({
'name': context_id,
'vertex_elements': vs,
'depth_write': True,
'compare_mode': 'less',
'cull_mode': 'clockwise',
'color_writes_red': [False],
'color_writes_green': [False],
'color_writes_blue': [False],
'color_writes_alpha': [False]
})
vert = con_depth.make_vert()
frag = con_depth.make_frag()
geom = None
tesc = None
tese = None
vert.write_attrib('vec4 spos = vec4(pos.xyz, 1.0);')
parse_opacity = 'translucent' in rpasses or mat_state.material.arm_discard
if parse_opacity:
frag.write('vec3 n;') # Discard at compile time
frag.write('float dotNV;')
frag.write('float opacity;')
if con_depth.is_elem('bone'):
make_skin.skin_pos(vert)
if con_depth.is_elem('ipos'):
make_inst.inst_pos(con_depth, vert)
rpdat = arm.utils.get_rp()
if mat_state.material.arm_particle_flag and rpdat.arm_particles == 'On':
make_particle.write(vert, shadowmap=shadowmap)
if is_disp:
if rpdat.arm_rp_displacement == 'Vertex':
frag.ins = vert.outs
vert.add_uniform('mat3 N', '_normalMatrix')
vert.write('vec3 wnormal = normalize(N * vec3(nor.xy, pos.w));')
cycles.parse(mat_state.nodes,
con_depth,
vert,
frag,
geom,
tesc,
tese,
parse_surface=False,
parse_opacity=parse_opacity)
if con_depth.is_elem('tex'):
vert.add_out('vec2 texCoord') ## vs only, remove out
vert.add_uniform('float texUnpack', link='_texUnpack')
vert.write_attrib('texCoord = tex * texUnpack;')
if con_depth.is_elem('tex1'):
vert.add_out('vec2 texCoord1') ## vs only, remove out
vert.add_uniform('float texUnpack', link='_texUnpack')
vert.write_attrib('texCoord1 = tex1 * texUnpack;')
if con_depth.is_elem('col'):
vert.add_out('vec3 vcolor')
vert.write_attrib('vcolor = col.rgb;')
vert.write('wposition += wnormal * disp;')
if shadowmap:
vert.add_uniform('mat4 LVP', '_lightViewProjectionMatrix')
vert.write('gl_Position = LVP * vec4(wposition, 1.0);')
else:
vert.add_uniform('mat4 VP', '_viewProjectionMatrix')
vert.write('gl_Position = VP * vec4(wposition, 1.0);')
else: # Tessellation
tesc = con_depth.make_tesc()
tese = con_depth.make_tese()
tesc.ins = vert.outs
tese.ins = tesc.outs
frag.ins = tese.outs
vert.add_out('vec3 wnormal')
vert.add_uniform('mat3 N', '_normalMatrix')
vert.write('wnormal = normalize(N * vec3(nor.xy, pos.w));')
make_tess.tesc_levels(tesc, rpdat.arm_tess_shadows_inner,
rpdat.arm_tess_shadows_outer)
make_tess.interpolate(tese, 'wposition', 3)
make_tess.interpolate(tese, 'wnormal', 3, normalize=True)
cycles.parse(mat_state.nodes,
con_depth,
vert,
frag,
geom,
tesc,
tese,
parse_surface=False,
parse_opacity=parse_opacity)
if con_depth.is_elem('tex'):
vert.add_out('vec2 texCoord')
vert.add_uniform('float texUnpack', link='_texUnpack')
vert.write('texCoord = tex * texUnpack;')
tese.write_pre = True
make_tess.interpolate(tese,
'texCoord',
2,
declare_out=frag.contains('texCoord'))
tese.write_pre = False
if con_depth.is_elem('tex1'):
vert.add_out('vec2 texCoord1')
vert.write('texCoord1 = tex1;')
tese.write_pre = True
make_tess.interpolate(tese,
'texCoord1',
2,
declare_out=frag.contains('texCoord1'))
tese.write_pre = False
if con_depth.is_elem('col'):
vert.add_out('vec3 vcolor')
vert.write('vcolor = col.rgb;')
tese.write_pre = True
make_tess.interpolate(tese,
'vcolor',
3,
declare_out=frag.contains('vcolor'))
tese.write_pre = False
if shadowmap:
tese.add_uniform('mat4 LVP', '_lightViewProjectionMatrix')
tese.write('wposition += wnormal * disp;')
tese.write('gl_Position = LVP * vec4(wposition, 1.0);')
else:
tese.add_uniform('mat4 VP', '_viewProjectionMatrix')
tese.write('wposition += wnormal * disp;')
tese.write('gl_Position = VP * vec4(wposition, 1.0);')
# No displacement
else:
frag.ins = vert.outs
billboard = mat_state.material.arm_billboard
if shadowmap:
if billboard == 'spherical':
vert.add_uniform('mat4 LWVP',
'_lightWorldViewProjectionMatrixSphere')
elif billboard == 'cylindrical':
vert.add_uniform('mat4 LWVP',
'_lightWorldViewProjectionMatrixCylinder')
else: # off
vert.add_uniform('mat4 LWVP',
'_lightWorldViewProjectionMatrix')
vert.write('gl_Position = LWVP * spos;')
else:
if billboard == 'spherical':
vert.add_uniform('mat4 WVP',
'_worldViewProjectionMatrixSphere')
elif billboard == 'cylindrical':
vert.add_uniform('mat4 WVP',
'_worldViewProjectionMatrixCylinder')
else: # off
vert.add_uniform('mat4 WVP', '_worldViewProjectionMatrix')
vert.write('gl_Position = WVP * spos;')
if parse_opacity:
cycles.parse(mat_state.nodes,
con_depth,
vert,
frag,
geom,
tesc,
tese,
parse_surface=False,
parse_opacity=True)
if con_depth.is_elem('tex'):
vert.add_out('vec2 texCoord')
vert.add_uniform('float texUnpack', link='_texUnpack')
if mat_state.material.arm_tilesheet_flag:
vert.add_uniform('vec2 tilesheetOffset',
'_tilesheetOffset')
vert.write('texCoord = tex * texUnpack + tilesheetOffset;')
else:
vert.write('texCoord = tex * texUnpack;')
if con_depth.is_elem('tex1'):
vert.add_out('vec2 texCoord1')
vert.write('texCoord1 = tex1;')
if con_depth.is_elem('col'):
vert.add_out('vec3 vcolor')
vert.write('vcolor = col.rgb;')
if parse_opacity:
if mat_state.material.arm_discard:
opac = mat_state.material.arm_discard_opacity_shadows
else:
opac = '1.0'
frag.write('if (opacity < {0}) discard;'.format(opac))
make_finalize.make(con_depth)
assets.vs_equal(con_depth, assets.shader_cons['depth_vert'])
assets.fs_equal(con_depth, assets.shader_cons['depth_frag'])
return con_depth
