// File: /workspace/github_c_makefile_star2_O3/archer1357[P]Offline-Raytracer/math.c
// Function: intersectRayTriangle
bool intersectRayTriangle(const float *P,const float *V,
                          const float *Q0,const float *Q1,
                          const float *Q2,
                          const float *plane,
                          float *t,float *colPt,
                          float *bcOut) {
  //ax+by+cz+d=0
  float d, NPd, NV;
  const float *N;
  float u0,u1,u2,v0,v1,v2;

  //
  d=plane[3];
  N=plane;

  //
  NPd=vec3_dot(N,P)+d;

  //origin below plane
  if(NPd <= 0.0f) {
    return false;
  }

  //
  NV=vec3_dot(N,V);

  //vector parallel or pointing away from plane
  if(NV >= 0.0f) {
    return false;
  }


  //
  (*t)=-NPd/NV;

  //
  vec3_mulScalar(colPt,V,(*t));
  vec3_add(colPt,colPt,P);

  //rest from '3D Math Primer For Graphics And Game Development'

  //
  if(fabs((double)N[0]) > fabs((double)N[1])) {
    if(fabs((double)N[0]) > fabs((double)N[2])) {
      u0 = colPt[1]-Q0[1];
      u1 = Q1[1]-Q0[1];
      u2 = Q2[1]-Q0[1];
      v0 = colPt[2]-Q0[2];
      v1 = Q1[2]-Q0[2];
      v2 = Q2[2]-Q0[2];
    } else {
      u0 = colPt[0]-Q0[0];
      u1 = Q1[0]-Q0[0];
      u2 = Q2[0]-Q0[0];
      v0 = colPt[1]-Q0[1];
      v1 = Q1[1]-Q0[1];
      v2 = Q2[1]-Q0[1];
    }
  } else {
    if(fabs((double)N[1]) > fabs((double)N[2])) {
      u0 = colPt[0]-Q0[0];
      u1 = Q1[0]-Q0[0];
      u2 = Q2[0]-Q0[0];
      v0 = colPt[2]-Q0[2];
      v1 = Q1[2]-Q0[2];
      v2 = Q2[2]-Q0[2];
    } else {
      u0 = colPt[0]-Q0[0];
      u1 = Q1[0]-Q0[0];
      u2 = Q2[0]-Q0[0];
      v0 = colPt[1]-Q0[1];
      v1 = Q1[1]-Q0[1];
      v2 = Q2[1]-Q0[1];
    }
  }

  //

  // Compute denominator, check for invalid
  float temp = u1*v2-v1*u2;

  if(!(temp != 0.0f)) {
    return false;
  }

  temp = 1.0f / temp;

  // Compute barycentric coords, checking for out-of-range
  // at each step
  float alpha = (u0 * v2-v0 * u2) * temp;

  if (!(alpha >= 0.0f)) {
    return false;
  }

  float beta = (u1 * v0-v1 * u0) * temp;

  if (!(beta >= 0.0f)) {
    return false;
  }

  float gamma = 1.0f-alpha-beta;

  if (!(gamma >= 0.0f)) {
    return false;
  }

  bcOut[0]=alpha;
  bcOut[1]=beta;
  bcOut[2]=gamma;
  //
  return true;
}

