Add Chromium-only Blender WebEngine parity work

blender-5.2.0/extern/opensubdiv-source/examples/glEvalLimit/particles.h

@@ -0,0 +1,155 @@
+//
+//   Copyright 2013 Pixar
+//
+//   Licensed under the terms set forth in the LICENSE.txt file available at
+//   https://opensubdiv.org/license.
+//
+
+#ifndef ST_PARTICLES_H
+#define ST_PARTICLES_H
+
+#include <opensubdiv/far/topologyRefiner.h>
+#include <opensubdiv/far/patchMap.h>
+#include <opensubdiv/osd/types.h>
+#include <iostream>
+
+//
+// In order to emphasize the dynamic nature of the EvalLimit API, where the
+// locations can be arbitrarily updated before each evaluation, the glEvalLimit
+// example treats each sample as a 'ST particle'.
+//
+// ST Particles are a simplified parametric-space particle dynamics simulation: each
+// particle is assigned a location on the subdivision surface limit that is
+// composed of a unique ptex face index, with a local (s,t) parametric pair.
+//
+// The system also generates an array of parametric velocities (ds, dt) for each
+// particle. An Update() function then applies the velocities to the locations and
+// moves the points along the parametric space.
+//
+// Face boundaries are managed using a ptex adjacency table obtained from the
+// Far::TopologyRefiner. Every time a particle moves outside of the [0.0f, 1.0f]
+// parametric range, a 'warp' function moves it to the neighboring face, or
+// bounces it, if the edge happens to be a boundary.
+// 
+// Note: currently the adjacency code does not handle 'diagonal' crossings, nor
+// crossings between quad and non-quad faces.
+//
+class STParticles {
+
+public:
+    /// \brief Coordinates set on a limit surface
+    ///
+    struct Position {
+        Position() { }
+
+        /// \brief Constructor
+        ///
+        /// @param f Ptex face id
+        ///
+        /// @param x parametric location on face
+        ///
+        /// @param y parametric location on face
+        ///
+        Position(int f, float x, float y) : ptexIndex(f), s(x), t(y) { }
+
+        int ptexIndex;      ///< ptex face index
+        float s, t;         ///< parametric location on face
+    };
+
+    //
+    // Topology adjacency (borrowed from Ptexture.h)
+    //
+    struct FaceInfo {
+
+        enum { flag_subface = 8 };
+
+        FaceInfo() : adjedges(0), flags(0) {
+            adjfaces[0] = adjfaces[1] = adjfaces[2] = adjfaces[3] = -1;
+        }
+
+        FaceInfo(int adjfaces_[4], int adjedges_[4], bool isSubface=false) :
+            flags(isSubface ? flag_subface : 0) {
+            setadjfaces(adjfaces_[0], adjfaces_[1], adjfaces_[2], adjfaces_[3]);
+            setadjedges(adjedges_[0], adjedges_[1], adjedges_[2], adjedges_[3]);
+        }
+
+        void setadjfaces(int f0, int f1, int f2, int f3) {
+            adjfaces[0] = f0;
+            adjfaces[1] = f1;
+            adjfaces[2] = f2;
+            adjfaces[3] = f3;
+        }
+
+        void setadjedges(int e0, int e1, int e2, int e3) {
+            adjedges = (e0&3) | ((e1&3)<<2) | ((e2&3)<<4) | ((e3&3)<<6);
+        }
+
+        int adjface(int eid) const { return adjfaces[eid]; }
+
+        int adjedge(int eid) const { return int((adjedges >> (2*eid)) & 3); }
+
+        bool isSubface() const { return (flags & flag_subface) != 0; }
+
+        unsigned int adjedges :8,
+                     flags    :8;
+                 int adjfaces[4];
+    };
+
+    typedef OpenSubdiv::Far::TopologyRefiner Refiner;
+    typedef OpenSubdiv::Far::PatchTable PatchTable;
+
+    STParticles(Refiner const & refiner, PatchTable const *patchTable,
+                int nparticles, bool centered=false);
+
+    ~STParticles();
+
+    void Update(float deltaTime);
+
+    int GetNumParticles() const {
+        return (int)_positions.size();
+    }
+
+    void SetSpeed(float speed) {
+        _speed = std::max(-1.0f, std::min(1.0f, speed));
+    }
+    
+    float GetSpeed() const {
+        return _speed;
+    }
+    
+    std::vector<Position> & GetPositions() {
+        return _positions;
+    }
+
+    std::vector<float> & GetVelocities() {
+        return _velocities;
+    }
+
+    std::vector<OpenSubdiv::Osd::PatchCoord> GetPatchCoords() const {
+        return _patchCoords;
+    }
+
+    friend std::ostream & operator << (std::ostream & os, STParticles const & f);
+
+private:
+
+    //
+    // Particle "Dynamics"
+    //
+    std::vector<Position> _positions;
+
+    std::vector<float> _velocities;
+
+    std::vector<OpenSubdiv::Osd::PatchCoord> _patchCoords;
+
+    float _speed;  // velocity multiplier
+    int _regFaceSize;
+
+    friend std::ostream & operator << (std::ostream & os, FaceInfo const & f);
+
+
+    std::vector<FaceInfo> _adjacency;
+    OpenSubdiv::Far::PatchMap const *_patchMap;
+};
+
+#endif // ST_PARTICLES_H