m[3][2] = 1.0;
    m[3][3] = 0.0;

Xerophyte fucked around with this message at 09:52 on Jul 6, 2016

Xerophyte fucked around with this message at 00:55 on Jul 31, 2016

Xerophyte fucked around with this message at 08:08 on Jul 16, 2017

Xerophyte fucked around with this message at 04:15 on Oct 27, 2017

class Ray {
  float3 o;   // origin
  float3 dir; // direction
};

// Minimum threshold: any point closer to the surface than this is counted as part of it.
const float kMinThreshold = 1e-5;

// Maximum threshold: if we are ever this far away from the surface then assume we will never
// intersect. In practice you'll probably clamp the ray to some bounding volume instead.
const float kMaxThreshold = 1e2;

bool march_ray(Ray& r, SDF f) {
  float distance;
  while(true) {
    // Compute the distance to the surface. We can move this far without intersecting.
    distance = f(r.o);

    // Specifically, we can move this far in the ray direction without intersecting.
    r.o = r.o + distance * r.dir;

    // If we're sufficiently close to the surface, count as an intersection.
    if (distance < kMinThreshold) {
      return true;
    }

    // If we're sufficiently far away from the surface, count as escaping.
    if (kMaxThreshold < distance) {
      return false;
    }
  }
}

Xerophyte fucked around with this message at 15:04 on Oct 28, 2017

void sdf(float3 p, float* sdf, float3* normal) {
  float3 sphere_to_point       = p - m_center;
  float  distance_from_center  = length(sphere_to_point);

  *sdf    = distance_from_center - m_radius;
  *normal = sphere_to_point / distance_from_center;
}

// Compute the gradient of a distance field by using the forward difference. This is cheap but can 
// have issues with floating point precision since you need a small EPSILON. Using a central
// difference is more accurate, but then you need to compute the SDF 6 times instead of 3 times.
float3 normalized_gradient(SDF sdf, float3 p, float sdf_at_p) {
  const float EPSILON = 1e-5f;
  float3      gradient =
      float3(sdf(float3(p.x + EPSILON, p.y, p.z)) - sdf_at_p,
             sdf(float3(p.x, p.y + EPSILON, p.z)) - sdf_at_p,
             sdf(float3(p.x, p.y, p.z + EPSILON)) - sdf_at_p);
  return gradient / length(gradient);
}

Xerophyte fucked around with this message at 07:22 on Oct 30, 2017

Xerophyte fucked around with this message at 00:40 on Apr 29, 2018

// Interpolate between face_normal and shading_normal, such that face_normal is used in
// most of the triangle interior and the shading_normal is used close to the triangle edges. 
float3 bevelNormal(float3 barycentric_pos,
                   float3 face_normal,
                   float3 shading_normal) {
  const float BEVEL_DISTANCE = 0.1;

  float  edge_normal_weight = 1.0 - saturate(min(barycentric_pos / BEVEL_DISTANCE));
  float3 normal             = slerp(face_normal, shading_normal, edge_normal_weight);
  
  return normal;
}

// Convert from "standard" sum-to-1 areal barycentric coordinates to distances to the
// associated triangle edges. Side lengths and triangle area should be in world units.
float3 arealBarycentricToEdgeDistance(float3 barycentric_pos,
                                      float3 triangle_side_lengths,
                                      float  triangle_area) {
  float  normalization_factor = 2.0 * triangle_area / sum(barycentric_pos);
  float3 edge_distances = normalization_factor * barycentric_pos * triangle_side_lengths;

  return edge_distances;
}

Xerophyte fucked around with this message at 19:00 on May 9, 2020