// Assembly:
movss (%r9), %xmm1
movss 0x4(%r9), %xmm3
movss 0x4(%rdi), %xmm0
mulss %xmm3, %xmm0
movss (%rdi), %xmm4
mulss %xmm1, %xmm4
addss %xmm0, %xmm4
movss 0x8(%r9), %xmm2
movss 0x8(%rdi), %xmm0
mulss %xmm2, %xmm0
addss %xmm4, %xmm0
addss 0xc(%r9), %xmm0
xorps %xmm4, %xmm4
ucomiss %xmm0, %xmm4
jae 0x408c17
mulss 0x4(%rsi), %xmm3
mulss (%rsi), %xmm1
mulss 0x8(%rsi), %xmm2
addss %xmm3, %xmm1
addss %xmm1, %xmm2
ucomiss %xmm4, %xmm2
jae 0x408c17
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r10
xorps 0xceeb2(%rip), %xmm0    # 0x4d7950
divss %xmm2, %xmm0
movss %xmm0, (%r10)
movss (%rsi), %xmm1
mulss %xmm0, %xmm1
movss %xmm1, (%rax)
movss 0x4(%rsi), %xmm4
mulss %xmm0, %xmm4
movss %xmm4, 0x4(%rax)
mulss 0x8(%rsi), %xmm0
movss %xmm0, 0x8(%rax)
addss (%rdi), %xmm1
movss %xmm1, (%rax)
addss 0x4(%rdi), %xmm4
movss %xmm4, 0x4(%rax)
addss 0x8(%rdi), %xmm0
movss %xmm0, 0x8(%rax)
movq (%r9), %xmm2
movdqa 0xcf1fc(%rip), %xmm6    # 0x4d7cf0
pand %xmm6, %xmm2
pshufd $0x55, %xmm2, %xmm5     # xmm5 = xmm2[1,1,1,1]
ucomiss %xmm5, %xmm2
movd 0x8(%r9), %xmm3
pand %xmm6, %xmm3
jbe 0x408b37
ucomiss %xmm3, %xmm2
jbe 0x408b67
movss 0x4(%rdx), %xmm1
subss %xmm1, %xmm4
movss 0x4(%rcx), %xmm2
subss %xmm1, %xmm2
movss 0x4(%r8), %xmm3
subss %xmm1, %xmm3
movl $0x8, %eax
movaps %xmm4, %xmm1
jmp 0x408b88
xorl %eax, %eax
ucomiss %xmm3, %xmm5
seta %al
movss (%rdx), %xmm5
movss (%rcx), %xmm2
movss (%r8), %xmm3
ja 0x408b51
movaps %xmm4, %xmm0
subss %xmm5, %xmm1
subss %xmm5, %xmm2
subss %xmm5, %xmm3
leaq 0x4(,%rax,4), %rax
jmp 0x408b88
movss (%rdx), %xmm0
subss %xmm0, %xmm1
movss (%rcx), %xmm2
subss %xmm0, %xmm2
movss (%r8), %xmm3
subss %xmm0, %xmm3
movl $0x4, %eax
movaps %xmm4, %xmm0
movss (%rdx,%rax), %xmm5
movss (%rcx,%rax), %xmm7
subss %xmm5, %xmm7
movss (%r8,%rax), %xmm4
subss %xmm5, %xmm4
movaps %xmm3, %xmm6
mulss %xmm7, %xmm6
movaps %xmm2, %xmm9
mulss %xmm4, %xmm9
subss %xmm6, %xmm9
xorps %xmm8, %xmm8
ucomiss %xmm8, %xmm9
jne 0x408bc1
jnp 0x408c17
subss %xmm5, %xmm0
movss 0xced53(%rip), %xmm5    # 0x4d7920
movaps %xmm5, %xmm6
divss %xmm9, %xmm6
mulss %xmm0, %xmm3
mulss %xmm1, %xmm4
subss %xmm3, %xmm4
mulss %xmm6, %xmm4
ucomiss %xmm8, %xmm4
jb 0x408c17
xorps 0xced5e(%rip), %xmm7    # 0x4d7950
mulss %xmm7, %xmm1
mulss %xmm0, %xmm2
addss %xmm1, %xmm2
mulss %xmm2, %xmm6
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm6
jb 0x408c17
subss %xmm4, %xmm5
subss %xmm6, %xmm5
ucomiss %xmm0, %xmm5
jae 0x408c1a
xorl %eax, %eax
retq
movq 0x18(%rsp), %rax
movss %xmm4, (%rax)
movss %xmm6, 0x4(%rax)
movss %xmm5, 0x8(%rax)
movb $0x1, %al
retq