File: closest_point.isph

package info (click to toggle)
embree 4.3.3%2Bdfsg-1
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 100,656 kB
  • sloc: cpp: 228,918; xml: 40,944; ansic: 2,685; python: 812; sh: 635; makefile: 228; csh: 42
file content (100 lines) | stat: -rw-r--r-- 2,652 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0

#pragma once

#include "../math/vec.isph"

Vec3f closestPointTriangle(Vec3f const& p, Vec3f const& a, Vec3f const& b, Vec3f const& c)
{
  const Vec3f ab = b - a;
  const Vec3f ac = c - a;
  const Vec3f ap = p - a;

  const float d1 = dot(ab, ap);
  const float d2 = dot(ac, ap);
  if (d1 <= 0.f && d2 <= 0.f) return a;

  const Vec3f bp = p - b;
  const float d3 = dot(ab, bp);
  const float d4 = dot(ac, bp);
  if (d3 >= 0.f && d4 <= d3) return b;

  const Vec3f cp = p - c;
  const float d5 = dot(ab, cp);
  const float d6 = dot(ac, cp);
  if (d6 >= 0.f && d5 <= d6) return c;

  const float vc = d1 * d4 - d3 * d2;
  if (vc <= 0.f && d1 >= 0.f && d3 <= 0.f)
  {
      const float v = d1 / (d1 - d3);
      return a + v * ab;
  }
  
  const float vb = d5 * d2 - d1 * d6;
  if (vb <= 0.f && d2 >= 0.f && d6 <= 0.f)
  {
      const float v = d2 / (d2 - d6);
      return a + v * ac;
  }
  
  const float va = d3 * d6 - d5 * d4;
  if (va <= 0.f && (d4 - d3) >= 0.f && (d5 - d6) >= 0.f)
  {
      const float v = (d4 - d3) / ((d4 - d3) + (d5 - d6));
      return b + v * (c - b);
  }

  const float denom = 1.f / (va + vb + vc);
  const float v = vb * denom;
  const float w = vc * denom;
  return a + v * ab + w * ac;
}

uniform Vec3f closestPointTriangle(uniform Vec3f& p, uniform Vec3f& a, uniform Vec3f& b, uniform Vec3f& c)
{
  const uniform Vec3f ab = b - a;
  const uniform Vec3f ac = c - a;
  const uniform Vec3f ap = p - a;

  const uniform float d1 = dot(ab, ap);
  const uniform float d2 = dot(ac, ap);
  if (d1 <= 0.f && d2 <= 0.f) return a;

  const uniform Vec3f bp = p - b;
  const uniform float d3 = dot(ab, bp);
  const uniform float d4 = dot(ac, bp);
  if (d3 >= 0.f && d4 <= d3) return b;

  const uniform Vec3f cp = p - c;
  const uniform float d5 = dot(ab, cp);
  const uniform float d6 = dot(ac, cp);
  if (d6 >= 0.f && d5 <= d6) return c;

  const uniform float vc = d1 * d4 - d3 * d2;
  if (vc <= 0.f && d1 >= 0.f && d3 <= 0.f)
  {
      const uniform float v = d1 / (d1 - d3);
      return a + v * ab;
  }
  
  const uniform float vb = d5 * d2 - d1 * d6;
  if (vb <= 0.f && d2 >= 0.f && d6 <= 0.f)
  {
      const uniform float v = d2 / (d2 - d6);
      return a + v * ac;
  }
  
  const uniform float va = d3 * d6 - d5 * d4;
  if (va <= 0.f && (d4 - d3) >= 0.f && (d5 - d6) >= 0.f)
  {
      const uniform float v = (d4 - d3) / ((d4 - d3) + (d5 - d6));
      return b + v * (c - b);
  }

  const uniform float denom = 1.f / (va + vb + vc);
  const uniform float v = vb * denom;
  const uniform float w = vc * denom;
  return a + v * ab + w * ac;
}