Changeset c62013e for libcfa/src/vec/vec.hfa

Timestamp:

Jul 14, 2026, 9:26:24 PM (4 hours ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

a12816e7

Parents:

f41b161

Message:

formatting, turn off -Wdangling-pointer around small code fragments because of false positive

File:

• libcfa/src/vec/vec.hfa (modified) (1 diff)

libcfa/src/vec/vec.hfa

@@ -59 +59 @@
 };
 forall(T)
-trait sqrt {
+        trait sqrt {
     T sqrt(T);
 };
 
 static inline {
-// int
-int ?=?(int& n, zero_t) { return n = 0.f; }
-// unsigned int
-int ?=?(unsigned int& n, zero_t) { return n = 0.f; }
-/* float */
-void ?{}(float& a, int b) { a = b; }
-float ?=?(float& n, zero_t) { return n = 0.f; }
-/* double */
-void ?{}(double& a, int b) { a = b; }
-double ?=?(double& n, zero_t) { return n = 0L; }
-// long double
-void ?{}(long double& a, int b) { a = b; }
-long double ?=?(long double& n, zero_t) { return n = 0L; }
-}
+        // int
+        int ?=?( int& n, zero_t ) { return n = 0.f; }
+        // unsigned int
+        int ?=?( unsigned int& n, zero_t ) { return n = 0.f; }
+        // float
+        void ?{}( float& a, int b ) { a = b; }
+        float ?=?( float& n, zero_t ) { return n = 0.f; }
+        // double
+        void ?{}( double& a, int b ) { a = b; }
+        double ?=?( double& n, zero_t ) { return n = 0L; }
+        // long double
+        void ?{}( long double& a, int b ) { a = b; }
+        long double ?=?( long double& n, zero_t ) { return n = 0L; }
+} // static inline
 
-forall(V, T)
+forall( V, T )
 trait dottable {
-    T dot(V, V);
+    T dot( V, V );
 };
 
 static inline {
+        forall( T | sqrt( T ), V | dottable( V, T ) )
+        T length( V v ) {
+                return sqrt( dot( v, v ) );
+        }
 
-forall(T | sqrt(T), V | dottable(V, T))
-T length(V v) {
-   return sqrt(dot(v, v));
-}
+        forall( T, V | dottable( V, T ) )
+        T length_squared( V v ) {
+                return dot( v, v );
+        }
 
-forall(T, V | dottable(V, T))
-T length_squared(V v) {
-   return dot(v, v);
-}
+        forall( T, V | { T length( V ); } | subtract( V ) )
+        T distance( V v1, V v2 ) {
+                return length( v1 - v2 );
+        }
 
-forall(T, V | { T length(V); } | subtract(V))
-T distance(V v1, V v2) {
-    return length(v1 - v2);
-}
+        forall( T, V | { T length( V ); V ?/?( V, T ); })
+        V normalize( V v ) {
+                return v / length( v );
+        }
 
-forall(T, V | { T length(V); V ?/?(V, T); })
-V normalize(V v) {
-    return v / length(v);
-}
+        // Project vector u onto vector v
+        forall( T, V | dottable( V, T ) | { V normalize( V ); V ?*?( V, T ); })
+        V project( V u, V v ) {
+                V v_norm = normalize( v );
+                return v_norm * dot( u, v_norm );
+        }
 
-// Project vector u onto vector v
-forall(T, V | dottable(V, T) | { V normalize(V); V ?*?(V, T); })
-V project(V u, V v) {
-    V v_norm = normalize(v);
-    return v_norm * dot(u, v_norm);
-}
+        // Reflect incident vector v with respect to surface with normal n
+        forall( T | fromint( T ), V | { V project( V, V ); V ?*?( T, V ); V ?-?( V,V ); })
+        V reflect( V v, V n ) {
+                return v - ( T ){2} * project( v, n );
+        }
 
-// Reflect incident vector v with respect to surface with normal n
-forall(T | fromint(T), V | { V project(V, V); V ?*?(T, V); V ?-?(V,V); })
-V reflect(V v, V n) {
-    return v - (T){2} * project(v, n);
-}
+        #pragma GCC diagnostic push
+        // FIX ME: false positive with gcc > 11, so disable.
+        #pragma GCC diagnostic ignored "-Wdangling-pointer"
 
-// Refract incident vector v with respect to surface with normal n
-// eta is the ratio of indices of refraction between starting material and
-// entering material (i.e., from air to water, eta = 1/1.33)
-// v and n must already be normalized
-forall(T | fromint(T) | subtract(T) | multiply(T) | add(T) | lessthan(T) | sqrt(T),
-       V | dottable(V, T) | { V ?*?(T, V); V ?-?(V,V); void ?{}(V&, zero_t); })
-V refract(V v, V n, T eta) {
-    T dotValue = dot(n, v);
-    T k = (T){1} - eta * eta * ((T){1} - dotValue * dotValue);
-    if (k < (T){0}) {
-        return 0;
-    }
-    return eta * v - (eta * dotValue + sqrt(k)) * n;
-}
+        // Refract incident vector v with respect to surface with normal n eta is the ratio of indices of refraction between
+        // starting material and entering material ( i.e., from air to water, eta = 1/1.33 ) v and n must already be
+        // normalized
+        forall( T | fromint( T ) | subtract( T ) | multiply( T ) | add( T ) | lessthan( T ) | sqrt( T ),
+                V | dottable( V, T ) | { V ?*?( T, V ); V ?-?( V,V ); void ?{}( V&, zero_t ); })
+        V refract( V v, V n, T eta ) {
+                T dotValue = dot( n, v );
+                T k = (T){1} - eta * eta * ((T){1} - dotValue * dotValue );
+                if ( k < (T){0}) {
+                        return 0;
+                }
+                return eta * v - ( eta * dotValue + sqrt( k ) ) * n;
+        }
 
-// Given a perturbed normal and a geometric normal,
-// flip the perturbed normal if the geometric normal is pointing away
-// from the observer.
-// n is the perturbed vector that we want to align
-// i is the incident vector
-// ng is the geometric normal of the surface
-forall(T | lessthan(T) | zeroinit(T), V | dottable(V, T) | negate(V))
-V faceforward(V n, V i, V ng) {
-    return dot(ng, i) < (T){0} ? n : -n;
-}
+        #pragma GCC diagnostic pop
 
-} // inline
+        // Given a perturbed normal and a geometric normal, flip the perturbed normal if the geometric normal is pointing
+        // away from the observer.  n is the perturbed vector that we want to align i is the incident vector ng is the
+        // geometric normal of the surface
+        forall( T | lessthan( T ) | zeroinit( T ), V | dottable( V, T ) | negate( V ) )
+        V faceforward( V n, V i, V ng ) {
+                return dot( ng, i ) < (T){0} ? n : -n;
+        }
+} // static inline