SkNx Load/store: take any pointer.

src/core/SkNx.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkNx_DEFINED
 #define SkNx_DEFINED
 
@@ skipping 14 matching lines @@
 
 // The default implementations just fall back on a pair of size N/2.
 // These support the union of operations we might do to ints and floats, but
 // platform specializations might support fewer (e.g. no float <<, no int /).
 template <int N, typename T>
 class SkNx {
 public:
     SkNx() {}
     SkNx(const SkNx<N/2, T>& lo, const SkNx<N/2, T>& hi) : fLo(lo), fHi(hi) {}
     SkNx(T val) : fLo(val), fHi(val) {}
-    static SkNx Load(const T vals[N]) {
+    static SkNx Load(const void* ptr) {
+        auto vals = (const T*)ptr;
         return SkNx(SkNx<N/2,T>::Load(vals), SkNx<N/2,T>::Load(vals+N/2));
     }
 
     SkNx(T a, T b)                                : fLo(a),       fHi(b)       { REQUIRE(N==2); }
     SkNx(T a, T b, T c, T d)                      : fLo(a,b),     fHi(c,d)     { REQUIRE(N==4); }
     SkNx(T a, T b, T c, T d,  T e, T f, T g, T h) : fLo(a,b,c,d), fHi(e,f,g,h) { REQUIRE(N==8); }
     SkNx(T a, T b, T c, T d,  T e, T f, T g, T h,
          T i, T j, T k, T l,  T m, T n, T o, T p)
         : fLo(a,b,c,d, e,f,g,h), fHi(i,j,k,l, m,n,o,p) { REQUIRE(N==16); }
 
-    void store(T vals[N]) const {
+    void store(void* ptr) const {
+        auto vals = (T*)ptr;
         fLo.store(vals);
         fHi.store(vals+N/2);
     }
 
     SkNx saturatedAdd(const SkNx& o) const {
         return SkNx(fLo.saturatedAdd(o.fLo), fHi.saturatedAdd(o.fHi));
     }
 
     SkNx operator + (const SkNx& o) const { return SkNx(fLo + o.fLo, fHi + o.fHi); }
     SkNx operator - (const SkNx& o) const { return SkNx(fLo - o.fLo, fHi - o.fHi); }
@@ skipping 44 matching lines @@
 
     SkNx<N/2, T> fLo, fHi;
 };
 
 // Bottom out the default implementations with scalars when nothing's been specialized.
 template <typename T>
 class SkNx<1,T> {
 public:
     SkNx() {}
     SkNx(T val) : fVal(val) {}
-    static SkNx Load(const T vals[1]) { return SkNx(vals[0]); }
+    static SkNx Load(const void* ptr) {
+        auto vals = (const T*)ptr;
+        return SkNx(vals[0]);
+    }
 
-    void store(T vals[1]) const { vals[0] = fVal; }
+    void store(void* ptr) const {
+        auto vals = (T*) ptr;
+        vals[0] = fVal;
+    }
 
     SkNx saturatedAdd(const SkNx& o) const {
         SkASSERT((T)(~0) > 0); // TODO: support signed T
         T sum = fVal + o.fVal;
         return SkNx(sum < fVal ? (T)(~0) : sum);
     }
 
     SkNx operator + (const SkNx& o) const { return SkNx(fVal + o.fVal); }
     SkNx operator - (const SkNx& o) const { return SkNx(fVal - o.fVal); }
     SkNx operator * (const SkNx& o) const { return SkNx(fVal * o.fVal); }
@@ skipping 118 matching lines @@
         SkNx_cast<uint8_t>(b).store(p+ 4);
         SkNx_cast<uint8_t>(c).store(p+ 8);
         SkNx_cast<uint8_t>(d).store(p+12);
     }
 #endif
 
 #undef REQUIRE
 
 
 #endif//SkNx_DEFINED