Commit 645227ce authored by unknown's avatar unknown
Browse files

Added c-t-btdf and emissive material part.

parent 1b132604
......@@ -118,12 +118,9 @@ bool shade(int id, inout vec3 radiance, uint bounce, out uint bsdf_id)
return false;
}
if(bsdf_result.generated_ray.direction == vec3(0))
if(bsdf_result.bsdf_id == eEmit)
{
// Treat as emissive material.
//writeColorStore(ray, radiance * bsdf_result.irradiance, clamp_color_max);
//if(!isnan(normali))
writeColorStore(ray, bsdf_result.radiance, clamp_color_max);
writeColorStore(ray, radiance * bsdf_result.radiance, clamp_color_max);
b_traces[id].hit.invalidate();
return false;
}
......
......@@ -71,6 +71,17 @@ BSDFResult computeBSDF(const in Material material, const in vec2 random, const i
{
const SampledMaterial sampled_material = material.getMaterialParameters(vertex);
BSDFResult result;
//Use the pixel coordinates of the incoming ray.
result.generated_ray = ray_in;
if(sampled_material.emissive.rgb != vec3(0))
{
result.radiance = sampled_material.emissive.rgb;
result.bsdf_id = eEmit;
return result;
}
// Importance sampling: compute an importance sample {phi, theta} and generate a local (z-up) microsurface normal, as well as an according normal distribution
HemisphereSample hemisphere_sample = ggxSample(random, sampled_material.roughness);
......@@ -80,361 +91,117 @@ BSDFResult computeBSDF(const in Material material, const in vec2 random, const i
// Turn around normal if looking at it from the backside
vec3 normal = faceforward(vertex.normal.xyz, -incoming, vertex.normal.xyz);
// Compute needed refraction values
bool enters = dot(incoming, normal) > 0;
float ior_in = enters ? 1 : sampled_material.ior;
float ior_out = enters ? sampled_material.ior : 1;
float eta = ior_in / ior_out;
// Transform the computed local microsurface normal to world space along the hit normal
vec3 micro_normal = normalize(toWorld(hemisphere_sample.micro_normal, normal));
// Now we can generate a direction of the ray being reflected at the microsurface normal
vec3 outgoing = normalize(2 * clamp(dot(incoming, micro_normal), 0, 1) * micro_normal - incoming);
// Schlick's fresnel approximation with the material's normal response
float normal_response = normalResponse(sampled_material.ior, sampled_material.metallic);
float fresnel = fresnelSchlick(clamp(dot(incoming, micro_normal), 0, 1), normal_response);
// Compute geometric attenuation via GGX
float geometry = ggxGeometry(incoming, outgoing, normal, micro_normal, sampled_material.roughness);
float k_s = fresnel;
float k_rest = 1-k_s;
float k_t = k_rest * ((sampled_material.transparent.r + sampled_material.transparent.g + sampled_material.transparent.b)/3);
float k_d = 1 - k_s - k_t;
// TODO: what exactly is causing the slight offset in color on metallic smooth surfaces?
float arbitrary_correction_factor = mix(1.f, 0.1f, sampled_material.metallic * (1-sampled_material.roughness));
float roulette_border_specular = k_s;
float roulette_border_transmit = k_s + k_t;
// Schlick's fresnel approximation with the material's normal response
float normal_response = arbitrary_correction_factor * normalResponse(sampled_material.ior, sampled_material.metallic);
float fresnel = arbitrary_correction_factor * fresnelSchlick(clamp(dot(incoming, micro_normal), 0, 1), normal_response);
// russian roulette part 1
if(roulette_border_transmit <= random.x)
{
// Sample lambertian diffuse
result.evaluation = (1-sampled_material.metallic)*sampled_material.diffuse.rgb * ONE_OVER_PI;
result.generated_ray.direction = normalize(toWorld(randCosineHemisphere(random.x, random.y), normal));
result.probability_density = abs(dot(vec4(result.generated_ray.direction, 0), vertex.normal)) * ONE_OVER_PI;
result.radiance = (1-sampled_material.metallic)*sampled_material.diffuse.rgb * ONE_OVER_PI;
result.bsdf_id = eDiffuse;
// offset by newly generated direction
result.generated_ray.origin = vertex.position.xyz + 1e-5f * result.generated_ray.direction;
return result;
}
//refracted outgoing ray
vec3 outgoing_refracted = refract(-incoming, (enters? 1 : -1) * micro_normal, eta);// normalize(((enters? -1 : 1) * micro_normal - ior_in * incoming) / ior_out);
// Now we can generate a direction of the ray being reflected at the microsurface normal
vec3 outgoing_reflected = normalize(2 * clamp(dot(incoming, micro_normal), 0, 1) * micro_normal - incoming);
// Compute geometric attenuation via GGX
float geometry = ggxGeometry(incoming, outgoing_reflected, normal, micro_normal, sampled_material.roughness);
float geometry_refracted = ggxGeometry(incoming, outgoing_refracted, normal, micro_normal, sampled_material.roughness);
// Reflections of metallic materials are tinted with the material base color.
vec3 fresnel_tint = fresnelTint(fresnel, sampled_material.metallic, sampled_material.diffuse.rgb);
float n_dot_in = clamp(dot(normal, incoming), 0, 1);
float n_dot_out = clamp(dot(normal, outgoing), 0, 1);
float m_dot_out = clamp(dot(micro_normal, outgoing), 0, 1);
float n_dot_out = clamp(dot(normal, outgoing_reflected), 0, 1);
float m_dot_in = clamp(dot(micro_normal, outgoing_reflected), 0, 1);
float m_dot_out = clamp(dot(micro_normal, outgoing_reflected), 0, 1);
float m_dot_out_refract = clamp(dot(micro_normal, outgoing_refracted), -1, 1);
float n_dot_out_refract = clamp(dot(normal, outgoing_refracted), -1, 1);
// In this implementation, it is defined that the importance sample generated is cos(theta) instead of the usual approach of only theta.
float cos_theta = hemisphere_sample.importance.y;
// Compute the microsurface normal probability and with that the final probability density function
// Clamp up denominator to not divide by zero.
float jacobian = 1 / clamp(4 * m_dot_out, 0.001f, 1);
float propability_m = hemisphere_sample.distribution * cos_theta;
float pdf = propability_m * jacobian;
float jacobian_reflect = 1 / clamp(4 * m_dot_out, 0.001f, 1);
float probability_m = hemisphere_sample.distribution * cos_theta;
float pdf = probability_m * jacobian_reflect;
// Same as above but for refractions
float ior_out_2 = ior_out * ior_out;
float jacobian_refract_denominator = ior_in * m_dot_in + ior_out * m_dot_out_refract;
jacobian_refract_denominator *= jacobian_refract_denominator;
jacobian_refract_denominator = clamp(jacobian_refract_denominator, 0.001f, 1.f);
//Take the absolute value as m_dot_out_refract is negative
float jacobian_refract = abs(ior_out_2 * m_dot_out_refract / jacobian_refract_denominator);
float pdf_refract = probability_m * jacobian_refract;
// Same here... clamp up denominator to not divide by zero
float brdf_denominator = clamp((4 * n_dot_in * n_dot_out), 0.001f, 1.f);
float btdf_denominator = jacobian_refract_denominator;
// Finally, build the brdf
vec3 brdf = fresnel_tint * geometry * hemisphere_sample.distribution / brdf_denominator;
// TODO: what exactly is causing the slight offset in color on smooth surfaces?
// This value will prohibit very high reflection values which occur for some reason.
float reflection_correction_factor = mix(1.f, 0.0002f, sampled_material.metallic * (1-sampled_material.roughness));
float transmission_correction_factor = mix(1.f, 0.01f, (1-sampled_material.roughness));
BSDFResult result;
//Use the pixel coordinates of the incoming ray.
result.generated_ray = ray_in;
// Finally, build the brdf. As we do russian roulette, we can just tint the brdf instead of multiplying with the fresnel value.
vec3 brdf = mix(vec3(1), sampled_material.diffuse.rgb * reflection_correction_factor, sampled_material.metallic) * geometry * hemisphere_sample.distribution / brdf_denominator;
// Same as above, we don't need the fresnel factor here either.
vec3 btdf = (m_dot_in * m_dot_out_refract / (n_dot_in * n_dot_out_refract)) * ior_out_2 * transmission_correction_factor * sampled_material.diffuse.rgb * geometry_refracted * hemisphere_sample.distribution / btdf_denominator;
// russian roulette via K_s = fresnel => K_d = 1-fresnel
if(sampled_material.metallic == 1 || fresnel > random.x)
// russian roulette Part 2
// Also check whether the refracted ray is valid, as we don't want to sample with NaN rays.
if(roulette_border_specular > random.x || isnan(outgoing_refracted.x))
{
// Use as brdf sample
result.generated_ray.direction = outgoing;
result.generated_ray.direction = outgoing_reflected;
result.radiance = brdf;
result.probability_density = pdf;
result.evaluation = vec3(0); // No diffuse if reflecting
result.bsdf_id = eReflect;
}
else
else if(roulette_border_transmit > random.x)
{
// Sample lambertian diffuse
result.evaluation = (1-fresnel)*(1-sampled_material.metallic)*sampled_material.diffuse.rgb * ONE_OVER_PI;
result.generated_ray.direction = normalize(toWorld(randCosineHemisphere(random.x, random.y), normal));
result.probability_density = abs(dot(vec4(result.generated_ray.direction, 0), vertex.normal)) * ONE_OVER_PI;
result.radiance = (1-fresnel)*(1-sampled_material.metallic)*sampled_material.diffuse.rgb * ONE_OVER_PI;
result.bsdf_id = eDiffuse;
// Use as btdf sample
result.generated_ray.direction = outgoing_refracted;
result.probability_density = pdf_refract;
result.radiance = btdf;
result.evaluation = vec3(0); // No diffuse if transmitting
result.bsdf_id = eTransmit;
}
// offset by newly generated direction
result.generated_ray.origin = vertex.position.xyz + 1e-8f * result.generated_ray.direction;
result.generated_ray.origin = vertex.position.xyz + 1e-2f * result.generated_ray.direction;
return result;
}
subroutine vec3 bsdfSampler(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id);
subroutine(bsdfSampler)
vec3 sampleDiffuse(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
{
bool entering = dot(-ray_in.direction.xyz, vertex.normal.xyz) > 0.f;
vec3 hemi = randCosineHemisphere(random.x, random.y);
ray_out.direction.xyz = normalize(localToWorldNormal(entering ? hemi : -hemi, vertex.normal.xyz));
pdf = abs(dot(vec4(ray_out.direction, 0), vertex.normal)) * ONE_OVER_PI;
bsdf_id = 0;
if (pdf == 0.f)
{
return vec3(0.f);
}
ray_out.origin = vertex.position.xyz + 1e-5 * -ray_in.direction;
vec3 diffuse = material.getDiffuse(vertex.texcoord).xyz;
light_influence = diffuse * ONE_OVER_PI;
return diffuse * ONE_OVER_PI;
}
subroutine(bsdfSampler)
vec3 sampleTranslucent(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
{
bool entering = dot(-ray_in.direction, vertex.normal.xyz) > 0.f;
vec3 hemi = randCosineHemisphere(random.x, random.y);
ray_out.direction.xyz =localToWorldNormal(hemi, (entering ? -1 : 1) * vertex.normal.xyz);
pdf = abs(dot(ray_out.direction, vertex.normal.xyz)) * ONE_OVER_PI;
ray_out.origin = vertex.position.xyz + 1e-5f * ray_in.direction;
bsdf_id = 1;
if (pdf == 0.f)
{
return vec3(0.f);
}
vec3 diffuse = material.getDiffuse(vertex.texcoord).xyz;
if(!entering){
diffuse = (diffuse + material.getSpecular(vertex.texcoord).xyz) / 2.f;
}
light_influence = diffuse * ONE_OVER_PI;
return diffuse * ONE_OVER_PI;
}
subroutine(bsdfSampler)
vec3 sampleGlass(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
{
bool entering = dot(-ray_in.direction, vertex.normal.xyz) > 0.f;
float eta_i = entering ? 1.f : material.ior;
float eta_t = entering ? material.ior : 1.f;
float fresnel = dialectricFresnel(abs(dot(-ray_in.direction, vertex.normal.xyz)), eta_i, eta_t);
//refract ray.
ray_out.direction = refract(ray_in.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz), eta_i / eta_t);
light_influence = vec3(0);
vec3 diffuse = material.getDiffuse(vertex.texcoord).xyz;
// Choose whether to sample refractive or reflective BSDF
if ((ray_out.direction.xyz != vec3(0)) && (random.x > fresnel) && (!isnan(ray_out.direction.x)))
{
ray_out.origin = vertex.position.xyz + 1e-5 * ray_out.direction;
pdf = 1.0f - fresnel;
vec3 ft = diffuse*material.getTransparent(vertex.texcoord).rgb * (1.0f - fresnel);
ft *= ( eta_i * eta_i ) / ( eta_t * eta_t );
bsdf_id = 3;
return ft / abs(dot(ray_out.direction, vertex.normal.xyz));
}
bsdf_id = 2;
ray_out.direction = reflect(ray_in.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz));
ray_out.origin = vertex.position.xyz + 1e-5 * ray_out.direction;
pdf = fresnel;
return fresnel * material.getSpecular(vertex.texcoord).rgb / abs(dot(ray_out.direction, vertex.normal.xyz));
}
subroutine(bsdfSampler)
vec3 sampleRoughGlass(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
{
//Needed parameters for refraction and reflection
bool entering = dot(-ray_in.direction, vertex.normal.xyz) > 0.f;
float eta_i = entering ? 1.f : material.ior;
float eta_t = entering ? material.ior : 1.f;
float fresnel = dialectricFresnel(abs(dot(-ray_in.direction, vertex.normal.xyz)), eta_i, eta_t);
float roughness = material.getRoughness();
vec3 diffuse = material.getDiffuse(vertex.texcoord).xyz;
light_influence = mix(vec3(0), diffuse * ONE_OVER_PI, roughness);
//refract ray.
vec3 refracted = refract(ray_in.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz), eta_i / eta_t).xyz;
// Choose whether to sample refractive or reflective BSDF
if ((refracted != vec3(0)) && (random.x > fresnel) && (!isnan(refracted.x)))
{
float rad = radians(180.0f - (1.0f - roughness) * 180.0f);
vec3 sampledPoint = randAngle(random.x, random.y, rad);
ray_out.direction.xyz = localToWorldNormal(sampledPoint, refracted);
if (dot(ray_out.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz)) > 0.0f)
{
ray_out.direction.xyz = localToWorldNormal(sampledPoint * vec3(-1, -1, 1), refracted);
}
pdf = mix(1.0f - fresnel, abs(dot(ray_out.direction, vertex.normal.xyz)) * ONE_OVER_PI, roughness);
vec3 ft = diffuse*material.getTransparent(vertex.texcoord).rgb * (1.0f - fresnel);
ft *= ( eta_i * eta_i ) / ( eta_t * eta_t );
bsdf_id = 3;
ray_out.origin = vertex.position.xyz + 1e-5 * ray_out.direction;
return mix(ft / abs(dot(ray_out.direction, vertex.normal.xyz)), diffuse * ONE_OVER_PI, roughness);
}
float rad = radians(180.0f - (1.0f - roughness) * 180.0f);
vec3 reflected = reflect(ray_in.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz)).xyz;
vec3 sampledPoint = randAngle(random.x, random.y, rad);
ray_out.direction.xyz = localToWorldNormal(sampledPoint, reflected);
if (dot(ray_out.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz)) < 0.0f)
{
ray_out.direction.xyz = localToWorldNormal(sampledPoint * vec3(-1, -1, 1), reflected);
}
bsdf_id = 2;
pdf = mix(fresnel, abs(dot(ray_out.direction, vertex.normal.xyz)) * ONE_OVER_PI, roughness);
ray_out.origin = vertex.position.xyz + 1e-5 * ray_out.direction;
return mix(fresnel * material.getSpecular(vertex.texcoord).rgb / abs(dot(ray_out.direction, vertex.normal.xyz)), diffuse * ONE_OVER_PI, roughness);
}
subroutine(bsdfSampler)
vec3 sampleTransparent(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
{
//refract ray.
ray_out.direction = ray_in.direction;
ray_out.origin = vertex.position.xyz + 1e-5 * ray_out.direction;
pdf = 1;
bsdf_id = 4;
light_influence = vec3(0);
return material.getTransparent(vertex.texcoord).xyz / abs(dot(ray_out.direction, vertex.normal.xyz));
}
subroutine(bsdfSampler)
vec3 sampleMirror(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
{
pdf = 1.f;
ray_out.direction = reflect(ray_in.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz));
light_influence = vec3(0);
bsdf_id = 2;
ray_out.origin = vertex.position.xyz + 1e-5 * ray_out.direction;
return material.getSpecular(vertex.texcoord).xyz / abs(dot(ray_out.direction, vertex.normal.xyz));
}
subroutine(bsdfSampler)
vec3 sampleGlossy(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
{
float roughness = material.getRoughness();
float rad = radians(180.0f - (1.0f - roughness) * 180.0f);
vec3 reflected = normalize(reflect(ray_in.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz)).xyz);
vec3 sampledPoint = normalize(randAngle(random.x, random.y, rad));
vec3 diffuse = material.getDiffuse(vertex.texcoord).xyz;
light_influence = roughness * diffuse * ONE_OVER_PI;
ray_out.direction.xyz = normalize(localToWorldNormal(sampledPoint, reflected));
bsdf_id = 2;
if (dot(ray_out.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz)) < 0.0f)
{
ray_out.direction.xyz = normalize(localToWorldNormal(sampledPoint * vec3(-1, -1, 1), reflected));
}
ray_out.origin = vertex.position.xyz + 1e-5 * ray_out.direction;
pdf = 1.f - roughness * abs(dot(ray_out.direction, vertex.normal.xyz)) * ONE_OVER_PI;
return mix(diffuse*material.getSpecular(vertex.texcoord).xyz / abs(dot(ray_out.direction, vertex.normal.xyz)), diffuse * ONE_OVER_PI, roughness);
}
subroutine(bsdfSampler)
vec3 sampleEmissive(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
{
bsdf_id = 5;
pdf = 1.f;
ray_out.direction = vec3(0);
vec3 diffuse = material.getDiffuse(vertex.texcoord).xyz;
light_influence = diffuse*material.getEmissive(vertex.texcoord).xyz;
ray_out.origin = vertex.position.xyz + 1e-5 * ray_out.direction;
return vec3(0);
}
// subroutine(bsdfSampler)
// vec3 sampleGGX(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
// {
// float roughness = 1-(material.specular_exponent / 100.f);
// bool entering = dot(-ray_in.direction.xyz, vertex.normal.xyz) > 0.f;
// vec3 hemi = randCosineHemisphere(random.x, random.y);
// hemi.xy *= roughness;
// vec3 reflected = normalize(reflect(ray_in.direction, faceforward(vertex.normal.xyz, ray_in.direction, vertex.normal.xyz)).xyz);
//
// ray_out.origin = vertex.position.xyz + 1e-5 * -ray_in.direction;
// ray_out.direction.xyz = normalize(localToWorldNormal(entering ? hemi : -hemi, reflected.xyz));
//
// vec3 half_view = ggxHalfView(ray_out.direction.xyz, -ray_in.direction.xyz);
//
// vec3 diffuse_color = material.getDiffuse(vertex.texcoord).xyz;
// vec3 specular_color = material.getDiffuse(vertex.texcoord).xyz;
//
// bsdf_id = 0;
// float metallic = 0.f;
//
// float cosT = clamp(dot(ray_out.direction.xyz, vertex.normal.xyz), 0, 1);
// float sinT = sqrt(1 - cosT * cosT);
//
// vec3 fresnel = fresnelSchlick(dot(-ray_in.direction.xyz, half_view), normalResponse(diffuse_color, material.ior, metallic));
// float normal_dot_view = dot(vertex.normal.xyz, ray_in.direction.xyz);
// float geometry = ggxPartialGeometry(-ray_in.direction.xyz, vertex.normal.xyz, half_view, roughness)
// * ggxPartialGeometry(ray_out.direction.xyz, vertex.normal.xyz, half_view, roughness);
//
// float denominator = clamp(4 * (normal_dot_view * dot(half_view, vertex.normal.xyz)) + 0.05f, 0, 1);
// pdf = ggxDistribution(vertex.normal.xyz, half_view, roughness);
//
// vec3 specular_factor = fresnel;
// vec3 diffuse_factor = (1-specular_factor)*(1-metallic);
//
// light_influence = diffuse_factor * diffuse_color * ONE_OVER_PI;
//
// return diffuse_factor * diffuse_color * ONE_OVER_PI + geometry * fresnel * sinT / denominator;
// }
subroutine uniform bsdfSampler u_bsdf_sample[8];
vec3 sampleBSDF(const in Material material, const in vec2 random, const in Vertex vertex, const in Ray ray_in, inout Ray ray_out, out vec3 light_influence, out float pdf, out uint bsdf_id)
{
//Kind of crude but also kind of well functional bsdf selector.
ray_out.px = ray_in.px;
ray_out.py = ray_in.py;
bool rough = material.specular_exponent < 99;
bool transparent = length(material.getTransparent(vertex.texcoord).xyz) >= 0.1;
bool emits = length(material.getEmissive(vertex.texcoord).xyz) >= 0.01;
uint index = rough ? 0 : 1;
index = material.specular_exponent <= 1 ? 2 : index;
index += transparent ? 3 : 0;
index = (transparent && material.ior==1) ? 6 : index;
index = emits ? 7 : index;
//return sampleGGX(material, random, vertex, ray_in, ray_out, light_influence, pdf, bsdf_id);
return u_bsdf_sample[index](material, random, vertex, ray_in, ray_out, light_influence, pdf, bsdf_id);
}
#endif //!__BDSF_DIFFUSE_GLH
......@@ -80,8 +80,8 @@ float ggxDistribution(float cosT, float roughness)
// Half of the full ggx geometry attenuation term
float ggxPartialGeometry(const in vec3 vector, const in vec3 normal, const in vec3 half_view, float roughness)
{
float eye_dot_half2 = clamp(dot(vector, half_view), 0, 1);
float chi = ggxChi(eye_dot_half2 / clamp(dot(vector, normal), 0, 1));
float eye_dot_half2 = clamp(dot(vector, half_view), -1, 1);
float chi = ggxChi(eye_dot_half2 / clamp(dot(vector, normal), -1, 1));
eye_dot_half2 = eye_dot_half2 * eye_dot_half2;
float tan2 = (1 - eye_dot_half2) / eye_dot_half2;
......
......@@ -111,7 +111,8 @@ namespace glare
//Create a skybox from cube map.
m_skybox = std::make_shared<core::Skybox>(core::Skybox::collectFilesFrom(files::asset("/textures/ryfjallet/")));
initializeScene(m_current_scene_root / "cbox.dae", 1.f);
//initializeScene(m_current_scene_root / "cbox.dae", 1.f);
initializeScene(m_current_scene_root / "dragn.dae", 1.f);
//initializeScene(m_current_scene_root / "benchmark_stfd_bunny_diff.dae", 1.f);
//initializeScene(m_current_scene_root / "banni.dae", 1.f);
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment