#include <Vec8.h>
 | 
| static JPH_INLINE Vec8  | sZero () | 
|   | Vector with all zeros.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sReplicate (float inV) | 
|   | Replicate across all components.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sSplatX (Vec4Arg inV) | 
|   | Replicate the X component of inV to all components.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sSplatY (Vec4Arg inV) | 
|   | Replicate the Y component of inV to all components.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sSplatZ (Vec4Arg inV) | 
|   | Replicate the Z component of inV to all components.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sFusedMultiplyAdd (Vec8Arg inMul1, Vec8Arg inMul2, Vec8Arg inAdd) | 
|   | Calculates inMul1 * inMul2 + inAdd.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sSelect (Vec8Arg inV1, Vec8Arg inV2, UVec8Arg inControl) | 
|   | Component wise select, returns inV1 when highest bit of inControl = 0 and inV2 when highest bit of inControl = 1.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sMin (Vec8Arg inV1, Vec8Arg inV2) | 
|   | Component wise min.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sMax (Vec8Arg inV1, Vec8Arg inV2) | 
|   | Component wise max.  More...
  | 
|   | 
| static JPH_INLINE UVec8  | sLess (Vec8Arg inV1, Vec8Arg inV2) | 
|   | Less than.  More...
  | 
|   | 
| static JPH_INLINE UVec8  | sGreater (Vec8Arg inV1, Vec8Arg inV2) | 
|   | Greater than.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sLoadFloat8 (const float *inV) | 
|   | Load from memory.  More...
  | 
|   | 
| static JPH_INLINE Vec8  | sLoadFloat8Aligned (const float *inV) | 
|   | Load 8 floats from memory, 32 bytes aligned.  More...
  | 
|   | 
◆ Vec8() [1/4]
Constructor. 
Intentionally not initialized for performance reasons 
 
 
◆ Vec8() [2/4]
  
  
      
        
          | Vec8::Vec8  | 
          ( | 
          const Vec8 &  | 
          inRHS | ) | 
           | 
         
       
   | 
  
default   | 
  
 
 
◆ Vec8() [3/4]
  
  
      
        
          | JPH_INLINE Vec8::Vec8  | 
          ( | 
          __m256  | 
          inRHS | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ Vec8() [4/4]
Set 256 bit vector from 2 128 bit vectors. 
 
 
◆ Abs()
Get absolute value of all components. 
 
 
◆ LowerVec4()
      
        
          | Vec4 Vec8::LowerVec4  | 
          ( | 
           | ) | 
           const | 
        
      
 
Fetch the lower 128 bit from a 256 bit variable. 
 
 
◆ operator*() [1/2]
      
        
          | Vec8 Vec8::operator*  | 
          ( | 
          float  | 
          inV2 | ) | 
           const | 
        
      
 
Multiply vector by float. 
 
 
◆ operator*() [2/2]
Multiply two float vectors. 
 
 
◆ operator+()
◆ operator-()
Subtract two float vectors. 
 
 
◆ operator/()
◆ operator[]() [1/2]
  
  
      
        
          | JPH_INLINE float & Vec8::operator[]  | 
          ( | 
          uint  | 
          inCoordinate | ) | 
           | 
         
       
   | 
  
inline   | 
  
 
 
◆ operator[]() [2/2]
  
  
      
        
          | JPH_INLINE float Vec8::operator[]  | 
          ( | 
          uint  | 
          inCoordinate | ) | 
           const | 
         
       
   | 
  
inline   | 
  
 
Get float component by index. 
 
 
◆ Reciprocal()
      
        
          | Vec8 Vec8::Reciprocal  | 
          ( | 
           | ) | 
           const | 
        
      
 
 
◆ ReduceMin()
      
        
          | float Vec8::ReduceMin  | 
          ( | 
           | ) | 
           const | 
        
      
 
Get the minimum value of the 8 floats. 
 
 
◆ sFusedMultiplyAdd()
Calculates inMul1 * inMul2 + inAdd. 
 
 
◆ sGreater()
◆ sLess()
◆ sLoadFloat8()
  
  
      
        
          | Vec8 Vec8::sLoadFloat8  | 
          ( | 
          const float *  | 
          inV | ) | 
           | 
         
       
   | 
  
static   | 
  
 
 
◆ sLoadFloat8Aligned()
  
  
      
        
          | Vec8 Vec8::sLoadFloat8Aligned  | 
          ( | 
          const float *  | 
          inV | ) | 
           | 
         
       
   | 
  
static   | 
  
 
Load 8 floats from memory, 32 bytes aligned. 
 
 
◆ sMax()
◆ sMin()
◆ sReplicate()
  
  
      
        
          | Vec8 Vec8::sReplicate  | 
          ( | 
          float  | 
          inV | ) | 
           | 
         
       
   | 
  
static   | 
  
 
Replicate across all components. 
 
 
◆ sSelect()
Component wise select, returns inV1 when highest bit of inControl = 0 and inV2 when highest bit of inControl = 1. 
 
 
◆ sSplatX()
Replicate the X component of inV to all components. 
 
 
◆ sSplatY()
Replicate the Y component of inV to all components. 
 
 
◆ sSplatZ()
Replicate the Z component of inV to all components. 
 
 
◆ Swizzle() [1/2]
      
        
          | JPH_INLINE Vec8 Vec8::Swizzle  | 
          ( | 
           | ) | 
           const | 
        
      
 
256 bit variant of Vec::Swizzle (no cross 128 bit lane swizzle) 
 
 
◆ Swizzle() [2/2]
      
        
          | Vec8 Vec8::Swizzle  | 
          ( | 
           | ) | 
           const | 
        
      
 
 
◆ sZero()
◆ UpperVec4()
      
        
          | Vec4 Vec8::UpperVec4  | 
          ( | 
           | ) | 
           const | 
        
      
 
Fetch the higher 128 bit from a 256 bit variable. 
 
 
◆ mF32
◆ mValue
The documentation for this class was generated from the following files: