Geometry.hpp - DPF - DISTRHO Plugin Framework

Geometry.hpp (20371B)
      1 /*
      2  * DISTRHO Plugin Framework (DPF)
      3  * Copyright (C) 2012-2021 Filipe Coelho <falktx@falktx.com>
      4  *
      5  * Permission to use, copy, modify, and/or distribute this software for any purpose with
      6  * or without fee is hereby granted, provided that the above copyright notice and this
      7  * permission notice appear in all copies.
      8  *
      9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
     10  * TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN
     11  * NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
     12  * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
     13  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
     14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
     15  */
     16 
     17 #ifndef DGL_GEOMETRY_HPP_INCLUDED
     18 #define DGL_GEOMETRY_HPP_INCLUDED
     19 
     20 #include "Base.hpp"
     21 
     22 START_NAMESPACE_DGL
     23 
     24 // --------------------------------------------------------------------------------------------------------------------
     25 // Forward class names
     26 
     27 template<typename> class Line;
     28 template<typename> class Circle;
     29 template<typename> class Triangle;
     30 template<typename> class Rectangle;
     31 
     32 // --------------------------------------------------------------------------------------------------------------------
     33 
     34 /**
     35    DGL Point class.
     36 
     37    This class describes a single point in space, defined by an X and Y value.
     38  */
     39 template<typename T>
     40 class Point
     41 {
     42 public:
     43    /**
     44       Constructor for (0, 0) point.
     45     */
     46     Point() noexcept;
     47 
     48    /**
     49       Constructor using custom X and Y values.
     50     */
     51     Point(const T& x, const T& y) noexcept;
     52 
     53    /**
     54       Constructor using another Point class values.
     55     */
     56     Point(const Point<T>& pos) noexcept;
     57 
     58    /**
     59       Get X value.
     60     */
     61     const T& getX() const noexcept;
     62 
     63    /**
     64       Get Y value.
     65     */
     66     const T& getY() const noexcept;
     67 
     68    /**
     69       Set X value to @a x.
     70     */
     71     void setX(const T& x) noexcept;
     72 
     73    /**
     74       Set Y value to @a y.
     75     */
     76     void setY(const T& y) noexcept;
     77 
     78    /**
     79       Set X and Y values to @a x and @a y respectively.
     80     */
     81     void setPos(const T& x, const T& y) noexcept;
     82 
     83    /**
     84       Set X and Y values according to @a pos.
     85     */
     86     void setPos(const Point<T>& pos) noexcept;
     87 
     88    /**
     89       Move this point by @a x and @a y values.
     90     */
     91     void moveBy(const T& x, const T& y) noexcept;
     92 
     93    /**
     94       Move this point by @a pos.
     95     */
     96     void moveBy(const Point<T>& pos) noexcept;
     97 
     98    /**
     99       Return true if point is (0, 0).
    100     */
    101     bool isZero() const noexcept;
    102 
    103    /**
    104       Return true if point is not (0, 0).
    105     */
    106     bool isNotZero() const noexcept;
    107 
    108     Point<T> operator+(const Point<T>& pos) noexcept;
    109     Point<T> operator-(const Point<T>& pos) noexcept;
    110     Point<T>& operator=(const Point<T>& pos) noexcept;
    111     Point<T>& operator+=(const Point<T>& pos) noexcept;
    112     Point<T>& operator-=(const Point<T>& pos) noexcept;
    113     bool operator==(const Point<T>& pos) const noexcept;
    114     bool operator!=(const Point<T>& pos) const noexcept;
    115 
    116 private:
    117     T x, y;
    118     template<typename> friend class Line;
    119     template<typename> friend class Circle;
    120     template<typename> friend class Triangle;
    121     template<typename> friend class Rectangle;
    122 };
    123 
    124 // --------------------------------------------------------------------------------------------------------------------
    125 
    126 /**
    127    DGL Size class.
    128 
    129    This class describes a size, defined by a width and height value.
    130  */
    131 template<typename T>
    132 class Size
    133 {
    134 public:
    135    /**
    136       Constructor for null size (0x0).
    137     */
    138     Size() noexcept;
    139 
    140    /**
    141       Constructor using custom width and height values.
    142     */
    143     Size(const T& width, const T& height) noexcept;
    144 
    145    /**
    146       Constructor using another Size class values.
    147     */
    148     Size(const Size<T>& size) noexcept;
    149 
    150    /**
    151       Get width.
    152     */
    153     const T& getWidth() const noexcept;
    154 
    155    /**
    156       Get height.
    157     */
    158     const T& getHeight() const noexcept;
    159 
    160    /**
    161       Set width.
    162     */
    163     void setWidth(const T& width) noexcept;
    164 
    165    /**
    166       Set height.
    167     */
    168     void setHeight(const T& height) noexcept;
    169 
    170    /**
    171       Set size to @a width and @a height.
    172     */
    173     void setSize(const T& width, const T& height) noexcept;
    174 
    175    /**
    176       Set size.
    177     */
    178     void setSize(const Size<T>& size) noexcept;
    179 
    180    /**
    181       Grow size by @a multiplier.
    182     */
    183     void growBy(double multiplier) noexcept;
    184 
    185    /**
    186       Shrink size by @a divider.
    187     */
    188     void shrinkBy(double divider) noexcept;
    189 
    190    /**
    191       Return true if size is null (0x0).
    192       An null size is also invalid.
    193     */
    194     bool isNull() const noexcept;
    195 
    196    /**
    197       Return true if size is not null (0x0).
    198       A non-null size is still invalid if its width or height are negative.
    199     */
    200     bool isNotNull() const noexcept;
    201 
    202    /**
    203       Return true if size is valid (width and height are higher than zero).
    204     */
    205     bool isValid() const noexcept;
    206 
    207    /**
    208       Return true if size is invalid (width or height are lower or equal to zero).
    209       An invalid size might not be null under some circumstances.
    210     */
    211     bool isInvalid() const noexcept;
    212 
    213     Size<int> toInt() const noexcept;
    214 
    215     Size<T> operator+(const Size<T>& size) noexcept;
    216     Size<T> operator-(const Size<T>& size) noexcept;
    217     Size<T>& operator=(const Size<T>& size) noexcept;
    218     Size<T>& operator+=(const Size<T>& size) noexcept;
    219     Size<T>& operator-=(const Size<T>& size) noexcept;
    220     Size<T>& operator*=(double m) noexcept;
    221     Size<T>& operator/=(double d) noexcept;
    222     Size<T> operator*(double m) const noexcept;
    223     Size<T> operator/(double m) const noexcept;
    224     bool operator==(const Size<T>& size) const noexcept;
    225     bool operator!=(const Size<T>& size) const noexcept;
    226 
    227 private:
    228     T fWidth, fHeight;
    229     template<typename> friend class Rectangle;
    230 };
    231 
    232 // -----------------------------------------------------------------------
    233 
    234 /**
    235    DGL Line class.
    236 
    237    This class describes a line, defined by two points.
    238  */
    239 template<typename T>
    240 class Line
    241 {
    242 public:
    243    /**
    244       Constructor for a null line ([0,0] to [0,0]).
    245     */
    246     Line() noexcept;
    247 
    248    /**
    249       Constructor using custom start X, start Y, end X and end Y values.
    250     */
    251     Line(const T& startX, const T& startY, const T& endX, const T& endY) noexcept;
    252 
    253    /**
    254       Constructor using custom start X, start Y and end pos values.
    255     */
    256     Line(const T& startX, const T& startY, const Point<T>& endPos) noexcept;
    257 
    258    /**
    259       Constructor using custom start pos, end X and end Y values.
    260     */
    261     Line(const Point<T>& startPos, const T& endX, const T& endY) noexcept;
    262 
    263    /**
    264       Constructor using custom start and end pos values.
    265     */
    266     Line(const Point<T>& startPos, const Point<T>& endPos) noexcept;
    267 
    268    /**
    269       Constructor using another Line class values.
    270     */
    271     Line(const Line<T>& line) noexcept;
    272 
    273    /**
    274       Get start X value.
    275     */
    276     const T& getStartX() const noexcept;
    277 
    278    /**
    279       Get start Y value.
    280     */
    281     const T& getStartY() const noexcept;
    282 
    283    /**
    284       Get end X value.
    285     */
    286     const T& getEndX() const noexcept;
    287 
    288    /**
    289       Get end Y value.
    290     */
    291     const T& getEndY() const noexcept;
    292 
    293    /**
    294       Get start position.
    295     */
    296     const Point<T>& getStartPos() const noexcept;
    297 
    298    /**
    299       Get end position.
    300     */
    301     const Point<T>& getEndPos() const noexcept;
    302 
    303    /**
    304       Set start X value to @a x.
    305     */
    306     void setStartX(const T& x) noexcept;
    307 
    308    /**
    309       Set start Y value to @a y.
    310     */
    311     void setStartY(const T& y) noexcept;
    312 
    313    /**
    314       Set start X and Y values to @a x and @a y respectively.
    315     */
    316     void setStartPos(const T& x, const T& y) noexcept;
    317 
    318    /**
    319       Set start X and Y values according to @a pos.
    320     */
    321     void setStartPos(const Point<T>& pos) noexcept;
    322 
    323    /**
    324       Set end X value to @a x.
    325     */
    326     void setEndX(const T& x) noexcept;
    327 
    328    /**
    329       Set end Y value to @a y.
    330     */
    331     void setEndY(const T& y) noexcept;
    332 
    333    /**
    334       Set end X and Y values to @a x and @a y respectively.
    335     */
    336     void setEndPos(const T& x, const T& y) noexcept;
    337 
    338    /**
    339       Set end X and Y values according to @a pos.
    340     */
    341     void setEndPos(const Point<T>& pos) noexcept;
    342 
    343    /**
    344       Move this line by @a x and @a y values.
    345     */
    346     void moveBy(const T& x, const T& y) noexcept;
    347 
    348    /**
    349       Move this line by @a pos.
    350     */
    351     void moveBy(const Point<T>& pos) noexcept;
    352 
    353    /**
    354       Return true if line is null (start and end pos are equal).
    355     */
    356     bool isNull() const noexcept;
    357 
    358    /**
    359       Return true if line is not null (start and end pos are different).
    360     */
    361     bool isNotNull() const noexcept;
    362 
    363 #ifndef DPF_TEST_POINT_CPP
    364    /**
    365       Draw this line using the provided graphics context, optionally specifying line width.
    366     */
    367     void draw(const GraphicsContext& context, T width = 1);
    368 #endif
    369 
    370     Line<T>& operator=(const Line<T>& line) noexcept;
    371     bool operator==(const Line<T>& line) const noexcept;
    372     bool operator!=(const Line<T>& line) const noexcept;
    373 
    374 #ifndef DPF_TEST_POINT_CPP
    375    /**
    376       Draw this line using the current OpenGL state.@n
    377       DEPRECATED Please use draw(const GraphicsContext&) instead.
    378     */
    379     DISTRHO_DEPRECATED_BY("draw(const GraphicsContext&)")
    380     void draw();
    381 #endif
    382 
    383 private:
    384     Point<T> posStart, posEnd;
    385 };
    386 
    387 // -----------------------------------------------------------------------
    388 
    389 /**
    390    DGL Circle class.
    391 
    392    This class describes a circle, defined by position, size and a minimum of 3 segments.
    393 
    394    TODO: report if circle starts at top-left, bottom-right or center.
    395          and size grows from which point?
    396  */
    397 template<typename T>
    398 class Circle
    399 {
    400 public:
    401    /**
    402       Constructor for a null circle.
    403     */
    404     Circle() noexcept;
    405 
    406    /**
    407       Constructor using custom X, Y and size values.
    408     */
    409     Circle(const T& x, const T& y, const float size, const uint numSegments = 300);
    410 
    411    /**
    412       Constructor using custom position and size values.
    413     */
    414     Circle(const Point<T>& pos, const float size, const uint numSegments = 300);
    415 
    416    /**
    417       Constructor using another Circle class values.
    418     */
    419     Circle(const Circle<T>& cir) noexcept;
    420 
    421    /**
    422       Get X value.
    423     */
    424     const T& getX() const noexcept;
    425 
    426    /**
    427       Get Y value.
    428     */
    429     const T& getY() const noexcept;
    430 
    431    /**
    432       Get position.
    433     */
    434     const Point<T>& getPos() const noexcept;
    435 
    436    /**
    437       Set X value to @a x.
    438     */
    439     void setX(const T& x) noexcept;
    440 
    441    /**
    442       Set Y value to @a y.
    443     */
    444     void setY(const T& y) noexcept;
    445 
    446    /**
    447       Set X and Y values to @a x and @a y respectively.
    448     */
    449     void setPos(const T& x, const T& y) noexcept;
    450 
    451    /**
    452       Set X and Y values according to @a pos.
    453     */
    454     void setPos(const Point<T>& pos) noexcept;
    455 
    456    /**
    457       Get size.
    458     */
    459     float getSize() const noexcept;
    460 
    461    /**
    462       Set size.
    463       @note Must always be > 0
    464     */
    465     void setSize(const float size) noexcept;
    466 
    467    /**
    468       Get the current number of line segments that make this circle.
    469     */
    470     uint getNumSegments() const noexcept;
    471 
    472    /**
    473       Set the number of line segments that will make this circle.
    474       @note Must always be >= 3
    475     */
    476     void setNumSegments(const uint num);
    477 
    478    /**
    479       Draw this circle using the provided graphics context.
    480     */
    481     void draw(const GraphicsContext& context);
    482 
    483    /**
    484       Draw lines (outline of this circle) using the provided graphics context, optionally specifying line width.
    485     */
    486     void drawOutline(const GraphicsContext& context, T lineWidth = 1);
    487 
    488     Circle<T>& operator=(const Circle<T>& cir) noexcept;
    489     bool operator==(const Circle<T>& cir) const noexcept;
    490     bool operator!=(const Circle<T>& cir) const noexcept;
    491 
    492 #ifndef DPF_TEST_POINT_CPP
    493    /**
    494       Draw this circle using the current OpenGL state.@n
    495       DEPRECATED Please use draw(const GraphicsContext&) instead.
    496     */
    497     DISTRHO_DEPRECATED_BY("draw(const GraphicsContext&)")
    498     void draw();
    499 
    500    /**
    501       Draw lines (outline of this circle) using the current OpenGL state.@n
    502       DEPRECATED Please use drawOutline(const GraphicsContext&,T) instead.
    503     */
    504     DISTRHO_DEPRECATED_BY("drawOutline(const GraphicsContext&)")
    505     void drawOutline();
    506 #endif
    507 
    508 private:
    509     Point<T> fPos;
    510     float    fSize;
    511     uint     fNumSegments;
    512 
    513     // cached values
    514     float fTheta, fCos, fSin;
    515 };
    516 
    517 // -----------------------------------------------------------------------
    518 
    519 /**
    520    DGL Triangle class.
    521 
    522    This class describes a triangle, defined by 3 points.
    523  */
    524 template<typename T>
    525 class Triangle
    526 {
    527 public:
    528    /**
    529       Constructor for a null triangle.
    530     */
    531     Triangle() noexcept;
    532 
    533    /**
    534       Constructor using custom X and Y values.
    535     */
    536     Triangle(const T& x1, const T& y1, const T& x2, const T& y2, const T& x3, const T& y3) noexcept;
    537 
    538    /**
    539       Constructor using custom position values.
    540     */
    541     Triangle(const Point<T>& pos1, const Point<T>& pos2, const Point<T>& pos3) noexcept;
    542 
    543    /**
    544       Constructor using another Triangle class values.
    545     */
    546     Triangle(const Triangle<T>& tri) noexcept;
    547 
    548    /**
    549       Return true if triangle is null (all its points are equal).
    550       An null triangle is also invalid.
    551     */
    552     bool isNull() const noexcept;
    553 
    554    /**
    555       Return true if triangle is not null (one its points is different from the others).
    556       A non-null triangle is still invalid if two of its points are equal.
    557     */
    558     bool isNotNull() const noexcept;
    559 
    560    /**
    561       Return true if triangle is valid (all its points are different).
    562     */
    563     bool isValid() const noexcept;
    564 
    565    /**
    566       Return true if triangle is invalid (one or two of its points are equal).
    567       An invalid triangle might not be null under some circumstances.
    568     */
    569     bool isInvalid() const noexcept;
    570 
    571    /**
    572       Draw this triangle using the provided graphics context.
    573     */
    574     void draw(const GraphicsContext& context);
    575 
    576    /**
    577       Draw lines (outline of this triangle) using the provided graphics context, optionally specifying line width.
    578     */
    579     void drawOutline(const GraphicsContext& context, T lineWidth = 1);
    580 
    581     Triangle<T>& operator=(const Triangle<T>& tri) noexcept;
    582     bool operator==(const Triangle<T>& tri) const noexcept;
    583     bool operator!=(const Triangle<T>& tri) const noexcept;
    584 
    585 #ifndef DPF_TEST_POINT_CPP
    586    /**
    587       Draw this triangle using the current OpenGL state.@n
    588       DEPRECATED Please use draw(const GraphicsContext&) instead.
    589     */
    590     DISTRHO_DEPRECATED_BY("draw(const GraphicsContext&)")
    591     void draw();
    592 
    593    /**
    594       Draw lines (outline of this triangle) using the current OpenGL state.@n
    595       DEPRECATED Please use drawOutline(const GraphicsContext&,T) instead.
    596     */
    597     DISTRHO_DEPRECATED_BY("drawOutline(const GraphicsContext&)")
    598     void drawOutline();
    599 #endif
    600 
    601 private:
    602     Point<T> pos1, pos2, pos3;
    603 };
    604 
    605 // -----------------------------------------------------------------------
    606 
    607 /**
    608    DGL Rectangle class.
    609 
    610    This class describes a rectangle, defined by a starting point and a size.
    611  */
    612 template<typename T>
    613 class Rectangle
    614 {
    615 public:
    616    /**
    617       Constructor for a null rectangle.
    618     */
    619     Rectangle() noexcept;
    620 
    621    /**
    622       Constructor using custom X, Y, width and height values.
    623     */
    624     Rectangle(const T& x, const T& y, const T& width, const T& height) noexcept;
    625 
    626    /**
    627       Constructor using custom X, Y and size values.
    628     */
    629     Rectangle(const T& x, const T& y, const Size<T>& size) noexcept;
    630 
    631    /**
    632       Constructor using custom pos, width and height values.
    633     */
    634     Rectangle(const Point<T>& pos, const T& width, const T& height) noexcept;
    635 
    636    /**
    637       Constructor using custom position and size.
    638     */
    639     Rectangle(const Point<T>& pos, const Size<T>& size) noexcept;
    640 
    641    /**
    642       Constructor using another Rectangle class values.
    643     */
    644     Rectangle(const Rectangle<T>& rect) noexcept;
    645 
    646    /**
    647       Get X value.
    648     */
    649     const T& getX() const noexcept;
    650 
    651    /**
    652       Get Y value.
    653     */
    654     const T& getY() const noexcept;
    655 
    656    /**
    657       Get width.
    658     */
    659     const T& getWidth() const noexcept;
    660 
    661    /**
    662       Get height.
    663     */
    664     const T& getHeight() const noexcept;
    665 
    666    /**
    667       Get position.
    668     */
    669     const Point<T>& getPos() const noexcept;
    670 
    671    /**
    672       Get size.
    673     */
    674     const Size<T>& getSize() const noexcept;
    675 
    676    /**
    677       Set X value as @a x.
    678     */
    679     void setX(const T& x) noexcept;
    680 
    681    /**
    682       Set Y value as @a y.
    683     */
    684     void setY(const T& y) noexcept;
    685 
    686    /**
    687       Set X and Y values as @a x and @a y respectively.
    688     */
    689     void setPos(const T& x, const T& y) noexcept;
    690 
    691    /**
    692       Set X and Y values according to @a pos.
    693     */
    694     void setPos(const Point<T>& pos) noexcept;
    695 
    696    /**
    697       Move this rectangle by @a x and @a y values.
    698     */
    699     void moveBy(const T& x, const T& y) noexcept;
    700 
    701    /**
    702       Move this rectangle by @a pos.
    703     */
    704     void moveBy(const Point<T>& pos) noexcept;
    705 
    706    /**
    707       Set width.
    708     */
    709     void setWidth(const T& width) noexcept;
    710 
    711    /**
    712       Set height.
    713     */
    714     void setHeight(const T& height) noexcept;
    715 
    716    /**
    717       Set size using @a width and @a height.
    718     */
    719     void setSize(const T& width, const T& height) noexcept;
    720 
    721    /**
    722       Set size.
    723     */
    724     void setSize(const Size<T>& size) noexcept;
    725 
    726    /**
    727       Grow size by @a multiplier.
    728     */
    729     void growBy(double multiplier) noexcept;
    730 
    731    /**
    732       Shrink size by @a divider.
    733     */
    734     void shrinkBy(double divider) noexcept;
    735 
    736    /**
    737       Set rectangle using @a pos and @a size.
    738     */
    739     void setRectangle(const Point<T>& pos, const Size<T>& size) noexcept;
    740 
    741    /**
    742       Set rectangle.
    743     */
    744     void setRectangle(const Rectangle<T>& rect) noexcept;
    745 
    746    /**
    747       Check if this rectangle contains the point defined by @a X and @a Y.
    748     */
    749     bool contains(const T& x, const T& y) const noexcept;
    750 
    751    /**
    752       Check if this rectangle contains the point @a pos.
    753     */
    754     bool contains(const Point<T>& pos) const noexcept;
    755 
    756    /**
    757       Check if this rectangle contains the point @a pos affected by a custom scale.
    758     */
    759     bool containsAfterScaling(const Point<T>& pos, double scaling) const noexcept;
    760 
    761    /**
    762       Check if this rectangle contains the point @a pos of another type.
    763     */
    764     template<typename T2>
    765     bool contains(const Point<T2>& pos) const noexcept;
    766 
    767    /**
    768       Check if this rectangle contains X.
    769     */
    770     bool containsX(const T& x) const noexcept;
    771 
    772    /**
    773       Check if this rectangle contains Y.
    774     */
    775     bool containsY(const T& y) const noexcept;
    776 
    777    /**
    778       Return true if size is null (0x0).
    779       An null size is also invalid.
    780     */
    781     bool isNull() const noexcept;
    782 
    783    /**
    784       Return true if size is not null (0x0).
    785       A non-null size is still invalid if its width or height are negative.
    786     */
    787     bool isNotNull() const noexcept;
    788 
    789    /**
    790       Return true if size is valid (width and height are higher than zero).
    791     */
    792     bool isValid() const noexcept;
    793 
    794    /**
    795       Return true if size is invalid (width or height are lower or equal to zero).
    796       An invalid size might not be null under some circumstances.
    797     */
    798     bool isInvalid() const noexcept;
    799 
    800    /**
    801       Draw this rectangle using the provided graphics context.
    802     */
    803     void draw(const GraphicsContext& context);
    804 
    805    /**
    806       Draw lines (outline of this rectangle) using the provided graphics context, optionally specifying line width.
    807     */
    808     void drawOutline(const GraphicsContext& context, T lineWidth = 1);
    809 
    810     Rectangle<T>& operator=(const Rectangle<T>& rect) noexcept;
    811     Rectangle<T>& operator*=(double m) noexcept;
    812     Rectangle<T>& operator/=(double d) noexcept;
    813     bool operator==(const Rectangle<T>& size) const noexcept;
    814     bool operator!=(const Rectangle<T>& size) const noexcept;
    815 
    816    /**
    817       Draw this rectangle using the current OpenGL state.@n
    818       DEPRECATED Please use draw(const GraphicsContext&) instead.
    819     */
    820     DISTRHO_DEPRECATED_BY("draw(const GraphicsContext&)")
    821     void draw();
    822 
    823    /**
    824       Draw lines (outline of this rectangle) using the current OpenGL state.@n
    825       DEPRECATED Please use drawOutline(const GraphicsContext&,T) instead.
    826     */
    827     DISTRHO_DEPRECATED_BY("drawOutline(const GraphicsContext&)")
    828     void drawOutline();
    829 
    830 private:
    831     Point<T> pos;
    832     Size<T> size;
    833 };
    834 
    835 // -----------------------------------------------------------------------
    836 
    837 END_NAMESPACE_DGL
    838 
    839 #endif // DGL_GEOMETRY_HPP_INCLUDED
	DPF DISTRHO Plugin Framework
	Log \| Files \| Refs \| Submodules \| README \| LICENSE