Changeset c62013e


Ignore:
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

Files:
5 edited

Legend:

Unmodified
Added
Removed

  • libcfa/src/vec/vec.hfa

    rf41b161 rc62013e  
    5959};
    6060forall(T)
    61 trait sqrt {
     61        trait sqrt {
    6262    T sqrt(T);
    6363};
    6464
    6565static inline {
    66 // int
    67 int ?=?(int& n, zero_t) { return n = 0.f; }
    68 // unsigned int
    69 int ?=?(unsigned int& n, zero_t) { return n = 0.f; }
    70 /* float */
    71 void ?{}(float& a, int b) { a = b; }
    72 float ?=?(float& n, zero_t) { return n = 0.f; }
    73 /* double */
    74 void ?{}(double& a, int b) { a = b; }
    75 double ?=?(double& n, zero_t) { return n = 0L; }
    76 // long double
    77 void ?{}(long double& a, int b) { a = b; }
    78 long double ?=?(long double& n, zero_t) { return n = 0L; }
    79 }
     66        // int
     67        int ?=?( int& n, zero_t ) { return n = 0.f; }
     68        // unsigned int
     69        int ?=?( unsigned int& n, zero_t ) { return n = 0.f; }
     70        // float
     71        void ?{}( float& a, int b ) { a = b; }
     72        float ?=?( float& n, zero_t ) { return n = 0.f; }
     73        // double
     74        void ?{}( double& a, int b ) { a = b; }
     75        double ?=?( double& n, zero_t ) { return n = 0L; }
     76        // long double
     77        void ?{}( long double& a, int b ) { a = b; }
     78        long double ?=?( long double& n, zero_t ) { return n = 0L; }
     79} // static inline
    8080
    81 forall(V, T)
     81forall( V, T )
    8282trait dottable {
    83     T dot(V, V);
     83    T dot( V, V );
    8484};
    8585
    8686static inline {
     87        forall( T | sqrt( T ), V | dottable( V, T ) )
     88        T length( V v ) {
     89                return sqrt( dot( v, v ) );
     90        }
    8791
    88 forall(T | sqrt(T), V | dottable(V, T))
    89 T length(V v) {
    90    return sqrt(dot(v, v));
    91 }
     92        forall( T, V | dottable( V, T ) )
     93        T length_squared( V v ) {
     94                return dot( v, v );
     95        }
    9296
    93 forall(T, V | dottable(V, T))
    94 T length_squared(V v) {
    95    return dot(v, v);
    96 }
     97        forall( T, V | { T length( V ); } | subtract( V ) )
     98        T distance( V v1, V v2 ) {
     99                return length( v1 - v2 );
     100        }
    97101
    98 forall(T, V | { T length(V); } | subtract(V))
    99 T distance(V v1, V v2) {
    100     return length(v1 - v2);
    101 }
     102        forall( T, V | { T length( V ); V ?/?( V, T ); })
     103        V normalize( V v ) {
     104                return v / length( v );
     105        }
    102106
    103 forall(T, V | { T length(V); V ?/?(V, T); })
    104 V normalize(V v) {
    105     return v / length(v);
    106 }
     107        // Project vector u onto vector v
     108        forall( T, V | dottable( V, T ) | { V normalize( V ); V ?*?( V, T ); })
     109        V project( V u, V v ) {
     110                V v_norm = normalize( v );
     111                return v_norm * dot( u, v_norm );
     112        }
    107113
    108 // Project vector u onto vector v
    109 forall(T, V | dottable(V, T) | { V normalize(V); V ?*?(V, T); })
    110 V project(V u, V v) {
    111     V v_norm = normalize(v);
    112     return v_norm * dot(u, v_norm);
    113 }
     114        // Reflect incident vector v with respect to surface with normal n
     115        forall( T | fromint( T ), V | { V project( V, V ); V ?*?( T, V ); V ?-?( V,V ); })
     116        V reflect( V v, V n ) {
     117                return v - ( T ){2} * project( v, n );
     118        }
    114119
    115 // Reflect incident vector v with respect to surface with normal n
    116 forall(T | fromint(T), V | { V project(V, V); V ?*?(T, V); V ?-?(V,V); })
    117 V reflect(V v, V n) {
    118     return v - (T){2} * project(v, n);
    119 }
     120        #pragma GCC diagnostic push
     121        // FIX ME: false positive with gcc > 11, so disable.
     122        #pragma GCC diagnostic ignored "-Wdangling-pointer"
    120123
    121 // Refract incident vector v with respect to surface with normal n
    122 // eta is the ratio of indices of refraction between starting material and
    123 // entering material (i.e., from air to water, eta = 1/1.33)
    124 // v and n must already be normalized
    125 forall(T | fromint(T) | subtract(T) | multiply(T) | add(T) | lessthan(T) | sqrt(T),
    126        V | dottable(V, T) | { V ?*?(T, V); V ?-?(V,V); void ?{}(V&, zero_t); })
    127 V refract(V v, V n, T eta) {
    128     T dotValue = dot(n, v);
    129     T k = (T){1} - eta * eta * ((T){1} - dotValue * dotValue);
    130     if (k < (T){0}) {
    131         return 0;
    132     }
    133     return eta * v - (eta * dotValue + sqrt(k)) * n;
    134 }
     124        // Refract incident vector v with respect to surface with normal n eta is the ratio of indices of refraction between
     125        // starting material and entering material ( i.e., from air to water, eta = 1/1.33 ) v and n must already be
     126        // normalized
     127        forall( T | fromint( T ) | subtract( T ) | multiply( T ) | add( T ) | lessthan( T ) | sqrt( T ),
     128                V | dottable( V, T ) | { V ?*?( T, V ); V ?-?( V,V ); void ?{}( V&, zero_t ); })
     129        V refract( V v, V n, T eta ) {
     130                T dotValue = dot( n, v );
     131                T k = (T){1} - eta * eta * ((T){1} - dotValue * dotValue );
     132                if ( k < (T){0}) {
     133                        return 0;
     134                }
     135                return eta * v - ( eta * dotValue + sqrt( k ) ) * n;
     136        }
    135137
    136 // Given a perturbed normal and a geometric normal,
    137 // flip the perturbed normal if the geometric normal is pointing away
    138 // from the observer.
    139 // n is the perturbed vector that we want to align
    140 // i is the incident vector
    141 // ng is the geometric normal of the surface
    142 forall(T | lessthan(T) | zeroinit(T), V | dottable(V, T) | negate(V))
    143 V faceforward(V n, V i, V ng) {
    144     return dot(ng, i) < (T){0} ? n : -n;
    145 }
     138        #pragma GCC diagnostic pop
    146139
    147 } // inline
     140        // Given a perturbed normal and a geometric normal, flip the perturbed normal if the geometric normal is pointing
     141        // away from the observer.  n is the perturbed vector that we want to align i is the incident vector ng is the
     142        // geometric normal of the surface
     143        forall( T | lessthan( T ) | zeroinit( T ), V | dottable( V, T ) | negate( V ) )
     144        V faceforward( V n, V i, V ng ) {
     145                return dot( ng, i ) < (T){0} ? n : -n;
     146        }
     147} // static inline

  • libcfa/src/vec/vec2.hfa

    rf41b161 rc62013e  
    1919#include "vec.hfa"
    2020
    21 forall (T) {
     21forall( T ) {
    2222    struct vec2 {
    2323        T x, y;
    … …  
    2525}
    2626
    27 forall (T) {
    28     static inline {
    29 
    30     void ?{}(vec2(T)& v, T x, T y) {
    31         v.[x, y] = [x, y];
    32     }
    33 
    34     forall(| zero_assign(T))
    35     void ?{}(vec2(T)& vec, zero_t) with (vec) {
    36         x = y = 0;
    37     }
    38 
    39     void ?{}(vec2(T)& vec, T val) with (vec) {
    40         x = y = val;
    41     }
    42 
    43     void ?{}(vec2(T)& vec, vec2(T) other) with (vec) {
    44         [x,y] = other.[x,y];
    45     }
    46 
    47     void ?=?(vec2(T)& vec, vec2(T) other) with (vec) {
    48         [x,y] = other.[x,y];
    49     }
    50     forall(| zero_assign(T))
    51     void ?=?(vec2(T)& vec, zero_t) with (vec) {
    52         x = y = 0;
    53     }
    54 
    55     // Primitive mathematical operations
    56 
    57     // -
    58     forall(| subtract(T)) {
    59     vec2(T) ?-?(vec2(T) u, vec2(T) v) {
    60         return [u.x - v.x, u.y - v.y];
    61     }
    62     vec2(T)& ?-=?(vec2(T)& u, vec2(T) v) {
    63         u = u - v;
    64         return u;
    65     }
    66     }
    67     forall(| negate(T))
    68     vec2(T) -?(vec2(T) v) with (v) {
    69         return [-x, -y];
    70     }
    71 
    72     forall(| { T --?(T&); }) {
    73     vec2(T)& --?(vec2(T)& v) {
    74         --v.x;
    75         --v.y;
    76         return v;
    77     }
    78     vec2(T) ?--(vec2(T)& v) {
    79         vec2(T) copy = v;
    80         --v;
    81         return copy;
    82     }
    83     }
    84 
    85     // +
    86     forall(| add(T)) {
    87     vec2(T) ?+?(vec2(T) u, vec2(T) v) {
    88         return [u.x + v.x, u.y + v.y];
    89     }
    90     vec2(T)& ?+=?(vec2(T)& u, vec2(T) v) {
    91         u = u + v;
    92         return u;
    93     }
    94     }
    95 
    96     forall(| { T ++?(T&); }) {
    97     vec2(T)& ++?(vec2(T)& v) {
    98         ++v.x;
    99         ++v.y;
    100         return v;
    101     }
    102     vec2(T) ?++(vec2(T)& v) {
    103         vec2(T) copy = v;
    104         ++v;
    105         return copy;
    106     }
    107     }
    108 
    109     // *
    110     forall(| multiply(T)) {
    111     vec2(T) ?*?(vec2(T) v, T scalar) with (v) {
    112         return [x * scalar, y * scalar];
    113     }
    114     vec2(T) ?*?(T scalar, vec2(T) v) {
    115         return v * scalar;
    116     }
    117     vec2(T) ?*?(vec2(T) u, vec2(T) v) {
    118         return [u.x * v.x, u.y * v.y];
    119     }
    120     vec2(T)& ?*=?(vec2(T)& v, T scalar) {
    121         v = v * scalar;
    122         return v;
    123     }
    124     vec2(T) ?*=?(vec2(T)& u, vec2(T) v) {
    125         u = u * v;
    126         return u;
    127     }
    128     }
    129 
    130     // /
    131     forall(| divide(T)) {
    132     vec2(T) ?/?(vec2(T) v, T scalar) with (v) {
    133         return [x / scalar, y / scalar];
    134     }
    135     vec2(T) ?/?(vec2(T) u, vec2(T) v) {
    136         return [u.x / v.x, u.y / v.y];
    137     }
    138     vec2(T)& ?/=?(vec2(T)& v, T scalar) {
    139         v = v / scalar;
    140         return v;
    141     }
    142     vec2(T) ?/=?(vec2(T)& u, vec2(T) v) {
    143         u = u / v;
    144         return u;
    145     }
    146     }
    147 
    148     // %
    149     forall(| { T ?%?(T,T); }) {
    150     vec2(T) ?%?(vec2(T) v, T scalar) with (v) {
    151         return [x % scalar, y % scalar];
    152     }
    153     vec2(T)& ?%=?(vec2(T)& u, T scalar) {
    154         u = u % scalar;
    155         return u;
    156     }
    157     vec2(T) ?%?(vec2(T) u, vec2(T) v) {
    158         return [u.x % v.x, u.y % v.y];
    159     }
    160     vec2(T)& ?%=?(vec2(T)& u, vec2(T) v) {
    161         u = u % v;
    162         return u;
    163     }
    164     }
    165 
    166     // &
    167     forall(| { T ?&?(T,T); }) {
    168     vec2(T) ?&?(vec2(T) v, T scalar) with (v) {
    169         return [x & scalar, y & scalar];
    170     }
    171     vec2(T)& ?&=?(vec2(T)& u, T scalar) {
    172         u = u & scalar;
    173         return u;
    174     }
    175     vec2(T) ?&?(vec2(T) u, vec2(T) v) {
    176         return [u.x & v.x, u.y & v.y];
    177     }
    178     vec2(T)& ?&=?(vec2(T)& u, vec2(T) v) {
    179         u = u & v;
    180         return u;
    181     }
    182     }
    183 
    184     // |
    185     forall(| { T ?|?(T,T); }) {
    186     vec2(T) ?|?(vec2(T) v, T scalar) with (v) {
    187         return [x | scalar, y | scalar];
    188     }
    189     vec2(T)& ?|=?(vec2(T)& u, T scalar) {
    190         u = u | scalar;
    191         return u;
    192     }
    193     vec2(T) ?|?(vec2(T) u, vec2(T) v) {
    194         return [u.x | v.x, u.y | v.y];
    195     }
    196     vec2(T)& ?|=?(vec2(T)& u, vec2(T) v) {
    197         u = u | v;
    198         return u;
    199     }
    200     }
    201 
    202     // ^
    203     forall(| { T ?^?(T,T); }) {
    204     vec2(T) ?^?(vec2(T) v, T scalar) with (v) {
    205         return [x ^ scalar, y ^ scalar];
    206     }
    207     vec2(T)& ?^=?(vec2(T)& u, T scalar) {
    208         u = u ^ scalar;
    209         return u;
    210     }
    211     vec2(T) ?^?(vec2(T) u, vec2(T) v) {
    212         return [u.x ^ v.x, u.y ^ v.y];
    213     }
    214     vec2(T)& ?^=?(vec2(T)& u, vec2(T) v) {
    215         u = u ^ v;
    216         return u;
    217     }
    218     }
    219 
    220     // <<
    221     forall(| { T ?<<?(T,T); }) {
    222     vec2(T) ?<<?(vec2(T) v, T scalar) with (v) {
    223         return [x << scalar, y << scalar];
    224     }
    225     vec2(T)& ?<<=?(vec2(T)& u, T scalar) {
    226         u = u << scalar;
    227         return u;
    228     }
    229     vec2(T) ?<<?(vec2(T) u, vec2(T) v) {
    230         return [u.x << v.x, u.y << v.y];
    231     }
    232     vec2(T)& ?<<=?(vec2(T)& u, vec2(T) v) {
    233         u = u << v;
    234         return u;
    235     }
    236     }
    237 
    238     // >>
    239     forall(| { T ?>>?(T,T); }) {
    240     vec2(T) ?>>?(vec2(T) v, T scalar) with (v) {
    241         return [x >> scalar, y >> scalar];
    242     }
    243     vec2(T)& ?>>=?(vec2(T)& u, T scalar) {
    244         u = u >> scalar;
    245         return u;
    246     }
    247     vec2(T) ?>>?(vec2(T) u, vec2(T) v) {
    248         return [u.x >> v.x, u.y >> v.y];
    249     }
    250     vec2(T)& ?>>=?(vec2(T)& u, vec2(T) v) {
    251         u = u >> v;
    252         return u;
    253     }
    254     }
    255 
    256     // ~
    257     forall(| { T ~?(T); })
    258     vec2(T) ~?(vec2(T) v) with (v) {
    259         return [~v.x, ~v.y];
    260     }
    261 
    262     // relational
    263     forall(| equality(T)) {
    264     bool ?==?(vec2(T) u, vec2(T) v) with (u) {
    265         return x == v.x && y == v.y;
    266     }
    267     bool ?!=?(vec2(T) u, vec2(T) v) {
    268         return !(u == v);
    269     }
    270     }
    271 
    272     // Geometric functions
    273     forall(| add(T) | multiply(T))
    274     T dot(vec2(T) u, vec2(T) v) {
    275         return u.x * v.x + u.y * v.y;
    276     }
    277 
    278     } // static inline
    279 }
    280 
    281 forall(ostype &, T | writeable(T, ostype)) {
    282     ostype & ?|?(ostype & os, vec2(T) v) with (v) {
     27static inline forall( T ) {
     28
     29        void ?{}( vec2( T )& v, T x, T y ) {
     30                v.[x, y] = [x, y];
     31        }
     32
     33        forall(| zero_assign( T ))
     34                void ?{}( vec2( T )& vec, zero_t ) with ( vec ) {
     35                x = y = 0;
     36        }
     37
     38        void ?{}( vec2( T )& vec, T val ) with ( vec ) {
     39                x = y = val;
     40        }
     41
     42        void ?{}( vec2( T )& vec, vec2( T ) other ) with ( vec ) {
     43                [x,y] = other.[x,y];
     44        }
     45
     46        void ?=?( vec2( T )& vec, vec2( T ) other ) with ( vec ) {
     47                [x,y] = other.[x,y];
     48        }
     49        forall(| zero_assign( T ))
     50                void ?=?( vec2( T )& vec, zero_t ) with ( vec ) {
     51                x = y = 0;
     52        }
     53
     54        // Primitive mathematical operations
     55
     56        // -
     57        forall(| subtract( T )) {
     58                vec2( T ) ?-?( vec2( T ) u, vec2( T ) v ) {
     59                        return [u.x - v.x, u.y - v.y];
     60                }
     61                vec2( T )& ?-=?( vec2( T )& u, vec2( T ) v ) {
     62                        u = u - v;
     63                        return u;
     64                }
     65        }
     66        forall(| negate( T ))
     67                vec2( T ) -?( vec2( T ) v ) with ( v ) {
     68                return [-x, -y];
     69        }
     70
     71        forall(| { T --?( T&); }) {
     72                vec2( T )& --?( vec2( T )& v ) {
     73                        --v.x;
     74                        --v.y;
     75                        return v;
     76                }
     77                vec2( T ) ?--( vec2( T )& v ) {
     78                        vec2( T ) copy = v;
     79                        --v;
     80                        return copy;
     81                }
     82        }
     83
     84        // +
     85        forall(| add( T )) {
     86                vec2( T ) ?+?( vec2( T ) u, vec2( T ) v ) {
     87                        return [u.x + v.x, u.y + v.y];
     88                }
     89                vec2( T )& ?+=?( vec2( T )& u, vec2( T ) v ) {
     90                        u = u + v;
     91                        return u;
     92                }
     93        }
     94
     95        forall(| { T ++?( T&); }) {
     96                vec2( T )& ++?( vec2( T )& v ) {
     97                        ++v.x;
     98                        ++v.y;
     99                        return v;
     100                }
     101                vec2( T ) ?++( vec2( T )& v ) {
     102                        vec2( T ) copy = v;
     103                        ++v;
     104                        return copy;
     105                }
     106        }
     107
     108        // *
     109        forall(| multiply( T )) {
     110                vec2( T ) ?*?( vec2( T ) v, T scalar ) with ( v ) {
     111                        return [x * scalar, y * scalar];
     112                }
     113                vec2( T ) ?*?( T scalar, vec2( T ) v ) {
     114                        return v * scalar;
     115                }
     116                vec2( T ) ?*?( vec2( T ) u, vec2( T ) v ) {
     117                        return [u.x * v.x, u.y * v.y];
     118                }
     119                vec2( T )& ?*=?( vec2( T )& v, T scalar ) {
     120                        v = v * scalar;
     121                        return v;
     122                }
     123                vec2( T ) ?*=?( vec2( T )& u, vec2( T ) v ) {
     124                        u = u * v;
     125                        return u;
     126                }
     127        }
     128
     129        // /
     130        forall(| divide( T )) {
     131                vec2( T ) ?/?( vec2( T ) v, T scalar ) with ( v ) {
     132                        return [x / scalar, y / scalar];
     133                }
     134                vec2( T ) ?/?( vec2( T ) u, vec2( T ) v ) {
     135                        return [u.x / v.x, u.y / v.y];
     136                }
     137                vec2( T )& ?/=?( vec2( T )& v, T scalar ) {
     138                        v = v / scalar;
     139                        return v;
     140                }
     141                vec2( T ) ?/=?( vec2( T )& u, vec2( T ) v ) {
     142                        u = u / v;
     143                        return u;
     144                }
     145        }
     146
     147        // %
     148        forall(| { T ?%?( T,T ); }) {
     149                vec2( T ) ?%?( vec2( T ) v, T scalar ) with ( v ) {
     150                        return [x % scalar, y % scalar];
     151                }
     152                vec2( T )& ?%=?( vec2( T )& u, T scalar ) {
     153                        u = u % scalar;
     154                        return u;
     155                }
     156                vec2( T ) ?%?( vec2( T ) u, vec2( T ) v ) {
     157                        return [u.x % v.x, u.y % v.y];
     158                }
     159                vec2( T )& ?%=?( vec2( T )& u, vec2( T ) v ) {
     160                        u = u % v;
     161                        return u;
     162                }
     163        }
     164
     165        // &
     166        forall(| { T ?&?( T,T ); }) {
     167                vec2( T ) ?&?( vec2( T ) v, T scalar ) with ( v ) {
     168                        return [x & scalar, y & scalar];
     169                }
     170                vec2( T )& ?&=?( vec2( T )& u, T scalar ) {
     171                        u = u & scalar;
     172                        return u;
     173                }
     174                vec2( T ) ?&?( vec2( T ) u, vec2( T ) v ) {
     175                        return [u.x & v.x, u.y & v.y];
     176                }
     177                vec2( T )& ?&=?( vec2( T )& u, vec2( T ) v ) {
     178                        u = u & v;
     179                        return u;
     180                }
     181        }
     182
     183        // |
     184        forall(| { T ?|?( T,T ); }) {
     185                vec2( T ) ?|?( vec2( T ) v, T scalar ) with ( v ) {
     186                        return [x | scalar, y | scalar];
     187                }
     188                vec2( T )& ?|=?( vec2( T )& u, T scalar ) {
     189                        u = u | scalar;
     190                        return u;
     191                }
     192                vec2( T ) ?|?( vec2( T ) u, vec2( T ) v ) {
     193                        return [u.x | v.x, u.y | v.y];
     194                }
     195                vec2( T )& ?|=?( vec2( T )& u, vec2( T ) v ) {
     196                        u = u | v;
     197                        return u;
     198                }
     199        }
     200
     201        // ^
     202        forall(| { T ?^?( T,T ); }) {
     203                vec2( T ) ?^?( vec2( T ) v, T scalar ) with ( v ) {
     204                        return [x ^ scalar, y ^ scalar];
     205                }
     206                vec2( T )& ?^=?( vec2( T )& u, T scalar ) {
     207                        u = u ^ scalar;
     208                        return u;
     209                }
     210                vec2( T ) ?^?( vec2( T ) u, vec2( T ) v ) {
     211                        return [u.x ^ v.x, u.y ^ v.y];
     212                }
     213                vec2( T )& ?^=?( vec2( T )& u, vec2( T ) v ) {
     214                        u = u ^ v;
     215                        return u;
     216                }
     217        }
     218
     219        // <<
     220        forall(| { T ?<<?( T,T ); }) {
     221                vec2( T ) ?<<?( vec2( T ) v, T scalar ) with ( v ) {
     222                        return [x << scalar, y << scalar];
     223                }
     224                vec2( T )& ?<<=?( vec2( T )& u, T scalar ) {
     225                        u = u << scalar;
     226                        return u;
     227                }
     228                vec2( T ) ?<<?( vec2( T ) u, vec2( T ) v ) {
     229                        return [u.x << v.x, u.y << v.y];
     230                }
     231                vec2( T )& ?<<=?( vec2( T )& u, vec2( T ) v ) {
     232                        u = u << v;
     233                        return u;
     234                }
     235        }
     236
     237        // >>
     238        forall(| { T ?>>?( T,T ); }) {
     239                vec2( T ) ?>>?( vec2( T ) v, T scalar ) with ( v ) {
     240                        return [x >> scalar, y >> scalar];
     241                }
     242                vec2( T )& ?>>=?( vec2( T )& u, T scalar ) {
     243                        u = u >> scalar;
     244                        return u;
     245                }
     246                vec2( T ) ?>>?( vec2( T ) u, vec2( T ) v ) {
     247                        return [u.x >> v.x, u.y >> v.y];
     248                }
     249                vec2( T )& ?>>=?( vec2( T )& u, vec2( T ) v ) {
     250                        u = u >> v;
     251                        return u;
     252                }
     253        }
     254
     255        // ~
     256        forall(| { T ~?( T ); })
     257                vec2( T ) ~?( vec2( T ) v ) with ( v ) {
     258                return [~v.x, ~v.y];
     259        }
     260
     261        // relational
     262        forall(| equality( T )) {
     263                bool ?==?( vec2( T ) u, vec2( T ) v ) with ( u ) {
     264                        return x == v.x && y == v.y;
     265                }
     266                bool ?!=?( vec2( T ) u, vec2( T ) v ) {
     267                        return !( u == v );
     268                }
     269        }
     270
     271        // Geometric functions
     272        forall(| add( T ) | multiply( T ))
     273                T dot( vec2( T ) u, vec2( T ) v ) {
     274                return u.x * v.x + u.y * v.y;
     275        }
     276} // static inline
     277
     278
     279forall( ostype &, T | writeable( T, ostype )) {
     280    ostype & ?|?( ostype & os, vec2( T ) v ) with ( v ) {
    283281        return os | '<' | x | ',' | y | '>';
    284282    }
    285         OSTYPE_VOID_IMPL( os, vec2(T) )
     283        OSTYPE_VOID_IMPL( os, vec2( T ) )
    286284}

  • libcfa/src/vec/vec3.hfa

    rf41b161 rc62013e  
    1919#include "vec.hfa"
    2020
    21 forall (T) {
     21forall( T ) {
    2222    struct vec3 {
    2323        T x, y, z;
    … …  
    2525}
    2626
    27 forall (T) {
    28     static inline {
    29 
    30     void ?{}(vec3(T)& v, T x, T y, T z) {
     27static inline forall( T ) {
     28    void ?{}( vec3( T )& v, T x, T y, T z ) {
    3129        v.[x, y, z] = [x, y, z];
    3230    }
    3331
    34     forall(| zero_assign(T))
    35     void ?{}(vec3(T)& vec, zero_t) with (vec) {
     32    forall( | zero_assign( T ) )
     33    void ?{}( vec3( T )& vec, zero_t ) with ( vec ) {
    3634        x = y = z = 0;
    3735    }
    3836
    39     void ?{}(vec3(T)& vec, T val) with (vec) {
     37    void ?{}( vec3( T )& vec, T val ) with ( vec ) {
    4038        x = y = z = val;
    4139    }
    4240
    43     void ?{}(vec3(T)& vec, vec3(T) other) with (vec) {
     41    void ?{}( vec3( T )& vec, vec3( T ) other ) with ( vec ) {
    4442        [x,y,z] = other.[x,y,z];
    4543    }
    4644
    47     void ?=?(vec3(T)& vec, vec3(T) other) with (vec) {
     45    void ?=?( vec3( T )& vec, vec3( T ) other ) with ( vec ) {
    4846        [x,y,z] = other.[x,y,z];
    4947    }
    50     forall(| zero_assign(T))
    51     void ?=?(vec3(T)& vec, zero_t) with (vec) {
     48
     49    forall( | zero_assign( T ) )
     50    void ?=?( vec3( T )& vec, zero_t ) with ( vec ) {
    5251        x = y = z = 0;
    5352    }
    … …  
    5655
    5756    // -
    58     forall(| subtract(T)) {
    59     vec3(T) ?-?(vec3(T) u, vec3(T) v) {
    60         return [u.x - v.x, u.y - v.y, u.z - v.z];
    61     }
    62     vec3(T)& ?-=?(vec3(T)& u, vec3(T) v) {
    63         u = u - v;
    64         return u;
    65     }
    66     }
    67     forall(| negate(T)) {
    68     vec3(T) -?(vec3(T) v) with (v) {
    69         return [-x, -y, -z];
    70     }
    71     }
    72     forall(| { T --?(T&); }) {
    73     vec3(T)& --?(vec3(T)& v) {
    74         --v.x;
    75         --v.y;
    76         --v.z;
    77         return v;
    78     }
    79     vec3(T) ?--(vec3(T)& v) {
    80         vec3(T) copy = v;
    81         --v;
    82         return copy;
    83     }
     57    forall( | subtract( T ) ) {
     58                vec3( T ) ?-?( vec3( T ) u, vec3( T ) v ) {
     59                        return [u.x - v.x, u.y - v.y, u.z - v.z];
     60                }
     61                vec3( T )& ?-=?( vec3( T )& u, vec3( T ) v ) {
     62                        u = u - v;
     63                        return u;
     64                }
     65    }
     66
     67    forall( | negate( T ) ) {
     68                vec3( T ) -?( vec3( T ) v ) with ( v ) {
     69                        return [-x, -y, -z];
     70                }
     71    }
     72
     73    forall( | { T --?( T&); }) {
     74                vec3( T )& --?( vec3( T )& v ) {
     75                        --v.x;
     76                        --v.y;
     77                        --v.z;
     78                        return v;
     79                }
     80                vec3( T ) ?--( vec3( T )& v ) {
     81                        vec3( T ) copy = v;
     82                        --v;
     83                        return copy;
     84                }
    8485    }
    8586
    8687    // +
    87     forall(| add(T)) {
    88     vec3(T) ?+?(vec3(T) u, vec3(T) v) {
    89         return [u.x + v.x, u.y + v.y, u.z + v.z];
    90     }
    91     vec3(T)& ?+=?(vec3(T)& u, vec3(T) v) {
    92         u = u + v;
    93         return u;
    94     }
    95     }
    96 
    97     forall(| { T ++?(T&); }) {
    98     vec3(T)& ++?(vec3(T)& v) {
    99         ++v.x;
    100         ++v.y;
    101         ++v.z;
    102         return v;
    103     }
    104     vec3(T) ?++(vec3(T)& v) {
    105         vec3(T) copy = v;
    106         ++v;
    107         return copy;
    108     }
     88    forall( | add( T ) ) {
     89                vec3( T ) ?+?( vec3( T ) u, vec3( T ) v ) {
     90                        return [u.x + v.x, u.y + v.y, u.z + v.z];
     91                }
     92                vec3( T )& ?+=?( vec3( T )& u, vec3( T ) v ) {
     93                        u = u + v;
     94                        return u;
     95                }
     96    }
     97
     98    forall( | { T ++?( T&); }) {
     99                vec3( T )& ++?( vec3( T )& v ) {
     100                        ++v.x;
     101                        ++v.y;
     102                        ++v.z;
     103                        return v;
     104                }
     105                vec3( T ) ?++( vec3( T )& v ) {
     106                        vec3( T ) copy = v;
     107                        ++v;
     108                        return copy;
     109                }
    109110    }
    110111
    111112    // *
    112     forall(| multiply(T)) {
    113     vec3(T) ?*?(vec3(T) v, T scalar) with (v) {
    114         return [x * scalar, y * scalar, z * scalar];
    115     }
    116     vec3(T) ?*?(T scalar, vec3(T) v) {
    117         return v * scalar;
    118     }
    119     vec3(T) ?*?(vec3(T) u, vec3(T) v) {
    120         return [u.x * v.x, u.y * v.y, u.z * v.z];
    121     }
    122     vec3(T)& ?*=?(vec3(T)& v, T scalar) {
    123         v = v * scalar;
    124         return v;
    125     }
    126     vec3(T)& ?*=?(vec3(T)& u, vec3(T) v) {
    127         u = u * v;
    128         return u;
    129     }
     113    forall( | multiply( T ) ) {
     114                vec3( T ) ?*?( vec3( T ) v, T scalar ) with ( v ) {
     115                        return [x * scalar, y * scalar, z * scalar];
     116                }
     117                vec3( T ) ?*?( T scalar, vec3( T ) v ) {
     118                        return v * scalar;
     119                }
     120                vec3( T ) ?*?( vec3( T ) u, vec3( T ) v ) {
     121                        return [u.x * v.x, u.y * v.y, u.z * v.z];
     122                }
     123                vec3( T )& ?*=?( vec3( T )& v, T scalar ) {
     124                        v = v * scalar;
     125                        return v;
     126                }
     127                vec3( T )& ?*=?( vec3( T )& u, vec3( T ) v ) {
     128                        u = u * v;
     129                        return u;
     130                }
    130131    }
    131132
    132133    // /
    133     forall(| divide(T)) {
    134     vec3(T) ?/?(vec3(T) v, T scalar) with (v) {
    135         return [x / scalar, y / scalar, z / scalar];
    136     }
    137     vec3(T) ?/?(vec3(T) u, vec3(T) v) {
    138         return [u.x / v.x, u.y / v.y, u.z / v.z];
    139     }
    140     vec3(T)& ?/=?(vec3(T)& v, T scalar) {
    141         v = v / scalar;
    142         return v;
    143     }
    144     vec3(T)& ?/=?(vec3(T)& u, vec3(T) v) {
    145         u = u / v;
    146         return u;
    147     }
    148     }
    149 
     134    forall( | divide( T ) ) {
     135                vec3( T ) ?/?( vec3( T ) v, T scalar ) with ( v ) {
     136                        return [x / scalar, y / scalar, z / scalar];
     137                }
     138                vec3( T ) ?/?( vec3( T ) u, vec3( T ) v ) {
     139                        return [u.x / v.x, u.y / v.y, u.z / v.z];
     140                }
     141                vec3( T )& ?/=?( vec3( T )& v, T scalar ) {
     142                        v = v / scalar;
     143                        return v;
     144                }
     145                vec3( T )& ?/=?( vec3( T )& u, vec3( T ) v ) {
     146                        u = u / v;
     147                        return u;
     148                }
     149    }
     150       
    150151    // %
    151     forall(| { T ?%?(T,T); }) {
    152     vec3(T) ?%?(vec3(T) v, T scalar) with (v) {
    153         return [x % scalar, y % scalar, z % scalar];
    154     }
    155     vec3(T)& ?%=?(vec3(T)& u, T scalar) {
    156         u = u % scalar;
    157         return u;
    158     }
    159     vec3(T) ?%?(vec3(T) u, vec3(T) v) {
    160         return [u.x % v.x, u.y % v.y, u.z % v.z];
    161     }
    162     vec3(T)& ?%=?(vec3(T)& u, vec3(T) v) {
    163         u = u % v;
    164         return u;
    165     }
     152    forall( | { T ?%?( T,T ); }) {
     153                vec3( T ) ?%?( vec3( T ) v, T scalar ) with ( v ) {
     154                        return [x % scalar, y % scalar, z % scalar];
     155                }
     156                vec3( T )& ?%=?( vec3( T )& u, T scalar ) {
     157                        u = u % scalar;
     158                        return u;
     159                }
     160                vec3( T ) ?%?( vec3( T ) u, vec3( T ) v ) {
     161                        return [u.x % v.x, u.y % v.y, u.z % v.z];
     162                }
     163                vec3( T )& ?%=?( vec3( T )& u, vec3( T ) v ) {
     164                        u = u % v;
     165                        return u;
     166                }
    166167    }
    167168
    168169    // &
    169     forall(| { T ?&?(T,T); }) {
    170     vec3(T) ?&?(vec3(T) v, T scalar) with (v) {
    171         return [x & scalar, y & scalar, z & scalar];
    172     }
    173     vec3(T)& ?&=?(vec3(T)& u, T scalar) {
    174         u = u & scalar;
    175         return u;
    176     }
    177     vec3(T) ?&?(vec3(T) u, vec3(T) v) {
    178         return [u.x & v.x, u.y & v.y, u.z & v.z];
    179     }
    180     vec3(T)& ?&=?(vec3(T)& u, vec3(T) v) {
    181         u = u & v;
    182         return u;
    183     }
     170    forall( | { T ?&?( T,T ); }) {
     171                vec3( T ) ?&?( vec3( T ) v, T scalar ) with ( v ) {
     172                        return [x & scalar, y & scalar, z & scalar];
     173                }
     174                vec3( T )& ?&=?( vec3( T )& u, T scalar ) {
     175                        u = u & scalar;
     176                        return u;
     177                }
     178                vec3( T ) ?&?( vec3( T ) u, vec3( T ) v ) {
     179                        return [u.x & v.x, u.y & v.y, u.z & v.z];
     180                }
     181                vec3( T )& ?&=?( vec3( T )& u, vec3( T ) v ) {
     182                        u = u & v;
     183                        return u;
     184                }
    184185    }
    185186
    186187    // |
    187     forall(| { T ?|?(T,T); }) {
    188     vec3(T) ?|?(vec3(T) v, T scalar) with (v) {
    189         return [x | scalar, y | scalar, z | scalar];
    190     }
    191     vec3(T)& ?|=?(vec3(T)& u, T scalar) {
    192         u = u | scalar;
    193         return u;
    194     }
    195     vec3(T) ?|?(vec3(T) u, vec3(T) v) {
    196         return [u.x | v.x, u.y | v.y, u.z | v.z];
    197     }
    198     vec3(T)& ?|=?(vec3(T)& u, vec3(T) v) {
    199         u = u | v;
    200         return u;
    201     }
     188    forall( | { T ?|?( T,T ); }) {
     189                vec3( T ) ?|?( vec3( T ) v, T scalar ) with ( v ) {
     190                        return [x | scalar, y | scalar, z | scalar];
     191                }
     192                vec3( T )& ?|=?( vec3( T )& u, T scalar ) {
     193                        u = u | scalar;
     194                        return u;
     195                }
     196                vec3( T ) ?|?( vec3( T ) u, vec3( T ) v ) {
     197                        return [u.x | v.x, u.y | v.y, u.z | v.z];
     198                }
     199                vec3( T )& ?|=?( vec3( T )& u, vec3( T ) v ) {
     200                        u = u | v;
     201                        return u;
     202                }
    202203    }
    203204
    204205    // ^
    205     forall(| { T ?^?(T,T); }) {
    206     vec3(T) ?^?(vec3(T) v, T scalar) with (v) {
    207         return [x ^ scalar, y ^ scalar, z ^ scalar];
    208     }
    209     vec3(T)& ?^=?(vec3(T)& u, T scalar) {
    210         u = u ^ scalar;
    211         return u;
    212     }
    213     vec3(T) ?^?(vec3(T) u, vec3(T) v) {
    214         return [u.x ^ v.x, u.y ^ v.y, u.z ^ v.z];
    215     }
    216     vec3(T)& ?^=?(vec3(T)& u, vec3(T) v) {
    217         u = u ^ v;
    218         return u;
    219     }
     206    forall( | { T ?^?( T,T ); }) {
     207                vec3( T ) ?^?( vec3( T ) v, T scalar ) with ( v ) {
     208                        return [x ^ scalar, y ^ scalar, z ^ scalar];
     209                }
     210                vec3( T )& ?^=?( vec3( T )& u, T scalar ) {
     211                        u = u ^ scalar;
     212                        return u;
     213                }
     214                vec3( T ) ?^?( vec3( T ) u, vec3( T ) v ) {
     215                        return [u.x ^ v.x, u.y ^ v.y, u.z ^ v.z];
     216                }
     217                vec3( T )& ?^=?( vec3( T )& u, vec3( T ) v ) {
     218                        u = u ^ v;
     219                        return u;
     220                }
    220221    }
    221222
    222223    // <<
    223     forall(| { T ?<<?(T,T); }) {
    224     vec3(T) ?<<?(vec3(T) v, T scalar) with (v) {
    225         return [x << scalar, y << scalar, z << scalar];
    226     }
    227     vec3(T)& ?<<=?(vec3(T)& u, T scalar) {
    228         u = u << scalar;
    229         return u;
    230     }
    231     vec3(T) ?<<?(vec3(T) u, vec3(T) v) {
    232         return [u.x << v.x, u.y << v.y, u.z << v.z];
    233     }
    234     vec3(T)& ?<<=?(vec3(T)& u, vec3(T) v) {
    235         u = u << v;
    236         return u;
    237     }
     224    forall( | { T ?<<?( T,T ); }) {
     225                vec3( T ) ?<<?( vec3( T ) v, T scalar ) with ( v ) {
     226                        return [x << scalar, y << scalar, z << scalar];
     227                }
     228                vec3( T )& ?<<=?( vec3( T )& u, T scalar ) {
     229                        u = u << scalar;
     230                        return u;
     231                }
     232                vec3( T ) ?<<?( vec3( T ) u, vec3( T ) v ) {
     233                        return [u.x << v.x, u.y << v.y, u.z << v.z];
     234                }
     235                vec3( T )& ?<<=?( vec3( T )& u, vec3( T ) v ) {
     236                        u = u << v;
     237                        return u;
     238                }
    238239    }
    239240
    240241    // >>
    241     forall(| { T ?>>?(T,T); }) {
    242     vec3(T) ?>>?(vec3(T) v, T scalar) with (v) {
    243         return [x >> scalar, y >> scalar, z >> scalar];
    244     }
    245     vec3(T)& ?>>=?(vec3(T)& u, T scalar) {
    246         u = u >> scalar;
    247         return u;
    248     }
    249     vec3(T) ?>>?(vec3(T) u, vec3(T) v) {
    250         return [u.x >> v.x, u.y >> v.y, u.z >> v.z];
    251     }
    252     vec3(T)& ?>>=?(vec3(T)& u, vec3(T) v) {
    253         u = u >> v;
    254         return u;
    255     }
     242    forall( | { T ?>>?( T,T ); }) {
     243                vec3( T ) ?>>?( vec3( T ) v, T scalar ) with ( v ) {
     244                        return [x >> scalar, y >> scalar, z >> scalar];
     245                }
     246                vec3( T )& ?>>=?( vec3( T )& u, T scalar ) {
     247                        u = u >> scalar;
     248                        return u;
     249                }
     250                vec3( T ) ?>>?( vec3( T ) u, vec3( T ) v ) {
     251                        return [u.x >> v.x, u.y >> v.y, u.z >> v.z];
     252                }
     253                vec3( T )& ?>>=?( vec3( T )& u, vec3( T ) v ) {
     254                        u = u >> v;
     255                        return u;
     256                }
    256257    }
    257258
    258259    // ~
    259     forall(| { T ~?(T); })
    260     vec3(T) ~?(vec3(T) v) with (v) {
     260    forall( | { T ~?( T ); })
     261                vec3( T ) ~?( vec3( T ) v ) with ( v ) {
    261262        return [~v.x, ~v.y, ~v.z];
    262263    }
    263264
    264265    // relational
    265     forall(| equality(T)) {
    266     bool ?==?(vec3(T) u, vec3(T) v) with (u) {
    267         return x == v.x && y == v.y && z == v.z;
    268     }
    269     bool ?!=?(vec3(T) u, vec3(T) v) {
    270         return !(u == v);
    271     }
     266    forall( | equality( T ) ) {
     267                bool ?==?( vec3( T ) u, vec3( T ) v ) with ( u ) {
     268                        return x == v.x && y == v.y && z == v.z;
     269                }
     270                bool ?!=?( vec3( T ) u, vec3( T ) v ) {
     271                        return !( u == v );
     272                }
    272273    }
    273274
    274275    // Geometric functions
    275     forall(| add(T) | multiply(T))
    276     T dot(vec3(T) u, vec3(T) v) {
     276    forall( | add( T ) | multiply( T ) )
     277                T dot( vec3( T ) u, vec3( T ) v ) {
    277278        return u.x * v.x + u.y * v.y + u.z * v.z;
    278279    }
    279280
    280     forall(| subtract(T) | multiply(T))
    281     vec3(T) cross(vec3(T) u, vec3(T) v) {
    282         return (vec3(T)){ u.y * v.z - v.y * u.z,
    283                           u.z * v.x - v.z * u.x,
    284                           u.x * v.y - v.x * u.y };
    285     }
    286 
    287     } // static inline
     281    forall( | subtract( T ) | multiply( T ) )
     282                vec3( T ) cross( vec3( T ) u, vec3( T ) v ) {
     283        return ( vec3( T ) ){ u.y * v.z - v.y * u.z,
     284                        u.z * v.x - v.z * u.x,
     285                        u.x * v.y - v.x * u.y };
     286    }
    288287}
    289288
    290 forall(ostype &, T | writeable(T, ostype)) {
    291     ostype & ?|?(ostype & os, vec3(T) v) with (v) {
     289forall( ostype &, T | writeable( T, ostype ) ) {
     290    ostype & ?|?( ostype & os, vec3( T ) v ) with ( v ) {
    292291        return os | '<' | x | ',' | y | ',' | z | '>';
    293292    }
    294         OSTYPE_VOID_IMPL( os, vec3(T) )
     293        OSTYPE_VOID_IMPL( os, vec3( T ) )
    295294}

  • libcfa/src/vec/vec4.hfa

    rf41b161 rc62013e  
    1919#include "vec.hfa"
    2020
    21 forall (T) {
     21forall( T ) {
    2222    struct vec4 {
    2323        T x, y, z, w;
    … …  
    2525}
    2626
    27 forall (T) {
    28     static inline {
    29 
    30     void ?{}(vec4(T)& v, T x, T y, T z, T w) {
     27static inline forall( T ) {
     28    void ?{}( vec4( T )& v, T x, T y, T z, T w ) {
    3129        v.[x, y, z, w] = [x, y, z, w];
    3230    }
    3331
    34     forall(| zero_assign(T))
    35     void ?{}(vec4(T)& vec, zero_t) with (vec) {
     32    forall( | zero_assign( T ) )
     33    void ?{}( vec4( T )& vec, zero_t ) with ( vec ) {
    3634        x = y = z = w = 0;
    3735    }
    3836
    39     void ?{}(vec4(T)& vec, T val) with (vec) {
     37    void ?{}( vec4( T )& vec, T val ) with ( vec ) {
    4038        x = y = z = w = val;
    4139    }
    4240
    43     void ?{}(vec4(T)& vec, vec4(T) other) with (vec) {
     41    void ?{}( vec4( T )& vec, vec4( T ) other ) with ( vec ) {
    4442        [x,y,z,w] = other.[x,y,z,w];
    4543    }
    4644
    47     void ?=?(vec4(T)& vec, vec4(T) other) with (vec) {
     45    void ?=?( vec4( T )& vec, vec4( T ) other ) with ( vec ) {
    4846        [x,y,z,w] = other.[x,y,z,w];
    4947    }
    50     forall(| zero_assign(T))
    51     void ?=?(vec4(T)& vec, zero_t) with (vec) {
     48
     49    forall( | zero_assign( T ) )
     50    void ?=?( vec4( T )& vec, zero_t ) with ( vec ) {
    5251        x = y = z = w = 0;
    5352    }
    … …  
    5655
    5756    // -
    58     forall(| subtract(T)) {
    59     vec4(T) ?-?(vec4(T) u, vec4(T) v) {
    60         return [u.x - v.x, u.y - v.y, u.z - v.z, u.w - v.w];
    61     }
    62     vec4(T)& ?-=?(vec4(T)& u, vec4(T) v) {
    63         u = u - v;
    64         return u;
    65     }
    66     }
    67     forall(| negate(T)) {
    68     vec4(T) -?(vec4(T) v) with (v) {
    69         return [-x, -y, -z, -w];
    70     }
    71     }
    72     forall(| { T --?(T&); }) {
    73     vec4(T)& --?(vec4(T)& v) {
    74         --v.x;
    75         --v.y;
    76         --v.z;
    77         --v.w;
    78         return v;
    79     }
    80     vec4(T) ?--(vec4(T)& v) {
    81         vec4(T) copy = v;
    82         --v;
    83         return copy;
    84     }
     57    forall( | subtract( T ) ) {
     58                vec4( T ) ?-?( vec4( T ) u, vec4( T ) v ) {
     59                        return [u.x - v.x, u.y - v.y, u.z - v.z, u.w - v.w];
     60                }
     61                vec4( T )& ?-=?( vec4( T )& u, vec4( T ) v ) {
     62                        u = u - v;
     63                        return u;
     64                }
     65    }
     66
     67    forall( | negate( T ) ) {
     68                vec4( T ) -?( vec4( T ) v ) with ( v ) {
     69                        return [-x, -y, -z, -w];
     70                }
     71    }
     72    forall( | { T --?( T&); }) {
     73                vec4( T )& --?( vec4( T )& v ) {
     74                        --v.x;
     75                        --v.y;
     76                        --v.z;
     77                        --v.w;
     78                        return v;
     79                }
     80                vec4( T ) ?--( vec4( T )& v ) {
     81                        vec4( T ) copy = v;
     82                        --v;
     83                        return copy;
     84                }
    8585    }
    8686
    8787    // +
    88     forall(| add(T)) {
    89     vec4(T) ?+?(vec4(T) u, vec4(T) v) {
    90         return [u.x + v.x, u.y + v.y, u.z + v.z, u.w + v.w];
    91     }
    92     vec4(T)& ?+=?(vec4(T)& u, vec4(T) v) {
    93         u = u + v;
    94         return u;
    95     }
    96     }
    97 
    98     forall(| { T ++?(T&); }) {
    99     vec4(T)& ++?(vec4(T)& v) {
    100         ++v.x;
    101         ++v.y;
    102         ++v.z;
    103         ++v.w;
    104         return v;
    105     }
    106     vec4(T) ?++(vec4(T)& v) {
    107         vec4(T) copy = v;
    108         ++v;
    109         return copy;
    110     }
     88    forall( | add( T ) ) {
     89                vec4( T ) ?+?( vec4( T ) u, vec4( T ) v ) {
     90                        return [u.x + v.x, u.y + v.y, u.z + v.z, u.w + v.w];
     91                }
     92                vec4( T )& ?+=?( vec4( T )& u, vec4( T ) v ) {
     93                        u = u + v;
     94                        return u;
     95                }
     96    }
     97
     98    forall( | { T ++?( T&); }) {
     99                vec4( T )& ++?( vec4( T )& v ) {
     100                        ++v.x;
     101                        ++v.y;
     102                        ++v.z;
     103                        ++v.w;
     104                        return v;
     105                }
     106                vec4( T ) ?++( vec4( T )& v ) {
     107                        vec4( T ) copy = v;
     108                        ++v;
     109                        return copy;
     110                }
    111111    }
    112112
    113113    // *
    114     forall(| multiply(T)) {
    115     vec4(T) ?*?(vec4(T) v, T scalar) with (v) {
    116         return [x * scalar, y * scalar, z * scalar, w * scalar];
    117     }
    118     vec4(T) ?*?(T scalar, vec4(T) v) {
    119         return v * scalar;
    120     }
    121     vec4(T) ?*?(vec4(T) u, vec4(T) v) {
    122         return [u.x * v.x, u.y * v.y, u.z * v.z, u.w * v.w];
    123     }
    124     vec4(T)& ?*=?(vec4(T)& v, T scalar) {
    125         v = v * scalar;
    126         return v;
    127     }
    128     vec4(T)& ?*=?(vec4(T)& u, vec4(T) v) {
    129         u = u * v;
    130         return u;
    131     }
     114    forall( | multiply( T ) ) {
     115                vec4( T ) ?*?( vec4( T ) v, T scalar ) with ( v ) {
     116                        return [x * scalar, y * scalar, z * scalar, w * scalar];
     117                }
     118                vec4( T ) ?*?( T scalar, vec4( T ) v ) {
     119                        return v * scalar;
     120                }
     121                vec4( T ) ?*?( vec4( T ) u, vec4( T ) v ) {
     122                        return [u.x * v.x, u.y * v.y, u.z * v.z, u.w * v.w];
     123                }
     124                vec4( T )& ?*=?( vec4( T )& v, T scalar ) {
     125                        v = v * scalar;
     126                        return v;
     127                }
     128                vec4( T )& ?*=?( vec4( T )& u, vec4( T ) v ) {
     129                        u = u * v;
     130                        return u;
     131                }
    132132    }
    133133
    134134    // /
    135     forall(| divide(T)) {
    136     vec4(T) ?/?(vec4(T) v, T scalar) with (v) {
     135    forall( | divide( T ) ) {
     136    vec4( T ) ?/?( vec4( T ) v, T scalar ) with ( v ) {
    137137        return [x / scalar, y / scalar, z / scalar, w / scalar];
    138138    }
    139     vec4(T) ?/?(vec4(T) u, vec4(T) v) {
     139    vec4( T ) ?/?( vec4( T ) u, vec4( T ) v ) {
    140140        return [u.x / v.x, u.y / v.y, u.z / v.z, u.w / v.w];
    141141    }
    142     vec4(T)& ?/=?(vec4(T)& v, T scalar) {
     142    vec4( T )& ?/=?( vec4( T )& v, T scalar ) {
    143143        v = v / scalar;
    144144        return v;
    145145    }
    146     vec4(T)& ?/=?(vec4(T)& u, vec4(T) v) {
     146    vec4( T )& ?/=?( vec4( T )& u, vec4( T ) v ) {
    147147        u = u / v;
    148148        return u;
    … …  
    151151
    152152    // %
    153     forall(| { T ?%?(T,T); }) {
    154     vec4(T) ?%?(vec4(T) v, T scalar) with (v) {
    155         return [x % scalar, y % scalar, z % scalar, w % scalar];
    156     }
    157     vec4(T)& ?%=?(vec4(T)& u, T scalar) {
    158         u = u % scalar;
    159         return u;
    160     }
    161     vec4(T) ?%?(vec4(T) u, vec4(T) v) {
    162         return [u.x % v.x, u.y % v.y, u.z % v.z, u.w % v.w];
    163     }
    164     vec4(T)& ?%=?(vec4(T)& u, vec4(T) v) {
    165         u = u % v;
    166         return u;
    167     }
     153    forall( | { T ?%?( T,T ); }) {
     154                vec4( T ) ?%?( vec4( T ) v, T scalar ) with ( v ) {
     155                        return [x % scalar, y % scalar, z % scalar, w % scalar];
     156                }
     157                vec4( T )& ?%=?( vec4( T )& u, T scalar ) {
     158                        u = u % scalar;
     159                        return u;
     160                }
     161                vec4( T ) ?%?( vec4( T ) u, vec4( T ) v ) {
     162                        return [u.x % v.x, u.y % v.y, u.z % v.z, u.w % v.w];
     163                }
     164                vec4( T )& ?%=?( vec4( T )& u, vec4( T ) v ) {
     165                        u = u % v;
     166                        return u;
     167                }
    168168    }
    169169
    170170    // &
    171     forall(| { T ?&?(T,T); }) {
    172     vec4(T) ?&?(vec4(T) v, T scalar) with (v) {
    173         return [x & scalar, y & scalar, z & scalar, w & scalar];
    174     }
    175     vec4(T)& ?&=?(vec4(T)& u, T scalar) {
    176         u = u & scalar;
    177         return u;
    178     }
    179     vec4(T) ?&?(vec4(T) u, vec4(T) v) {
    180         return [u.x & v.x, u.y & v.y, u.z & v.z, u.w & v.w];
    181     }
    182     vec4(T)& ?&=?(vec4(T)& u, vec4(T) v) {
    183         u = u & v;
    184         return u;
    185     }
     171    forall( | { T ?&?( T,T ); }) {
     172                vec4( T ) ?&?( vec4( T ) v, T scalar ) with ( v ) {
     173                        return [x & scalar, y & scalar, z & scalar, w & scalar];
     174                }
     175                vec4( T )& ?&=?( vec4( T )& u, T scalar ) {
     176                        u = u & scalar;
     177                        return u;
     178                }
     179                vec4( T ) ?&?( vec4( T ) u, vec4( T ) v ) {
     180                        return [u.x & v.x, u.y & v.y, u.z & v.z, u.w & v.w];
     181                }
     182                vec4( T )& ?&=?( vec4( T )& u, vec4( T ) v ) {
     183                        u = u & v;
     184                        return u;
     185                }
    186186    }
    187187
    188188    // |
    189     forall(| { T ?|?(T,T); }) {
    190     vec4(T) ?|?(vec4(T) v, T scalar) with (v) {
    191         return [x | scalar, y | scalar, z | scalar, w | scalar];
    192     }
    193     vec4(T)& ?|=?(vec4(T)& u, T scalar) {
    194         u = u | scalar;
    195         return u;
    196     }
    197     vec4(T) ?|?(vec4(T) u, vec4(T) v) {
    198         return [u.x | v.x, u.y | v.y, u.z | v.z, u.w | v.w];
    199     }
    200     vec4(T)& ?|=?(vec4(T)& u, vec4(T) v) {
    201         u = u | v;
    202         return u;
    203     }
     189    forall( | { T ?|?( T,T ); }) {
     190                vec4( T ) ?|?( vec4( T ) v, T scalar ) with ( v ) {
     191                        return [x | scalar, y | scalar, z | scalar, w | scalar];
     192                }
     193                vec4( T )& ?|=?( vec4( T )& u, T scalar ) {
     194                        u = u | scalar;
     195                        return u;
     196                }
     197                vec4( T ) ?|?( vec4( T ) u, vec4( T ) v ) {
     198                        return [u.x | v.x, u.y | v.y, u.z | v.z, u.w | v.w];
     199                }
     200                vec4( T )& ?|=?( vec4( T )& u, vec4( T ) v ) {
     201                        u = u | v;
     202                        return u;
     203                }
    204204    }
    205205
    206206    // ^
    207     forall(| { T ?^?(T,T); }) {
    208     vec4(T) ?^?(vec4(T) v, T scalar) with (v) {
    209         return [x ^ scalar, y ^ scalar, z ^ scalar, w ^ scalar];
    210     }
    211     vec4(T)& ?^=?(vec4(T)& u, T scalar) {
    212         u = u ^ scalar;
    213         return u;
    214     }
    215     vec4(T) ?^?(vec4(T) u, vec4(T) v) {
    216         return [u.x ^ v.x, u.y ^ v.y, u.z ^ v.z, u.w ^ v.w];
    217     }
    218     vec4(T)& ?^=?(vec4(T)& u, vec4(T) v) {
    219         u = u ^ v;
    220         return u;
    221     }
     207    forall( | { T ?^?( T,T ); }) {
     208                vec4( T ) ?^?( vec4( T ) v, T scalar ) with ( v ) {
     209                        return [x ^ scalar, y ^ scalar, z ^ scalar, w ^ scalar];
     210                }
     211                vec4( T )& ?^=?( vec4( T )& u, T scalar ) {
     212                        u = u ^ scalar;
     213                        return u;
     214                }
     215                vec4( T ) ?^?( vec4( T ) u, vec4( T ) v ) {
     216                        return [u.x ^ v.x, u.y ^ v.y, u.z ^ v.z, u.w ^ v.w];
     217                }
     218                vec4( T )& ?^=?( vec4( T )& u, vec4( T ) v ) {
     219                        u = u ^ v;
     220                        return u;
     221                }
    222222    }
    223223
    224224    // <<
    225     forall(| { T ?<<?(T,T); }) {
    226     vec4(T) ?<<?(vec4(T) v, T scalar) with (v) {
    227         return [x << scalar, y << scalar, z << scalar, w << scalar];
    228     }
    229     vec4(T)& ?<<=?(vec4(T)& u, T scalar) {
    230         u = u << scalar;
    231         return u;
    232     }
    233     vec4(T) ?<<?(vec4(T) u, vec4(T) v) {
    234         return [u.x << v.x, u.y << v.y, u.z << v.z, u.w << v.w];
    235     }
    236     vec4(T)& ?<<=?(vec4(T)& u, vec4(T) v) {
    237         u = u << v;
    238         return u;
    239     }
     225    forall( | { T ?<<?( T,T ); }) {
     226                vec4( T ) ?<<?( vec4( T ) v, T scalar ) with ( v ) {
     227                        return [x << scalar, y << scalar, z << scalar, w << scalar];
     228                }
     229                vec4( T )& ?<<=?( vec4( T )& u, T scalar ) {
     230                        u = u << scalar;
     231                        return u;
     232                }
     233                vec4( T ) ?<<?( vec4( T ) u, vec4( T ) v ) {
     234                        return [u.x << v.x, u.y << v.y, u.z << v.z, u.w << v.w];
     235                }
     236                vec4( T )& ?<<=?( vec4( T )& u, vec4( T ) v ) {
     237                        u = u << v;
     238                        return u;
     239                }
    240240    }
    241241
    242242    // >>
    243     forall(| { T ?>>?(T,T); }) {
    244     vec4(T) ?>>?(vec4(T) v, T scalar) with (v) {
    245         return [x >> scalar, y >> scalar, z >> scalar, w >> scalar];
    246     }
    247     vec4(T)& ?>>=?(vec4(T)& u, T scalar) {
    248         u = u >> scalar;
    249         return u;
    250     }
    251     vec4(T) ?>>?(vec4(T) u, vec4(T) v) {
    252         return [u.x >> v.x, u.y >> v.y, u.z >> v.z, u.w >> v.w];
    253     }
    254     vec4(T)& ?>>=?(vec4(T)& u, vec4(T) v) {
    255         u = u >> v;
    256         return u;
    257     }
     243    forall( | { T ?>>?( T,T ); }) {
     244                vec4( T ) ?>>?( vec4( T ) v, T scalar ) with ( v ) {
     245                        return [x >> scalar, y >> scalar, z >> scalar, w >> scalar];
     246                }
     247                vec4( T )& ?>>=?( vec4( T )& u, T scalar ) {
     248                        u = u >> scalar;
     249                        return u;
     250                }
     251                vec4( T ) ?>>?( vec4( T ) u, vec4( T ) v ) {
     252                        return [u.x >> v.x, u.y >> v.y, u.z >> v.z, u.w >> v.w];
     253                }
     254                vec4( T )& ?>>=?( vec4( T )& u, vec4( T ) v ) {
     255                        u = u >> v;
     256                        return u;
     257                }
    258258    }
    259259
    260260    // ~
    261     forall(| { T ~?(T); })
    262     vec4(T) ~?(vec4(T) v) with (v) {
     261    forall( | { T ~?( T ); })
     262    vec4( T ) ~?( vec4( T ) v ) with ( v ) {
    263263        return [~x, ~y, ~z, ~w];
    264264    }
    265265
    266266    // relational
    267     forall(| equality(T)) {
    268     bool ?==?(vec4(T) u, vec4(T) v) with (u) {
    269         return x == v.x && y == v.y && z == v.z && w == v.w;
    270     }
    271     bool ?!=?(vec4(T) u, vec4(T) v) {
    272         return !(u == v);
    273     }
     267    forall( | equality( T ) ) {
     268                bool ?==?( vec4( T ) u, vec4( T ) v ) with ( u ) {
     269                        return x == v.x && y == v.y && z == v.z && w == v.w;
     270                }
     271                bool ?!=?( vec4( T ) u, vec4( T ) v ) {
     272                        return !( u == v );
     273                }
    274274    }
    275275
    276276    // Geometric functions
    277     forall(| add(T) | multiply(T))
    278     T dot(vec4(T) u, vec4(T) v) {
     277    forall( | add( T ) | multiply( T ) )
     278    T dot( vec4( T ) u, vec4( T ) v ) {
    279279        return u.x * v.x + u.y * v.y + u.z * v.z + u.w * v.w;
    280280    }
    281 
    282     } // static inline
    283281}
    284282
    285 forall(ostype &, T | writeable(T, ostype)) {
    286     ostype & ?|?(ostype & os, vec4(T) v) with (v) {
     283forall( ostype &, T | writeable( T, ostype ) ) {
     284    ostype & ?|?( ostype & os, vec4( T ) v ) with ( v ) {
    287285        return os | '<' | x | ',' | y | ',' | z | ',' | w | '>';
    288286    }
    289         OSTYPE_VOID_IMPL( os, vec4(T) )
     287        OSTYPE_VOID_IMPL( os, vec4( T ) )
    290288}
    291 

  • tests/enum_tests/planet.cfa

    rf41b161 rc62013e  
    3636
    3737//      Planet rp = fromInt( prng( countof( Planet ) ) );       // select random orbiting body
     38
     39        #pragma GCC diagnostic push
     40        // FIX ME: false positive with gcc > 11, so disable.
     41        #pragma GCC diagnostic ignored "-Wdangling-pointer"
    3842        Planet rp = fromInt( countof( Planet ) - 1 );           // non-random for test suite
     43        #pragma GCC diagnostic pop
     44
    3945        choose( rp ) {                                                                          // implicit breaks
    4046          case MERCURY, VENUS, EARTH, MARS:
Note: See TracChangeset for help on using the changeset viewer.